doxygen/integration_8h_source.html

// -*-c++-*-

#ifndef STORMM_INTEGRATION_H

#define STORMM_INTEGRATION_H


#include "copyright.h"

#include "Constants/behavior.h"

#include "Constants/fixed_precision.h"

#include "DataTypes/common_types.h"

#include "Potential/cellgrid.h"

#include "Synthesis/atomgraph_synthesis.h"

#include "Synthesis/phasespace_synthesis.h"

#include "Synthesis/synthesis_abstracts.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 trajectory {


using constants::PrecisionModel;

using data_types::isSignedIntegralScalarType;

using energy::CellGrid;

using energy::CellGridReader;

using numerics::force_scale_nonoverflow_bits;

using numerics::velocity_scale_nonoverflow_bits;

using numerics::globalpos_scale_nonoverflow_bits;

using symbols::boltzmann_constant;

using symbols::boltzmann_constant_f;

using symbols::kcal_to_gafs;

using symbols::kcal_to_gafs_f;

using synthesis::AtomGraphSynthesis;

using synthesis::SyAtomUpdateKit;

using synthesis::PhaseSpaceSynthesis;

using synthesis::PsSynthesisWriter;

using topology::AtomGraph;

using topology::ChemicalDetailsKit;


template <typename Tcoord, typename Tcalc>

void velocityVerletVelocityUpdate(const Tcoord* xvel, const Tcoord* yvel, const Tcoord* zvel,

                                  const Tcoord* xfrc, const Tcoord* yfrc, const Tcoord* zfrc,

                                  int natom, const Tcalc* masses, Tcoord* vxalt, Tcoord* vyalt,

                                  Tcoord* vzalt, const ThermostatReader<Tcalc> &tstr,

                                  const int* xvel_ovrf = nullptr, const int* yvel_ovrf = nullptr,

                                  const int* zvel_ovrf = nullptr, const int* xfrc_ovrf = nullptr,

                                  const int* yfrc_ovrf = nullptr, const int* zfrc_ovrf = nullptr,

                                  int* vxalt_ovrf = nullptr, int* vyalt_ovrf = nullptr,

                                  int* vzalt_ovrf = nullptr, int atom_offset = 0,

                                  Tcalc vel_scale_factor = 1.0, Tcalc frc_scale_factor = 1.0);


void velocityVerletVelocityUpdate(PhaseSpaceWriter *psw, const ChemicalDetailsKit &cdk,

                                  const ThermostatReader<double> &tstr);


void velocityVerletVelocityUpdate(PhaseSpace *ps, const AtomGraph *ag, const Thermostat *tst);


void velocityVerletVelocityUpdate(PhaseSpace *ps, const AtomGraph &ag, const Thermostat &tst);


template <typename T, typename T2, typename T4>

void velocityVerletVelocityUpdate(PsSynthesisWriter *poly_psw,

                                  const SyAtomUpdateKit<T, T2, T4> &poly_auk,

                                  const ThermostatReader<T> &tstr);


void velocityVerletVelocityUpdate(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag,

                                  const Thermostat *tst,

                                  PrecisionModel prec = PrecisionModel::SINGLE);


void velocityVerletVelocityUpdate(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag,

                                  const Thermostat &tst,

                                  PrecisionModel prec = PrecisionModel::SINGLE);


template <typename Tcoord, typename Tacc, typename Tcoord4>

void velocityVerletVelocityUpdate(PhaseSpaceSynthesis *poly_ps,

                                  const CellGrid<Tcoord, Tacc, Tcoord, Tcoord4> &cg,

                                  const AtomGraphSynthesis &poly_ag, const Thermostat &tst,

                                  PrecisionModel prec = PrecisionModel::SINGLE);


template <typename Tcoord, typename Tacc, typename Tcoord4>

void velocityVerletVelocityUpdate(PhaseSpaceSynthesis *poly_ps,

                                  const CellGrid<Tcoord, Tacc, Tcoord, Tcoord4> &cg_qq,

                                  const CellGrid<Tcoord, Tacc, Tcoord, Tcoord4> &cg_lj,

                                  const AtomGraphSynthesis &poly_ag, const Thermostat &tst,

                                  PrecisionModel prec = PrecisionModel::SINGLE);


template <typename Tcoord, typename Tcalc>

void velocityVerletCoordinateUpdate(const Tcoord* xcrd, const Tcoord* ycrd, const Tcoord* zcrd,

                                    const Tcoord* xfrc, const Tcoord* yfrc, const Tcoord* zfrc,

                                    int natom, const Tcalc* masses, Tcoord* xalt, Tcoord* yalt,

                                    Tcoord* zalt, Tcoord* vxalt, Tcoord* vyalt, Tcoord* vzalt,

                                    const ThermostatReader<Tcalc> &tstr,

                                    const int* xcrd_ovrf = nullptr, const int* ycrd_ovrf = nullptr,

                                    const int* zcrd_ovrf = nullptr, const int* xfrc_ovrf = nullptr,

                                    const int* yfrc_ovrf = nullptr, const int* zfrc_ovrf = nullptr,

                                    int* xalt_ovrf = nullptr, int* yalt_ovrf = nullptr,

                                    int* zalt_ovrf = nullptr, int* vxalt_ovrf = nullptr,

                                    int* vyalt_ovrf = nullptr, int* vzalt_ovrf = nullptr,

                                    int atom_offset = 0, Tcalc gpos_scale_factor = 1.0,

                                    Tcalc vel_scale_factor = 1.0, Tcalc frc_scale_factor = 1.0);


void velocityVerletCoordinateUpdate(PhaseSpaceWriter *psw, const ChemicalDetailsKit &cdk,

                                    const ThermostatReader<double> &tstr);


void velocityVerletCoordinateUpdate(PhaseSpace *ps, const AtomGraph *ag, const Thermostat *tst);


void velocityVerletCoordinateUpdate(PhaseSpace *ps, const AtomGraph &ag, const Thermostat &tst);


template <typename T, typename T2, typename T4>

void velocityVerletCoordinateUpdate(PsSynthesisWriter *poly_psw,

                                    const SyAtomUpdateKit<T, T2, T4> &poly_auk,

                                    const ThermostatReader<T> &tstr);


void velocityVerletCoordinateUpdate(PhaseSpaceSynthesis *poly_ps,

                                    const AtomGraphSynthesis *poly_ag, const Thermostat *tst);


void velocityVerletCoordinateUpdate(PhaseSpaceSynthesis *poly_ps,

                                    const AtomGraphSynthesis &poly_ag, const Thermostat &tst);


} // namespace structure

} // namespace stormm


#include "integration.tpp"


#endif

stormm::energy::CellGrid
An object to manage the spatial decomposition of a system of particles. The general strategy is to ar...
Definition cellgrid.h:562

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::trajectory::Thermostat
Store the parameters for a simulation thermostat. Includes Berendsen, Andersen, and Langevin methods....
Definition thermostat.h:221

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::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