ClusterOrbits.hh

Go to the documentation of this file.

#ifndef CASM_ClusterOrbits
#define CASM_ClusterOrbits
 
#include <functional>
#include <iostream>
#include <utility>
#include <vector>
 
#include "casm/clusterography/ClusterSymCompare.hh"
#include "casm/clusterography/IntegralCluster.hh"
#include "casm/clusterography/IntegralClusterSymCompareTraits.hh"
 
namespace CASM {
 
namespace xtal {
class Site;
class UnitCellCoord;
}  // namespace xtal
template <typename OrbitType>
struct OrbitGenerators;
class PermuteIterator;
class Structure;
class SymGroup;
 
typedef std::function<bool(xtal::Site)> SiteFilterFunction;
 
typedef std::function<bool(IntegralCluster)> ClusterFilterFunction;
 
typedef std::function<std::vector<xtal::UnitCellCoord>(Structure const &,
                                                       SiteFilterFunction)>
    CandidateSitesFunction;
 
struct IntegralClusterOrbitGenerator {
  IntegralClusterOrbitGenerator(const IntegralCluster &_prototype,
                                bool _include_subclusters = true);
 
  IntegralCluster prototype;
  bool include_subclusters;
};
 
/* -- OrbitBranchSpecs Declarations ------------------------------------- */
 
template <typename _OrbitType>
class OrbitBranchSpecs {
 public:
  typedef std::vector<xtal::UnitCellCoord> Container;
  typedef Container::const_iterator const_iterator;
  typedef _OrbitType OrbitType;
  typedef typename OrbitType::Element ClusterType;
  typedef typename OrbitType::SymCompareType SymCompareType;
  typedef Structure PrimType;
 
  typedef std::function<bool(ClusterType)> Filter;
 
  template <typename SiteIterator>
  OrbitBranchSpecs(const PrimType &_prim, SiteIterator _begin,
                   SiteIterator _end, const SymGroup &_generating_grp,
                   Filter _filter, const SymCompareType &_sym_compare)
      : m_prim_ptr(&_prim),
        m_candidate_sites(_begin, _end),
        m_generating_grp(&_generating_grp),
        m_filter(_filter),
        m_sym_compare(_sym_compare) {}
 
  const PrimType &prim() const { return *m_prim_ptr; }
 
  std::pair<const_iterator, const_iterator> candidate_sites() const {
    return std::make_pair(m_candidate_sites.cbegin(), m_candidate_sites.cend());
  }
 
  const SymGroup &generating_group() const { return *m_generating_grp; }
 
  Filter filter() const { return m_filter; }
 
  const SymCompareType &sym_compare() const { return m_sym_compare; }
 
 private:
  const PrimType *m_prim_ptr;
 
  Container m_candidate_sites;
 
  const SymGroup *m_generating_grp;
 
  Filter m_filter;
 
  SymCompareType m_sym_compare;
};
 
template <typename OutputIterator>
OutputIterator neighborhood(Structure const &unit, double max_radius,
                            SiteFilterFunction site_filter,
                            OutputIterator result, double xtal_tol);
 
template <typename OutputIterator>
OutputIterator neighborhood(IntegralCluster const &phenomenal,
                            double cutoff_radius,
                            SiteFilterFunction site_filter,
                            bool include_phenomenal_sites,
                            OutputIterator result, double xtal_tol);
 
template <typename OrbitType, typename OutputIterator>
OutputIterator local_orbit_neighborhood(const OrbitType &orbit,
                                        OutputIterator result);
 
template <typename ClusterOrbitIterator, typename OutputIterator>
OutputIterator local_neighborhood(ClusterOrbitIterator begin,
                                  ClusterOrbitIterator end,
                                  OutputIterator result);
 
template <typename OrbitType>
bool has_local_neighborhood_overlap(std::vector<OrbitType> &local_orbits,
                                    const Eigen::Matrix3i &transf_mat);
 
template <typename OrbitType>
std::vector<Eigen::Matrix3i> viable_supercells(
    std::vector<OrbitType> &local_orbits,
    const std::vector<Eigen::Matrix3i> &transf_mat);
 
/* -- Custom clusters --- */
 
template <typename OrbitType>
OrbitGenerators<OrbitType> &insert_subcluster_generators(
    typename OrbitType::Element cluster,
    OrbitGenerators<OrbitType> &generators);
 
/* -- Orbit access/usage function declarations
 * ------------------------------------- */
 
template <typename OrbitIterator>
std::pair<OrbitIterator, OrbitIterator> orbit_branch(OrbitIterator begin,
                                                     OrbitIterator end,
                                                     Index size);
 
/* -- Cluster Orbit generating function declarations
 * ------------------------------------- */
 
template <typename OrbitType, typename OrbitOutputIterator>
OrbitOutputIterator make_asymmetric_unit(
    const OrbitBranchSpecs<OrbitType> &specs, OrbitOutputIterator result,
    std::ostream &status);
 
template <typename OrbitType, typename OrbitInputIterator,
          typename OrbitOutputIterator>
OrbitOutputIterator make_next_orbitbranch(
    OrbitInputIterator begin, OrbitInputIterator end,
    const OrbitBranchSpecs<OrbitType> &specs, OrbitOutputIterator result,
    std::ostream &status);
 
template <typename OrbitBranchSpecsIterator, typename OrbitOutputIterator>
OrbitOutputIterator make_orbits(
    OrbitBranchSpecsIterator begin, OrbitBranchSpecsIterator end,
    const std::vector<IntegralClusterOrbitGenerator> &custom_generators,
    OrbitOutputIterator result, std::ostream &status);
 
/* -- SymCompareType-Specific IntegralCluster Orbit functions --- */
 
template <typename OrbitOutputIterator>
OrbitOutputIterator make_prim_periodic_asymmetric_unit(
    std::shared_ptr<Structure const> prim_ptr,
    SiteFilterFunction const &site_filter, double xtal_tol,
    OrbitOutputIterator result, std::ostream &status);
 
template <typename OrbitOutputIterator>
OrbitOutputIterator make_prim_periodic_orbits(
    std::shared_ptr<Structure const> prim_ptr,
    std::vector<double> const &max_length,
    std::vector<IntegralClusterOrbitGenerator> const &custom_generators,
    SiteFilterFunction const &site_filter, double xtal_tol,
    OrbitOutputIterator result, std::ostream &status);
 
template <typename OutputIterator>
OutputIterator prim_periodic_orbit_neighborhood(
    const PrimPeriodicOrbit<IntegralCluster> &orbit, OutputIterator result);
 
template <typename ClusterOrbitIterator, typename OutputIterator>
OutputIterator prim_periodic_neighborhood(ClusterOrbitIterator begin,
                                          ClusterOrbitIterator end,
                                          OutputIterator result);
 
template <typename OutputIterator, typename OrbitType>
OutputIterator flower_neighborhood(OrbitType const &orbit,
                                   OutputIterator result);
 
template <typename ClusterOrbitIterator, typename OutputIterator>
OutputIterator flower_neighborhood(ClusterOrbitIterator begin,
                                   ClusterOrbitIterator end,
                                   OutputIterator result);
 
}  // namespace CASM
 
#endif