MonteSampler.cc

Go to the documentation of this file.

#include "casm/monte_carlo/MonteSampler.hh"

#include "casm/monte_carlo/MonteCarlo.hh"

namespace CASM {

  // ---- 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);
  }

}