Canonical.hh

Go to the documentation of this file.

#ifndef CASM_Canonical_HH
#define CASM_Canonical_HH
 
#include "casm/clex/Clex.hh"
#include "casm/monte_carlo/Conversions.hh"
#include "casm/monte_carlo/MonteCarlo.hh"
#include "casm/monte_carlo/MonteDefinitions.hh"
#include "casm/monte_carlo/OccCandidate.hh"
#include "casm/monte_carlo/OccLocation.hh"
#include "casm/monte_carlo/canonical/CanonicalConditions.hh"
#include "casm/monte_carlo/canonical/CanonicalEvent.hh"
#include "casm/monte_carlo/canonical/CanonicalSettings.hh"
 
namespace CASM {
namespace Monte {
 
class Canonical : public MonteCarlo {
 public:
  static const ENSEMBLE ensemble;
  typedef CanonicalEvent EventType;
  typedef CanonicalConditions CondType;
  typedef CanonicalSettings SettingsType;
 
  Canonical(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 CanonicalConditions &new_conditions,
      const CanonicalSettings &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;
 
  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_nlist(size_type l) const;
  void _calc_delta_point_corr(size_type l, int new_occ,
                              Eigen::VectorXd &dCorr_comp) const;
 
  void _set_dCorr(CanonicalEvent &event) const;
 
  void _print_correlations(const Eigen::VectorXd &corr, std::string title,
                           std::string colheader, bool all_correlations) const;
 
  void _update_deltas(CanonicalEvent &event) const;
 
  void _update_properties();
 
  ConfigDoF _default_motif() const;
 
  std::pair<ConfigDoF, std::string> _auto_motif(
      const CanonicalConditions &cond) const;
 
  std::pair<ConfigDoF, std::string> _restricted_auto_motif(
      const CanonicalConditions &cond) const;
 
  ConfigDoF _configname_motif(const std::string &configname) const;
 
  void _make_possible_swaps(const CanonicalSettings &settings);
 
  std::vector<OccSwap>::const_iterator _find_grand_canonical_swap(
      const Configuration &config, std::vector<OccSwap>::const_iterator begin,
      std::vector<OccSwap>::const_iterator end);
 
  ConfigDoF _enforce_conditions(const ConfigDoF &configdof);
 
  Clex m_formation_energy_clex;
 
  Conversions m_convert;
 
  OccCandidateList m_cand;
 
  bool m_all_correlations;
 
  bool m_use_deltas;
 
  OccLocation m_occ_loc;
 
  CanonicalConditions m_condition;
 
  CanonicalEvent m_event;
 
  // ---- 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