Configuration.hh

Go to the documentation of this file.

#ifndef CASM_Configuration
#define CASM_Configuration
 
#include <map>
#include <memory>
 
#include "casm/clex/Calculable.hh"
#include "casm/clex/ConfigDoF.hh"
#include "casm/clex/ConfigurationTraits.hh"
#include "casm/clex/HasCanonicalForm.hh"
#include "casm/clex/HasSupercell.hh"
#include "casm/clusterography/ClusterDecl.hh"
#include "casm/crystallography/UnitCellCoord.hh"
#include "casm/database/Cache.hh"
#include "casm/database/Database.hh"
#include "casm/database/Named.hh"
#include "casm/misc/Comparisons.hh"
#include "casm/symmetry/PermuteIterator.hh"
 
namespace CASM {
namespace xtal {
class Molecule;
class UnitCellCoord;
}  // namespace xtal
using xtal::Molecule;
using xtal::UnitCellCoord;
 
class IntegralCluster;
class PrimClex;
class Supercell;
class Clexulator;
class ConfigIsEquivalent;
template <typename ConfigType, typename IsEqualImpl>
class GenericConfigCompare;
using ConfigCompare = GenericConfigCompare<Configuration, ConfigIsEquivalent>;
 
struct ConfigInsertResult;
struct RefToCanonicalPrim;
 
 
typedef ConfigCanonicalForm<
    HasSupercell<Comparisons<Calculable<CRTPBase<Configuration>>>>>
    ConfigurationBase;
 
//    the supercell (i.e. the translationally unique perturbation), plus the
//    values of the
class Configuration : public ConfigurationBase {
 public:
  //********* CONSTRUCTORS *********
 
  explicit Configuration(
      std::shared_ptr<Supercell const> const &_supercell_ptr);
 
  explicit Configuration(std::shared_ptr<Supercell const> const &_supercell_ptr,
                         ConfigDoF const &_dof);
 
  static Configuration zeros(
      const std::shared_ptr<Supercell const> &_supercell_ptr);
 
  static Configuration zeros(
      const std::shared_ptr<Supercell const> &_supercell_ptr, double _tol);
 
  // *** The following constructors should be avoided in new code, if possible
  //
  //     They are currently still required in some code. In the future:
  //     - Configuration will make exclusive use of std::shared_ptr<Supercell
  //     const>
  //     - The jsonConstructor<Configuration>::from_json method will be used to
  //       construct Configuration from JSON
 
  explicit Configuration(Supercell const &_supercell);
 
  explicit Configuration(const Supercell &_supercell, const ConfigDoF &_dof);
 
  static Configuration zeros(Supercell const &_scel);
 
  static Configuration zeros(Supercell const &_scel, double _tol);
 
  // ******** Supercell **********************
 
  const Supercell &supercell() const;
 
  const Lattice &ideal_lattice() const;
 
  Index size() const;
 
  UnitCellCoord uccoord(Index site_l) const;
 
  Index linear_index(const UnitCellCoord &bijk) const;
 
  int sublat(Index site_l) const;
 
  // ******** Degrees of Freedom **************
  //
  // ** Note: Calculated properties are not automatically updated when dof are
  // changed, **
  // **       nor are the written records automatically updated **
 
  const ConfigDoF &configdof() const { return m_configdof; }
 
  ConfigDoF &configdof() {
    _modify_dof();
    return m_configdof;
  }
 
  void clear();
 
  // ----- Occupation ------------
 
  void init_occupation();
 
  void set_occupation(Eigen::Ref<const Eigen::VectorXi> const &_occupation) {
    configdof().set_occupation(_occupation);
  }
 
  Eigen::VectorXi const &occupation() const { return configdof().occupation(); }
 
  void set_occ(Index site_l, int val);
 
  const int &occ(Index site_l) const { return configdof().occ(site_l); }
 
  const Molecule &mol(Index site_l) const;
 
