BasicStructure.hh

Go to the documentation of this file.

#ifndef BASICSTRUCTURE_HH
#define BASICSTRUCTURE_HH
 
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <istream>
#include <string>
#include <vector>
 
#include "casm/crystallography/Adapter.hh"
#include "casm/crystallography/DoFDecl.hh"
#include "casm/crystallography/DoFSet.hh"
#include "casm/crystallography/Lattice.hh"
#include "casm/crystallography/Site.hh"
#include "casm/global/enum.hh"
 
namespace CASM {
namespace xtal {
 
class Coordinate;
class UnitCellCoord;
class Molecule;
 
class BasicStructure {
 protected:
  Lattice m_lattice;
 
  std::string m_title;
 
  std::vector<Site> m_basis;
 
  std::map<DoFKey, DoFSet> m_global_dof_map;
 
 private:
  void main_print(std::ostream &stream, COORD_TYPE mode, bool version5,
                  int option) const;
 
  // TODO: Extract
  // CASM canonical input/output
  void read(std::istream &stream, double tol = TOL);  // John do this
 
 public:
  // ****Constructors****
  BasicStructure(const Lattice &init_lat) : m_lattice(init_lat){};
  BasicStructure() : m_lattice(){};  // added by Ivy (do we need/want this??)
 
  BasicStructure(const BasicStructure &RHS);
 
  static BasicStructure from_poscar_stream(std::istream &poscar_stream,
                                           double tol = TOL);
 
  ~BasicStructure(){};
 
  //  ****Inspectors/Accessors****
 
  const Lattice &lattice() const { return m_lattice; }
 
  const std::vector<Site> &basis() const { return m_basis; }
 
  std::vector<Site> &set_basis() { return m_basis; }
 
  const std::string &title() const { return m_title; }
 
  DoFSet const &global_dof(std::string const &dof_type) const;
 
  std::map<DoFKey, DoFSet> const &global_dofs() const {
    return m_global_dof_map;
  }
 
  BasicStructure &operator=(const BasicStructure &RHS);
 
  void within();
 
  void set_lattice(const Lattice &lattice, COORD_TYPE mode);
 
  void set_title(std::string const &_title);
 
  void set_global_dofs(std::map<DoFKey, DoFSet> const &new_dof_map) {
    m_global_dof_map = new_dof_map;
  }
 
  void set_global_dofs(std::vector<DoFSet> const &new_dof_vec) {
    m_global_dof_map = make_dofset_map(new_dof_vec);
  }
 
  void set_basis(std::vector<Site> const &_basis, COORD_TYPE mode = CART);
 
  void push_back(Site const &_site, COORD_TYPE mode = CART);
 
  bool is_time_reversal_active() const;
 
  BasicStructure &operator+=(const Coordinate &shift);
  BasicStructure &operator-=(const Coordinate &shift);
 
  Index max_possible_vacancies() const;
 
  // TODO: Extract
  void print_xyz(std::ostream &stream, bool frac = false) const;
};
 
/* BasicStructure operator*(const Lattice &LHS, const BasicStructure &RHS); */
 
std::vector<UnitCellCoord> symop_site_map(SymOp const &_op,
                                          BasicStructure const &_struc);
 
template <typename ExternSymOp>
std::vector<UnitCellCoord> symop_site_map(ExternSymOp const &_op,
                                          BasicStructure const &_struc) {
  return symop_site_map(adapter::Adapter<SymOp, ExternSymOp>()(_op), _struc);
}
 
std::vector<UnitCellCoord> symop_site_map(SymOp const &_op,
                                          BasicStructure const &_struc,
                                          double _tol);
 
template <typename ExternSymOp>
std::vector<UnitCellCoord> symop_site_map(ExternSymOp const &_op,
                                          BasicStructure const &_struc,
                                          double _tol) {
  return symop_site_map(adapter::Adapter<SymOp, ExternSymOp>()(_op), _struc,
                        _tol);
}
 
std::vector<Molecule> struc_molecule(BasicStructure const &_struc);
 
std::vector<std::string> struc_species(BasicStructure const &_struc);
 
std::vector<std::string> struc_molecule_name(BasicStructure const &_struc);
 
std::vector<std::vector<std::string> > allowed_molecule_unique_names(
    BasicStructure const &_struc);
 
std::vector<std::vector<std::string> > allowed_molecule_names(
    BasicStructure const &_struc);
 
std::vector<DoFKey> all_local_dof_types(BasicStructure const &_struc);
 
std::vector<DoFKey> continuous_local_dof_types(BasicStructure const &_struc);
 
std::vector<DoFKey> global_dof_types(BasicStructure const &_struc);
 
std::vector<DoFKey> all_dof_types(BasicStructure const &_struc);
 
std::map<DoFKey, Index> local_dof_dims(BasicStructure const &_struc);
 
std::map<DoFKey, Index> global_dof_dims(BasicStructure const &_struc);
 
Index local_dof_dim(DoFKey const &_name, BasicStructure const &_struc);
 
bool has_strain_dof(BasicStructure const &structure);
 
DoFKey get_strain_dof_key(BasicStructure const &structure);
 
std::string get_strain_metric(DoFKey strain_dof_key);
 
}  // namespace xtal
}  // namespace CASM
 
#endif