TRExMC.jl

TRExMC: Thermodynamics via Replica-Exchange Monte Carlo

Model{L, H[, O]}

The main container used for simulations. The type parameters are given by

• R <: Random.AbstractRNG
• L <:AbstractLattice
• H <:AbstractHamiltonian
• O <:AbstractObservable
  • If no observable is provided, then the NullObservable is used.

hamiltonian(::Model)

Convenience function to access the <:AbstractHamiltonian of a Model.

measure!(m::Model)

Convenience function to take measurements in a Model.

iterate_DoFs(m::AbstractModel)

Wrapper to extract the Hamiltonian from the Model and iterate.

lattice(::Model)

Convenience function to access the <:AbstractLattice of a Model.

observables(::Model)

Convenience function to access the <:AbstractObservables of a Model.

rng(::Model)

Convenience function to access the Random Number Generator a Model.

module Lattices

Main entry point for any simulated model to access an underlying geometrical structure. Currently comprised of the following subfiles:

• [AbstractLattices.jl]:
  • Interface module that defines the `AbstractLattice as the supertype for all lattices
• [CubicLattices.jl]:
  • Defines the AbstractCubicLattice subtype
  • Implements the CubicLattice2D <: AbstractCubicLattice and the CubicLattice2DParams

abstract type AbstractLattice end

The supertype for all Types of lattices one can dream of.

Required Interface Methods

One must define the following methods for each new (non-abstract) AbstractLattice:

• Base.size
• construct_lattice!
• num_sites
• site_index
• nearest_neighbors
• parameters

Default Interface Methods

The following represent the default methods for AbstractLattices. One may still overload them for any peculiar subtype.

• DrWatson.savename

construct_lattice!(::AbstractLattice)

Build a lattice and its geometry. Meant to be used in a constructor.

nearest_neighbors(::AbstractLattice, site)

Return the set of nearest_neighbors for a given site in the AbstractLattice.

Example

julia> latt = Lattices.CubicLattice2D(4, 4);

julia> Lattices.nearest_neighbors(latt, 1)
4-element view(::Matrix{Int32}, 1, :) with eltype Int32:
 13
  4
  2
  5

num_sites(::AbstractLattice)

Return the number of sites that an AbstractLattice contains.

Example

julia> latt = Lattices.CubicLattice2D(4, 4);

julia> Lattices.num_sites(latt)
16

parameters(::AbstractLattice)

Return the parameters used to define the AbstractLattice.

Example

julia> latt = Lattices.CubicLattice2D(4, 4);

julia> Lattices.parameters(latt)
TRExMC.Models.Lattices.CubicLattice2DParams(4, 4)

site_index(::AbstractLattice, indices::itr)

Calculate the flattened index from an iterable set of indices in an AbstractLattice.

Example

julia> latt = Lattices.CubicLattice2D(4, 4);

julia> Lattices.site_index(latt, (1, 2))
5

abstract type AbstractDoF end

Parent type for all degrees of freedom used in the simulations.

The required interface for all DoF types is the following:

• DoF_location: Defines the in-memory identification for where the DoF is.
• DoF_value: Defines what the value of the DoF is (its current state).

abstract type AbstractHamiltonian end

Parent type for all Hamiltonians in the simulation.

The required interface that all Hamiltonians must satisfy are specified by the following functions:

• DoF: the AbstractDoF stored at a given memory location
• energy: total energy of the Hamiltonian
• DoF_energy: energy associated with a single AbstractDoF

abstract type AbstractHamiltonianIterator end

Iterface for iteration through a given Hamiltonian.

abstract type AbstractObservables end

Parent type for all observables.

Required Interface

The following methods must be implemented for all subtypes:

* [`measure!`](@ref): how one should take measurements of a system for a given system configuration.

NullObservable <: AbstractObservables

Empty observable used for testing purposes.

_observables(name, symbol_funcs::AbstractDict)
_observables(name, symbols, funcs)

Return an Expression used by the @observables macro.

@observables name symbol_funcs::AbstractDict
@observables name symbols funcs

Generate an AbstractObservables subtype with the given name whose fields will be denoted by the given symbols iterable. The measure! method will also be implemented with the supplied [funcs] iterable.

Alternatively one can supply a Dictionary of symbol-function pairs as a single argument.

@algorithm

monte_carlo!(models, algorithm, mcparams)

A single sweep of the Monte Carlo simulation. It's an internal function that is supposed to be used by the monte_carlo_run! function.

monte_carlo_run!(models, algorithm, mcparams; kwargs...)

Main Monte Carlo function that performs a certain simulation algorithm on the systems defined by the given models. The parameters for the simulation are contained with mcparams.

Currently, the available keyword arguments (kwargs) are:

• procedure::AbstractMCProcedure = MonteCarloSimulation(): defines the type of simulation to be run
• verbose = false: whether to dump the progress for run during the simulation

run_and_record!(models, algorithm, mcparams; [kwargs...])

Monte Carlo simulation for a set of models to be simulated in parallel according to the specified algorithm with respect to the given parameters, mcparams.

thermalize(models, algorithm, mcparams; [kwargs...])

Thermalization process for a given set of models to be thermalized in parallel according to the specified algorithm with respect to the given parameters, mcparams.