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/MonteDefinitions.hh"
#include "casm/monte_carlo/MonteCarlo.hh"
#include "casm/monte_carlo/MonteCarloEnum.hh"
#include "casm/monte_carlo/SiteExchanger.hh"
#include "casm/monte_carlo/grand_canonical/GrandCanonicalEvent.hh"
#include "casm/monte_carlo/grand_canonical/GrandCanonicalConditions.hh"
#include "casm/monte_carlo/grand_canonical/GrandCanonicalSettings.hh"


namespace CASM {

  class GrandCanonical : public MonteCarlo {

  public:

    static const Monte::ENSEMBLE ensemble;
    typedef GrandCanonicalEvent EventType;
    typedef GrandCanonicalConditions CondType;
    typedef GrandCanonicalSettings SettingsType;


    GrandCanonical(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 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 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;


    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 &_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;

  };

}

#endif