ChemicalReference.hh

Go to the documentation of this file.

#ifndef CASM_ChemicalReference
#define CASM_ChemicalReference
 
#include "casm/clex/Reference.hh"
 
namespace CASM {
namespace xtal {
class BasicStructure;
class Site;
}  // namespace xtal
using xtal::BasicStructure;
using xtal::Site;
 
class PrimClex;
 
struct ChemicalReferenceState {
  ChemicalReferenceState() {}
 
  ChemicalReferenceState(const Configuration &config,
                         std::function<Eigen::VectorXd(Configuration)> n,
                         std::function<double(Configuration)> e);
 
  std::map<std::string, double> species_num;
 
  double energy_per_species;
};
 
class ChemicalReference : public HyperPlaneReferenceBase {
 public:
  typedef std::vector<ChemicalReferenceState> RefStateVec;
  typedef std::map<std::string, RefStateVec> RefStateMap;
  typedef Index size_type;
 
  static const std::string Name;
  static const std::string Desc;
 
  explicit ChemicalReference(const BasicStructure &prim,
                             const Eigen::VectorXd &_global_ref,
                             SpecializedRef _supercell_ref = SpecializedRef(),
                             SpecializedRef _config_ref = SpecializedRef());
 
  template <typename RefStateIterator>
  explicit ChemicalReference(const BasicStructure &prim, RefStateIterator begin,
                             RefStateIterator end, double tol);
 
  std::unique_ptr<ChemicalReference> clone() const;
 
  const BasicStructure &prim() const;
 
  // --- Global reference ---
 
  const Eigen::VectorXd &global() const;
 
  void set_global(const Eigen::VectorXd &ref);
 
  template <typename RefStateIterator>
  void set_global(RefStateIterator begin, RefStateIterator end, double tol);
 
  const RefStateVec &global_ref_states() const;
 
  // --- Supercell specialized references ---
 
  const std::map<std::string, Eigen::VectorXd> &supercell() const;
 
  void set_supercell(const std::string &scelname, const Eigen::VectorXd &ref);
 
  template <typename RefStateIterator>
  void set_supercell(const std::string &scelname, RefStateIterator begin,
                     RefStateIterator end, double tol);
 
  size_type erase_supercell(const std::string &scelname);
 
  const RefStateMap &supercell_ref_states() const;
 
  // --- Configuration specialized references ---
 
  const std::map<std::string, Eigen::VectorXd> &config() const;
 
  void set_config(const std::string &configname, const Eigen::VectorXd &ref);
 
  template <typename RefStateIterator>
  void set_config(const std::string &configname, RefStateIterator begin,
                  RefStateIterator end, double tol);
 
  size_type erase_config(const std::string &configname);
 
  const RefStateMap &config_ref_states() const;
 
  template <typename RefStateIterator>
  static Eigen::VectorXd hyperplane(const BasicStructure &prim,
                                    RefStateIterator begin,
                                    RefStateIterator end, double tol);
 
 private:
  Eigen::VectorXd &_global();
 
  std::map<std::string, Eigen::VectorXd> &_supercell();
 
  std::map<std::string, Eigen::VectorXd> &_config();
 
  // --- For use in hyperplane() ------
 
  static Eigen::VectorXd _calc_hyperplane(
      const BasicStructure &prim,
      const std::vector<std::string> &struc_mol_name, Eigen::MatrixXd N,
      Eigen::VectorXd E, double tol);
 
  ChemicalReference *_clone() const;
 
  // \brief non-owning pointer to const primitive BasicStructure
  const BasicStructure *m_prim;
 
  // --- Store ChemicalReferenceState if known ----
 
  RefStateVec m_global_ref_vec;
  RefStateMap m_supercell_ref_map;
  RefStateMap m_config_ref_map;
};
 
ChemicalReference auto_chemical_reference(const PrimClex &primclex,
                                          double lin_alg_tol);
 
struct ChemicalReferencePrinter {
  // -- constructor --
  ChemicalReferencePrinter(std::ostream &_stream, const ChemicalReference &_ref,
                           int _indent = 0, int _indent_incr = 2);
 
  // -- data --
  std::ostream &stream;
  int indent;
  int indent_incr;
  const ChemicalReference &ref;
  std::vector<std::string> struc_mol_name;
 
  void incr();
 
  void decr();
 
  // print regular string
  void print(const std::string &str);
 
  // print plane as '<indent>mol_i(1): energy_per_species\n', for each molecule
  void print(const Eigen::VectorXd &plane);
 
  // print plane as:
  // \code
  // <indent>mol_i(N_i)mol_j(N_j)...: energy_per_species //for each ref state
  // ...
  // \endcode
  void print(const std::vector<ChemicalReferenceState> &ref_state_vec);
 
  // print supercell/config specific plane as:
  // \code
  // <indent>name:
  // <indent>  mol_i: energy_per_species // for each molecule
  // \endcode
  void print(const std::pair<std::string, Eigen::VectorXd> &_pair);
 
  // print supercell/config specific ref states as:
  // \code
  // <indent>name:
  // <indent>  mol_i(N_i)mol_j(N_j)...: energy_per_species // for each ref state
  // \endcode
  void print(const std::pair<std::string, std::vector<ChemicalReferenceState> >
                 &_pair);
 
  void print_global();
 
  void print_supercell();
 
  void print_supercell(const std::string &name);
 
  void print_config();
 
  void print_config(const std::string &name);
 
  void print_all();
};
 
}  // namespace CASM
 
#endif