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/MonteDefinitions.hh"
#include "casm/monte_carlo/MonteCarlo.hh"
#include "casm/monte_carlo/MonteCarloEnum.hh"
#include "casm/monte_carlo/Conversions.hh"
#include "casm/monte_carlo/OccCandidate.hh"
#include "casm/monte_carlo/OccLocation.hh"
#include "casm/monte_carlo/canonical/CanonicalEvent.hh"
#include "casm/monte_carlo/canonical/CanonicalConditions.hh"
#include "casm/monte_carlo/canonical/CanonicalSettings.hh"


namespace CASM {
  namespace Monte {

    class Canonical : public MonteCarlo {

    public:

      static const Monte::ENSEMBLE ensemble;
      typedef CanonicalEvent EventType;
      typedef CanonicalConditions CondType;
      typedef CanonicalSettings SettingsType;


      Canonical(PrimClex &primclex, const SettingsType &settings, Log &_log);


      Index 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 check_corr() {
        std::cout << "corr:" << std::endl;
        std::cout << correlations_vec(_configdof(), supercell(), _clexulator()) << std::endl;
        std::cout << "OK corr" << std::endl;
      }

      void write_results(Index 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 &_clexulator() const {
        return m_formation_energy_clex.clexulator();
      }

      const ECIContainer &_eci() const {
        return m_formation_energy_clex.eci();
      }

      void _set_nlist(Index l) const;
      void _calc_delta_point_corr(Index 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;

    };
  }
}

#endif