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