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:
/* Typedefs */
  using StereopermutationType = Stereopermutations::Stereopermutation;


  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(
    const Graph& graph,
    AtomIndex centerAtom,
    const Shapes::Shape shape,
    const RankingInformation& ranking
  );

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

/* Modification */
  void assign(boost::optional<unsigned> assignment);

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

  void assignRandom(Random::Engine& engine);

  void applyPermutation(const std::vector<AtomIndex>& permutation);

  boost::optional<ShapeMap> fit(
    const Graph& graph,
    const AngstromPositions& angstromWrapper
  );

  boost::optional<PropagatedState> propagate(
    const Graph& graph,
    RankingInformation newRanking,
    boost::optional<Shapes::Shape> shapeOption
  );

  void propagateVertexRemoval(AtomIndex removedIndex);

  void setShape(
    Shapes::Shape shape,
    const Graph& graph
  );

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

  const Stereopermutators::Abstract& getAbstract() const;

  const Stereopermutators::Feasible& 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_;

  Stereopermutators::Feasible feasible_;

  boost::optional<unsigned> assignmentOption_;

  ShapeMap shapePositionMap_;

  bool thermalized_;
};

} // namespace Molassembler

} // namespace Scine

#endif