MonteSampler.hh

Go to the documentation of this file.

#ifndef CASM_MonteSampler_HH
#define CASM_MonteSampler_HH

#include "casm/CASM_global_definitions.hh"
#include "casm/monte_carlo/MCData.hh"
#include "casm/monte_carlo/MonteCounter.hh"
#include "casm/clex/CompositionConverter.hh"
#include "casm/casm_io/DataFormatter.hh"
#include "casm/clex/Configuration.hh"

namespace CASM {

  class MonteCarlo;

  class MonteSampler {

  public:

    typedef MCData::size_type size_type;

    MonteSampler(const std::string &print_name,
                 double data_confidence,
                 size_type data_initsize);

    MonteSampler(const std::string &print_name,
                 double data_prec,
                 double data_confidence,
                 size_type data_initsize);

    virtual ~MonteSampler() {}


    virtual void sample(const MonteCarlo &mc, const MonteCounter &counter) {
      throw std::runtime_error("Error: MonteSampler base class used to sample");
    }

    void clear() {
      m_data.clear();
    }

    std::pair<bool, size_type> is_equilibrated() const {

      if(!must_converge()) {
        return std::make_pair(false, m_data.size());
      }

      if(!m_convergence_uptodate) {
        m_equilibration = MCDataEquilibration(m_data.observations(), m_prec);
        m_equilibration_uptodate = true;
      }

      return std::make_pair(m_equilibration.is_equilibrated(), m_equilibration.equilibration_samples());
    }

    bool must_converge() const {
      return m_must_converge;
    }

    double requested_precision() const {
      return m_prec;
    }

    bool is_converged(size_type equil_samples) const {

      if(!must_converge()) {
        return false;
      }

      // if not calculated, or calculated for a different range of data, re-calculate
      if(!m_convergence_uptodate || m_convergence_start_sample != equil_samples) {
        _check_convergence(equil_samples);
      }

      return m_convergence.is_converged(m_prec);
    }

    double mean(size_type equil_samples) const {

      // if not calculated, or calculated for a different range of data, re-calculate
      if(!m_convergence_uptodate || m_convergence_start_sample != equil_samples) {
        _check_convergence(equil_samples);
      }

      return m_convergence.mean();
    }

    double squared_norm(size_type equil_samples) const {

      // if not calculated, or calculated for a different range of data, re-calculate
      if(!m_convergence_uptodate || m_convergence_start_sample != equil_samples) {
        _check_convergence(equil_samples);
      }

      return m_convergence.squared_norm();
    }

    double calculated_precision(size_type equil_samples) const {

      // if not calculated, or calculated for a different range of data, re-calculate
      if(!m_convergence_uptodate || m_convergence_start_sample != equil_samples) {
        _check_convergence(equil_samples);
      }

      return m_convergence.calculated_precision();
    }

    const MCData &data() const {
      return m_data;
    }

    std::string name() const {
      return m_name;
    }

    std::unique_ptr<MonteSampler> clone() const {
      return std::unique_ptr<MonteSampler>(this->_clone());
    }


  protected:

    MCData &data() {
      m_convergence_uptodate = false;
      m_equilibration_uptodate = false;
      return m_data;
    }

  private:

    virtual MonteSampler *_clone() const {
      return new MonteSampler(*this);
    }

    void _check_convergence(size_type equil_samples) const {

      m_convergence_start_sample = equil_samples;
      m_convergence = MCDataConvergence(m_data.observations().segment(equil_samples, m_data.observations().size() - equil_samples), m_conf);
      m_convergence_uptodate = true;
    }

    bool m_must_converge;

    double m_prec;

    double m_conf;

    MCData m_data;

    std::string m_name;

    // enable storing equilibration and convergence info

    mutable bool m_equilibration_uptodate = false;
    mutable MCDataEquilibration m_equilibration;
    mutable bool m_convergence_uptodate = false;
    mutable size_type m_convergence_start_sample = 0;
    mutable MCDataConvergence m_convergence;
  };


  class ScalarMonteSampler : public MonteSampler {

  public:

    ScalarMonteSampler(std::string _property_name,
                       std::string print_name,
                       double data_confidence,
                       size_type data_initsize);

    ScalarMonteSampler(std::string _property_name,
                       std::string print_name,
                       double data_prec,
                       double data_confidence,
                       size_type data_initsize);


    void sample(const MonteCarlo &mc, const MonteCounter &counter);

    std::unique_ptr<ScalarMonteSampler> clone() const {
      return std::unique_ptr<ScalarMonteSampler>(this->_clone());
    }

  private:

    virtual ScalarMonteSampler *_clone() const {
      return new ScalarMonteSampler(*this);
    }

    std::string m_property_name;

  };

  class VectorMonteSampler : public MonteSampler {

  public:

    typedef Index size_type;

