PrimClex.hh

Go to the documentation of this file.

#ifndef PRIMCLEX_HH
#define PRIMCLEX_HH

#include "casm/external/boost.hh"

#include "casm/misc/cloneable_ptr.hh"
#include "casm/casm_io/Log.hh"

#include "casm/crystallography/Structure.hh"
#include "casm/clex/DoFManager.hh"
#include "casm/clex/CompositionConverter.hh"
#include "casm/clex/Supercell.hh"
#include "casm/clex/Clexulator.hh"
#include "casm/clex/ChemicalReference.hh"
#include "casm/misc/cloneable_ptr.hh"
#include "casm/clex/NeighborList.hh"

#include "casm/app/DirectoryStructure.hh"
#include "casm/app/ProjectSettings.hh"
#include "casm/app/EnumeratorHandler.hh"
#include "casm/app/QueryHandler.hh"

namespace CASM {

  class ECIContainer;

  template<typename T, typename U> class ConfigIterator;

  class PrimClex : public Logging {

    fs::path root;

    DirectoryStructure m_dir;
    ProjectSettings m_settings;

    Structure prim;
    bool m_vacancy_allowed;
    Index m_vacancy_index;

    mutable DoFManager m_dof_manager;

    boost::container::stable_vector< Supercell > supercell_list;


    bool m_has_composition_axes = false;
    CompositionConverter m_comp_converter;

    notstd::cloneable_ptr<ChemicalReference> m_chem_ref;

    mutable notstd::cloneable_ptr<PrimNeighborList> m_nlist;


  public:

    typedef ConfigIterator<Configuration, PrimClex> config_iterator;
    typedef ConfigIterator<const Configuration, const PrimClex> config_const_iterator;

    // **** Constructors ****

    PrimClex(const Structure &_prim, const Logging &logging = Logging());

    PrimClex(const fs::path &_root, const Logging &logging = Logging());

    void refresh(bool read_settings = false,
                 bool read_composition = false,
                 bool read_chem_ref = false,
                 bool read_configs = false,
                 bool clear_clex = false);

    // **** Accessors ****

    std::string name() const;


    // ** Directory path accessors **

    const DirectoryStructure &dir() const {
      return m_dir;
    }

    ProjectSettings &settings() {
      return m_settings;
    }

    const ProjectSettings &settings() const {
      return m_settings;
    }

    double crystallography_tol() const {
      return settings().crystallography_tol();
    }

    double lin_alg_tol() const {
      return settings().lin_alg_tol();
    }

    fs::path get_path() const;

    fs::path get_path(const Index &scel_index) const;

    fs::path get_path(const Index &scel_index, const Index &config_index) const;

    fs::path get_config_list_path() const;


    // ** Composition accessors **

    bool has_composition_axes() const;

    const CompositionConverter &composition_axes() const;

    // ** Chemical reference **

    bool has_chemical_reference() const;

    const ChemicalReference &chemical_reference() const;


    // ** Prim and Orbitree accessors **

    const Structure &get_prim() const;

    PrimNeighborList &nlist() const;

    bool vacancy_allowed() const;

    Index vacancy_index() const;

    // ** Supercell and Configuration accessors **

    boost::container::stable_vector<Supercell> &get_supercell_list();

    const boost::container::stable_vector<Supercell> &get_supercell_list() const;

    const Supercell &get_supercell(Index i) const;

    Supercell &get_supercell(Index i);

    const Supercell &get_supercell(std::string scellname) const;

    Supercell &get_supercell(std::string scellname);

    Supercell &get_supercell(const Lattice &lat);

    const Configuration &configuration(const std::string &configname) const;
    Configuration &configuration(const std::string &configname);

    config_iterator config_begin();

    config_iterator config_end();

    config_const_iterator config_begin() const;

    config_const_iterator config_end() const;

    config_const_iterator config_cbegin() const;

    config_const_iterator config_cend() const;

    config_iterator selected_config_begin();

    config_iterator selected_config_end();

    config_const_iterator selected_config_cbegin() const;

    config_const_iterator selected_config_cend() const;


    Eigen::MatrixXd shift_vectors() const;


    // **** Mutators ****

    void set_composition_axes(const CompositionConverter &_converter);

    // **** IO ****

    void write_config_list(std::set<std::string> scel_to_delete = {});


    // **** Operators ****

    // **** Functions for preparing CLEXulators ****

    //Generate the global orbitree
    //John G 011013

    void generate_supercells(const ScelEnumProps &enum_props);

    //Enumerate configurations for all the supercells that are stored in 'supercell_list'
    void print_enum_info(std::ostream &stream);
    void print_supercells(std::set<std::string> scel_to_delete = {}) const;
    void print_supercells(std::ostream &stream, std::set<std::string> scel_to_delete = {}) const;
    void read_supercells(std::istream &stream);
    void print_clex_configurations();


    //ParamComposition i/o and calculators in PrimClex

    void read_config_list();

    void read_scel_props(int scel_index, const std::string &JSON_output);
    void read_all_scel_props(const std::string &JSON_output);

    int amount_selected() const;

    bool contains_supercell(std::string scellname, Index &index) const;

    bool contains_supercell(const Supercell &scel) const;
    bool contains_supercell(const Supercell &scel, Index &index) const;

    Index add_supercell(const Lattice &superlat);

    Index add_canonical_supercell(const Lattice &superlat);

    Eigen::Matrix3i calc_transf_mat(const Lattice &superlat) const;

    void set_global_dof_state(const Configuration &curr_config)const {
      m_dof_manager.set_global_dof_state(curr_config);
    };

    void set_local_dof_state(const Configuration &curr_config, Index l)const {
      m_dof_manager.set_local_dof_state(curr_config, l);
    };

    //void clear_reference_states();

    //void set_reference_state(int refid, const Configuration &config);

    //bool valid_reference_state(int refid, const Configuration &config, std::string &reason_invalid) const;

    //void set_reference_state_auto();

    //void generate_references();

    bool has_orbitree(const ClexDescription &key) const;
    const SiteOrbitree &orbitree(const ClexDescription &key) const;

    bool has_clexulator(const ClexDescription &key) const;
    Clexulator clexulator(const ClexDescription &key) const;

    bool has_eci(const ClexDescription &key) const;
    const ECIContainer &eci(const ClexDescription &key) const;

  private:

    void _init();

    mutable std::map<ClexDescription, SiteOrbitree> m_orbitree;
    mutable std::map<ClexDescription, Clexulator> m_clexulator;
    mutable std::map<ClexDescription, ECIContainer> m_eci;

  };


  SiteOrbitree make_orbitree(Structure &prim, const jsonParser &json, double _tol);

  void print_clexulator(const Structure &prim,
                        SiteOrbitree &tree,
                        const PrimNeighborList &nlist,
                        std::string class_name,
                        std::ostream &stream,
                        double xtal_tol);

}
#endif