MonteSampler.hh

Go to the documentation of this file.

#ifndef CASM_MonteSampler_HH
#define CASM_MonteSampler_HH
 
#include "casm/casm_io/dataformatter/DataFormatter.hh"
#include "casm/clex/CompositionConverter.hh"
#include "casm/clex/Configuration.hh"
#include "casm/global/definitions.hh"
#include "casm/monte_carlo/MCData.hh"
#include "casm/monte_carlo/MonteCounter.hh"
 
namespace CASM {
namespace Monte {
 
class MonteCarlo;
 
class MonteSampler {
 public:
  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:
  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:
    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<size_type, size_type> m_last_sample;
  };
 
  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:
  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:
  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:
  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;
};
 
}  // namespace Monte
}  // namespace CASM
 
#endif