CanonicalConditions.cc

Go to the documentation of this file.

#include "casm/monte_carlo/canonical/CanonicalConditions.hh"
 
#include "casm/casm_io/container/json_io.hh"
#include "casm/clex/PrimClex.hh"
#include "casm/misc/CASM_Eigen_math.hh"
#include "casm/monte_carlo/MonteCarlo.hh"
#include "casm/monte_carlo/MonteSettings.hh"
 
namespace CASM {
namespace Monte {
 
CanonicalConditions::CanonicalConditions(const PrimClex &_primclex,
                                         double _temperature,
                                         const Eigen::VectorXd &_param_comp,
                                         double _tol)
    :
 
      m_primclex(&_primclex),
      m_tolerance(_tol) {
  // -- set T ----
  set_temperature(_temperature);
 
  // -- set mol composition per prim ----
  set_param_composition(_param_comp);
}
 
// ***************************************ACCESSORS**********************************************
// //
 
const PrimClex &CanonicalConditions::primclex() const { return *m_primclex; }
 
double CanonicalConditions::temperature() const { return m_temperature; }
 
double CanonicalConditions::beta() const { return m_beta; }
 
Eigen::VectorXd CanonicalConditions::param_composition() const {
  return m_param_composition;
}
 
double CanonicalConditions::param_composition(Index index) const {
  return m_param_composition(index);
}
 
Eigen::VectorXd CanonicalConditions::mol_composition() const {
  return primclex().composition_axes().mol_composition(m_param_composition);
}
 
double CanonicalConditions::mol_composition(Index index) const {
  return mol_composition()(index);
}
 
double CanonicalConditions::tolerance() const { return m_tolerance; }
 
// ***************************************MUTATORS***********************************************
// //
 
void CanonicalConditions::set_temperature(double in_temp) {
  m_temperature = in_temp;
  m_beta = 1.0 / (KB * m_temperature);
  return;
}
 
void CanonicalConditions::set_param_composition(
    const Eigen::VectorXd &in_param_comp) {
  m_param_composition = in_param_comp;
}
 
void CanonicalConditions::set_param_composition(Index ind,
                                                double in_param_comp) {
  m_param_composition(ind) = in_param_comp;
}
 
// ***************************************OPERATORS**********************************************
// //
 
CanonicalConditions &CanonicalConditions::operator+=(
    const CanonicalConditions &RHS) {
  m_temperature += RHS.m_temperature;
  m_param_composition += RHS.m_param_composition;
  m_beta = 1.0 / (CASM::KB * m_temperature);
  return *this;
}
 
CanonicalConditions CanonicalConditions::operator+(
    const CanonicalConditions &RHS) const {
  return CanonicalConditions(*this) += RHS;
}
 
CanonicalConditions &CanonicalConditions::operator-=(
    const CanonicalConditions &RHS) {
  m_temperature -= RHS.m_temperature;
  m_param_composition -= RHS.m_param_composition;
  m_beta = 1.0 / (CASM::KB * m_temperature);
  return *this;
}
 
CanonicalConditions CanonicalConditions::operator-(
    const CanonicalConditions &RHS) const {
  return CanonicalConditions(*this) -= RHS;
}
 
bool CanonicalConditions::operator==(const CanonicalConditions &RHS) const {
  if (!almost_zero(m_temperature - RHS.m_temperature, m_tolerance)) {
    return false;
  }
 
  if (!almost_zero(m_param_composition - RHS.m_param_composition,
                   m_tolerance)) {
    return false;
  }
 
  return true;
}
 
bool CanonicalConditions::operator!=(const CanonicalConditions &RHS) const {
  return !(*this == RHS);
}
 
int CanonicalConditions::operator/(const CanonicalConditions &RHS_inc) const {
  int max_division = 0;
 
  if (!almost_zero(RHS_inc.temperature())) {
    max_division = round(temperature() / RHS_inc.temperature());
  }
 
  for (Index i = 0; i < m_param_composition.size(); i++) {
    int temp_division =
        round(m_param_composition(i) / RHS_inc.m_param_composition(i));
 
    if (temp_division > max_division &&
        !almost_zero(RHS_inc.m_param_composition(i))) {
      max_division = temp_division;
    }
  }
 
  return max_division;
}
 
std::ostream &operator<<(std::ostream &sout, const CanonicalConditions &cond) {
  sout << "T: " << cond.temperature() << "\n";
  for (int i = 0; i < cond.param_composition().size(); i++) {
    jsonParser json;
    sout << "param_composition: "
         << to_json_array(cond.param_composition(), json) << "\n";
  }
  return sout;
}
 
}  // namespace Monte
}  // namespace CASM