Struct Realization 

pub struct Realization {
    pub couplings: Vec<f32>,
    pub spins: Vec<i8>,
    pub temperatures: Vec<f32>,
    pub system_ids: Vec<usize>,
    pub rngs: Vec<Xoshiro256StarStar>,
    pub pair_rngs: Vec<Xoshiro256StarStar>,
    pub energies: Vec<f32>,
}

Mutable state for one disorder realization.

Holds the coupling array (fixed after construction), spin configurations for every replica at every temperature, and bookkeeping for parallel tempering.

With n_replicas replicas and n_temps temperatures there are n_systems = n_replicas * n_temps independent spin configurations. Spins are stored in a single flat Vec of length n_systems * n_spins, where system i occupies spins[i*n_spins .. (i+1)*n_spins].

Fields

couplings: Vec<f32>

Forward couplings, length n_spins * n_neighbors.

spins: Vec<i8>

All spin configurations, length n_systems * n_spins (+1/−1).

temperatures: Vec<f32>

Temperature assigned to each system slot, length n_systems.

system_ids: Vec<usize>

Parallel-tempering permutation: system_ids[slot] is the system index currently occupying temperature slot slot.

rngs: Vec<Xoshiro256StarStar>

One PRNG per system.

pair_rngs: Vec<Xoshiro256StarStar>

One PRNG per overlap-update pair slot, length n_temps * (n_replicas / 2).

energies: Vec<f32>

Cached total energy per system (E / N), length n_systems.

Implementations

impl Realization

pub fn new( lattice: &Lattice, couplings: Vec<f32>, temps: &[f32], n_replicas: usize, base_seed: u64, ) -> Self

Initialize a realization with random ±1 spins.

Seeds replica RNGs deterministically as base_seed, base_seed+1, ….

Examples found in repository

examples/bench.rs (lines 34-36)

fn main() {
    let lattice = Lattice::new(vec![L, L]);
    let n_spins = lattice.n_spins;
    let n_neighbors = lattice.n_neighbors;

    let temps: Vec<f32> = (0..N_TEMPS)
        .map(|i| 0.1 * (50.0f32).powf(i as f32 / (N_TEMPS - 1) as f32))
        .collect();

    let n_pairs = N_REPLICAS / 2;
    let n_systems = N_REPLICAS * N_TEMPS;
    let rngs_per_real = n_systems + N_TEMPS * n_pairs;

    let mut rng = rand::thread_rng();
    let mut realizations = Vec::with_capacity(N_REALIZATIONS);
    for r in 0..N_REALIZATIONS {
        let couplings: Vec<f32> = (0..n_spins * n_neighbors)
            .map(|_| if rng.gen::<bool>() { 1.0 } else { -1.0 })
            .collect();
        let base_seed = 42 + (r * rngs_per_real) as u64;
        realizations.push(Realization::new(
            &lattice, couplings, &temps, N_REPLICAS, base_seed,
        ));
    }

    let interrupted = AtomicBool::new(false);

    let config = SimConfig {
        n_sweeps: N_SWEEPS,
        warmup_sweeps: 0,
        sweep_mode: SweepMode::Metropolis,
        cluster_update: None,
        pt_interval: Some(1),
        overlap_cluster: Some(OverlapClusterConfig {
            interval: 1,
            modes: vec![OverlapClusterBuildMode::Cmr],
            cluster_mode: ClusterMode::Sw,
            collect_stats: false,
            snapshot_interval: None,
        }),
        autocorrelation_max_lag: None,
        sequential: false,
        equilibration_diagnostic: false,
    };

    println!(
        "Lattice: {}x{}  |  Temps: {}  |  Replicas: {}  |  Sweeps: {}  |  Realizations: {}",
        L, L, N_TEMPS, N_REPLICAS, N_SWEEPS, N_REALIZATIONS
    );
    println!("Config: bimodal, CMR, SW overlap, PT every sweep");
    println!("{}", "-".repeat(70));

    let t0 = Instant::now();
    run_sweep_parallel(
        &lattice,
        &mut realizations,
        N_REPLICAS,
        N_TEMPS,
        &config,
        &interrupted,
        &|| {},
    )
    .unwrap();
    let elapsed = t0.elapsed().as_secs_f64();

    let per_sweep = elapsed / N_SWEEPS as f64 * 1000.0;
    println!("Total: {:.3} s  |  {:.3} ms/sweep", elapsed, per_sweep);
}

pub fn reset( &mut self, lattice: &Lattice, n_replicas: usize, n_temps: usize, base_seed: u64, )

Re-randomize all spins and reset the tempering permutation.