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