DirectedConformerGenerator.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MOLASSEMBLER_DIRECTED_CONFORMER_GENERATOR_H
#define INCLUDE_MOLASSEMBLER_DIRECTED_CONFORMER_GENERATOR_H
 
#include "Molassembler/Conformers.h"
#include "Molassembler/BondStereopermutator.h"
#include "Molassembler/Options.h"
 
#include "boost/variant/variant_fwd.hpp"
 
#include <unordered_map>
 
namespace Scine {
namespace Utils {
class AtomCollection;
} // namespace Utils
 
namespace Molassembler {
 
class Molecule;
 
class MASM_EXPORT DirectedConformerGenerator {
public:
  using BondList = std::vector<BondIndex>;
  using DecisionList = std::vector<std::uint8_t>;
 
  constexpr static std::uint8_t unknownDecision = std::numeric_limits<std::uint8_t>::max();
 
  //* @brief Reason why a bond is ignored
  enum class IgnoreReason {
    AtomStereopermutatorPreconditionsUnmet,
    HasAssignedBondStereopermutator,
    HasTerminalConstitutingAtom,
    InCycle,
    IsEtaBond,
    RotationIsIsotropic
  };
 
  struct Relabeler;
 
 
  static boost::variant<IgnoreReason, BondStereopermutator> considerBond(
    const BondIndex& bondIndex,
    const Molecule& molecule,
    BondStereopermutator::Alignment alignment = BondStereopermutator::Alignment::Staggered
  );
 
  static unsigned distance(
    const DecisionList& a,
    const DecisionList& b,
    const DecisionList& bounds
  );
 
 
  explicit DirectedConformerGenerator(
    Molecule molecule,
    BondStereopermutator::Alignment alignment = BondStereopermutator::Alignment::Staggered,
    const BondList& bondsToConsider = {}
  );
 
  DirectedConformerGenerator(DirectedConformerGenerator&& other) noexcept;
  DirectedConformerGenerator& operator = (DirectedConformerGenerator&& other) noexcept;
  DirectedConformerGenerator(const DirectedConformerGenerator& other) = delete;
  DirectedConformerGenerator& operator = (const DirectedConformerGenerator& other) = delete;
  ~DirectedConformerGenerator();
 
 
  DecisionList generateNewDecisionList(Random::Engine& engine = randomnessEngine());
 
  bool insert(const DecisionList& decisionList);
 
  bool contains(const DecisionList& decisionList) const;
 
  BondStereopermutator::Alignment alignment() const;
 
  const BondList& bondList() const;
 
  unsigned decisionListSetSize() const;
 
  unsigned idealEnsembleSize() const;
 
  Result<Utils::PositionCollection> generateRandomConformation(
    const DecisionList& decisionList,
    const DistanceGeometry::Configuration& configuration = DistanceGeometry::Configuration {},
    BondStereopermutator::FittingMode fitting = BondStereopermutator::FittingMode::Nearest
  ) const;
 
  Result<Utils::PositionCollection> generateConformation(
    const DecisionList& decisionList,
    unsigned seed,
    const DistanceGeometry::Configuration& configuration = DistanceGeometry::Configuration {},
    BondStereopermutator::FittingMode fitting = BondStereopermutator::FittingMode::Nearest
  ) const;
 
  Molecule conformationMolecule(const DecisionList& decisionList) const;
 
  DecisionList getDecisionList(
    const Utils::AtomCollection& atomCollection,
    BondStereopermutator::FittingMode mode = BondStereopermutator::FittingMode::Nearest
  ) const;
 
  DecisionList getDecisionList(
    const Utils::PositionCollection& positions,
    BondStereopermutator::FittingMode mode = BondStereopermutator::FittingMode::Thresholded
  ) const;
 
  struct EnumerationSettings {
    EnumerationSettings() : configuration() {}
 
    unsigned dihedralRetries = 3;
    BondStereopermutator::FittingMode fitting = BondStereopermutator::FittingMode::Nearest;
    DistanceGeometry::Configuration configuration;
  };
 
  void enumerate(
    std::function<void(const DecisionList&, Utils::PositionCollection)> callback,
    unsigned seed,
    const EnumerationSettings& settings = {}
  );
 
  void enumerateRandom(
    std::function<void(const DecisionList&, Utils::PositionCollection)> callback,
    const EnumerationSettings& settings = {}
  );
 
  Relabeler relabeler() const;
 
  [[deprecated]]
  std::vector<int> binMidpointIntegers(const DecisionList& decision) const;
 
  std::vector<std::pair<int, int>> binBounds(const DecisionList& decision) const;
 
private:
  class Impl;
  std::unique_ptr<Impl> pImpl_;
};
 
struct DirectedConformerGenerator::Relabeler {
  struct DihedralInfo {
    std::vector<AtomIndex> is;
    AtomIndex j;
    AtomIndex k;
    std::vector<AtomIndex> ls;
    unsigned symmetryOrder;
  };
  using Interval = std::pair<double, double>;
  using Intervals = std::vector<Interval>;
 
  static Intervals densityBins(
    const std::vector<double>& dihedrals,
    double delta,
    unsigned symmetryOrder = 1
  );
 
  static std::pair<double, double> makeBounds(double phi, double tolerance);
  static std::pair<int, int> integerBounds(const std::pair<double, double>& bounds);
 
  Relabeler(const DirectedConformerGenerator::BondList& bonds, const Molecule& mol);
 
  std::vector<double> add(const Utils::PositionCollection& positions);
 
  std::vector<Intervals> bins(double delta=M_PI / 6) const;
 
  std::vector<std::vector<unsigned>> binIndices(
    const std::vector<Intervals>& allBins
  ) const;
 
  std::vector<std::vector<int>> binMidpointIntegers(
    const std::vector<std::vector<unsigned>>& binIndices,
    const std::vector<Intervals>& allBins
  ) const;
 
  std::vector<
    std::vector<std::pair<int, int>>
  > binBounds(
    const std::vector<std::vector<unsigned>>& binIndices,
    const std::vector<Intervals>& allBins
  ) const;
 
  std::vector<DihedralInfo> sequences;
  std::vector<std::vector<double>> observedDihedrals;
};
 
} // namespace Molassembler
} // namespace Scine
 
#endif