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 {

namespace outcome = OUTCOME_V2_NAMESPACE;

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;

  outcome::result<Utils::PositionCollection> generateRandomConformation(
    const DecisionList& decisionList,
    const DistanceGeometry::Configuration& configuration = DistanceGeometry::Configuration {},
    BondStereopermutator::FittingMode fitting = BondStereopermutator::FittingMode::Nearest
  ) const;

  outcome::result<Utils::PositionCollection> generateConformation(
    const DecisionList& decisionList,
    const 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()
      : dihedralRetries(3),
        fitting(BondStereopermutator::FittingMode::Nearest),
        configuration()
    {}

    unsigned dihedralRetries;
    BondStereopermutator::FittingMode fitting;
    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;

  std::vector<int> binMidpointIntegers(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
  );

  Relabeler(DirectedConformerGenerator::BondList bonds, const Molecule& mol);

  void 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<DihedralInfo> sequences;
  std::vector<std::vector<double>> observedDihedrals;
};

} // namespace Molassembler
} // namespace Scine

#endif