GitHub

Measurements

MonteCarloX separates what you measure from when you measure it. Measurement and Measurements are convenience helpers — they are not required for running MonteCarloX algorithms. You can always collect observables manually in your simulation loop.

Building blocks

  • Measurement: one observable paired with one data container
  • Measurements: named collection with a shared schedule
  • schedule types:
    • IntervalSchedule
    • PreallocatedSchedule

Step-based measurements (common in equilibrium loops)

using MonteCarloX

measurements = Measurements([
    :energy        => energy        => Float64[],
    :magnetization => magnetization => Float64[],
], interval=10)

# in your loop:
# measure!(measurements, sys, step)

This records every 10 loop steps.

Time-based measurements (common in Gillespie loops)

using MonteCarloX

times = collect(0.0:0.1:10.0)
measurements = Measurements([
    :N => (state -> state[:N]) => Float64[],
], times)

# in your loop:
# measure!(measurements, state, t)
# stop criterion: is_complete(measurements)

PreallocatedSchedule handles event skipping by consuming all crossed checkpoints.

Data access and reset

  • measurements[:energy].data — raw storage
  • data(measurements, :energy) — convenience accessor
  • reset!(measurements) — clears data and restarts schedule state

API reference

MonteCarloX.Measurement — Type
Measurement{F,T}

A measurement consisting of an observable function and a data container.

Fields

  • observable::F: Function that extracts a value from the system
  • data::T: Container for storing measurements (Vector, Histogram, etc.)
source
MonteCarloX.Measurements — Type
Measurements{K,S<:MeasurementSchedule}

Container for multiple measurements with a shared schedule.

Fields

  • measurements::Dict{K, Measurement}: Dictionary of named measurements
  • schedule::S: Measurement schedule
source
MonteCarloX.IntervalSchedule — Type
IntervalSchedule <: MeasurementSchedule

Schedule measurements at regular intervals.

Fields

  • interval::Float64: Time/step interval between measurements
  • _checkpoint::Float64: Internal checkpoint for next measurement
source
MonteCarloX.PreallocatedSchedule — Type
PreallocatedSchedule <: MeasurementSchedule

Schedule measurements at pre-specified times.

Fields

  • times::Vector{Float64}: Sorted vector of measurement times
  • checkpoint_idx::Int: Current index in times vector
source
MonteCarloX.measure! — Function
measure!(measurement::Measurement, sys; kwargs...)

Perform a single measurement by evaluating the observable on the system and storing the result.

source
measure!(measurements::Measurements{K, IntervalSchedule}, sys, t; kwargs...)

Perform measurements at regular intervals (indefinite simulation).

source
measure!(measurements::Measurements{K, PreallocatedSchedule}, sys, t; kwargs...)

Perform measurements at preallocated times (handles event skipping).

source
measure!(sys, event, t)

Observe system sys at time t before modify!. Default is a no-op.

source
MonteCarloX.reset! — Method
reset!(measurement::Measurement)

Reset a single measurement to its initial state by clearing its data container. For histogram-backed measurements this zeros the bin counts while preserving binning.

source
MonteCarloX.reset! — Method
reset!(schedule::MeasurementSchedule)

Reset schedule counters/checkpoints back to their initial state.

source
MonteCarloX.reset! — Method
reset!(measurements::Measurements)

Reset all measurement data containers and schedule state in-place.

source
MonteCarloX.times — Method
times(m::Measurements)

Return the measurement time points for preallocated schedules.

source
MonteCarloX.data — Method
data(m::Measurements{K}, key::K)

Return the raw data container for a named measurement.

source
MonteCarloX.is_complete — Function
is_complete(m::Measurements)

Check if all scheduled measurements are complete. Returns false for interval-based schedules (indefinite).

source