ClexBasis.hh

Go to the documentation of this file.

#ifndef CLEXBASIS_HH
#define CLEXBASIS_HH
 
#include <string>
 
#include "casm/basis_set/BasisSet.hh"
#include "casm/casm_io/json/jsonParser.hh"
#include "casm/clex/ClexBasisSpecs.hh"
#include "casm/clex/OrbitFunctionTraits.hh"
#include "casm/clusterography/ClusterDecl.hh"
#include "casm/crystallography/DoFDecl.hh"
#include "casm/global/enum.hh"
#include "casm/misc/ParsingDictionary.hh"
 
namespace CASM {
namespace xtal {
class Site;
class BasicStructure;
class UnitCell;
}  // namespace xtal
using xtal::BasicStructure;
using xtal::Site;
using xtal::UnitCell;
 
namespace DoFType {
class Traits;
}
class PrimNeighborList;
class ClexBasisBuilder;
 
class ClexBasis {
 public:
  typedef std::vector<BasisSet> BSetOrbit;
  typedef std::vector<BSetOrbit>::const_iterator BSetOrbitIterator;
 
  typedef Structure PrimType;
  typedef std::shared_ptr<const Structure> PrimType_ptr;
 
  ClexBasis(PrimType_ptr _prim_ptr, ClexBasisSpecs const &_basis_set_specs,
            ParsingDictionary<DoFType::Traits> const *_dof_dict);
 
  PrimType const &prim() const;
 
  PrimType_ptr shared_prim() const;
 
  ClexBasisSpecs const &basis_set_specs() const;
 
  ParsingDictionary<DoFType::Traits> const *dof_dict() const;
 
  DoFType::Traits const &lookup_dof_type_traits(std::string const &key) const;
 
  Index n_sublat() const;
 
  Index n_orbits() const;
 
  Index n_functions() const;
 
  BasisSet const &clust_basis(Index orbit_ind, Index equiv_ind) const {
    return m_bset_tree[orbit_ind][equiv_ind];
  }
 
  BSetOrbit const &bset_orbit(Index orbit_ind) const {
    return m_bset_tree[orbit_ind];
  }
 
  BSetOrbitIterator begin() const { return m_bset_tree.cbegin(); }
 
  BSetOrbitIterator cbegin() const { return m_bset_tree.cbegin(); }
 
  BSetOrbitIterator end() const { return m_bset_tree.cbegin(); }
 
  BSetOrbitIterator cend() const { return m_bset_tree.cbegin(); }
 
  std::map<DoFKey, std::vector<BasisSet> > const &site_bases() const {
    return m_site_bases;
  }
 
  std::map<DoFKey, std::vector<BasisSet> > const &global_bases() const {
    return m_global_bases;
  }
 
  template <typename OrbitIterType>
  void generate(OrbitIterType _begin, OrbitIterType _end);
 
 private:
  template <typename OrbitType>
  BasisSet _construct_prototype_basis(OrbitType const &_orbit,
                                      std::vector<DoFKey> const &local_keys,
                                      std::vector<DoFKey> const &global_keys,
                                      Index max_poly_order) const;
 
  void _populate_site_bases();
 
  PrimType_ptr m_prim_ptr;
 
  ClexBasisSpecs m_basis_set_specs;
 
  ParsingDictionary<DoFType::Traits> const *m_dof_dict;
 
  notstd::cloneable_ptr<ClexBasisBuilder> m_basis_builder;
 
  // std::vector<OrbitType> m_orbitree
 
  std::vector<BSetOrbit> m_bset_tree;
 
  std::map<DoFKey, std::vector<BasisSet> > m_site_bases;
 
  std::map<DoFKey, std::vector<BasisSet> > m_global_bases;
};
 
Index print_clust_basis(std::ostream &stream, BasisSet _clust_basis,
                        IntegralCluster const &_prototype, Index func_ind = 0,
                        int space = 18, char delim = '\n');
 
template <typename OrbitType>
void print_proto_clust_funcs(ClexBasis const &_clex_basis, std::ostream &out,
                             BasicStructure const &_prim,
                             std::vector<OrbitType> const &_tree);
 
namespace ClexBasis_impl {
std::vector<DoFKey> extract_dof_types(Structure const &_prim);
 
template <typename OrbitType>
BasisSet construct_proto_dof_basis(OrbitType const &_orbit,
                                   BasisSet::ArgList const &site_dof_sets);
 
// template<typename UCCIterType, typename IntegralClusterSymCompareType>
// std::map<UnitCellCoord, std::set<UnitCellCoord> > unique_ucc(UCCIterType
// begin, UCCIterType end, IntegralClusterSymCompareType const &sym_compare);
}  // namespace ClexBasis_impl
}  // namespace CASM
 
#endif