Composites.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_STEREOPERMUTATION_COMPOSITES_H
#define INCLUDE_MOLASSEMBLER_STEREOPERMUTATION_COMPOSITES_H

#include "Molassembler/Shapes/Shapes.h"
#include "Molassembler/Shapes/Data.h"
#include "Molassembler/Stereopermutation/Stereopermutation.h"
#include "Molassembler/Temple/OrderedPair.h"
#include "Molassembler/Temple/constexpr/FloatingPointComparison.h"

#include "boost/optional.hpp"

namespace Scine {
namespace Molassembler {
namespace Stereopermutations {

class MASM_EXPORT Composite {
public:
  struct AngleGroup {
    double angle;
    std::vector<Shapes::Vertex> vertices;
    bool isotropic;
  };

  struct OrientationState : public Temple::Crtp::LexicographicComparable<OrientationState> {
    Shapes::Shape shape;
    Shapes::Vertex fusedVertex;
    Stereopermutation::Occupation occupation;
    std::size_t identifier;

    OrientationState(
      Shapes::Shape passShape,
      Shapes::Vertex passFusedVertex,
      Stereopermutation::Occupation passOccupation,
      std::size_t passIdentifier
    );

    Stereopermutation::Occupation rotateOccupation(const std::vector<Shapes::Vertex>& rotation) const;

    Shapes::Vertex lowestEqualVertexInShape() const;

    std::vector<Shapes::Vertex> findReductionMapping(Shapes::Vertex reducedFusedVertex) const;

    [[nodiscard]] std::vector<Shapes::Vertex> transformToCanonical();

    void revert(const std::vector<Shapes::Vertex>& reversionMapping);

    AngleGroup smallestAngleGroup() const;

    inline auto tie() const {
      // Comparisons should be performed in canonical space
      const Shapes::Vertex reducedVertex = lowestEqualVertexInShape();
      return std::make_tuple(
        shape,
        reducedVertex,
        rotateOccupation(findReductionMapping(reducedVertex))
      );
    }
  };

  enum class Alignment {
    Eclipsed,
    Staggered,
    EclipsedAndStaggered,
    BetweenEclipsedAndStaggered
  };

  struct Permutation {
    using DihedralTuple = std::tuple<Shapes::Vertex, Shapes::Vertex, double>;
    using VertexPair = std::pair<Shapes::Vertex, Shapes::Vertex>;

    bool close(const std::vector<DihedralTuple>& comparisonDihedrals) const;

    VertexPair alignedVertices;
    Alignment alignment;
    std::vector<DihedralTuple> dihedrals;
    boost::optional<VertexPair> rankingEquivalentTo;
  };

  using PermutationsList = std::vector<Permutation>;

  struct PermutationGenerator {
    static bool isDuplicate(
      Permutation permutation,
      const PermutationsList& permutations,
      double degrees
    );

    static PermutationsList deduplicate(PermutationsList permutations, double degrees);

    PermutationGenerator(Temple::OrderedPair<OrientationState> orientations);

    double dihedral(
      Shapes::Vertex firstVertex,
      Shapes::Vertex secondVertex
    ) const;

    Permutation align(
      Shapes::Vertex firstVertex,
      Shapes::Vertex secondVertex,
      Alignment alignment
    );

    PermutationsList generateEclipsedOrStaggered(
      Alignment alignment,
      double deduplicationDegrees
    );

    PermutationsList generate(
      Alignment alignment,
      double deduplicationDegrees=15
    );

    Temple::OrderedPair<OrientationState> orientations;
    std::pair<Shapes::Permutation, Shapes::Permutation> reversionMappings;
    std::pair<AngleGroup, AngleGroup> angleGroups;
    std::pair<Eigen::MatrixXd, Eigen::MatrixXd> coordinates;
  };


  Composite(
    OrientationState first,
    OrientationState second,
    Alignment alignment = Alignment::Eclipsed
  );
//
  static constexpr Temple::Floating::ExpandedAbsoluteEqualityComparator<double> fpComparator {
    Temple::Math::toRadians(1.0)
  };

  static std::vector<Shapes::Vertex> generateRotation(
    Shapes::Shape shape,
    Shapes::Vertex fixedVertex,
    const std::vector<Shapes::Vertex>& changedVertices
  );

  static std::vector<Shapes::Vertex> rotation(
    Shapes::Shape shape,
    Shapes::Vertex fixedVertex,
    const std::vector<Shapes::Vertex>& perpendicularPlaneVertices
  );

  void applyIdentifierPermutation(const std::vector<std::size_t>& permutation);

  template<typename F>
  void updateIdentifiers(F f) {
    // NOTE: OrientationState identifiers are not part of their comparison
    // operators, so no reordering can take place
    for(auto& orientationState : orientations_) {
      orientationState.identifier = f(orientationState.identifier);
    }
  }

  const PermutationsList& allPermutations() const;

  bool isIsotropic() const;

  std::pair<unsigned, unsigned> orders() const;

  unsigned order() const;

  unsigned rotationalAxisSymmetryOrder() const;

  const Temple::OrderedPair<OrientationState>& orientations() const;

  unsigned rankingEquivalentBase(unsigned permutation) const;

  std::vector<unsigned> nonEquivalentPermutationIndices() const;

  unsigned countNonEquivalentPermutations() const;

  Alignment alignment() const;

  PermutationsList::const_iterator begin() const;
  PermutationsList::const_iterator end() const;

  bool operator < (const Composite& other) const;
  bool operator == (const Composite& other) const;
  bool operator != (const Composite& other) const;

private:
  Temple::OrderedPair<OrientationState> orientations_;

  PermutationsList stereopermutations_;

  Alignment alignment_;

  static double perpendicularSubstituentAngle(
    double angleFromBoundShapeVertex,
    double angleBetweenSubstituents
  );
};

} // namespace Stereopermutations
} // namespace Molassembler
} // namespace Scine

#endif