forcefield.hpp

Go to the documentation of this file.

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

#include <EASTL/bitset.h>
#include <map>
#include <memory>
#include <vector>

#ifndef INDIGOX_CLASSES_FORCEFIELD_HPP
#define INDIGOX_CLASSES_FORCEFIELD_HPP

namespace indigox {

  using FFParam = std::initializer_list<double>;

  class FFAtom {
    friend class cereal::access;
    friend class Forcefield;

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

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

  private:
    FFAtom(int32_t id, std::string name, const Element &element,
           const Forcefield &ff);

  public:
    int32_t GetID() const;

    std::string GetName() const;

    Forcefield GetForcefield() const;
    Element GetElement() const;

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

  class FFBond {
  public:
    friend class Forcefield;
    friend class cereal::access;

    enum class Type {
      Empty,    
      Harmonic, 
      Quartic,  
      Morse,
      Cubic,
      FENE
    };

  private:
    enum AllowEnum {
      Allow_ForceConstant,
      Allow_IdealLength,
      num_allow_positions
    };

    enum StoreEnum {
      Store_ForceConstant = 0,
      Store_IdealLength = 1,
      STORE_SIZE = 2
    };

    using AllowedMask = eastl::bitset<num_allow_positions, uint8_t>;

    using DataStore = std::array<double, STORE_SIZE>;

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

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

  private:
    FFBond(Type type, int32_t id, FFParam params, const Forcefield &ff);

  public:
    double GetForceConstant() const;

    double GetIdealLength() const;

    Type GetType() const;

    int32_t GetID() const;

    FFBond GetLinkedType() const;

    Forcefield GetForcefield() const;

  private:
    struct Impl;
    std::shared_ptr<Impl> m_data;
  };
  using BondType = FFBond::Type;

  class FFAngle {
  public:
    friend class Forcefield;
    friend class cereal::access;

    enum class Type { Empty, Harmonic, CosineHarmonic, UreyBradley, Quartic };

  private:
    enum AllowEnum {
      Allow_ForceConstant,
      Allow_IdealAngle,
      num_allow_positions
    };

    enum StoreEnum {
      Store_ForceConstant = 0,
      Store_IdealAngle = 1,
      STORE_SIZE = 2
    };

    using DataStore = std::array<double, STORE_SIZE>;
    using AllowedMask = eastl::bitset<num_allow_positions, uint8_t>;

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

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

  private:
    FFAngle(Type type, int32_t id, FFParam parameters, const Forcefield &ff);

  public:
    double GetForceConstant() const;

    double GetIdealAngle() const;

    Type GetType() const;

    int32_t GetID() const;

    FFAngle GetLinkedType() const;

    Forcefield GetForcefield() const;

  private:
    struct Impl;
    std::shared_ptr<Impl> m_data;
  };
  using AngleType = FFAngle::Type;

  class FFDihedral {
  public:
    friend class Forcefield;
    friend class cereal::access;

    enum class Type {
      Empty,
      Proper,
      Improper,
      RyckaertBellemans,
      PeriodicImproper,
      Fourier,
      Restricted
    };

  private:
    enum AllowEnum {
      Allow_PhaseShift,
      Allow_ForceConstant,
      Allow_Multiplicity,
      Allow_IdealAngle,
      num_allow_positions
    };

    enum StoreEnum {
      Store_PhaseShift = 0,
      Store_ForceConstant = 1,
      Store_Multiplicity = 2,
      Store_IdealAngle = 0,
      STORE_SIZE = 3
    };

    using DataStore = std::array<double, STORE_SIZE>;
    using AllowedMask = eastl::bitset<num_allow_positions>;

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

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

  private:
    FFDihedral(Type type, int32_t id, FFParam parameters, const Forcefield &ff);

  public:
    double GetPhaseShift() const;

    double GetForceConstant() const;

    int32_t GetMultiplicity() const;

    double GetIdealAngle() const;

    Type GetType() const;

    int32_t GetID() const;

    Forcefield GetForcefield() const;

  private:
    struct Impl;
    std::shared_ptr<Impl> m_data;
  };
  using DihedralType = FFDihedral::Type;

  class Forcefield {
    friend class cereal::access;

  public:
    enum class Family { Empty, GROMOS, CHARMM, AMBER, Other };

  private:
    using AtomTypes = std::vector<FFAtom>;
    using BondTypes = std::map<BondType, std::vector<FFBond>>;
    using AngleTypes = std::map<AngleType, std::vector<FFAngle>>;
    using DihedralTypes = std::map<DihedralType, std::vector<FFDihedral>>;

  public:
    INDIGOX_GENERIC_PIMPL_CLASS_DEFAULTS(Forcefield);
    INDIGOX_GENERIC_PIMPL_CLASS_OPERATORS(Forcefield, ff);

    Forcefield(Family family, std::string name);

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

  private:
    FFBond NewBondType(BondType type, int32_t id, FFParam param);

    FFAngle NewAngleType(AngleType type, int32_t id, FFParam param);

    FFDihedral NewDihedralType(DihedralType type, int32_t id, FFParam param);

  public:
    FFAtom NewAtomType(int32_t id, std::string name, const Element &element);

    void ReserveAtomTypes(size_t size);

    FFBond NewBondType(BondType type, int32_t id, double a, double b);

    void LinkBondTypes(const FFBond &a, const FFBond &b);

    void ReserveBondTypes(BondType type, size_t size);

    FFAngle NewAngleType(AngleType type, int32_t id, double a, double b);

    void LinkAngleTypes(const FFAngle &a, const FFAngle &b);

    void ReserveAngleTypes(AngleType type, size_t size);

    FFDihedral NewDihedralType(DihedralType type, int32_t id, double a,
                               double b, double c);

    FFDihedral NewDihedralType(DihedralType type, int32_t id, double a,
                               double b);

    void ReserveDihedralTypes(DihedralType type, size_t size);

  public:
    FFAtom GetAtomType(std::string name) const;

    FFAtom GetAtomType(int32_t id) const;

    size_t NumAtomTypes() const;

    FFBond GetBondType(BondType type, int32_t id) const;

    FFBond GetBondType(int32_t id) const;

    size_t NumBondTypes() const;

    size_t NumBondTypes(BondType type) const;

    FFAngle GetAngleType(AngleType type, int32_t id) const;

    FFAngle GetAngleType(int32_t id) const;

    size_t NumAngleTypes() const;

    size_t NumAngleTypes(AngleType type) const;

    FFDihedral GetDihedralType(DihedralType type, int32_t id) const;

    FFDihedral GetDihedralType(int32_t id) const;

    size_t NumDihedralTypes() const;

    size_t NumDihedralTypes(DihedralType type) const;

    Family GetFamily() const;

    std::string GetName() const;

  private:
    struct Impl;
    std::shared_ptr<Impl> m_data;
  };
  using FFFamily = Forcefield::Family;

  Forcefield GenerateGROMOS54A7();

  std::ostream &operator<<(std::ostream &os, BondType type);
  std::ostream &operator<<(std::ostream &os, AngleType type);
  std::ostream &operator<<(std::ostream &os, DihedralType type);
} // namespace indigox

#endif /* INDIGOX_CLASSES_FORCEFIELD_HPP */