montecarlo.h

#pragma once
#ifndef FAUNUS_MONTECARLO_H
#define FAUNUS_MONTECARLO_H

#include "space.h"
#include <memory>

namespace Faunus {

namespace Energy {
class Hamiltonian;
}

namespace move {
class Move;
class MoveCollection;
} // namespace move

class MetropolisMonteCarlo
{
  public:
    struct State
    {
        std::unique_ptr<Space> spc; 
        std::unique_ptr<Energy::Hamiltonian> pot; 
        void
        sync(const State& other,
             const Change& change); 
    };

  private:
    spdlog::level::level_enum original_log_level; 
    std::unique_ptr<State> state;                 
    std::unique_ptr<State> trial_state;           
    std::unique_ptr<move::MoveCollection> moves;  
    std::string latest_move_name;                 
    double sum_of_energy_changes = 0.0;           
    double initial_energy = 0.0;                  
    Average<double> average_energy;               
    void init();                                  
    void performMove(move::Move& move);           
    double getEnergyChange(double new_energy, double old_energy) const;
    friend void to_json(json&, const MetropolisMonteCarlo&); 
    unsigned int number_of_sweeps = 0; 

  public:
    MetropolisMonteCarlo(const json& j);
    Energy::Hamiltonian& getHamiltonian(); 
    Space& getSpace();                     
    Space& getTrialSpace();                
    double relativeEnergyDrift();          
    void sweep();                          
    void restore(const json& j);           
    static bool metropolisCriterion(double energy_change); 
    ~MetropolisMonteCarlo(); 
};

void from_json(const json&, MetropolisMonteCarlo::State&); 
void to_json(json&, const MetropolisMonteCarlo&);

class TranslationalEntropy
{
  private:
    const Space& trial_spc;                        
    const Space& spc;                              
    double bias(int trial_count, int count) const; 
    double atomSwapEnergy(
        const Change::GroupChange& group_change) const; 
    double atomChangeEnergy(int molid) const; 
    double moleculeChangeEnergy(
        int molid) const; 

  public:
    TranslationalEntropy(const Space& trial_space, const Space& space);
    double energy(const Change& change); 
};

} // namespace Faunus
#endif // FAUNUS_MONTECARLO_H