  bool has_occupation() const { return configdof().has_occupation(); }
 
  // void clear_occupation();
 
  // ******** Comparisons, Symmetry, Crystallography  ******
 
  bool operator<(const Configuration &B) const;
 
  ConfigCompare less() const;
 
  ConfigIsEquivalent equal_to() const;
 
  bool is_primitive() const;
 
  PermuteIterator find_translation() const;
 
  Configuration primitive() const;
 
  Configuration in_canonical_supercell() const;
 
  std::vector<PermuteIterator> factor_group() const;
 
  using ConfigurationBase::invariant_subgroup;
  std::vector<PermuteIterator> invariant_subgroup() const;
 
  using ConfigurationBase::is_canonical;
  bool is_canonical() const;
 
  int multiplicity() const;
 
  std::vector<PermuteIterator> point_group() const;
 
  std::string point_group_name() const;
 
  Configuration &apply_sym(const PermuteIterator &it);
 
  //********** Composition ***********
 
  // Returns composition on each sublattice: sublat_comp[ prim basis site /
  // sublattice][ molecule_type]
  //   molucule_type is ordered as in the Prim structure's site_occupant list
  //   for that basis site (includes vacancies)
  std::vector<Eigen::VectorXd> sublattice_composition() const;
 
  // Returns number of each molecule by sublattice:
  //   sublat_num_each_molecule[ prim basis site / sublattice ][ molecule_type]
  //   molucule_type is ordered as in the Prim structure's site_occupant list
  //   for that basis site
  std::vector<Eigen::VectorXi> sublat_num_each_molecule() const;
 
  // Returns composition, not counting vacancies
  //    composition[ molecule_type ]: molecule_type ordered as prim structure's
  //    get_struc_molecule(), with [Va]=0.0
  Eigen::VectorXd composition() const;
 
  // Returns composition, including vacancies
  //    composition[ molecule_type ]: molecule_type ordered as prim structure's
  //    get_struc_molecule()
  Eigen::VectorXd true_composition() const;
 
  Eigen::VectorXi num_each_molecule() const;
 
  Eigen::VectorXd param_composition() const;
 
  Eigen::VectorXd num_each_component() const;
 
  //********* IO ************
 
  ConfigInsertResult insert(bool primitive_only = false) const;
 
  // /// Writes the Configuration to JSON
  // jsonParser &to_json(jsonParser &json) const;
  //
  // /// Reads the Configuration from JSON
  // void from_json(const jsonParser &json, const Supercell &scel,
  //                std::string _id);
  //
  // /// Reads the Configuration from JSON
  // void from_json(const jsonParser &json, const PrimClex &primclex,
  //                std::string _configname);
 
  static std::pair<std::string, std::string> split_name(std::string configname);
 
 private:
  friend struct Comparisons<Calculable<CRTPBase<Configuration>>>;
  friend class DB::Named<CRTPBase<Configuration>>;
 
  std::string generate_name_impl() const;
 
  bool eq_impl(const Configuration &B) const;
 
  Supercell const *m_supercell;
 
  std::shared_ptr<Supercell const> m_supercell_ptr;
 
  ConfigDoF m_configdof;
};
 
struct ConfigInsertResult {
  typedef DB::DatabaseIterator<Configuration> iterator;
 
  bool insert_primitive;
 
  iterator primitive_it;
 
  bool insert_canonical;
 
  iterator canonical_it;
};
 
struct RefToCanonicalPrim {
  RefToCanonicalPrim(const Configuration &_config);
 
  std::string name() const;
 
