molecule.hpp

Go to the documentation of this file.

#include "../utils/fwd_declares.hpp"

#include <bitset>
#include <cstdint>
#include <map>
#include <unordered_map>
#include <vector>

#ifndef INDIGOX_CLASSES_MOLECULE_HPP
#define INDIGOX_CLASSES_MOLECULE_HPP

namespace indigox {

  class Molecule {
    friend class cereal::access;

  public:
    using MoleculeAtoms = std::vector<Atom>;
    using MoleculeBonds = std::vector<Bond>;
    using MoleculeAngles = std::vector<Angle>;
    using MoleculeDihedrals = std::vector<Dihedral>;

    using MoleculeResidues = std::vector<Residue>;

  private:
    template <typename Archive>
    void serialise(Archive &archive, const uint32_t version);

  public:
    Molecule(std::string name);

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(Molecule);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(Molecule, mol);

  public:
    bool HasAtom(const Atom &atom) const;

    bool HasBond(const Bond &bond) const;

    bool HasBond(const Atom &a, const Atom &b) const;

    bool HasAngle(const Angle &angle) const;

    bool HasAngle(const Atom &a, const Atom &b, const Atom &c);

    bool HasDihedral(const Dihedral &dihedral) const;

    bool HasDihedral(const Atom &a, const Atom &b, const Atom &c,
                     const Atom &d);

    int64_t NumAtoms() const;

    int64_t NumBonds() const;

    int64_t NumAngles();

    int64_t NumDihedrals();

  public:
    Atom GetAtom(uint32_t pos) const;

    Atom GetAtomID(int64_t id) const;

    Atom GetAtomTag(int64_t tag) const;

    Bond GetBond(uint32_t pos) const;

    Bond GetBond(const Atom &a, const Atom &b) const;

    Bond GetBondID(int64_t id) const;

    Bond GetBondTag(int64_t tag) const;

    Angle GetAngle(uint32_t pos);

    Angle GetAngle(const Atom &a, const Atom &b, const Atom &c);

    Angle GetAngleID(int64_t id) const;

    Angle GetAngleTag(int64_t tag) const;

    Dihedral GetDihedral(uint32_t pos);

    Dihedral GetDihedral(const Atom &a, const Atom &b, const Atom &c,
                         const Atom &d);

    Dihedral GetDihedralID(int64_t id) const;

    Dihedral GetDihedralTag(int64_t tag) const;

    std::string GetFormula();

    const graph::MolecularGraph &GetGraph() const;

    const graph::CondensedMolecularGraph &GetCondensedGraph() const;

    const std::string &GetName() const;

    int32_t GetMolecularCharge() const;

    void SetName(std::string name);

    void SetMolecularCharge(int32_t q);

    Atom NewAtom();

    Atom NewAtom(const Element &element);

    Atom NewAtom(const Element &element, double x, double y, double z);

    Bond NewBond(const Atom &a, const Atom &b);

  private:
    Angle NewAngle(const Atom &a, const Atom &b, const Atom &c);

    Dihedral NewDihedral(const Atom &a, const Atom &b, const Atom &c,
                         const Atom &d, bool manual);

  public:
    Dihedral NewDihedral(const Atom &a, const Atom &b, const Atom &c,
                         const Atom &d);

    bool RemoveAtom(const Atom &atom);

    bool RemoveBond(const Bond &bond);

    bool RemoveBond(const Atom &a, const Atom &b);

  public:
    int64_t PerceiveAngles();

    int64_t PerceiveDihedrals();

    int32_t PerceiveResidues();
    //    size_t AssignElectrons();
    //    bool ApplyElectronAssignment(size_t);
    //    FCSCORE GetMinimumElectronAssignmentScore();

    void ReserveAtoms(int64_t num);

    void ReserveBonds(int64_t num);

    const MoleculeAtoms &GetAtoms() const;

    const MoleculeBonds &GetBonds() const;

    const MoleculeAngles &GetAngles(); // percevie first

    const MoleculeDihedrals &GetDihedrals(); // perceive first

    Residue GetResidueID(int32_t id); // perceive first

    const MoleculeResidues &GetResidues(); // perceive first

    const Forcefield &GetForcefield() const;

    void SetForcefield(const Forcefield &ff);

    void ResetForcefield(const Forcefield &ff);

    bool HasForcefield() const;

    void OptimiseChargeGroups();

    void ReorderAtoms(MoleculeAtoms &new_order);

    void ModificationMade();

  private:
    struct Impl;
    std::shared_ptr<Impl> m_data;
  };

  void SaveMolecule(const Molecule &mol, std::string path);
  Molecule LoadMolecule(std::string path);

} // namespace indigox

#endif /* INDIGOX_CLASSES_MOLECULE_HPP */