doxygen/mm__evaluation_8h_source.html

// -*-c++-*-

#ifndef STORMM_MM_EVALUATION_H

#define STORMM_MM_EVALUATION_H


#include "copyright.h"

#include "Constants/generalized_born.h"

#include "Math/vector_ops.h"

#include "Potential/energy_enumerators.h"

#include "Potential/nonbonded_potential.h"

#include "Potential/scorecard.h"

#include "Potential/static_exclusionmask.h"

#include "Potential/valence_potential.h"

#include "Numerics/split_fixed_precision.h"

#include "Numerics/numeric_enumerators.h"

#include "Restraints/restraint_apparatus.h"

#include "Synthesis/atomgraph_synthesis.h"

#include "Synthesis/phasespace_synthesis.h"

#include "Topology/atomgraph.h"

#include "Topology/atomgraph_abstracts.h"

#include "Topology/atomgraph_enumerators.h"

#include "Trajectory/coordinateframe.h"

#include "Trajectory/phasespace.h"


namespace stormm {

namespace mm {


using chemistry::PsSynthesisReader;

using energy::DihedralStyle;

using energy::evalAttenuated14Pair;

using energy::evalHarmonicBend;

using energy::evalHarmonicStretch;

using energy::evalDihedralTwist;

using energy::evalPosnRestraint;

using energy::evalBondRestraint;

using energy::evalAnglRestraint;

using energy::evalDiheRestraint;

using energy::evalCmap;

using energy::evalAttenuated14Pair;

using energy::EvaluateForce;

using energy::evaluateAngleTerms;

using energy::evaluateAttenuated14Terms;

using energy::evaluateBondTerms;

using energy::evaluateCharmmImproperTerms;

using energy::evaluateCmapTerms;

using energy::evaluateDihedralTerms;

using energy::evaluateGeneralizedBornEnergy;

using energy::evaluateNonbondedEnergy;

using energy::evaluateRestraints;

using energy::evaluateUreyBradleyTerms;

using energy::ScoreCard;

using energy::StateVariable;

using energy::StaticExclusionMask;

using energy::StaticExclusionMaskReader;

using energy::TorsionKind;

using energy::ValenceKernelSize;

using numerics::globalpos_scale_nonoverflow_bits;

using numerics::force_scale_nonoverflow_bits;

using restraints::RestraintApparatus;

using restraints::RestraintKit;

using stmath::readBitFromMask;

using structure::PhaseSpaceWriter;

using synthesis::AtomGraphSynthesis;

using synthesis::PhaseSpaceSynthesis;

using synthesis::SyAtomUpdateKit;

using synthesis::SyValenceKit;

using topology::AtomGraph;

using topology::ImplicitSolventKit;

using topology::NonbondedKit;

using topology::UnitCellType;

using topology::ValenceKit;

using topology::VirtualSiteKit;

using trajectory::CoordinateFrame;

using trajectory::CoordinateFrameReader;

using trajectory::PhaseSpace;

using trajectory::PhaseSpaceReader;

using trajectory::PhaseSpaceWriter;

using namespace generalized_born_defaults;

using namespace structure;

using namespace synthesis;


template <typename Tcoord, typename Tforce, typename Tcalc>

void evalValeMM(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 *sc, const ValenceKit<Tcalc> &vk,

                const NonbondedKit<Tcalc> &nbk, EvaluateForce eval_force, int system_index = 0,

                Tcalc inv_gpos_factor = 1.0, Tcalc force_factor = 1.0, Tcalc clash_distance = 0.0,

                Tcalc clash_ratio = 0.0);


void evalValeMM(PhaseSpaceWriter psw, ScoreCard *sc, const ValenceKit<double> &vk,

                const NonbondedKit<double> &nbk, EvaluateForce eval_force, int system_index = 0,

                double clash_distance = 0.0, double clash_ratio = 0.0);


void evalValeMM(PhaseSpace *ps, ScoreCard *sc, const AtomGraph &ag, EvaluateForce eval_force,

                int system_index = 0, double clash_distance = 0.0, double clash_ratio = 0.0);


void evalValeMM(PhaseSpace *ps, ScoreCard *sc, const AtomGraph *ag, EvaluateForce eval_force,

                int system_index = 0, double clash_distance = 0.0, double clash_ratio = 0.0);


template <typename Tc, typename Tc2, typename Tc4>

void evalValeMM(PsSynthesisWriter *poly_psw, ScoreCard* sc, const SyValenceKit<Tc> &poly_vk,

                const SyAtomUpdateKit<Tc, Tc2, Tc4> &poly_auk, EvaluateForce eval_force,

                VwuTask activity = VwuTask::ALL_TASKS, double clash_distance = 0.0,

                double clash_ratio = 0.0, int step = 0,

                const SyRestraintKit<Tc, Tc2, Tc4> &poly_rk = SyRestraintKit<Tc, Tc2, Tc4>());


void evalValeMM(PhaseSpaceSynthesis *poly_ps, ScoreCard *sc, const AtomGraphSynthesis *poly_ag,

                EvaluateForce eval_force, PrecisionModel prec,

                VwuTask activity = VwuTask::ALL_TASKS, int step = 0,

                bool include_restraints = false);


void evalValeMM(PhaseSpaceSynthesis *poly_ps, ScoreCard *sc, const AtomGraphSynthesis &poly_ag,

                EvaluateForce eval_force, PrecisionModel prec, int step = 0,

                VwuTask activity = VwuTask::ALL_TASKS, bool include_restraints = false);


void evalValeMM(PhaseSpaceSynthesis* poly_ps, ScoreCard* sc, const AtomGraphSynthesis* poly_ag,

                EvaluateForce eval_force, PrecisionModel prec);


template <typename Tcoord, typename Tforce, typename Tcalc, typename Tcalc2, typename Tcalc4>

void evalValeRestMM(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 *sc, const ValenceKit<Tcalc> &vk,

                    const NonbondedKit<Tcalc> &nbk, const RestraintKit<Tcalc, Tcalc2, Tcalc4> &rar,

                    EvaluateForce eval_force, int system_index = 0, int step = 0,

                    Tcalc inv_gpos_factor = 1.0, Tcalc force_factor = 1.0,

                    Tcalc clash_distance = 0.0, Tcalc clash_ratio = 0.0);


void evalValeRestMM(PhaseSpaceWriter psw, ScoreCard *sc, const ValenceKit<double> &vk,

                    const NonbondedKit<double> &nbk,

                    const RestraintKit<double, double2, double4> &rar, EvaluateForce eval_force,

                    int system_index = 0, int step = 0, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void evalValeRestMM(PhaseSpace *ps, ScoreCard *sc, const AtomGraph &ag,

                    const RestraintApparatus &ra, EvaluateForce eval_force, int system_index = 0,

                    int step = 0, double clash_distance = 0.0, double clash_ratio = 0.0);


void evalValeRestMM(PhaseSpace *ps, ScoreCard *sc, const AtomGraph *ag,

                    const RestraintApparatus &ra, EvaluateForce eval_force, int system_index = 0,

                    int step = 0, double clash_distance = 0.0, double clash_ratio = 0.0);


template <typename Tc, typename Tc2, typename Tc4>

void evalValeRestMM(PsSynthesisWriter *poly_psw, ScoreCard* sc, const SyValenceKit<Tc> &poly_vk,

                    const SyRestraintKit<Tc, Tc2, Tc4> &poly_rk,

                    const SyAtomUpdateKit<Tc, Tc2, Tc4> &poly_auk, EvaluateForce eval_force,

                    VwuTask activity = VwuTask::ALL_TASKS, int step = 0, Tc clash_distance = 0.0,

                    Tc clash_ratio = 0.0);


void evalValeRestMM(PhaseSpaceSynthesis* poly_ps, ScoreCard* sc, const AtomGraphSynthesis* poly_ag,

                    int step_number, EvaluateForce eval_force, PrecisionModel prec);


template <typename Tcoord, typename Tforce, typename Tcalc>

void evalNonbValeMM(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 *sc, const ValenceKit<Tcalc> &vk,

                    const NonbondedKit<Tcalc> &nbk, const StaticExclusionMaskReader &ser,

                    EvaluateForce eval_force, int system_index = 0, Tcalc inv_gpos_factor = 1.0,

                    Tcalc force_factor = 1.0, Tcalc clash_distance = 0.0, Tcalc clash_ratio = 0.0);


void evalNonbValeMM(PhaseSpaceWriter psw, ScoreCard *sc, const ValenceKit<double> &vk,

                    const NonbondedKit<double> &nbk, const StaticExclusionMaskReader &ser,

                    EvaluateForce eval_force, int system_index = 0,

                    double clash_distance = 0.0, double clash_ratio = 0.0);


void evalNonbValeMM(PhaseSpace *ps, ScoreCard *sc, const AtomGraph &ag,

                    const StaticExclusionMask &se, EvaluateForce eval_force, int system_index = 0,

                    double clash_distance = 0.0, double clash_ratio = 0.0);


void evalNonbValeMM(PhaseSpace *ps, ScoreCard *sc, const AtomGraph *ag,

                    const StaticExclusionMask &se, EvaluateForce eval_force, int system_index = 0,

                    double clash_distance = 0.0, double clash_ratio = 0.0);


template <typename Tcoord, typename Tforce, typename Tcalc, typename Tcalc2, typename Tcalc4>

void evalNonbValeRestMM(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 *sc,

                        const ValenceKit<Tcalc> &vk, const NonbondedKit<Tcalc> &nbk,

                        const StaticExclusionMaskReader &ser,

                        const RestraintKit<Tcalc, Tcalc2, Tcalc4> &rar, EvaluateForce eval_force,

                        int system_index = 0, int step = 0, Tcalc inv_gpos_factor = 1.0,

                        Tcalc force_factor = 1.0, Tcalc clash_distance = 0.0,

                        Tcalc clash_ratio = 0.0);


void evalNonbValeRestMM(PhaseSpaceWriter psw, ScoreCard *sc, const ValenceKit<double> &vk,

                        const NonbondedKit<double> &nbk, const StaticExclusionMaskReader &ser,

                        const RestraintKit<double, double2, double4> &rar,

                        EvaluateForce eval_force, int system_index = 0, int step = 0,

                        double clash_distance = 0.0, double clash_ratio = 0.0);


void evalNonbValeRestMM(PhaseSpace *ps, ScoreCard *sc, const AtomGraph &ag,

                        const StaticExclusionMask &se, const RestraintApparatus &ra,

                        EvaluateForce eval_force, int system_index = 0, int step = 0,

                        double clash_distance = 0.0, double clash_ratio = 0.0);


void evalNonbValeRestMM(PhaseSpace *ps, ScoreCard *sc, const AtomGraph *ag,

                        const StaticExclusionMask &se, const RestraintApparatus *ra,

                        EvaluateForce eval_force, int system_index = 0, int step = 0,

                        double clash_distance = 0.0, double clash_ratio = 0.0);


template <typename Tcoord, typename Tforce, typename Tcalc, typename Tcalc2, typename Tcalc4>

void evalRestrainedMMGB(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 *sc,

                        const ValenceKit<Tcalc> &vk, const NonbondedKit<Tcalc> &nbk,

                        const StaticExclusionMaskReader &ser, const ImplicitSolventKit<Tcalc> &isk,

                        const NeckGeneralizedBornKit<Tcalc> &neck_gbk,

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

                        const RestraintKit<Tcalc, Tcalc2, Tcalc4> &rar, EvaluateForce eval_force,

                        int system_index = 0, int step = 0, Tcalc inv_gpos_factor = 1.0,

                        Tcalc force_factor = 1.0, Tcalc clash_distance = 0.0,

                        Tcalc clash_ratio = 0.0);


void evalRestrainedMMGB(PhaseSpaceWriter psw, ScoreCard *sc, const ValenceKit<double> &vk,

                        const NonbondedKit<double> &nbk, const StaticExclusionMaskReader &ser,

                        const ImplicitSolventKit<double> &isk,

                        const NeckGeneralizedBornKit<double> &neck_gbk,

                        const RestraintKit<double, double2, double4> &rar,

                        EvaluateForce eval_force, int system_index = 0, int step = 0,

                        double clash_distance = 0.0, double clash_ratio = 0.0);


void evalRestrainedMMGB(PhaseSpace *ps, ScoreCard *sc, const AtomGraph &ag,

                        const NeckGeneralizedBornTable &neck_gbtab,

                        const StaticExclusionMask &se, const RestraintApparatus &ra,

                        EvaluateForce eval_force, int system_index = 0, int step = 0,

                        double clash_distance = 0.0, double clash_ratio = 0.0);


void evalRestrainedMMGB(PhaseSpace *ps, ScoreCard *sc, const AtomGraph *ag,

                        const NeckGeneralizedBornTable &neck_gbtab,

                        const StaticExclusionMask &se, const RestraintApparatus *ra,

                        EvaluateForce eval_force, int system_index = 0, int step = 0,

                        double clash_distance = 0.0, double clash_ratio = 0.0);


void evalVwuInitEnergy(ScoreCard *ecard, const VwuTask activity, const int sysid);


void commitVwuEnergies(llint bond_acc, llint angl_acc, llint dihe_acc, llint impr_acc,

                       llint ubrd_acc, llint cimp_acc, llint cmap_acc, llint qq14_acc,

                       llint lj14_acc, llint rest_acc, int sysid, VwuTask activity,

                       ScoreCard *ecard);


} // namespace mm

} // namespace stormm


#include "mm_evaluation.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::restraints::RestraintApparatus
A collection of all restraints pertaining to a specific topology for the purposes of one simulation,...
Definition restraint_apparatus.h:109

stormm::synthesis::AtomGraphSynthesis
A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays ...
Definition atomgraph_synthesis.h:55

stormm::synthesis::PhaseSpaceSynthesis
A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulation...
Definition phasespace_synthesis.h:325

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::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::restraints::RestraintKit
Double-precision reader abstract for the RestraintApparatus class. Restraints are very detailed thing...
Definition restraint_apparatus.h:28

stormm::synthesis::PsSynthesisWriter
The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dyna...
Definition phasespace_synthesis.h:87

stormm::synthesis::SyAtomUpdateKit
Collect the virtual site details and constraint parameters of the topology synthesis into a single ab...
Definition synthesis_abstracts.h:257

stormm::synthesis::SyRestraintKit
Collect the critical restraint parameters and masking information for work unit-based evaluation of t...
Definition synthesis_abstracts.h:100

stormm::synthesis::SyValenceKit
Collect the critical valence parameters and indexing information for work unit-based evaluation of th...
Definition synthesis_abstracts.h:19

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::topology::ValenceKit
Information need for bonded calculations. Templating is used to serve either of two levels of precisi...
Definition atomgraph_abstracts.h:88

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