Configuration.hh

Go to the documentation of this file.

#ifndef CASM_Configuration
#define CASM_Configuration

#include <map>

#include "casm/external/boost.hh"

#include "casm/misc/Comparisons.hh"
#include "casm/misc/cloneable_ptr.hh"
#include "casm/container/Array.hh"
#include "casm/container/LinearAlgebra.hh"
#include "casm/symmetry/PermuteIterator.hh"
#include "casm/clex/Properties.hh"
#include "casm/clex/Correlation.hh"
#include "casm/clusterography/Orbitree.hh"
#include "casm/clex/ConfigDoF.hh"
#include "casm/clex/ConfigIterator.hh"

namespace CASM {

  class PrimClex;
  class Supercell;
  class UnitCellCoord;
  class Clexulator;
  class FillSupercell;
  template<typename ConfigType, typename PrimClexType>
  class ConfigIterator;


  namespace ConfigIO {
    class Selected;
  }
  template <bool IsConst> class ConfigSelection;
  typedef ConfigSelection<true> ConstConfigSelection;

  template<typename DataObject> struct QueryTraits;

  template<>
  struct QueryTraits<Configuration> {
    static const std::string name;
    typedef ConfigIO::Selected Selected;
    typedef ConstConfigSelection Selection;
  };



  struct ConfigInsertResult {

    typedef ConfigIterator<const Configuration, const PrimClex> config_const_iterator;

    bool insert_primitive;

    config_const_iterator primitive_it;

    bool insert_canonical;

    config_const_iterator canonical_it;

  };

  class Configuration : public Comparisons<Configuration> {
  private:





    // Configuration id is the index into Supercell::config_list
    std::string id;

    Supercell *supercell;

    std::shared_ptr<Supercell> m_supercell_ptr;

    jsonParser m_source;
    bool source_updated;


    // symmetric multiplicity (i.e., size of configuration's factor_group)
    int multiplicity;



    // 'occupation' is a list of the indices describing the occupants in each crystal site.
    //   get_prim().basis[ get_b(i) ].site_occupant[ occupation[i]] -> Molecule on site i
    //   This means that for the background structure, 'occupation' is all 0

    // Configuration sites are arranged by basis, and then prim:
    //   occupation: [basis0                |basis1               |basis2          |...] up to prim.basis.size()
    //       basis0: [prim0|prim1|prim2|...] up to supercell.volume()
    //
    ConfigDoF m_configdof;


    /*  calculated:
     *    calculated["energy"]
     *    calculated["relaxed_energy"]
     *
     *  generated:
     *    generated["is_groundstate"]
     *    generated["dist_from_hull"]
     *    generated["sublat_struct_fact"]
     *    generated["struct_fact"]
     */
    bool prop_updated;
    Properties calculated;  //Stuff you got directly from your DFT calculations
    Properties generated;   //Everything else you came up with through casm


    bool m_selected;

    mutable notstd::cloneable_ptr<FillSupercell> m_fill_canonical;

    mutable std::string m_name;

  public:
    typedef ConfigDoF::displacement_matrix_t displacement_matrix_t;
    typedef ConfigDoF::displacement_t displacement_t;
    typedef ConfigDoF::const_displacement_t const_displacement_t;

    //********* CONSTRUCTORS *********

    Configuration(Supercell &_supercell, const jsonParser &source = jsonParser(), const ConfigDoF &_dof = ConfigDoF());

    Configuration(const jsonParser &json, Supercell &_supercell, Index _id);


    //Configuration(Supercell &_supercell, std::string con_name, bool select, const jsonParser &source = jsonParser());


    //********** DESTRUCTORS *********

    //********** MUTATORS  ***********

    void set_multiplicity(int m) {
      multiplicity = m;
    }

    void set_id(Index _id);

    void set_source(const jsonParser &source);

    void push_back_source(const jsonParser &source);

    // ** Degrees of Freedom **
    //
    // ** Note: Properties and correlations are not automatically updated when dof are changed, **
    // **       nor are the written records automatically updated                               **

    void clear();


    void init_occupation();

    void set_occupation(const Array<int> &newoccupation);

    void set_occ(Index site_l, int val);

    void clear_occupation();


    void init_displacement();

