GrandCanonical.hh

Go to the documentation of this file.

#ifndef CASM_GrandCanonical_HH
#define CASM_GrandCanonical_HH
 
#include "casm/clex/Clex.hh"
#include "casm/monte_carlo/MonteCarlo.hh"
#include "casm/monte_carlo/MonteCarloEnum.hh"
#include "casm/monte_carlo/MonteDefinitions.hh"
#include "casm/monte_carlo/SiteExchanger.hh"
#include "casm/monte_carlo/grand_canonical/GrandCanonicalConditions.hh"
#include "casm/monte_carlo/grand_canonical/GrandCanonicalEvent.hh"
#include "casm/monte_carlo/grand_canonical/GrandCanonicalSettings.hh"
 
namespace CASM {
namespace Monte {
 
class GrandCanonical : public MonteCarlo {
 public:
  static const ENSEMBLE ensemble;
  typedef GrandCanonicalEvent EventType;
  typedef GrandCanonicalConditions CondType;
  typedef GrandCanonicalSettings SettingsType;
 
  GrandCanonical(const PrimClex &primclex, const SettingsType &settings,
                 Log &_log);
 
  size_type steps_per_pass() const;
 
  const CondType &conditions() const;
 
  void set_conditions(const CondType &new_conditions);
 
  void set_configdof(const ConfigDoF &configdof, const std::string &msg = "");
 
  std::pair<ConfigDoF, std::string> set_state(
      const GrandCanonicalConditions &new_conditions,
      const GrandCanonicalSettings &settings);
 
  void set_state(const CondType &new_conditions, const ConfigDoF &configdof,
                 const std::string &msg = "");
 
  const EventType &propose();
 
  bool check(const EventType &event);
 
  void accept(const EventType &event);
 
  void reject(const EventType &event);
 
  void write_results(size_type cond_index) const;
 
  double lte_grand_canonical_free_energy() const;
 
  const double &formation_energy() const { return *m_formation_energy; }
 
  const double &potential_energy() const { return *m_potential_energy; }
 
  const Eigen::VectorXd &corr() const { return *m_corr; }
 
  const Eigen::VectorXd &comp_n() const { return *m_comp_n; }
 
  double potential_energy(const Configuration &config) const;
 
 private:
  double &_formation_energy() { return *m_formation_energy; }
 
  double &_potential_energy() { return *m_potential_energy; }
 
  Eigen::VectorXd &_corr() { return *m_corr; }
 
  Eigen::VectorXd &_comp_n() { return *m_comp_n; }
 
  Clexulator const &_clexulator() const {
    return m_formation_energy_clex.clexulator;
  }
 
  const ECIContainer &_eci() const { return m_formation_energy_clex.eci; }
 
  void _set_dCorr(GrandCanonicalEvent &event, Index mutating_site, int sublat,
                  int current_occupant, int new_occupant, bool use_deltas,
                  bool all_correlations) const;
 
  void _print_correlations(const Eigen::VectorXd &corr, std::string title,
                           std::string colheader, bool all_correlations) const;
 
  void _update_deltas(GrandCanonicalEvent &event, Index mutating_site,
                      int sublat, int current_occupant, int new_occupant) const;
 
  void _update_properties();
 
  ConfigDoF _default_motif() const;
 
  std::pair<ConfigDoF, std::string> _auto_motif(
      const GrandCanonicalConditions &cond) const;
 
  std::pair<ConfigDoF, std::string> _restricted_auto_motif(
      const GrandCanonicalConditions &cond) const;
 
  ConfigDoF _configname_motif(const std::string &configname) const;
 
  const SiteExchanger m_site_swaps;
 
  GrandCanonicalConditions m_condition;
 
  Clex m_formation_energy_clex;
 
  bool m_all_correlations;
 
  EventType m_event;
 
  bool m_use_deltas;
 
  // ---- Pointers to properties for faster access
 
  double *m_formation_energy;
 
  double *m_potential_energy;
 
  Eigen::VectorXd *m_corr;
 
  Eigen::VectorXd *m_comp_n;
};
 
}  // namespace Monte
}  // namespace CASM
 
#endif