BasisFunctionSpecs.hh

Go to the documentation of this file.

#ifndef CASM_BasisFunctionSpecs
#define CASM_BasisFunctionSpecs
 
#include <algorithm>
#include <map>
#include <vector>
 
#include "casm/crystallography/DoFDecl.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/cloneable_ptr.hh"
 
namespace CASM {
 
// --- Generic BasisFunctionSpecs ---
 
enum class PARAM_PACK_TYPE { DEFAULT, DIFF };
 
class DoFSpecs : public notstd::Cloneable {
  ABSTRACT_CLONEABLE(DoFSpecs)
 public:
  DoFKey name() const;
 
 private:
  virtual DoFKey _name() const = 0;
};
 
struct BasisFunctionSpecs {
  typedef Index MaxPolyOrder;
  typedef Index OrbitBranchSize;
 
  BasisFunctionSpecs(
      std::vector<DoFKey> _dof_keys = {},
      std::vector<notstd::cloneable_ptr<DoFSpecs>> _dof_specs = {},
      MaxPolyOrder _global_max_poly_order = -1,
      std::map<OrbitBranchSize, MaxPolyOrder> _orbit_branch_max_poly_order = {},
      std::vector<Index> _include_functions = {},
      std::vector<Index> _exclude_functions = {},
      PARAM_PACK_TYPE _param_pack_type = PARAM_PACK_TYPE::DEFAULT);
 
  std::vector<DoFKey> dof_keys;
 
  std::vector<notstd::cloneable_ptr<DoFSpecs>> dof_specs;
 
  MaxPolyOrder global_max_poly_order;
 
  std::map<OrbitBranchSize, MaxPolyOrder> orbit_branch_max_poly_order;
 
  // Note: Could allow more customization of max_poly_order, by orbit
  // std::map<IntegralCluster, Index> orbit_max_poly_order;
 
  std::vector<Index> include_functions;
 
  std::vector<Index> exclude_functions;
 
  PARAM_PACK_TYPE param_pack_type;
};
 
template <typename DoFSpecsType>
DoFSpecsType const &get(DoFKey const &key,
                        BasisFunctionSpecs const &basis_function_specs);
 
}  // namespace CASM
 
#include <sstream>
 
#include "casm/global/errors.hh"
 
namespace CASM {
 
inline DoFKey DoFSpecs::name() const { return this->_name(); }
 
inline BasisFunctionSpecs::BasisFunctionSpecs(
    std::vector<DoFKey> _dof_keys,
    std::vector<notstd::cloneable_ptr<DoFSpecs>> _dof_specs,
    MaxPolyOrder _global_max_poly_order,
    std::map<OrbitBranchSize, MaxPolyOrder> _orbit_branch_max_poly_order,
    std::vector<Index> _include_functions,
    std::vector<Index> _exclude_functions, PARAM_PACK_TYPE _param_pack_type)
    : dof_keys(std::move(_dof_keys)),
      dof_specs(std::move(_dof_specs)),
      global_max_poly_order(_global_max_poly_order),
      orbit_branch_max_poly_order(_orbit_branch_max_poly_order),
      include_functions(_include_functions),
      exclude_functions(_exclude_functions),
      param_pack_type(_param_pack_type) {}
 
template <typename DoFSpecsType>
DoFSpecsType const &get(DoFKey const &key,
                        BasisFunctionSpecs const &basis_function_specs) {
  auto it = std::find_if(basis_function_specs.dof_specs.begin(),
                         basis_function_specs.dof_specs.end(),
                         [&](notstd::cloneable_ptr<DoFSpecs> const &ptr) {
                           return ptr->name() == key;
                         });
  if (it == basis_function_specs.dof_specs.end()) {
    std::stringstream ss;
    ss << "DoFSpecs not found in BasisFunctionSpecs for " << key;
    throw libcasm_runtime_error{ss.str()};
  }
  return static_cast<DoFSpecsType const &>(**it);
}
 
}  // namespace CASM
#endif