ConfigMapping.hh

Go to the documentation of this file.

#ifndef CONFIGMAPPING_HH
#define CONFIGMAPPING_HH
#include "casm/CASM_global_definitions.hh"
#include <vector>
namespace CASM {
  class Supercell;
  class Lattice;
  class SymGroup;
  class PrimClex;
  class Configuration;
  class ConfigDoF;

  class ConfigMapper {
  public:
    enum NullInitializer {null_initializer};
    enum Options {none = 0,
                  rotate = (1u << 0),
                  strict = (1u << 1),
                  robust = (1u << 2)
                 };

    ConfigMapper(NullInitializer) :
      m_pclex(nullptr),
      m_lattice_weight(0.5),
      m_max_volume_change(0.5),
      m_min_va_frac(0.),
      m_max_va_frac(1.) {
    }

    ConfigMapper(PrimClex &_pclex,
                 double _lattice_weight,
                 double _max_volume_change = 0.5,
                 int _options = robust, // this should actually be a bitwise-OR of ConfigMapper::Options
                 double _tol = TOL);


    PrimClex &primclex() const {
      return *m_pclex;
    }

    void set_primclex(PrimClex &_pclex) {
      m_pclex = &_pclex;
    }

    double lattice_weight() const {
      return m_lattice_weight;
    }

    void set_lattice_weight(double _lw) {
      m_lattice_weight = max(min(_lw, 1.0), 1e-9);
    }

    double min_va_frac() const {
      return m_min_va_frac;
    }

    void set_min_va_frac(double _min_va) {
      m_min_va_frac = max(_min_va, 0.);
    }

    double max_va_frac() const {
      return m_max_va_frac;
    }

    void set_max_va_frac(double _max_va) {
      m_max_va_frac = min(_max_va, 1.);
    }


    bool import_structure_occupation(const fs::path &pos_path,
                                     std::string &imported_name,
                                     jsonParser &relaxation_properties,
                                     std::vector<Index> &best_assignment,
                                     Eigen::Matrix3d &cart_op) const;

    bool import_structure_occupation(BasicStructure<Site> &_struc,
                                     std::string &imported_name,
                                     jsonParser &relaxation_properties,
                                     std::vector<Index> &best_assignment,
                                     Eigen::Matrix3d &cart_op,
                                     bool update_struc = false) const;

    bool import_structure_occupation(BasicStructure<Site> &_struc,
                                     const Configuration *hint_ptr,
                                     std::string &imported_name,
                                     jsonParser &relaxation_properties,
                                     std::vector<Index> &best_assignment,
                                     Eigen::Matrix3d &cart_op,
                                     bool update_struc = false) const;


    bool import_structure(const fs::path &pos_path,
                          std::string &imported_name,
                          jsonParser &relaxation_properties,
                          std::vector<Index> &best_assignment,
                          Eigen::Matrix3d &cart_op) const;

    bool import_structure(const BasicStructure<Site> &_struc,
                          std::string &imported_name,
                          jsonParser &relaxation_properties,
                          std::vector<Index> &best_assignment,
                          Eigen::Matrix3d &cart_op) const;

    bool struc_to_configdof(const BasicStructure<Site> &_struc,
                            ConfigDoF &mapped_configdof,
                            Lattice &mapped_lat) const;

    bool struc_to_configdof(const BasicStructure<Site> &_struc,
                            ConfigDoF &mapped_configdof,
                            Lattice &mapped_lat,
                            std::vector<Index> &best_assignment,
                            Eigen::Matrix3d &cart_op,
                            double best_cost = 1e20) const;


    bool ideal_struc_to_configdof(const BasicStructure<Site> &struc,
                                  ConfigDoF &mapped_config_dof,
                                  Lattice &mapped_lat,
                                  std::vector<Index> &best_assignment,
                                  Eigen::Matrix3d &cart_op) const;


    bool deformed_struc_to_configdof(const BasicStructure<Site> &_struc,
                                     ConfigDoF &mapped_config_dof,
                                     Lattice &mapped_lat,
                                     std::vector<Index> &best_assignment,
                                     Eigen::Matrix3d &cart_op,
                                     double best_cost = 1e20) const;

