doxygen/kinetic_8h_source.html

// -*-c++-*-

#ifndef STORMM_KINETIC_H

#define STORMM_KINETIC_H


#include "copyright.h"

#include "Constants/behavior.h"

#include "Constants/fixed_precision.h"

#include "Constants/symbol_values.h"

#include "DataTypes/common_types.h"

#include "Potential/energy_enumerators.h"

#include "Potential/scorecard.h"

#include "Structure/structure_enumerators.h"

#include "Synthesis/atomgraph_synthesis.h"

#include "Synthesis/phasespace_synthesis.h"

#include "Topology/atomgraph.h"

#include "Topology/atomgraph_abstracts.h"

#include "Trajectory/phasespace.h"

#include "Trajectory/thermostat.h"

#include "Trajectory/trajectory_enumerators.h"


namespace stormm {

namespace mm {


using constants::PrecisionModel;

using data_types::isSignedIntegralScalarType;

using energy::ScoreCard;

using energy::StateVariable;

using numerics::velocity_scale_nonoverflow_bits;

using structure::ApplyConstraints;

using symbols::boltzmann_constant;

using symbols::boltzmann_constant_f;

using symbols::gafs_to_kcal;

using synthesis::AtomGraphSynthesis;

using synthesis::PhaseSpaceSynthesis;

using synthesis::PsSynthesisReader;

using synthesis::PsSynthesisWriter;

using synthesis::SyAtomUpdateKit;

using synthesis::SyNonbondedKit;

using topology::AtomGraph;

using topology::ChemicalDetailsKit;

using trajectory::CoordinateCycle;

using trajectory::PhaseSpace;

using trajectory::PhaseSpaceReader;

using trajectory::PhaseSpaceWriter;

using trajectory::Thermostat;

using trajectory::ThermostatReader;


template <typename Tcoord, typename Tmass, typename Tcalc>

llint evalKineticEnergy(const Tcoord* xvel, const Tcoord* yvel, const Tcoord* zvel,

                        const int* xvel_ovrf, const int* yvel_ovrf, const int* zvel_ovrf,

                        const Tmass* masses, const int natom, const Tcalc nrg_scale_factor,

                        Tcalc inv_vel_scale = 1.0);


template <typename Tcoord, typename Tcalc>

void evalKineticEnergy(const Tcoord* xvel, const Tcoord* yvel, const Tcoord* zvel, ScoreCard *sc,

                       const int* xvel_ovrf, const int* yvel_ovrf, const int* zvel_ovrf,

                       const ChemicalDetailsKit &cdk, int system_index = 0,

                       Tcalc inv_vel_scale = 1.0);


void evalKineticEnergy(const PhaseSpaceWriter *psw, ScoreCard *sc, const ChemicalDetailsKit &cdk,

                       int system_index);


void evalKineticEnergy(const PhaseSpaceWriter &psw, ScoreCard *sc, const ChemicalDetailsKit &cdk,

                       int system_index);


void evalKineticEnergy(const PhaseSpace *ps, CoordinateCycle orientation, ScoreCard *sc,

                       const AtomGraph *ag, int system_index = 0);


void evalKineticEnergy(const PhaseSpace &ps, CoordinateCycle orientation, ScoreCard *sc,

                       const AtomGraph &ag, int system_index = 0);


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

                       int system_index = 0);


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

                       int system_index = 0);


template <typename Tmass, typename Tmass2, typename Tmass4, typename Tcalc>

void evalKineticEnergy(const PsSynthesisReader &poly_psr, ScoreCard *sc,

                       const SyAtomUpdateKit<Tmass, Tmass2, Tmass4> &poly_auk);


template <typename Tcoord, typename Tmass, typename Tcalc>

llint evalRescaledKineticEnergy(const Tcoord* xvel, const Tcoord* yvel, const Tcoord* zvel,

                                const int* xvel_ovrf, const int* yvel_ovrf, const int* zvel_ovrf,

                                const Tmass* masses, const int natom, const Tcalc nrg_scale_factor,

                                const Tcalc inv_vel_scale);


template <typename Tcoord, typename Tmass, typename Tcalc>

llint evalMomenta(const Tcoord* xvel, const Tcoord* yvel, const Tcoord* zvel,

                  const int* xvel_ovrf, const int* yvel_ovrf, const int* zvel_ovrf,

                  const Tmass* masses, const int natom, const Tcalc inv_vel_scale);


template <typename Tcoord, typename Tmass, typename Tcalc>

Tcalc computeTemperature(const Tcoord* xvel, const Tcoord* yvel, const Tcoord* zvel,

                         const int* xvel_ovrf, const int* yvel_ovrf, const int* zvel_ovrf,

                         const Tmass* masses, int natom, int ndof, Tcalc nrg_scale_factor,

                         Tcalc inv_vel_scale);


template <typename Tcalc>

Tcalc computeTemperature(const PhaseSpace *ps, const AtomGraph *ag, ApplyConstraints use_cnst);


template <typename Tcalc>

Tcalc computeTemperature(const PhaseSpace &ps, const AtomGraph &ag, ApplyConstraints use_cnst);


template <typename Tmass, typename Tmass2, typename Tmass4, typename Tcalc>

void computeTemperature(const PsSynthesisReader &poly_psr, ScoreCard *sc,

                        const SyAtomUpdateKit<Tmass, Tmass2, Tmass4> &poly_auk,

                        const ThermostatReader<Tcalc> &tstr, bool ke_computed = false);


double computeTemperature(const PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag,

                          ApplyConstraints use_cnst, int system_index,

                          PrecisionModel prec = PrecisionModel::SINGLE);


double computeTemperature(const PhaseSpaceSynthesis &ps, const AtomGraphSynthesis &ag,

                          ApplyConstraints use_cnst, int system_index,

                          PrecisionModel prec = PrecisionModel::SINGLE);


void computeTemperature(ScoreCard *sc, const ChemicalDetailsKit &cdk, bool cnst, int index = 0);


void computeTemperature(ScoreCard *sc, const AtomGraph &ag, bool cnst, int index = 0);


void computeTemperature(ScoreCard *sc, const AtomGraph *ag, bool cnst, int index = 0);


template <typename Tcalc>

std::vector<llint> initiateMomentaRescale(const PhaseSpaceSynthesis *PsSynthesis,

                                          const AtomGraphSynthesis *AgSynthesis,

                                          const ScoreCard *sc, std::vector<int> swap_indices,

                                          std::vector<double> temp);


template <typename Tcalc>

std::vector<llint> initiateKineticEnergyRescale(const PhaseSpaceSynthesis *PsSynthesis,

                                                const AtomGraphSynthesis *AgSynthesis,

                                                const ScoreCard *sc);


} // namespace mm

} // namespace stormm


#include "kinetic.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::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::synthesis::PsSynthesisReader
The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dyna...
Definition phasespace_synthesis.h:199

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::topology::ChemicalDetailsKit
Information on atoms and residues which may be useful for applying atom masks or identifying specific...
Definition atomgraph_abstracts.h:382

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

stormm::trajectory::ThermostatReader
Read-only abstract for the Thermostat object.
Definition thermostat.h:135