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/StrongIndexMap.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::StrongIndexFlatMap<SiteIndex, Shapes::Vertex>;

  using PropagatedState = std::tuple<
    RankingInformation,
    Stereopermutators::Abstract,
    Stereopermutators::Feasible,
    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();

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


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

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


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

  void assignRandom(Random::Engine& engine);

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

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

  MASM_NO_EXPORT 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
  );


  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;

  MASM_NO_EXPORT const Stereopermutators::Abstract& getAbstract() const;

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