    void set_displacement(const displacement_matrix_t &_disp);

    void set_disp(Index site_l, const Eigen::VectorXd &_disp);

    void clear_displacement();


    void init_deformation();

    void set_deformation(const Eigen::Matrix3d &_deformation);

    void clear_deformation();


    bool is_primitive() const;

    PermuteIterator find_translation() const;

    Configuration primitive() const;


    bool is_canonical() const;

    PermuteIterator to_canonical() const;

    PermuteIterator from_canonical() const;

    Configuration canonical_form() const;

    Configuration in_canonical_supercell() const;

    ConfigInsertResult insert(bool primitive_only) const;

    std::vector<PermuteIterator> factor_group() const;

    SymGroup point_group() const;

    Configuration fill_supercell(Supercell &scel, const SymOp &op) const;

    Configuration fill_supercell(Supercell &scel, const SymGroup &g) const;


    // ** Properties **
    //
    // ** Note: DeltaProperties are automatically updated, but not written upon changes **

    //void read_calculated();

    void set_calc_properties(const jsonParser &json);

    bool read_calc_properties(jsonParser &parsed_props) const;

    void set_selected(bool _selected) {
      m_selected = _selected;
    }


    //********** ACCESSORS ***********

    const Lattice &ideal_lattice()const;

    std::string get_id() const;

    int get_multiplicity()const {
      return multiplicity;
    }

    std::string name() const;

    std::string calc_status() const;

    std::string failure_type() const;

    const jsonParser &source() const;

    fs::path get_path() const;

    Index size() const;

    const Structure &get_prim() const;

    bool selected() const {
      return m_selected;
    }

    PrimClex &get_primclex() const;

    Supercell &get_supercell() const;

    double crystallography_tol() const;

    UnitCellCoord get_uccoord(Index site_l) const;

    int get_b(Index site_l) const;

    const ConfigDoF &configdof() const {
      return m_configdof;
    }

    ConfigDoF &configdof() {
      _invalidate_id();
      return m_configdof;
    }

    bool has_occupation() const {
      return configdof().has_occupation();
    }

    const Array<int> &occupation() const {
      return configdof().occupation();
    }

    const int &occ(Index site_l) const {
      return configdof().occ(site_l);
    }

    const Molecule &get_mol(Index site_l) const;


    bool has_displacement() const {
      return configdof().has_displacement();
    }

    const displacement_matrix_t &displacement() const {
      return configdof().displacement();
    }

    const_displacement_t disp(Index site_l) const {
      return configdof().disp(site_l);
    }

    const Eigen::Matrix3d &deformation() const {
      return configdof().deformation();
    }

    bool has_deformation() const {
      return configdof().has_deformation();
    }


    //fs::path get_reference_state_dir() const;

    //const Properties &ref_properties() const;

    const Properties &calc_properties() const;

    //const DeltaProperties &delta_properties() const;

    const Properties &generated_properties() const;


    //const Correlation &get_correlations() const;


    // 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)
    ReturnArray< Array < double > > get_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
    ReturnArray< Array<int> > get_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
    ReturnArray<double> get_composition() const;

    // Returns composition, including vacancies
    //    composition[ molecule_type ]: molecule_type ordered as prim structure's get_struc_molecule()
    ReturnArray<double> get_true_composition() const;

    ReturnArray<int> get_num_each_molecule() const;

    Eigen::VectorXd get_param_composition() const;

    Eigen::VectorXd get_num_each_component() const;

    //-----------------------------------
    //Structure Factor
    Eigen::VectorXd get_struct_fact_intensities() const;
    Eigen::VectorXd get_struct_fact_intensities(const Eigen::VectorXd &component_intensities) const;

    void calc_sublat_struct_fact();
    void calc_struct_fact();
    void calc_sublat_struct_fact(const Eigen::VectorXd &intensities);
    void calc_struct_fact(const Eigen::VectorXd &intensities);

    Eigen::MatrixXcd sublat_struct_fact();
    Eigen::MatrixXd struct_fact();

    //********* IO ************

    jsonParser &write(jsonParser &json) const;

    void write_pos() const;

