StrucMapCalculatorInterface.hh

Go to the documentation of this file.

#ifndef CASM_StrucMapCalculatorInterface
#define CASM_StrucMapCalculatorInterface
 
#include <iostream>
#include <unordered_set>
#include <vector>
 
#include "casm/crystallography/Adapter.hh"
#include "casm/crystallography/SimpleStructure.hh"
#include "casm/crystallography/SymType.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/CASM_Eigen_math.hh"
#include "casm/misc/CASM_math.hh"
 
namespace CASM {
namespace xtal {
class SimpleStructure;
 
// In this file:
struct MappingNode;
class StrucMapCalculatorInterface;
 
namespace StrucMapping {
 
// Denotes (name, number composition) of any species whose number-composition is
// fixed for the parent primitive cell
using FixedSpecies = std::map<std::string, Index>;
 
// List of species allowed at each site of primitive
using AllowedSpecies = std::vector<std::vector<std::string>>;
 
}  // namespace StrucMapping
 
class StrucMapCalculatorInterface {
 public:
  StrucMapCalculatorInterface(
      SimpleStructure _parent,
      SymOpVector const &_factor_group = {SymOp::identity()},
      SimpleStructure::SpeciesMode _species_mode =
          SimpleStructure::SpeciesMode::ATOM,
      StrucMapping::AllowedSpecies allowed_species = {})
      : m_parent(std::move(_parent)), m_species_mode(_species_mode) {
    this->_set_sym_info(_factor_group);
 
    if (allowed_species.empty()) {
      auto const &p_info(this->struc_info(parent()));
      allowed_species.resize(p_info.size());
      for (Index i = 0; i < p_info.size(); ++i) {
        allowed_species[i].push_back(p_info.names[i]);
      }
    }
    _set_allowed_species(allowed_species);
  }
 
  SimpleStructure::Info const &struc_info(SimpleStructure const &_struc) const {
    return _struc.info(m_species_mode);
  }
 
  SimpleStructure::Info &struc_info(SimpleStructure &_struc) const {
    return _struc.info(m_species_mode);
  }
 
  SimpleStructure const &parent() const { return m_parent; }
 
  double xtal_tol() const { return TOL; }
 
  SymOpVector const &point_group() const { return m_point_group; }
 
  std::vector<Eigen::Vector3d> const &internal_translations() const {
    return m_internal_translations;
  }
 
  std::unordered_set<Index> const &va_allowed() const { return m_va_allowed; }
 
  StrucMapping::FixedSpecies const &fixed_species() const {
    return m_fixed_species;
  }
 
  void set_sym_invariant_displacement_modes(
      const std::vector<Eigen::MatrixXd> &_sym_invariant_displacement_modes) {
    m_sym_invariant_displacement_modes = _sym_invariant_displacement_modes;
  }
 
  const std::vector<Eigen::MatrixXd> &sym_invariant_displacement_modes() const {
    return m_sym_invariant_displacement_modes;
  };
 
  Index max_n_va() const { return va_allowed().size(); }
 
  virtual ~StrucMapCalculatorInterface() {}
 
  virtual std::vector<Eigen::Vector3d> translations(
      MappingNode const &_node, SimpleStructure const &child_struc) const = 0;
 
  virtual SimpleStructure resolve_setting(
      MappingNode const &_node, SimpleStructure const &_child_struc) const = 0;
 
  virtual void finalize(MappingNode &_node, SimpleStructure const &child_struc,
                        bool const &symmetrize_atomic_cost = false) const = 0;
 
  virtual bool populate_cost_mat(MappingNode &_node,
                                 SimpleStructure const &child_struc) const = 0;
 
  std::unique_ptr<StrucMapCalculatorInterface> clone() const {
    return std::unique_ptr<StrucMapCalculatorInterface>(this->_clone());
  }
 
  std::unique_ptr<StrucMapCalculatorInterface> quasi_clone(
      SimpleStructure _parent,
      SymOpVector const &_factor_group = {SymOp::identity()},
      SimpleStructure::SpeciesMode _species_mode =
          SimpleStructure::SpeciesMode::ATOM,
      StrucMapping::AllowedSpecies _allowed_species = {}) const {
    return std::unique_ptr<StrucMapCalculatorInterface>(
        this->_quasi_clone(std::move(_parent), _factor_group, _species_mode,
                           std::move(_allowed_species)));
  }
 