    VectorMonteSampler(std::string _property_name,
                       size_type _index,
                       std::string print_name,
                       double data_confidence,
                       size_type data_initsize);

    VectorMonteSampler(std::string _property_name,
                       size_type _index,
                       std::string print_name,
                       double data_prec,
                       double data_confidence,
                       size_type data_initsize);


    void sample(const MonteCarlo &mc, const MonteCounter &counter);

    std::unique_ptr<VectorMonteSampler> clone() const {
      return std::unique_ptr<VectorMonteSampler>(this->_clone());
    }

  private:

    virtual VectorMonteSampler *_clone() const {
      return new VectorMonteSampler(*this);
    }

    std::string m_property_name;

    size_type m_index;

  };

  class QueryMonteSampler : public MonteSampler {

  public:

    class Formatter {

    public:

      typedef Index size_type;

      Formatter(const DataFormatter<Configuration> &formatter);

      DataFormatter<Configuration> &get() {
        return m_formatter;
      }

      const DataFormatter<Configuration> &get() const {
        return m_formatter;
      }

      const Eigen::VectorXd &sample(const MonteCarlo &mc, const MonteCounter &counter);

    private:

      DataFormatter<Configuration> m_formatter;
      Eigen::VectorXd m_value;
      std::pair<MonteCounter::size_type, MonteCounter::size_type> m_last_sample;
    };

    typedef Index size_type;

    QueryMonteSampler(std::shared_ptr<QueryMonteSampler::Formatter> formatter,
                      size_type _index,
                      std::string print_name,
                      double data_confidence,
                      size_type data_initsize);

    QueryMonteSampler(std::shared_ptr<QueryMonteSampler::Formatter> formatter,
                      size_type _index,
                      std::string print_name,
                      double data_prec,
                      double data_confidence,
                      size_type data_initsize);


    void sample(const MonteCarlo &mc, const MonteCounter &counter);

    std::unique_ptr<QueryMonteSampler> clone() const {
      return std::unique_ptr<QueryMonteSampler>(this->_clone());
    }

  private:

    virtual QueryMonteSampler *_clone() const {
      return new QueryMonteSampler(*this);
    }

    size_type m_index;
    std::shared_ptr<QueryMonteSampler::Formatter> m_formatter;
  };

  class CompMonteSampler : public MonteSampler {

  public:

    typedef Index size_type;

    CompMonteSampler(size_type _index,
                     const CompositionConverter &_comp_converter,
                     std::string print_name,
                     double data_confidence,
                     size_type data_initsize);

    CompMonteSampler(size_type _index,
                     const CompositionConverter &_comp_converter,
                     std::string print_name,
                     double data_prec,
                     double data_confidence,
                     size_type data_initsize);


    void sample(const MonteCarlo &mc, const MonteCounter &counter);

    std::unique_ptr<CompMonteSampler> clone() const {
      return std::unique_ptr<CompMonteSampler>(this->_clone());
    }

  private:

    virtual CompMonteSampler *_clone() const {
      return new CompMonteSampler(*this);
    }

    size_type m_index;

    CompositionConverter m_comp_converter;

  };


  class SiteFracMonteSampler : public MonteSampler {

  public:

    typedef Index size_type;

    SiteFracMonteSampler(size_type _index,
                         size_type _basis_size,
                         std::string print_name,
                         double data_confidence,
                         size_type data_initsize);

    SiteFracMonteSampler(size_type _index,
                         size_type _basis_size,
                         std::string print_name,
                         double data_prec,
                         double data_confidence,
                         size_type data_initsize);


    void sample(const MonteCarlo &mc, const MonteCounter &counter);

    std::unique_ptr<SiteFracMonteSampler> clone() const {
      return std::unique_ptr<SiteFracMonteSampler>(this->_clone());
    }

  private:

    virtual SiteFracMonteSampler *_clone() const {
      return new SiteFracMonteSampler(*this);
    }

    size_type m_index;

    size_type m_basis_size;

  };


  class AtomFracMonteSampler : public MonteSampler {

  public:

    typedef Index size_type;

    AtomFracMonteSampler(size_type _index,
                         size_type _vacancy_index,
                         std::string print_name,
                         double data_confidence,
                         size_type data_initsize);

    AtomFracMonteSampler(size_type _index,
                         size_type _vacancy_index,
                         std::string print_name,
                         double data_prec,
                         double data_confidence,
                         size_type data_initsize);


    void sample(const MonteCarlo &mc, const MonteCounter &counter);

    std::unique_ptr<AtomFracMonteSampler> clone() const {
      return std::unique_ptr<AtomFracMonteSampler>(this->_clone());
    }

  private:

    virtual AtomFracMonteSampler *_clone() const {
      return new AtomFracMonteSampler(*this);
    }

    size_type m_index;

    size_type m_vacancy_index;

  };

}

#endif