doxygen/nonbonded__potential_8h_source.html

// -*-c++-*-

#ifndef STORMM_NONBONDED_POTENTIAL_H

#define STORMM_NONBONDED_POTENTIAL_H


#include "copyright.h"

#include "Constants/generalized_born.h"

#include "DataTypes/common_types.h"

#include "Math/rounding.h"

#include "Topology/atomgraph.h"

#include "Trajectory/coordinateframe.h"

#include "Trajectory/coordinate_series.h"

#include "Trajectory/phasespace.h"

#include "energy_abstracts.h"

#include "energy_enumerators.h"

#include "scorecard.h"

#include "soft_core_potentials.h"

#include "static_exclusionmask.h"


namespace stormm {

namespace energy {


using data_types::isSignedIntegralScalarType;

using stmath::roundUp;

using topology::AtomGraph;

using topology::ImplicitSolventKit;

using topology::NonbondedKit;

using topology::UnitCellType;

using trajectory::CoordinateFrame;

using trajectory::CoordinateFrameReader;

using trajectory::CoordinateFrameWriter;

using trajectory::CoordinateSeries;

using trajectory::CoordinateSeriesReader;

using trajectory::CoordinateSeriesWriter;

using trajectory::PhaseSpace;

using trajectory::PhaseSpaceWriter;

using namespace generalized_born_defaults;


template <typename Tcoord, typename Tforce, typename Tcalc>

double2 evaluateNonbondedEnergy(const NonbondedKit<Tcalc> nbk, const StaticExclusionMaskReader ser,

                                const Tcoord* xcrd, const Tcoord* ycrd, const Tcoord* zcrd,

                                const double* umat, const double* invu, UnitCellType unit_cell,

                                Tforce* xfrc, Tforce* yfrc, Tforce* zfrc, ScoreCard *ecard,

                                EvaluateForce eval_elec_force, EvaluateForce eval_vdw_force,

                                int system_index, Tcalc inv_gpos_factor = 1.0,

                                Tcalc force_factor = 1.0, Tcalc clash_distance = 0.0,

                                Tcalc clash_ratio = 0.0);


double2 evaluateNonbondedEnergy(const NonbondedKit<double> nbk,

                                const StaticExclusionMaskReader ser, PhaseSpaceWriter psw,

                                ScoreCard *ecard,

                                EvaluateForce eval_elec_force = EvaluateForce::NO,

                                EvaluateForce eval_vdw_force  = EvaluateForce::NO,

                                int system_index = 0, double clash_distance = 0.0,

                double clash_ratio = 0.0);


double2 evaluateNonbondedEnergy(const AtomGraph &ag, const StaticExclusionMask &se, PhaseSpace *ps,

                                ScoreCard *ecard,

                                EvaluateForce eval_elec_force = EvaluateForce::NO,

                                EvaluateForce eval_vdw_force  = EvaluateForce::NO,

                                int system_index = 0, double clash_distance = 0.0,

                double clash_ratio = 0.0);


double2 evaluateNonbondedEnergy(const AtomGraph *ag, const StaticExclusionMask &se, PhaseSpace *ps,

                                ScoreCard *ecard,

                                EvaluateForce eval_elec_force = EvaluateForce::NO,

                                EvaluateForce eval_vdw_force  = EvaluateForce::NO,

                                int system_index = 0, double clash_distance = 0.0,

                double clash_ratio = 0.0);


double2 evaluateNonbondedEnergy(const NonbondedKit<double> nbk,

                                const StaticExclusionMaskReader ser, CoordinateFrameReader cfr,

                                ScoreCard *ecard, int system_index = 0,

                                double clash_distance = 0.0, double clash_ratio = 0.0);


double2 evaluateNonbondedEnergy(const NonbondedKit<double> nbk,

                                const StaticExclusionMaskReader ser,

                                const CoordinateFrameWriter &cfw, ScoreCard *ecard,

                                int system_index = 0, double clash_distance = 0.0,

                double clash_ratio = 0.0);


double2 evaluateNonbondedEnergy(const AtomGraph &ag, const StaticExclusionMask &se,

                                const CoordinateFrame &cf, ScoreCard *ecard, int system_index = 0,

                                double clash_distance = 0.0, double clash_ratio = 0.0);


double2 evaluateNonbondedEnergy(const AtomGraph *ag, const StaticExclusionMask &se,

                                const CoordinateFrame &cf, ScoreCard *ecard, int system_index = 0,

                                double clash_distance = 0.0, double clash_ratio = 0.0);


template <typename Tcoord, typename Tcalc>

double2 evaluateNonbondedEnergy(const NonbondedKit<Tcalc> &nbk,

                                const StaticExclusionMaskReader &ser,

                                const CoordinateSeriesReader<Tcoord> csr, ScoreCard *ecard,

                                int system_index = 0, Tcalc clash_distance = 0.0,

                Tcalc clash_ratio = 0.0);


template <typename Tcoord, typename Tforce, typename Tcalc>

double evaluateGeneralizedBornEnergy(const NonbondedKit<Tcalc> nbk,

                                     const StaticExclusionMaskReader ser,

                                     const ImplicitSolventKit<Tcalc> isk,

                                     const NeckGeneralizedBornKit<Tcalc> ngb_kit,

                                     const Tcoord* xcrd, const Tcoord* ycrd, const Tcoord* zcrd,

                                     Tforce* xfrc, Tforce* yfrc, Tforce* zfrc,

                                     Tforce *effective_gb_radii, Tforce *psi, Tforce *sumdeijda,

                                     ScoreCard *ecard, EvaluateForce eval_force,

                                     int system_index = 0, Tcalc inv_gpos_factor = 1.0,

                                     Tcalc force_factor = 1.0);


double evaluateGeneralizedBornEnergy(const NonbondedKit<double> nbk,

                                     const StaticExclusionMaskReader ser,

                                     const ImplicitSolventKit<double> isk,

                                     const NeckGeneralizedBornKit<double> ngb_kit,

                                     PhaseSpaceWriter psw, ScoreCard *ecard,

                                     EvaluateForce eval_force = EvaluateForce::NO,

                                     int system_index = 0);


double evaluateGeneralizedBornEnergy(const AtomGraph &ag, const StaticExclusionMask &se,

                                     const NeckGeneralizedBornTable &ngb_tables, PhaseSpace *ps,

                                     ScoreCard *ecard,

                                     EvaluateForce eval_force = EvaluateForce::NO,

                                     int system_index = 0);


double evaluateGeneralizedBornEnergy(const AtomGraph *ag, const StaticExclusionMask &se,

                                     const NeckGeneralizedBornTable &ngb_tables, PhaseSpace *ps,

                                     ScoreCard *ecard,

                                     EvaluateForce eval_force = EvaluateForce::NO,

                                     int system_index = 0);


double evaluateGeneralizedBornEnergy(const NonbondedKit<double> nbk,

                                     const StaticExclusionMaskReader ser,

                                     const ImplicitSolventKit<double> isk,

                                     const NeckGeneralizedBornKit<double> ngb_kit,

                                     const CoordinateFrameReader cfr, ScoreCard *ecard,

                                     int system_index = 0);


double evaluateGeneralizedBornEnergy(const NonbondedKit<double> nbk,

                                     const StaticExclusionMaskReader ser,

                                     const ImplicitSolventKit<double> isk,

                                     const NeckGeneralizedBornKit<double> ngb_kit,

                                     const CoordinateFrameWriter &cfw, ScoreCard *ecard,

                                     int system_index = 0);


double evaluateGeneralizedBornEnergy(const AtomGraph &ag, const StaticExclusionMask &se,

                                     const NeckGeneralizedBornTable &ngb_tables,

                                     const CoordinateFrame &cf, ScoreCard *ecard,

                                     int system_index = 0);


double evaluateGeneralizedBornEnergy(const AtomGraph *ag, const StaticExclusionMask &se,

                                     const NeckGeneralizedBornTable &ngb_tables,

                                     const CoordinateFrame &cf, ScoreCard *ecard,

                                     int system_index = 0);


template <typename Tcoord, typename Tcalc>

double evaluateGeneralizedBornEnergy(const NonbondedKit<Tcalc> nbk,

                                     const StaticExclusionMaskReader ser,

                                     const ImplicitSolventKit<Tcalc> isk,

                                     const NeckGeneralizedBornKit<Tcalc> ngb_kit,

                                     const CoordinateSeriesReader<Tcoord> csr, ScoreCard *ecard,

                                     int system_index = 0, int force_scale_bits = 23);


} // namespace energy

} // namespace stormm