  template <typename ExternSymOpVector>
  std::unique_ptr<StrucMapCalculatorInterface> quasi_clone(
      SimpleStructure _parent,
      ExternSymOpVector const &_factor_group = {SymOp::identity()},
      SimpleStructure::SpeciesMode _species_mode =
          SimpleStructure::SpeciesMode::ATOM,
      StrucMapping::AllowedSpecies _allowed_species = {}) const {
    return this->quasi_clone(
        _parent,
        adapter::Adapter<SymOpVector, ExternSymOpVector>()(_factor_group),
        _species_mode, _allowed_species);
  }
 
 protected:
  void _set_allowed_species(StrucMapping::AllowedSpecies allowed_species) {
    m_allowed_species = std::move(allowed_species);
 
    // Analyze allowed_species:
    for (Index i = 0; i < m_allowed_species.size(); ++i) {
      for (std::string &sp : m_allowed_species[i]) {
        if (sp == "Va" || sp == ("VA") || sp == "va") {
          // Is vacancy
          sp = "Va";
          m_va_allowed.insert(i);
        } else if (m_allowed_species[i].size() > 1) {
          // Not vacancy, but variable species
          m_fixed_species[sp] = 0;
        } else {
          // potentially fixed species
          auto it = m_fixed_species.find(sp);
          if (it == m_fixed_species.end())
            m_fixed_species[sp] = 1;
          else if ((it->second) > 0)
            ++(it->second);
        }
        if (!m_max_n_species.count(sp)) m_max_n_species[sp] = 0;
        ++m_max_n_species[sp];
      }
    }
 
    for (auto it = m_fixed_species.begin(); it != m_fixed_species.end();) {
      auto curr = it;
      ++it;
      if ((curr->second) == 0) m_fixed_species.erase(curr);
    }
  }
 
  void _set_sym_info(SymOpVector const &_factor_group) {
    m_point_group.clear();
    m_internal_translations.clear();
 
    // Internal translations are any translation associated with identity
    m_point_group.push_back(SymOp::identity());
 
    for (SymOp const &op : _factor_group) {
      if (get_matrix(op).isIdentity(TOL) && !get_time_reversal(op)) {
        m_internal_translations.push_back(get_translation(op));
      }
      if (!almost_equal(get_matrix(op), get_matrix(m_point_group.back()),
                        TOL) ||
          get_time_reversal(op) != get_time_reversal(m_point_group.back())) {
        m_point_group.push_back(op);
        m_point_group.back().translation.setZero();
      }
    }
  }
 
  StrucMapping::AllowedSpecies const &_allowed_species() const {
    return m_allowed_species;
  }
 
  StrucMapping::FixedSpecies const &_fixed_species() const {
    return m_fixed_species;
  }
 
  bool _sublat_allows_va(Index b) const { return m_va_allowed.count(b); }
 
  std::map<std::string, Index> const &_max_n_species() const {
    return m_max_n_species;
  }
 
 private:
  SimpleStructure m_parent;
 
  // Point group of parent crystal, must contain at least Identity
  SymOpVector m_point_group;
 
  // internal translations that map parent crystal onto itself, must contain at
  // least (0,0,0)
  std::vector<Eigen::Vector3d> m_internal_translations;
 
  SimpleStructure::SpeciesMode m_species_mode;
 
  StrucMapping::AllowedSpecies m_allowed_species;
 
  StrucMapping::FixedSpecies m_fixed_species;
 
  std::map<std::string, Index> m_max_n_species;
 
  std::unordered_set<Index> m_va_allowed;
 
  std::vector<Eigen::MatrixXd> m_sym_invariant_displacement_modes;
 
  virtual StrucMapCalculatorInterface *_clone() const = 0;
 
  virtual StrucMapCalculatorInterface *_quasi_clone(
      SimpleStructure _parent,
      SymOpVector const &_factor_group = {SymOp::identity()},
      SimpleStructure::SpeciesMode _species_mode =
          SimpleStructure::SpeciesMode::ATOM,
      StrucMapping::AllowedSpecies _allowed_species = {}) const = 0;
};
}  // namespace xtal
}  // namespace CASM
 
#endif