MonteSampler.cc

Go to the documentation of this file.

#include "casm/monte_carlo/MonteSampler.hh"
 
#include "casm/monte_carlo/MonteCarlo.hh"
 
namespace CASM {
namespace Monte {
 
// ---- MonteSampler Definitions ---------------------------------
 
MonteSampler::MonteSampler(const std::string &print_name,
                           double data_confidence, size_type data_initsize)
    : m_must_converge(false),
      m_conf(data_confidence),
      m_data(data_initsize),
      m_name(print_name) {}
 
MonteSampler::MonteSampler(const std::string &print_name, double data_prec,
                           double data_confidence, size_type data_initsize)
    : m_must_converge(true),
      m_prec(data_prec),
      m_conf(data_confidence),
      m_data(data_initsize),
      m_name(print_name) {}
 
// ---- ScalarMonteSampler Definitions ---------------------------------
 
ScalarMonteSampler::ScalarMonteSampler(std::string _property_name,
                                       std::string print_name,
                                       double data_confidence,
                                       size_type data_initsize)
    : MonteSampler(print_name, data_confidence, data_initsize),
      m_property_name(_property_name) {}
 
ScalarMonteSampler::ScalarMonteSampler(std::string _property_name,
                                       std::string print_name, double data_prec,
                                       double data_confidence,
                                       size_type data_initsize)
    : MonteSampler(print_name, data_prec, data_confidence, data_initsize),
      m_property_name(_property_name) {}
 
void ScalarMonteSampler::sample(const MonteCarlo &mc,
                                const MonteCounter &counter) {
  data().push_back(mc.scalar_property(m_property_name));
}
 
// ---- VectorMonteSampler Definitions ---------------------------------
 
VectorMonteSampler::VectorMonteSampler(std::string _property_name,
                                       size_type _index, std::string print_name,
                                       double data_confidence,
                                       size_type data_initsize)
    : MonteSampler(print_name, data_confidence, data_initsize),
      m_property_name(_property_name),
      m_index(_index) {}
 
VectorMonteSampler::VectorMonteSampler(std::string _property_name,
                                       size_type _index, std::string print_name,
                                       double data_prec, double data_confidence,
                                       size_type data_initsize)
    : MonteSampler(print_name, data_prec, data_confidence, data_initsize),
      m_property_name(_property_name),
      m_index(_index) {}
 
void VectorMonteSampler::sample(const MonteCarlo &mc,
                                const MonteCounter &counter) {
  data().push_back(mc.vector_property(m_property_name)(m_index));
}
 
// ---- QueryMonteSampler Definitions --------------------------------
 
QueryMonteSampler::Formatter::Formatter(
    const DataFormatter<Configuration> &formatter)
    : m_formatter(formatter),
      m_last_sample(std::numeric_limits<MonteCounter::size_type>::max(),
                    std::numeric_limits<MonteCounter::size_type>::max()) {}
 
const Eigen::VectorXd &QueryMonteSampler::Formatter::sample(
    const MonteCarlo &mc, const MonteCounter &counter) {
  auto curr_sample = std::make_pair(counter.pass(), counter.step());
  if (curr_sample != m_last_sample) {
    m_value = m_formatter.evaluate_as_matrix(mc.config()).row(0);
    m_last_sample = curr_sample;
  }
  return m_value;
}
 
QueryMonteSampler::QueryMonteSampler(
    std::shared_ptr<QueryMonteSampler::Formatter> formatter, size_type _index,
    std::string print_name, double data_confidence, size_type data_initsize)
    : MonteSampler(print_name, data_confidence, data_initsize),
      m_index(_index),
      m_formatter(formatter) {}
 
QueryMonteSampler::QueryMonteSampler(
    std::shared_ptr<QueryMonteSampler::Formatter> formatter, size_type _index,
    std::string print_name, double data_prec, double data_confidence,
    size_type data_initsize)
    : MonteSampler(print_name, data_prec, data_confidence, data_initsize),
      m_index(_index),
      m_formatter(formatter) {}
 
void QueryMonteSampler::sample(const MonteCarlo &mc,
                               const MonteCounter &counter) {
  data().push_back(m_formatter->sample(mc, counter)[m_index]);
}
 
// ---- CompMonteSampler Definitions ---------------------------------
 
CompMonteSampler::CompMonteSampler(size_type _index,
                                   const CompositionConverter &_comp_converter,
                                   std::string print_name,
                                   double data_confidence,
                                   size_type data_initsize)
    : MonteSampler(print_name, data_confidence, data_initsize),
      m_index(_index),
      m_comp_converter(_comp_converter) {}
 
CompMonteSampler::CompMonteSampler(size_type _index,
                                   const CompositionConverter &_comp_converter,
                                   std::string print_name, double data_prec,
                                   double data_confidence,
                                   size_type data_initsize)
    : MonteSampler(print_name, data_prec, data_confidence, data_initsize),
      m_index(_index),
      m_comp_converter(_comp_converter) {}
 
void CompMonteSampler::sample(const MonteCarlo &mc,
                              const MonteCounter &counter) {
  auto comp_n = mc.vector_property("comp_n");
  auto comp = m_comp_converter.param_composition(comp_n);
 
  data().push_back(comp(m_index));
}
 
// ---- SiteFracMonteSampler Definitions ---------------------------------
 
SiteFracMonteSampler::SiteFracMonteSampler(size_type _index,
                                           size_type _basis_size,
                                           std::string print_name,
                                           double data_confidence,
                                           size_type data_initsize)
    : MonteSampler(print_name, data_confidence, data_initsize),
      m_index(_index),
      m_basis_size(_basis_size) {}
 
SiteFracMonteSampler::SiteFracMonteSampler(
    size_type _index, size_type _basis_size, std::string print_name,
    double data_prec, double data_confidence, size_type data_initsize)
    : MonteSampler(print_name, data_prec, data_confidence, data_initsize),
      m_index(_index),
      m_basis_size(_basis_size) {}
 
void SiteFracMonteSampler::sample(const MonteCarlo &mc,
                                  const MonteCounter &counter) {
  data().push_back(mc.vector_property("comp_n")(m_index) / m_basis_size);
}
 
// ---- AtomFracMonteSampler Definitions ---------------------------------
 
AtomFracMonteSampler::AtomFracMonteSampler(size_type _index,
                                           size_type _vacancy_index,
                                           std::string print_name,
                                           double data_confidence,
                                           size_type data_initsize)
    : MonteSampler(print_name, data_confidence, data_initsize),
      m_index(_index),
      m_vacancy_index(_vacancy_index) {}
 
AtomFracMonteSampler::AtomFracMonteSampler(
    size_type _index, size_type _vacancy_index, std::string print_name,
    double data_prec, double data_confidence, size_type data_initsize)
    : MonteSampler(print_name, data_prec, data_confidence, data_initsize),
      m_index(_index),
      m_vacancy_index(_vacancy_index) {}
 
void AtomFracMonteSampler::sample(const MonteCarlo &mc,
                                  const MonteCounter &counter) {
  double atom_sum = 0.0;
  for (size_type i = 0; i < mc.vector_property("comp_n").size(); ++i) {
    if (i != m_vacancy_index) {
      atom_sum += mc.vector_property("comp_n")(i);
    }
  }
 
  data().push_back(mc.vector_property("comp_n")(m_index) / atom_sum);
}
 
}  // namespace Monte
}  // namespace CASM