Molecule.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MOLASSEMBLER_MOLECULE_H
#define INCLUDE_MOLASSEMBLER_MOLECULE_H
 
#include "Molassembler/Graph/GraphInterface.h"
#include "boost/optional.hpp"
 
#include "Molassembler/BondStereopermutator.h"
#include "Molassembler/Options.h"
 
namespace Scine {
// External forward declarations
namespace Utils {
using ElementTypeCollection = std::vector<ElementType>;
class AtomCollection;
} // namespace Utils
 
namespace Molassembler {
 
// Forward declarations
class Graph;
class StereopermutatorList;
struct RankingInformation;
class AtomStereopermutator;
struct PeriodicBoundaryDuplicates;
 
class MASM_EXPORT Molecule final : public GraphInterface {
public:
 
 
  static Utils::AtomCollection applyCanonicalizationMap(
    const std::vector<AtomIndex>& canonicalizationIndexMap,
    const Utils::AtomCollection& atomCollection
  );
 
  /* Rule of five members */
  Molecule(Molecule&& other) noexcept;
  Molecule& operator = (Molecule&& rhs) noexcept;
  Molecule(const Molecule& other);
  Molecule& operator = (const Molecule& rhs);
  ~Molecule() final;
 
  Molecule() noexcept;
 
  Molecule(Utils::ElementType element) noexcept;
 
  Molecule(
    Utils::ElementType a,
    Utils::ElementType b,
    BondType bondType = BondType::Single
  ) noexcept;
 
  explicit Molecule(Graph graph);
 
  Molecule(
    Graph graph,
    const AngstromPositions& positions,
    const boost::optional<
      std::vector<BondIndex>
    >& bondStereopermutatorCandidatesOptional = boost::none
  );
 
  MASM_NO_EXPORT Molecule(
    Graph graph,
    const AngstromPositions& positions,
    const boost::optional<
      std::vector<BondIndex>
    >& bondStereopermutatorCandidatesOptional,
    const PeriodicBoundaryDuplicates& boundaries
  );
 
  MASM_NO_EXPORT Molecule(
    Graph graph,
    StereopermutatorList stereopermutators,
    boost::optional<AtomEnvironmentComponents> canonicalComponentsOption = boost::none
  );
 
 
  AtomIndex addAtom(
    Utils::ElementType elementType,
    AtomIndex adjacentTo,
    BondType bondType = BondType::Single
  ) final;
 
  BondIndex addBond(
    AtomIndex a,
    AtomIndex b,
    BondType bondType = BondType::Single
  ) final;
 
  const BondStereopermutator& addPermutator(
    const BondIndex& bond,
    BondStereopermutator::Alignment alignment = BondStereopermutator::Alignment::Eclipsed
  );
 
  void applyPermutation(const std::vector<AtomIndex>& permutation);
 
  void assignStereopermutator(
    AtomIndex a,
    const boost::optional<unsigned>& assignmentOption
  );
 
  void assignStereopermutator(
    const BondIndex& edge,
    const boost::optional<unsigned>& assignmentOption
  );
 
  void assignStereopermutatorRandomly(AtomIndex a, Random::Engine& engine = randomnessEngine());
 
  void assignStereopermutatorRandomly(const BondIndex& e, Random::Engine& engine = randomnessEngine());
 
  std::vector<AtomIndex> canonicalize(
    AtomEnvironmentComponents componentBitmask = AtomEnvironmentComponents::All
  );
 
  void removeAtom(AtomIndex a) final;
 
  void removeBond(AtomIndex a, AtomIndex b);
 
  void removeBond(const BondIndex& bond) final;
 
  bool removePermutator(const BondIndex& bond);
 
  bool setBondType(
    AtomIndex a,
    AtomIndex b,
    BondType bondType
  ) final;
 
  void setElementType(
    AtomIndex a,
    Utils::ElementType elementType
  ) final;
 
  void setShapeAtAtom(
    AtomIndex a,
    Shapes::Shape shape
  );
 
  void thermalizeStereopermutator(AtomIndex a, bool thermalization = true);
 
  struct MASM_NO_EXPORT unsafe_tag_t {};
  static constexpr unsafe_tag_t unsafe_tag {};
  MASM_NO_EXPORT StereopermutatorList& stereopermutators(unsafe_tag_t /* tag */);
  MASM_NO_EXPORT Graph& graph(unsafe_tag_t /* tag */);
  MASM_NO_EXPORT void propagate(unsafe_tag_t /* tag */);
 
  bool adjacent(AtomIndex a, AtomIndex b) const final;
 
  boost::optional<BondIndex> bond(AtomIndex a, AtomIndex b) const final;
 
  BondType bondType(const BondIndex& edge) const final;
 
  bool canRemove(AtomIndex a) const final;
 
  bool canRemove(const BondIndex& edge) const final;
 
  const Cycles& cycles() const final;
 
  unsigned degree(AtomIndex a) const final;
 
  Utils::ElementType elementType(AtomIndex a) const final;
 
  AtomIndex V() const final;
 
  unsigned E() const final;
 
 
  boost::optional<AtomEnvironmentComponents> canonicalComponents() const;
 
  boost::optional<Shapes::Shape> inferShape(
    AtomIndex index,
    const RankingInformation& ranking
  ) const;
 
  std::string dumpGraphviz() const;
 
  const Graph& graph() const;
 
  std::size_t hash() const;
 
  const StereopermutatorList& stereopermutators() const;
 
  StereopermutatorList inferStereopermutatorsFromPositions(
    const AngstromPositions& angstromWrapper,
    const boost::optional<
      std::vector<BondIndex>
    >& explicitBondStereopermutatorCandidatesOption = boost::none
  ) const;
 
  std::string str() const;
 
  RankingInformation rankPriority(
    AtomIndex a,
    const std::vector<AtomIndex>& excludeAdjacent = {},
    const boost::optional<AngstromPositions>& positionsOption = boost::none
  ) const;
 
 
  bool canonicalCompare(
    const Molecule& other,
    AtomEnvironmentComponents componentBitmask = AtomEnvironmentComponents::All
  ) const;
 
  boost::optional<std::vector<AtomIndex>> modularIsomorphism(
    const Molecule& other,
    AtomEnvironmentComponents componentBitmask
  ) const;
 
 
  bool operator == (const Molecule& other) const;
  bool operator != (const Molecule& other) const;
 
private:
  struct Impl;
  std::unique_ptr<Impl> pImpl_;
};
 
} // namespace Molassembler
} // namespace Scine
 
MASM_EXPORT std::ostream& operator << (
  std::ostream& os,
  const Scine::Molassembler::Molecule& molecule
);
 
#endif