AtomStereopermutatorImpl.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_ATOM_STEREOPERMUTATOR_IMPL_H
#define INCLUDE_MOLASSEMBLER_ATOM_STEREOPERMUTATOR_IMPL_H

#include "Molassembler/AtomStereopermutator.h"

#include "Molassembler/DistanceGeometry/DistanceGeometry.h"
#include "Molassembler/Stereopermutators/AbstractPermutations.h"
#include "Molassembler/Stereopermutators/FeasiblePermutations.h"

#include "boost/optional.hpp"

namespace Scine {
namespace Molassembler {

namespace Shapes {
namespace Properties {
struct ShapeTransitionGroup;
} // namespace Properties
} // namespace Shapes

class AtomStereopermutator::Impl : public Temple::Crtp::LexicographicComparable<Impl> {
public:

  static Shapes::Shape up(Shapes::Shape shape);

  static Shapes::Shape down(Shapes::Shape shape, Shapes::Vertex removedVertex);

  static boost::optional<std::vector<Shapes::Vertex>> selectTransitionMapping(
    const Shapes::Properties::ShapeTransitionGroup& mappingsGroup,
    const ChiralStatePreservation& preservationOption
  );

  static bool thermalized(
    AtomIndex centerAtom,
    Shapes::Shape shape,
    const RankingInformation& ranking,
    const Graph& graph
  );

/* Constructors */
  Impl(
    const Graph& graph,
    Shapes::Shape shape,
    AtomIndex centerAtom,
    RankingInformation ranking
  );

  Impl(
    AtomIndex centerAtom,
    Shapes::Shape shape,
    RankingInformation ranking,
    const FeasiblesGenerator& feasibility,
    const ThermalizationPredicate& thermalization,
    const std::vector<std::vector<SiteIndex>>& siteGroups = {});

/* Modification */
  void assign(boost::optional<unsigned> assignment,
              const std::vector<std::vector<SiteIndex>>& siteGroups = {});

  void assign(std::vector<Shapes::Vertex> vertexMapping);

  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<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 = {}
  );

  void thermalize(bool thermalization);

/* Information */
  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;

  inline bool thermalized() const {
    return thermalized_;
  }

  const Stereopermutators::Abstract& getAbstract() const;

  const std::vector<unsigned>& getFeasible() const;

  const RankingInformation& getRanking() const;

  Shapes::Shape getShape() const;

  const ShapeMap& getShapePositionMap() const;

  unsigned numAssignments() const;

  unsigned numStereopermutations() const;

/* Operators */
  inline auto tie() const {
    return std::make_tuple(shape_, centerAtom_, numStereopermutations(), assigned());
  }

private:
/* State */
  AtomIndex centerAtom_;

  Shapes::Shape shape_;

  RankingInformation ranking_;

  Stereopermutators::Abstract abstract_;

  std::vector<unsigned> feasibles_;

  boost::optional<unsigned> assignmentOption_;

  ShapeMap shapePositionMap_;

  bool thermalized_;
};

} // namespace Molassembler
} // namespace Scine

#endif