    bool deformed_struc_to_configdof_of_lattice(const BasicStructure<Site> &struc,
                                                const Lattice &imposed_lat,
                                                double &best_cost,
                                                ConfigDoF &mapped_configdof,
                                                Lattice &mapped_lat,
                                                std::vector<Index> &best_assignment,
                                                Eigen::Matrix3d &cart_op) const;

  private:
    PrimClex *m_pclex;
    mutable std::map<Index, std::vector<Lattice> > m_superlat_map;
    double m_lattice_weight;
    double m_max_volume_change;
    double m_min_va_frac;
    double m_max_va_frac;
    bool m_robust_flag, m_strict_flag, m_rotate_flag;
    double m_tol;
    std::vector<std::pair<std::string, Index> > m_fixed_components;
    const std::vector<Lattice> &_lattices_of_vol(Index prim_vol) const;
  };

  namespace ConfigMap_impl {

    // Assignment Problem Routines
    // Find cost matrix for displacements between ideal crystal and relaxed structure ('rstruc').
    // Returns false if 'rstruc' is incompatible with 'scel'
    bool calc_cost_matrix(const Supercell &scel,
                          const BasicStructure<Site> &rstruc,
                          const Coordinate &trans,
                          const Eigen::Matrix3d &metric,
                          Eigen::MatrixXd &cost_matrix);

    // Assignment Problem Routines
    // Find cost matrix for displacements between ideal configuration and a relaxed structure ('rstruc').
    // Returns false if 'rstruc' is incompatible with 'scel'
    bool calc_cost_matrix(const Configuration &config,
                          const BasicStructure<Site> &rstruc,
                          const Coordinate &trans,
                          const Eigen::Matrix3d &metric,
                          Eigen::MatrixXd &cost_matrix);

    //\JSB



    // mapping routine. Return an ideal configuration corresponding to a relaxed structure.
    // Return false if 'rstruc' is incompatible with supercell (can happen frequently when vacancies are allowed)
    // Options:
    //   TRANSLATE = true -> rigid-translations are removed. (typically this option should be used, especially if you care about vacancies)
    //
    //   TRANSLATE = false -> rigid translations are not considered. (less robust but more efficient -- use only if you know rigid translations are small or zero)

    bool struc_to_configdof(const Supercell &scel,
                            BasicStructure<Site> rstruc,
                            ConfigDoF &config_dof,
                            std::vector<Index> &best_assignment,
                            const bool translate_flag,
                            const double _tol);

    bool preconditioned_struc_to_configdof(const Supercell &scel,
                                           const BasicStructure<Site> &rstruc,
                                           const Eigen::Matrix3d &deformation,
                                           ConfigDoF &config_dof,
                                           std::vector<Index> &best_assignment,
                                           const bool translate_flag,
                                           const double _tol);

    bool struc_to_configdof(const Configuration &config,
                            BasicStructure<Site> rstruc,
                            ConfigDoF &config_dof,
                            std::vector<Index> &best_assignment,
                            const bool translate_flag,
                            const double _tol);

    bool preconditioned_struc_to_configdof(const Configuration &config,
                                           const BasicStructure<Site> &rstruc,
                                           const Eigen::Matrix3d &deformation,
                                           ConfigDoF &config_dof,
                                           std::vector<Index> &best_assignment,
                                           const bool translate_flag,
                                           const double _tol);


  }

  namespace ConfigMapping {
    double strain_cost(const Lattice &relaxed_lat, const ConfigDoF &_dof, Index Nsites);

    double basis_cost(const ConfigDoF &_dof, Index Nsites);


    Lattice find_nearest_super_lattice(const Lattice &prim_lat,
                                       const Lattice &relaxed_lat,
                                       const SymGroup &sym_group,
                                       Eigen::Matrix3d &trans_mat,
                                       Eigen::Matrix3d &deformation,
                                       double &best_cost,
                                       Index min_vol,
                                       Index max_vol,
                                       double _tol);

    Lattice find_nearest_super_lattice(const Lattice &prim_lat,
                                       const Lattice &relaxed_lat,
                                       const SymGroup &sym_group,
                                       Eigen::Matrix3d &trans_mat,
                                       Eigen::Matrix3d &deformation,
                                       double &best_cost,
                                       const std::vector<Lattice> &from_range,
                                       double _tol);


  }


}

#endif