ConfigMapping.hh

Go to the documentation of this file.

#ifndef CASM_ConfigMapping
#define CASM_ConfigMapping
 
#include "casm/clex/Configuration.hh"
#include "casm/crystallography/BasicStructure.hh"
#include "casm/crystallography/SimpleStrucMapCalculator.hh"
#include "casm/crystallography/StrucMapping.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/CASM_math.hh"
 
namespace CASM {
namespace xtal {
class Lattice;
class Site;
class BasicStructure;
struct MappingNode;
class SimpleStructure;
class SimpleStrucMapCalculator;
class StrucMapper;
}  // namespace xtal
using xtal::BasicStructure;
using xtal::Lattice;
using xtal::MappingNode;
using xtal::SimpleStrucMapCalculator;
using xtal::SimpleStructure;
using xtal::Site;
using xtal::StrucMapper;
 
class Supercell;
class PermuteIterator;
class PrimClex;
class Configuration;
class ConfigDoF;
class SupercellSymInfo;
 
namespace ConfigMapping {
 
 
struct Settings {
  Settings(double _lattice_weight = 0.5, bool _ideal = false,
           bool _strict = false, bool _robust = false,
           bool _primitive_only = false, bool _fix_volume = false,
           bool _fix_lattice = false, Index _k_best = 1,
           std::vector<std::string> _forced_lattices = {},
           std::string _filter = "", double _cost_tol = CASM::TOL,
           double _min_va_frac = 0., double _max_va_frac = 0.5,
           double _max_vol_change = 0.3)
      : lattice_weight(_lattice_weight),
        ideal(_ideal),
        strict(_strict),
        robust(_robust),
        primitive_only(_primitive_only),
        fix_volume(_fix_volume),
        fix_lattice(_fix_lattice),
        k_best(_k_best),
        forced_lattices(_forced_lattices),
        filter(_filter),
        cost_tol(_cost_tol),
        min_va_frac(_min_va_frac),
        max_va_frac(_max_va_frac),
        max_vol_change(_max_vol_change) {}
 
  int options() const {
    int opt = 0;
    if (robust) opt |= StrucMapper::robust;
    return opt;
  }
 
  void set_default() { *this = Settings(); }
 
  double lattice_weight;
 
  bool ideal;
 
  bool strict;
 
  bool robust;
 
  bool primitive_only;
 
  bool fix_volume;
 
  bool fix_lattice;
 
  Index k_best;
 
  std::vector<std::string> forced_lattices;
 
  std::string filter;
 
  double cost_tol;
 
  double min_va_frac;
 
  double max_va_frac;
 
  double max_vol_change;
};
}  // namespace ConfigMapping
 
MappingNode copy_apply(PermuteIterator const &_it, MappingNode const &_node,
                       bool transform_cost_mat = true);
 
std::pair<ConfigDoF, std::set<std::string> > to_configdof(
    SimpleStructure const &_child_struc, Supercell const &_scel);
 
class PrimStrucMapCalculator : public SimpleStrucMapCalculator {
 public:
  PrimStrucMapCalculator(BasicStructure const &_prim,
                         std::vector<xtal::SymOp> const &symgroup = {},
                         SimpleStructure::SpeciesMode _species_mode =
                             SimpleStructure::SpeciesMode::ATOM);
 
 private:
  StrucMapCalculatorInterface *_clone() const override {
    return new PrimStrucMapCalculator(*this);
  }
 
  BasicStructure m_prim;
};
 
struct ConfigMapperResult {
  enum class HintStatus {
    None,
    Derivative,
    Equivalent,
    Identical,
    NewOcc,
    NewScel
  };
 
  struct Individual {
    Individual(Configuration _config, SimpleStructure _resolved_struc,
               std::set<std::string> _dof_managed_properties,
               HintStatus _hint_status = HintStatus::None,
               double _hint_cost = xtal::StrucMapping::big_inf())
        : config(std::move(_config)),
          resolved_struc(std::move(_resolved_struc)),
          dof_managed_properties(std::move(_dof_managed_properties)),
          hint_status(_hint_status),
          hint_cost(_hint_cost) {}
 
    Configuration config;
 
    // Child structure, converted to setting of reference structure (i.e., prim)
    // It is equivalent to initial child structure, but the following
    // transformations have been performed:
    // - Atoms converted to molecules and ordered as in reference structure
    // - Vacancies explicitly inserted, if any were inferred from mapping
    // - Sites are translated such that average displacement of child sites
    // relative to parent sites is 0
    // - Lattice and coordinates rotated
    // - Integer combinations of child lattice vectors (Lc) to match parent
    // lattice vectors (Lp) such that
    //      Lc = U * Lp
    //   where U is symmetric right stretch tensor
    // - Permutation and rotation also applied to all properties of
    // resolved_struc
    SimpleStructure resolved_struc;
 
    // list of properties that are handled by DoFs and are thus not considered
    // properties
    std::set<std::string> dof_managed_properties;
 
    HintStatus hint_status;
    double hint_cost;
  };
 
  ConfigMapperResult() {}
 
  bool success() const { return !maps.empty(); }
 
  Index n_optimal(double tol = TOL) const;
 
  SimpleStructure structure;
 
  std::map<MappingNode, Individual> maps;
 
  std::string fail_msg;
};
 
class ConfigMapper {
 public:
  using HintStatus = ConfigMapperResult::HintStatus;
 
  ConfigMapper(PrimClex const &_pclex, ConfigMapping::Settings const &_settings,
               double _tol = -1.);
 
  const PrimClex &primclex() const { return *m_pclex; }
 
  ConfigMapping::Settings const &settings() const { return m_settings; }
 
  void set_primclex(const PrimClex &_pclex) { m_pclex = &_pclex; }
 
  StrucMapper const &struc_mapper() const { return m_struc_mapper; }
 
  void add_allowed_lattices(std::vector<std::string> const &_lattice_names);
 
  void clear_allowed_lattices();
 
  // STEPS:
  //    0) [If Hint] Do SimpleStructure -> SimpleStructure(Config) mapping =>
  //    HintMapping (Default, HintMapping.cost=inf()) 1) If HintMapping.cost>tol
  //    Do SimpleStructure -> PrimClex mapping => ClexMapping (Default,
  //    ClexMapping.cost=inf()) 2) If HintMapping.cost<ClexMapping.cost, use
  //    HintMapping, else use ClexMapping => BestMapping 3) Convert BestMapping
  //    to ConfigDoF
  //       [a] - BestMapping attributes that define ConfigDoF are mapped 'DoF',
  //       all others mapped 'property' [b] - 'property' attributes are subsumed
  //       into 'relaxation_properties' object
  //    4) Construct Configuration as ConfigDoF + relation_properties
 
  ConfigMapperResult import_structure(SimpleStructure const &_struc,
                                      Configuration const *hint_ptr = nullptr,
                                      std::vector<DoFKey> const &_hint_dofs = {
                                          "occ"}) const;
 
  ConfigMapperResult import_structure(SimpleStructure const &_struc, Index k,
                                      Configuration const *hint_ptr = nullptr,
                                      std::vector<DoFKey> const &_hint_dofs = {
                                          "occ"}) const;
 
 private:
  const PrimClex *m_pclex;
  StrucMapper m_struc_mapper;
 
  ConfigMapping::Settings m_settings;
};
 
}  // namespace CASM
 
#endif