    // Va_mode      description
    // 0            print no information about the vacancies
    // 1            print only the coordinates of the vacancies
    // 2            print the number of vacancies and the coordinates of the vacancies
    void print(std::ostream &stream, COORD_TYPE mode, int Va_mode = 0, char term = '\n', int prec = 10, int pad = 5) const;

    void print_occupation(std::ostream &stream) const;

    void print_config_list(std::ostream &stream, int composition_flag) const;

    void print_composition(std::ostream &stream) const;

    void print_true_composition(std::ostream &stream) const;

    void print_sublattice_composition(std::ostream &stream) const;


    fs::path calc_dir() const;
    fs::path calc_properties_path() const;
    fs::path calc_status_path() const;
    fs::path get_pos_path() const;

    bool is_equivalent(const Configuration &B) const;

    bool operator<(const Configuration &B) const;

    static std::pair<std::string, Index> split_name(std::string configname);

  private:
    int &_occ(Index site_l) {
      return m_configdof.occ(site_l);
    }

    displacement_t _disp(Index site_l) {
      return m_configdof.disp(site_l);
    }

    void _invalidate_id() {
      id = "none";
      m_name.clear();
    }

    void _generate_name() const;

    friend Comparisons<Configuration>;

    bool _eq(const Configuration &B) const;

    void read(const jsonParser &json);

    void read_dof(const jsonParser &json);
    void read_properties(const jsonParser &json);

    jsonParser &write_dof(jsonParser &json) const;
    jsonParser &write_source(jsonParser &json) const;
    jsonParser &write_pos(jsonParser &json) const;
    jsonParser &write_param_composition(jsonParser &json) const;
    jsonParser &write_properties(jsonParser &json) const;

    //bool reference_states_exist() const;
    //void read_reference_states(Array<Properties> &ref_state_prop, Array<Eigen::VectorXd> &ref_state_comp) const;
    //void generate_reference_scalar(std::string propname, const Array<Properties> &ref_state_prop, const Array<Eigen::VectorXd> &ref_state_comp);

  };

  // Calculate transformed ConfigDoF from PermuteIterator via
  //   apply(permute_iterator, dof)
  Configuration &apply(const PermuteIterator &it, Configuration &config);

  Configuration sub_configuration(Supercell &sub_scel,
                                  const Configuration &super_config,
                                  const UnitCell &origin = UnitCell(0, 0, 0));

  Configuration make_configuration(PrimClex &primclex, std::string name);

  Correlation correlations(const Configuration &config, Clexulator &clexulator);

  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 relaxed_energy(const Configuration &config);

  double relaxed_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);

  bool is_calculated(const Configuration &config);

  double rms_force(const Configuration &_config);

  double basis_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::VectorXd relaxed_mag_basis(const Configuration &_config);
  /* std::vector<double> relaxed_mag_basis(const Configuration &_config); */

  Eigen::VectorXd relaxed_mag(const Configuration &_config);



  bool is_primitive(const Configuration &_config);

  bool is_canonical(const Configuration &_config);

  inline
  std::string calc_status(const Configuration &_config) {
    return _config.calc_status();
  }

  // \brief Reason for calculation failure.
  inline
  std::string failure_type(const Configuration &_config) {
    return _config.failure_type();
  }

  bool has_relaxed_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_basis_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);

  inline
  bool has_calc_status(const Configuration &_config) {
    return !_config.calc_status().empty();
  }

  inline
  bool has_failure_type(const Configuration &_config) {
    return !_config.failure_type().empty();
  }

  class FillSupercell {

  public:

    FillSupercell(Supercell &_scel, const SymOp &_op);

    FillSupercell(Supercell &_scel, const Configuration &motif, double tol);

    Configuration operator()(const Configuration &motif) const;

    const SymOp *find_symop(const Configuration &motif, double tol);

    const SymOp &symop() const {
      return *m_op;
    }


  private:

    void _init(Supercell &_motif_scel) const;

    Supercell *m_scel;
    const SymOp *m_op;

    mutable Supercell *m_motif_scel;
    mutable std::vector<std::vector<Index> > m_index_table;

  };

  std::ostream &operator<<(std::ostream &sout, const Configuration &c);


  inline
  void reset_properties(Configuration &_config) {
    _config.set_calc_properties(jsonParser());
  }

}

#endif