  Configuration config;
  Configuration prim_canon_config;
  SymOp from_canonical_lat;
  PermuteIterator from_canonical_config;
  Eigen::Matrix3i transf_mat;
};
 
Configuration sub_configuration(std::shared_ptr<Supercell const> sub_scel_ptr,
                                const Configuration &super_config,
                                const UnitCell &origin = UnitCell(0, 0, 0));
 
Configuration make_configuration(const PrimClex &primclex, std::string name);
 
Eigen::VectorXd correlations(const Configuration &config,
                             Clexulator const &clexulator);
 
Eigen::VectorXd corr_contribution(Index linear_unitcell_index,
                                  const Configuration &config,
                                  Clexulator const &clexulator);
 
Eigen::VectorXd point_corr(Index linear_unitcell_index, Index neighbor_index,
                           const Configuration &config,
                           Clexulator const &clexulator);
 
Eigen::MatrixXd gradcorrelations(const Configuration &config,
                                 Clexulator const &clexulator, DoFKey &key);
 
Eigen::VectorXd comp(const Configuration &config);
 
Eigen::VectorXd comp_n(const Configuration &config);
 
double n_vacancy(const Configuration &config);
 
double n_species(const Configuration &config);
 
Eigen::VectorXd species_frac(const Configuration &config);
 
Eigen::VectorXd site_frac(const Configuration &config);
 
double energy(const Configuration &config);
 
double energy_per_species(const Configuration &config);
 
double reference_energy(const Configuration &config);
 
double reference_energy_per_species(const Configuration &config);
 
double formation_energy(const Configuration &config);
 
double formation_energy_per_species(const Configuration &config);
 
double clex_formation_energy(const Configuration &config);
 
double clex_formation_energy_per_species(const Configuration &config);
 
double rms_force(const Configuration &_config);
 
double atomic_deformation(const Configuration &_config);
 
double lattice_deformation(const Configuration &_config);
 
double volume_relaxation(const Configuration &_config);
 
double relaxed_magmom(const Configuration &_config);
 
double relaxed_magmom_per_species(const Configuration &_config);
 
Eigen::MatrixXd relaxed_forces(const Configuration &_config);
 
Eigen::MatrixXd relaxed_forces(const Configuration &_config);
 
IntegralCluster config_diff(const Configuration &_config1,
                            const Configuration &_config2);
 
Configuration closest_setting(const Configuration &_config1,
                              const Configuration &_config2);
 
Configuration config_clip(const Configuration &_config,
                          const Configuration &_bg, IntegralCluster &_clust);
 
bool is_primitive(const Configuration &_config);
 
bool is_canonical(const Configuration &_config);
 
bool is_diff_trans_endpoint(const Configuration &_config);
 
std::string diff_trans_endpoint_of(const Configuration &_config);
 
bool has_energy(const Configuration &_config);
 
bool has_reference_energy(const Configuration &_config);
 
bool has_formation_energy(const Configuration &_config);
 
bool has_rms_force(const Configuration &_config);
 
bool has_atomic_deformation(const Configuration &_config);
 
bool has_lattice_deformation(const Configuration &_config);
 
bool has_volume_relaxation(const Configuration &_config);
 
bool has_relaxed_magmom(const Configuration &_config);
 
bool has_relaxed_mag_basis(const Configuration &_config);
 
Eigen::VectorXd correlations(const ConfigDoF &configdof, const Supercell &scel,
                             Clexulator const &clexulator);
 
Eigen::VectorXd corr_contribution(Index linear_unitcell_index,
                                  const ConfigDoF &configdof,
                                  const Supercell &scel,
                                  Clexulator const &clexulator);
 
Eigen::VectorXd point_corr(Index linear_unitcell_index, Index neighbor_index,
                           const ConfigDoF &configdof, const Supercell &scel,
                           Clexulator const &clexulator);
 
Eigen::MatrixXd gradcorrelations(const ConfigDoF &configdof,
                                 const Supercell &scel,
                                 Clexulator const &clexulator, DoFKey &key);
 
Eigen::VectorXi num_each_molecule(const ConfigDoF &configdof,
                                  const Supercell &scel);
 
Eigen::VectorXd comp_n(const ConfigDoF &configdof, const Supercell &scel);
 
}  // namespace CASM
 
#endif