Molecule.hh

Go to the documentation of this file.

#ifndef MOLECULE_HH
#define MOLECULE_HH
 
#include <array>
#include <iostream>
#include <string>
#include <vector>
 
#include "casm/crystallography/Adapter.hh"
#include "casm/crystallography/SpeciesAttribute.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/Comparisons.hh"
 
namespace CASM {
namespace xtal {
class Molecule;
 
//****************************************************
 
class AtomPosition {
 public:
  AtomPosition(double _pos1, double _pos2, double _pos3,
               std::string const &_species)
      : m_species(_species), m_position(_pos1, _pos2, _pos3) {}
 
  AtomPosition(Eigen::Ref<const Eigen::Vector3d> const &_pos,
               std::string const &_species)
      : m_species(_species), m_position(_pos) {}
 
  std::string const &name() const { return m_species; }
 
  Eigen::Vector3d const &cart() const { return m_position; }
 
  bool time_reversal_active() const {
    for (auto const &_attr : attributes()) {
      if (_attr.second.traits().time_reversal_active()) return true;
    }
    return false;
  }
 
  std::map<std::string, SpeciesAttribute> const &attributes() const {
    return m_attribute_map;
  }
 
  void set_attributes(std::map<std::string, SpeciesAttribute> _attr) {
    m_attribute_map = std::move(_attr);
  }
 
  bool identical(AtomPosition const &RHS, double _tol) const;
 
 private:
  std::string m_species;
 
  Eigen::Vector3d m_position;
 
  std::map<std::string, SpeciesAttribute> m_attribute_map;
};
 
bool compare_type(AtomPosition const &A, AtomPosition const &B, double tol);
//****************************************************
 
class Molecule {
 public:
  static Molecule make_atom(std::string const &atom_name);
 
  static Molecule make_unknown() { return make_atom("UNKNOWN"); }
 
  static Molecule make_vacancy();
 
  Molecule(std::string const &_name, std::vector<AtomPosition> _atoms = {},
           bool _divisible = false)
      : m_name(_name), m_atoms(std::move(_atoms)), m_divisible(_divisible) {
    if (m_atoms.empty()) m_atoms.emplace_back(0., 0., 0., m_name);
  }
 
  Index size() const { return m_atoms.size(); }
 
  std::string const &name() const { return m_name; }
 
  std::vector<AtomPosition> const &atoms() const { return m_atoms; }
 
  AtomPosition const &atom(Index i) const { return m_atoms[i]; }
 
  bool is_atomic() const;
 
  bool is_vacancy() const;
 
  bool time_reversal_active() const {
    for (auto const &_atom : atoms()) {
      if (_atom.time_reversal_active()) return true;
    }
    for (auto const &_attr : attributes()) {
      if (_attr.second.traits().time_reversal_active()) return true;
    }
    return false;
  }
 
  std::map<std::string, SpeciesAttribute> const &attributes() const {
    return m_attribute_map;
  }
 
  void set_attributes(std::map<std::string, SpeciesAttribute> _attr) {
    m_attribute_map = std::move(_attr);
  }
 
  void set_atoms(std::vector<AtomPosition> _atoms) {
    m_atoms = std::move(_atoms);
  }
 
  bool identical(Molecule const &RHS, double _tol) const;
 
  bool contains(std::string const &atom_name) const;
 
  bool is_divisible() const { return m_divisible; }
 
  bool is_indivisible() const { return !m_divisible; }
 
 private:
  std::string m_name;
  std::vector<AtomPosition> m_atoms;
  bool m_divisible;
 
  std::map<std::string, SpeciesAttribute> m_attribute_map;
};
 
inline bool operator==(Molecule const &A, Molecule const &B) {
  return A.identical(B, TOL);
}
 
inline bool is_vacancy(const std::string &name) {
  return (name == "VA" || name == "va" || name == "Va");
}
 
inline bool is_molecule_name(const Molecule &mol, std::string name) {
  return mol.name() == name || (mol.is_vacancy() && is_vacancy(name));
}
 
}  // namespace xtal
}  // namespace CASM
 
namespace CASM {
namespace sym {
xtal::AtomPosition &apply(const xtal::SymOp &op,
                          xtal::AtomPosition &mutating_atom_pos);
xtal::AtomPosition copy_apply(const xtal::SymOp &op,
                              xtal::AtomPosition atom_pos);
 
template <typename ExternSymOp>
xtal::AtomPosition copy_apply(const ExternSymOp &op,
                              xtal::AtomPosition atom_pos) {
  return sym::copy_apply(adapter::Adapter<xtal::SymOp, ExternSymOp>()(op),
                         atom_pos);
}
 
xtal::Molecule &apply(const xtal::SymOp &op, xtal::Molecule &mutating_mol);
xtal::Molecule copy_apply(const xtal::SymOp &op, xtal::Molecule mol);
 
template <typename ExternSymOp>
xtal::Molecule copy_apply(const ExternSymOp &op, xtal::Molecule mol) {
  return sym::copy_apply(adapter::Adapter<xtal::SymOp, ExternSymOp>()(op), mol);
}
}  // namespace sym
}  // namespace CASM
 
#endif