AtomStereopermutator.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MOLASSEMBLER_ATOM_STEREOPERMUTATOR_H
#define INCLUDE_MOLASSEMBLER_ATOM_STEREOPERMUTATOR_H
 
#include "Molassembler/RankingInformation.h"
#include "Molassembler/Shapes/Data.h"
#include "Molassembler/Temple/StrongIndexPermutation.h"
 
#include <array>
#include <memory>
 
namespace Scine {
namespace Molassembler {
 
/* Forward declarations */
struct RankingInformation;
class AngstromPositions;
class Graph;
 
namespace Stereopermutators {
struct Abstract;
struct Feasible;
} // namespace Stereopermutators
 
namespace Random {
class Engine;
} // namespace Random
 
namespace DistanceGeometry {
 
class SpatialModel;
struct ChiralConstraint;
 
} // namespace DistanceGeometry
 
class MASM_EXPORT AtomStereopermutator {
public:
  using ShapeMap = Temple::StrongIndexPermutation<SiteIndex, Shapes::Vertex>;
 
  using SiteCentroids = Eigen::Matrix<double, 3, Eigen::Dynamic>;
 
  using ThermalizationPredicate = std::function<bool(AtomIndex, Shapes::Shape, const RankingInformation&)>;
 
  using FeasiblesGenerator = std::function<
    std::vector<unsigned>(
      const Stereopermutators::Abstract& abstract,
      Shapes::Shape shape,
      AtomIndex placement,
      const RankingInformation& ranking,
      std::vector<std::vector<SiteIndex>> siteGroups
    )
  >;
 
  using PropagatedState = std::tuple<RankingInformation, ShapeMap>;
 
  using MinimalChiralConstraint = std::array<boost::optional<SiteIndex>, 4>;
 
  AtomStereopermutator(AtomStereopermutator&& other) noexcept;
  AtomStereopermutator& operator = (AtomStereopermutator&& other) noexcept;
  AtomStereopermutator(const AtomStereopermutator& other);
  AtomStereopermutator& operator = (const AtomStereopermutator& other);
  ~AtomStereopermutator();
 
  [[deprecated("Prefer constructor without graph argument")]]
  AtomStereopermutator(
    const Graph& graph,
    Shapes::Shape shape,
    AtomIndex centerAtom,
    RankingInformation ranking
  );
 
  AtomStereopermutator(
    AtomIndex centerAtom,
    Shapes::Shape shape,
    RankingInformation ranking,
    const FeasiblesGenerator& feasibility = {},
    const ThermalizationPredicate& thermalization = {},
    const std::vector<std::vector<SiteIndex>>& siteGroups = {}
  );
 
 
  static Shapes::Shape up(Shapes::Shape shape);
 
  static Shapes::Shape down(Shapes::Shape shape, Shapes::Vertex removedVertex);
 
 
  static bool thermalized(
    AtomIndex centerAtom,
    Shapes::Shape shape,
    const RankingInformation& ranking,
    const Graph& graph
  );
 
  static auto thermalizationFunctor(const Graph& g) {
    return [&g](AtomIndex centerAtom, Shapes::Shape shape, const RankingInformation& ranking) {
      return AtomStereopermutator::thermalized(centerAtom, shape, ranking, g);
    };
  }
 
 
  void assign(boost::optional<unsigned> assignment,
              const std::vector<std::vector<SiteIndex>>& siteGroups = {});
 
  void assignRandom(Random::Engine& engine);
 
  void applyPermutation(const std::vector<AtomIndex>& permutation);
 
  boost::optional<ShapeMap> fit(
    const SiteCentroids& centroids,
    const FeasiblesGenerator& feasibility = {},
    const ThermalizationPredicate& thermalization = {}
  );
 
  boost::optional<ShapeMap> fit(
    const AngstromPositions& wrapper,
    const FeasiblesGenerator& feasibility = {},
    const ThermalizationPredicate& thermalization = {}
  );
 
  [[deprecated("Prefer graph-less alternative parameters")]]
  boost::optional<ShapeMap> fit(
    const Graph& graph,
    const AngstromPositions& angstromWrapper
  );
 
  MASM_NO_EXPORT boost::optional<PropagatedState> propagate(
    RankingInformation newRanking,
    boost::optional<Shapes::Shape> shapeOption,
    const FeasiblesGenerator& feasibility = {},
    const ThermalizationPredicate& thermalization = {}
  );
 
  void propagateVertexRemoval(AtomIndex removedIndex);
 
  void setShape(
    Shapes::Shape shape,
    const FeasiblesGenerator& feasibility = {},
    const ThermalizationPredicate& thermalization = {},
    const std::vector<std::vector<SiteIndex>>& siteGroups = {}
  );
 
  [[deprecated("Prefer graph-less alternative parameters")]]
  void setShape(
    Shapes::Shape shape,
    const Graph& graph,
    const std::vector<std::vector<SiteIndex>>& siteGroups = {}
  );
 
  void thermalize(bool thermalization = true);
 
 
  double angle(SiteIndex i, SiteIndex j) const;
 
  boost::optional<unsigned> assigned() const;
 
  AtomIndex placement() const;
 
  boost::optional<unsigned> indexOfPermutation() const;
 
  std::vector<MinimalChiralConstraint> minimalChiralConstraints(bool enforce = false) const;
 
  std::string info() const;
 
  std::string rankInfo() const;
 
  std::vector<std::vector<SiteIndex>> siteGroups() const;
 
  SiteCentroids sitePositions(
    const AngstromPositions& wrapper,
    const std::vector<std::pair<AtomIndex, AtomIndex>>& substitutions = {}
  ) const;
 
  bool thermalized() const;
 
  MASM_NO_EXPORT const Stereopermutators::Abstract& getAbstract() const;
 
  MASM_NO_EXPORT const std::vector<unsigned>& getFeasible() const;
 
  const RankingInformation& getRanking() const;
 
  Shapes::Shape getShape() const;
 
  const ShapeMap& getShapePositionMap() const;
 
  unsigned numAssignments() const;
 
  unsigned numStereopermutations() const;
 
 
 
  bool operator == (const AtomStereopermutator& other) const;
  bool operator != (const AtomStereopermutator& other) const;
 
  bool operator < (const AtomStereopermutator& other) const;
 
private:
  class Impl;
  std::unique_ptr<Impl> pImpl_;
};
 
} // namespace Molassembler
} // namespace Scine
 
#endif