#include "nonbonded_potential.tpp"


#endif

stormm::energy::ScoreCard
Track the energy components of a collection of systems in an HPC-capable array. This object uses the ...
Definition scorecard.h:101

stormm::energy::StaticExclusionMask
A simple pair list for an all-to-all calculation with exclusion masks. The list stores masks for 16 x...
Definition static_exclusionmask.h:81

stormm::generalized_born_defaults::NeckGeneralizedBornTable
Object to hold a complex array of constants referenced by various GB calculations using the "neck" fo...
Definition generalized_born.h:151

stormm::topology::AtomGraph
A struct to hold information relating to an Amber topology. This struct's member functions are limite...
Definition atomgraph.h:50

stormm::trajectory::CoordinateFrame
Store the coordinates and box information for a frame, only. This abridged struct can serve when the ...
Definition coordinateframe.h:111

stormm::trajectory::PhaseSpace
An object to complement a topology and hold positions, velocities, and forces of all particles in a s...
Definition phasespace.h:141

stormm::energy::StaticExclusionMaskReader
The abstract for a StaticExclusionMask object, read-only due to the const-ness of the data() member f...
Definition static_exclusionmask.h:45

stormm::generalized_born_defaults::NeckGeneralizedBornKit
Abstract for the NeckGeneralizedBornTable object, in single- or double-precision.
Definition generalized_born.h:130

stormm::topology::ImplicitSolventKit
Information needed for Generalized Born (and perhaps other) implicit solvent methods....
Definition atomgraph_abstracts.h:352

stormm::topology::NonbondedKit
Information needed for non-bonded real-space calculations. Templating is used as above,...
Definition atomgraph_abstracts.h:287

stormm::trajectory::CoordinateFrameReader
Collect C-style pointers for the elements of a read-only CoordinateFrame object.
Definition coordinateframe.h:65

stormm::trajectory::CoordinateFrameWriter
Collect C-style pointers for the elements of a writable CoordinateFrame object.
Definition coordinateframe.h:30

stormm::trajectory::CoordinateSeriesReader
Collect C-style pointers and critical constants for a read-only CoordinateSeries object.
Definition coordinate_series.h:96

stormm::trajectory::PhaseSpaceWriter
Collect constants and pointers to the components of a modifiable PhaseSpace object.
Definition phasespace.h:31