Source code for scripts.ising.measure_z

"""
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()