"""
Measure the dynamical critical exponent z for Metropolis and Wolff algorithms.
This script runs simulations of the 2D Ising model at the critical temperature Tc
for various lattice sizes L. It calculates the integrated autocorrelation time
tau_int and fits tau_int ~ L^z to extract the dynamic exponent z.
Results are saved to ``results/ising/dynamic_exponent_z.npz``.
"""
from __future__ import annotations
import argparse
import logging
import os
import time
from typing import Any
import numpy as np
from models.ising_model import IsingSimulation
from utils.equilibration import prepare_equilibrated_simulation
from utils.exceptions import ZeroVarianceAutocorrelationError
from utils.statistics import (
DEFAULT_CONFIDENCE_LEVEL,
UNCERTAINTY_METHOD_REPLICATE,
calculate_autocorr,
summarize_replicate_samples,
)
from utils.sweep_helpers import derive_point_seed
from utils.system import parallel_sweep, parse_args_compat, setup_logging
#: Exact Onsager critical temperature for the 2D nearest-neighbour Ising model.
TC_ISING: float = 2.0 / np.log(1.0 + np.sqrt(2.0))
def _measure_tau_point(
params: tuple[int, int, str, int, int, int, int, int],
) -> dict[str, Any]:
"""
Worker: measure tau_int for a specific algorithm and lattice size at Tc.
Parameters
----------
params : tuple
``(size_idx, seed_idx, update, L, eq_probe_steps, eq_max_steps,
meas_steps, seed)`` — grid indices for result aggregation, update
scheme, lattice size, chunk size for convergence, hard cap on
equilibration, measurement steps, and RNG seed.
Returns
-------
dict
Keys: ``size_idx``, ``seed_idx``, ``update``, ``L``, ``tau_int``,
``wall_time``, and ``equilibrated``. When the two starts did not
converge within ``eq_max_steps``, ``equilibrated`` is False and
``tau_int`` and ``wall_time`` are NaN.
"""
size_idx, seed_idx, update, L, eq_probe_steps, eq_max_steps, meas_steps, seed = params
# Thorough equilibration at Tc via two-start convergence. A pair that never
# converges is not measured; its tau_int is stored as NaN.
sim, outcome = prepare_equilibrated_simulation(
model_cls=IsingSimulation, model_kwargs={}, size=L, temp=TC_ISING, seed=seed,
chunk_size=eq_probe_steps, max_steps=eq_max_steps, update=update,
)
if not outcome.certified:
return {
'size_idx': int(size_idx),
'seed_idx': int(seed_idx),
'update': update,
'L': float(L),
'tau_int': float('nan'),
'wall_time': float('nan'),
'equilibrated': False,
}
t0 = time.perf_counter()
mags, _ = sim.run(n_steps=meas_steps)
wall_time = time.perf_counter() - t0
mags_arr = np.array(mags)
try:
_, tau_int = calculate_autocorr(time_series=mags_arr)
except ZeroVarianceAutocorrelationError:
tau_int = float('nan')
return {
'size_idx': int(size_idx),
'seed_idx': int(seed_idx),
'update': update,
'L': float(L),
'tau_int': float(tau_int),
'wall_time': float(wall_time),
'equilibrated': True,
}
[docs]
def main() -> None:
"""
Execute the dynamical critical exponent measurement sweep.
"""
parser = argparse.ArgumentParser(
description='Measure dynamical critical exponent z for the 2D Ising model.',
)
parser.add_argument(
'--sizes', type=int, nargs='+', default=[16, 32, 48, 64, 96, 128],
help='Lattice sizes L to sweep (default: 16 32 48 64 96 128)',
)
parser.add_argument(
'--eq-probe-steps', type=int, default=1000,
help='Chunk size for convergence check during equilibration (default: 1000)',
)
parser.add_argument(
'--eq-max-steps', type=int, default=500000,
help='Hard cap on equilibration steps at Tc (default: 500000)',
)
parser.add_argument(
'--meas-steps-metro', type=int, default=400000,
help='Measurement steps for Metropolis (default: 400000)',
)
parser.add_argument(
'--meas-steps-wolff', type=int, default=100000,
help='Measurement steps for Wolff (default: 100000)',
)
parser.add_argument(
'--n-seeds', type=int, default=10,
help='Independent seed replicas per (algorithm, L) point (default: 10)',
)
parser.add_argument(
'--output-dir', type=str, default='results/ising',
help='Output directory (default: results/ising)',
)
parser.add_argument('--verbose', action='store_true', help='Enable verbose logging')
args = parse_args_compat(parser=parser)
log_level = logging.DEBUG if args.verbose else logging.INFO
logger = setup_logging(level=log_level)
sizes = sorted(args.sizes)
n_seeds = int(args.n_seeds)
logger.info(
f'Measuring dynamical exponent z at Tc={TC_ISING:.6f} for L in {sizes}, '
f'{n_seeds} seed replicas.'
)
# Seeds are derived deterministically from (size_idx, seed_idx) via
# derive_point_seed; Wolff draws from stream 1 so its seed sequences
# cannot overlap the Metropolis ones at the same grid point.
sweep_params: list[tuple[int, int, str, int, int, int, int, int]] = []
for size_idx, L in enumerate(sizes):
for seed_idx in range(n_seeds):
base = derive_point_seed(temperature_index=size_idx, seed_index=seed_idx)
sweep_params.append((
size_idx, seed_idx, 'random', L,
args.eq_probe_steps, args.eq_max_steps, args.meas_steps_metro,
base,
))
sweep_params.append((
size_idx, seed_idx, 'wolff', L,
args.eq_probe_steps, args.eq_max_steps, args.meas_steps_wolff,
derive_point_seed(
temperature_index=size_idx, seed_index=seed_idx, stream_index=1,
),
))
raw: list[dict[str, Any]] = parallel_sweep(
worker_func=_measure_tau_point, params=sweep_params,
)
n_sizes = len(sizes)
tau_metro_samples = np.full((n_sizes, n_seeds), np.nan)
tau_wolff_samples = np.full((n_sizes, n_seeds), np.nan)
metro_equilibrated = np.zeros((n_sizes, n_seeds), dtype=bool)
wolff_equilibrated = np.zeros((n_sizes, n_seeds), dtype=bool)
for r in raw:
i = int(r['size_idx'])
s = int(r['seed_idx'])
if r['update'] == 'random':
tau_metro_samples[i, s] = float(r['tau_int'])
metro_equilibrated[i, s] = bool(r['equilibrated'])
else:
tau_wolff_samples[i, s] = float(r['tau_int'])
wolff_equilibrated[i, s] = bool(r['equilibrated'])
L_arr = np.asarray(sizes, dtype=float)
# summarize_replicate_samples at the default 0.68 confidence yields exactly
# the median and 16-84 percentile envelope previously computed inline.
metro_summary = summarize_replicate_samples(samples=tau_metro_samples)
wolff_summary = summarize_replicate_samples(samples=tau_wolff_samples)
tau_metro = np.asarray(metro_summary['value'])
tau_metro_p16 = np.asarray(metro_summary['ci_low'])
tau_metro_p84 = np.asarray(metro_summary['ci_high'])
tau_wolff = np.asarray(wolff_summary['value'])
tau_wolff_p16 = np.asarray(wolff_summary['ci_low'])
tau_wolff_p84 = np.asarray(wolff_summary['ci_high'])
os.makedirs(args.output_dir, exist_ok=True)
npz_path = os.path.join(args.output_dir, 'dynamic_exponent_z.npz')
np.savez(
npz_path,
L_metro=L_arr,
tau_metro=tau_metro,
tau_metro_p16=tau_metro_p16,
tau_metro_p84=tau_metro_p84,
tau_metro_samples=tau_metro_samples,
L_wolff=L_arr,
tau_wolff=tau_wolff,
tau_wolff_p16=tau_wolff_p16,
tau_wolff_p84=tau_wolff_p84,
tau_wolff_samples=tau_wolff_samples,
metro_equilibrated=metro_equilibrated,
wolff_equilibrated=wolff_equilibrated,
Tc=TC_ISING,
n_seeds=np.int64(n_seeds),
tau_metro_value=metro_summary['value'],
tau_metro_err=metro_summary['err'],
tau_metro_ci_low=metro_summary['ci_low'],
tau_metro_ci_high=metro_summary['ci_high'],
tau_wolff_value=wolff_summary['value'],
tau_wolff_err=wolff_summary['err'],
tau_wolff_ci_low=wolff_summary['ci_low'],
tau_wolff_ci_high=wolff_summary['ci_high'],
# The observable is itself an autocorrelation time summarised over
# independent seeds, so no autocorrelation time or effective sample
# size of its own applies; the fields are NaN to complete the schema.
tau_metro_tau_int=np.full(n_sizes, np.nan),
tau_metro_n_eff=np.full(n_sizes, np.nan),
tau_wolff_tau_int=np.full(n_sizes, np.nan),
tau_wolff_n_eff=np.full(n_sizes, np.nan),
uncertainty_method=UNCERTAINTY_METHOD_REPLICATE,
confidence_level=DEFAULT_CONFIDENCE_LEVEL,
bootstrap_resamples=0,
nan_or_undefined_count=int(
np.isnan(tau_metro_samples).sum() + np.isnan(tau_wolff_samples).sum()
),
)
logger.info(f'Data saved to {npz_path}')
if __name__ == '__main__':
main()