parameterised.hpp

Go to the documentation of this file.

#include "../utils/fwd_declares.hpp"
#include "../utils/numerics.hpp"
#include "../utils/quad.hpp"
#include "../utils/triple.hpp"

#include <EASTL/vector_map.h>
#include <array>
#include <vector>

#ifndef INDIGOX_CLASSES_PARAMETERISED_HPP
#define INDIGOX_CLASSES_PARAMETERISED_HPP

namespace indigox {

  class ParamAtom {
  public:
    using TypeCounts = eastl::vector_map<FFAtom, size_t>;
    using MappedCharge = std::vector<double>;
    friend class ParamMolecule;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(ParamAtom);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(ParamAtom, atm);

  public:
    ParamAtom(const Atom &atm);

  public:
    void MappedWith(const Atom &mapped);

    bool ApplyParameterisation(bool self_consistent);

  public:
    int64_t NumSourceAtoms() const;

    const Atom &GetAtom() const;

    double MeanCharge() const;

    double MeadianCharge();

    double StandardDeviationCharge() const;

    const FFAtom &GetMostCommonType() const;

    const TypeCounts &GetMappedTypeCounts() const;
    const MappedCharge &GetMappedCharges() const;

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

  class ParamBond {
  public:
    using TypeCounts = eastl::vector_map<FFBond, size_t>;
    using BondAtoms = std::pair<Atom, Atom>;
    friend class ParamMolecule;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(ParamBond);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(ParamBond, bnd);

  public:
    ParamBond(BondAtoms atms, const Bond &bnd);

  public:
    void MappedWith(const Bond &mapped);

    bool ApplyParameterisation(bool self_consistent);

  public:
    int64_t NumSourceBonds() const;

    const BondAtoms &GetAtoms() const;

    const Bond &GetBond() const;

    const FFBond &GetMostCommonType() const;

    const TypeCounts &GetMappedTypeCounts() const;

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

  class ParamAngle {
  public:
    using TypeCounts = eastl::vector_map<FFAngle, size_t>;
    using AngleAtoms = stdx::triple<Atom>;
    friend class ParamMolecule;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(ParamAngle);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(ParamAngle, ang);

  public:
    ParamAngle(AngleAtoms atms, const Angle &ang);

  public:
    void MappedWith(const Angle &mapped);

    bool ApplyParameterisation(bool self_consistent);

  public:
    int64_t NumSourceAngles() const;

    const AngleAtoms &GetAtoms() const;

    const Angle &GetAngle() const;

    const FFAngle &GetMostCommonType() const;

    const TypeCounts &GetMappedTypeCounts() const;

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

  class ParamDihedral {
  public:
    using TypeGroup = std::vector<FFDihedral>;
    using TypeCounts = eastl::vector_map<TypeGroup, size_t>;
    using DihedralAtoms = stdx::quad<Atom>;

    friend class ParamMolecule;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(ParamDihedral);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(ParamDihedral, dhd);

  public:
    ParamDihedral(DihedralAtoms atms, const Dihedral &dhd);

  public:
    void MappedWith(const Dihedral &mapped);

    bool ApplyParameterisation(bool self_consistent);

  public:
    int64_t NumSourceDihedral() const;

    const DihedralAtoms &GetAtoms() const;

    const Dihedral &GetDihedral() const;

    const TypeGroup &GetMostCommonType() const;

    const TypeCounts &GetMappedTypeCounts() const;

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

  class ParamMolecule {
  public:
    using ParamAtoms = eastl::vector_map<Atom, uint32_t>;
    using PBond = std::pair<Atom, Atom>;
    using ParamBonds = eastl::vector_map<PBond, uint32_t>;
    using PAngle = stdx::triple<Atom>;
    using ParamAngles = eastl::vector_map<PAngle, uint32_t>;
    using PDihedral = stdx::quad<Atom>;
    using ParamDihedrals = eastl::vector_map<PDihedral, uint32_t>;

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

    ParamMolecule(const Molecule &mol);

  public:
    void ApplyParameteristion(bool self_consistent);

  public:
    const ParamAtom &GetAtom(const Atom &atm) const;

    const ParamBond &GetBond(const Bond &bnd) const;

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

    const ParamAngle &GetAngle(const Angle &ang) const;

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

    const ParamDihedral &GetDihedral(const Dihedral &dhd);

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

    const std::vector<ParamAtom> &GetAtoms() const;
    const std::vector<ParamBond> &GetBonds() const;
    const std::vector<ParamAngle> &GetAngles() const;
    const std::vector<ParamDihedral> &GetDihedrals() const;

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

} // namespace indigox

#endif /* INDIGOX_CLASSES_PARAMETERISED_HPP */