doxygen/hpc__valence__potential_8h_source.html

// -*-c++-*-

#ifndef STORMM_VALENCE_POTENTIAL_CUH

#define STORMM_VALENCE_POTENTIAL_CUH


#ifdef STORMM_USE_CUDA

#  include <cuda_runtime.h>

#endif

#include "copyright.h"

#include "Accelerator/core_kernel_manager.h"

#include "Accelerator/gpu_details.h"

#include "Constants/behavior.h"

#include "Constants/fixed_precision.h"

#include "DataTypes/stormm_vector_types.h"

#include "MolecularMechanics/mm_controls.h"

#include "Potential/energy_enumerators.h"

#include "Synthesis/atomgraph_synthesis.h"

#include "Synthesis/phasespace_synthesis.h"

#include "Synthesis/synthesis_abstracts.h"

#include "Synthesis/synthesis_enumerators.h"

#include "Trajectory/thermostat.h"

#include "cacheresource.h"

#include "energy_enumerators.h"

#include "scorecard.h"


namespace stormm {

namespace energy {


using card::GpuDetails;

using card::CoreKlManager;

using constants::PrecisionModel;

using mm::MMControlKit;

using mm::MolecularMechanicsControls;

using numerics::AccumulationMethod;

using synthesis::AtomGraphSynthesis;

using synthesis::PhaseSpaceSynthesis;

using synthesis::PsSynthesisWriter;

using synthesis::SyAtomUpdateKit;

using synthesis::SyRestraintKit;

using synthesis::SyValenceKit;

using synthesis::VwuGoal;

using trajectory::Thermostat;

using trajectory::ThermostatWriter;


int2 testValenceKernelSubdivision(const int max_threads, const int smp_count, const int vwu_size,

                                  const int vwu_count);


#ifdef STORMM_USE_CUDA

cudaFuncAttributes

queryValenceKernelRequirementsXL(EvaluateForce eval_frc, EvaluateEnergy eval_nrg,

                                 AccumulationMethod acc_meth, VwuGoal purpose,

                                 ClashResponse collision_handling);


cudaFuncAttributes

queryValenceKernelRequirementsLG(EvaluateForce eval_frc, EvaluateEnergy eval_nrg,

                                 AccumulationMethod acc_meth, VwuGoal purpose,

                                 ClashResponse collision_handling);


cudaFuncAttributes

queryValenceKernelRequirementsMD(EvaluateForce eval_frc, EvaluateEnergy eval_nrg,

                                 AccumulationMethod acc_meth, VwuGoal purpose,

                                 ClashResponse collision_handling);


cudaFuncAttributes

queryValenceKernelRequirementsSM(EvaluateForce eval_frc, EvaluateEnergy eval_nrg,

                                 AccumulationMethod acc_meth, VwuGoal purpose,

                                 ClashResponse collision_handling);


cudaFuncAttributes

queryValenceKernelRequirementsD(EvaluateForce eval_frc, EvaluateEnergy eval_nrg,

                                VwuGoal purpose, ClashResponse collision_handling);


cudaFuncAttributes

queryValenceKernelRequirementsFPME(EvaluateEnergy eval_nrg, AccumulationMethod acc_meth,

                                   ClashResponse collision_handling, PrecisionModel neighbor_prec);


cudaFuncAttributes

queryValenceKernelRequirementsFPMEDual(EvaluateEnergy eval_nrg, AccumulationMethod acc_meth,

                                       ClashResponse collision_handling,

                                       PrecisionModel neighbor_prec);


cudaFuncAttributes

queryValenceKernelRequirementsDPME(EvaluateEnergy eval_nrg, ClashResponse collision_handling,

                                   PrecisionModel neighbor_prec);


cudaFuncAttributes

queryValenceKernelRequirementsDPMEDual(EvaluateEnergy eval_nrg, ClashResponse collision_handling,

                                       PrecisionModel neighbor_prec);


cudaFuncAttributes

queryValenceKernelRequirements(PrecisionModel prec, EvaluateForce eval_frc,

                               EvaluateEnergy eval_nrg, AccumulationMethod acc_meth,

                               VwuGoal purpose, ClashResponse collision_handling,

                               ValenceKernelSize kwidth, bool pme_compatible = false,

                               PrecisionModel neighbor_prec = PrecisionModel::SINGLE,

                               NeighborListKind neighbor_layout = NeighborListKind::MONO);


cudaFuncAttributes

queryPmeValenceKernelRequirements(PrecisionModel prec, PrecisionModel neighbor_prec,

                                  EvaluateForce eval_frc, EvaluateEnergy eval_nrg,

                                  AccumulationMethod acc_meth, ClashResponse clash_handling);

#endif


void launchValence(const SyValenceKit<double> &poly_vk,

                   const SyRestraintKit<double, double2, double4> &poly_rk,

                   MMControlKit<double> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<double, double2, double4> &poly_auk,

                   ThermostatWriter<double> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<double> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, const int2 bt,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValenceXL(const SyValenceKit<float> &poly_vk,

                     const SyRestraintKit<float, float2, float4> &poly_rk,

                     MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                     const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                     ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                     CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                     EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                     const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValenceLG(const SyValenceKit<float> &poly_vk,

                     const SyRestraintKit<float, float2, float4> &poly_rk,

                     MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                     const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                     ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                     CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                     EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                     const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValenceMD(const SyValenceKit<float> &poly_vk,

                     const SyRestraintKit<float, float2, float4> &poly_rk,

                     MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                     const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                     ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                     CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                     EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                     const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValenceSM(const SyValenceKit<float> &poly_vk,

                     const SyRestraintKit<float, float2, float4> &poly_rk,

                     MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                     const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                     ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                     CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                     EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                     const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValence(const SyValenceKit<float> &poly_vk,

                   const SyRestraintKit<float, float2, float4> &poly_rk,

                   MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                   ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                   const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValence(const SyValenceKit<double> &poly_vk,

                   const SyRestraintKit<double, double2, double4> &poly_rk,

                   const CellGridReader<double, llint, double, double4> &cgr,

                   MMControlKit<double> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<double, double2, double4> &poly_auk,

                   ThermostatWriter<double> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<double> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, const int2 bt,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(const SyValenceKit<double> &poly_vk,

                   const SyRestraintKit<double, double2, double4> &poly_rk,

                   const CellGridReader<float, int, float, float4> &cgr,

                   MMControlKit<double> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<double, double2, double4> &poly_auk,

                   ThermostatWriter<double> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<double> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, const int2 bt,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(const SyValenceKit<float> &poly_vk,

                   const SyRestraintKit<float, float2, float4> &poly_rk,

                   const CellGridReader<double, llint, double, double4> &cgr,

                   MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                   ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                   const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValence(const SyValenceKit<float> &poly_vk,

                   const SyRestraintKit<float, float2, float4> &poly_rk,

                   const CellGridReader<float, int, float, float4> &cgr,

                   MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                   ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                   const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValence(const SyValenceKit<double> &poly_vk,

                   const SyRestraintKit<double, double2, double4> &poly_rk,

                   const CellGridReader<double, llint, double, double4> &cgr_qq,

                   const CellGridReader<double, llint, double, double4> &cgr_lj,

                   MMControlKit<double> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<double, double2, double4> &poly_auk,

                   ThermostatWriter<double> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<double> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, const int2 bt,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(const SyValenceKit<double> &poly_vk,

                   const SyRestraintKit<double, double2, double4> &poly_rk,

                   const CellGridReader<float, int, float, float4> &cgr_qq,

                   const CellGridReader<float, int, float, float4> &cgr_lj,

                   MMControlKit<double> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<double, double2, double4> &poly_auk,

                   ThermostatWriter<double> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<double> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, const int2 bt,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(const SyValenceKit<float> &poly_vk,

                   const SyRestraintKit<float, float2, float4> &poly_rk,

                   const CellGridReader<double, llint, double, double4> &cgr_qq,

                   const CellGridReader<double, llint, double, double4> &cgr_lj,

                   MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                   ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                   const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValence(const SyValenceKit<float> &poly_vk,

                   const SyRestraintKit<float, float2, float4> &poly_rk,

                   const CellGridReader<float, int, float, float4> &cgr_qq,

                   const CellGridReader<float, int, float, float4> &cgr_lj,

                   MMControlKit<float> *ctrl, PsSynthesisWriter *poly_psw,

                   const SyAtomUpdateKit<float, float2, float4> &poly_auk,

                   ThermostatWriter<float> *tstw, ScoreCardWriter *scw,

                   CacheResourceKit<float> *gmem_r, EvaluateForce eval_force,

                   EvaluateEnergy eval_energy, VwuGoal purpose, AccumulationMethod force_sum,

                   const int2 bt, float clash_distance = 0.0, float clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   AccumulationMethod force_sum, const CoreKlManager &launcher,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   const CoreKlManager &launcher, double clash_distance = 0.0,

                   double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   const CellGrid<double, llint, double, double4> &cg,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   AccumulationMethod force_sum, const CoreKlManager &launcher,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   const CellGrid<double, llint, double, double4> &cg,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   const CoreKlManager &launcher, double clash_distance = 0.0,

                   double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   const CellGrid<double, llint, double, double4> &cg_qq,

                   const CellGrid<double, llint, double, double4> &cg_lj,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   AccumulationMethod force_sum, const CoreKlManager &launcher,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   const CellGrid<double, llint, double, double4> &cg_qq,

                   const CellGrid<double, llint, double, double4> &cg_lj,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   const CoreKlManager &launcher, double clash_distance = 0.0,

                   double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   const CellGrid<float, int, float, float4> &cg,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   AccumulationMethod force_sum, const CoreKlManager &launcher,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   const CellGrid<float, int, float, float4> &cg,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   const CoreKlManager &launcher, double clash_distance = 0.0,

                   double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   const CellGrid<float, int, float, float4> &cg_qq,

                   const CellGrid<float, int, float, float4> &cg_lj,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   AccumulationMethod force_sum, const CoreKlManager &launcher,

                   double clash_distance = 0.0, double clash_ratio = 0.0);


void launchValence(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,

                   const CellGrid<float, int, float, float4> &cg_qq,

                   const CellGrid<float, int, float, float4> &cg_lj,

                   MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,

                   Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,

                   EvaluateForce eval_force, EvaluateEnergy eval_energy, VwuGoal purpose,

                   const CoreKlManager &launcher, double clash_distance = 0.0,

                   double clash_ratio = 0.0);


} // namespace energy

} // namespace stormm


#endif

stormm::card::CoreKlManager
A class to guide the implementation of GPU kernels, with selected thread counts per block and block c...
Definition core_kernel_manager.h:56

stormm::energy::CacheResource
An object to hold temporary data for a particular work unit (whether bonded or non-bonded),...
Definition cacheresource.h:63

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::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::mm::MolecularMechanicsControls
A collection of contol data for molecular mechanics simulations, conveying the current step number,...
Definition mm_controls.h:100

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

stormm::energy::CacheResourceKit
Abstract for the CacheResource object, accessible as a C-style struct and suitable for passing to GPU...
Definition cacheresource.h:17

stormm::energy::CellGridReader
Read-only abstract for the CellGrid object. This is unused in typical MD applications,...
Definition cellgrid.h:296

stormm::energy::ScoreCardWriter
Writeable abstract for the ScoreCard object, useful for accumulating energies in many kernels.
Definition scorecard.h:64

stormm::mm::MMControlKit
The C-style, always writeable abstract for the MolecularMechanicsControls object. To not be able to m...
Definition mm_controls.h:52

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::trajectory::ThermostatWriter
Partially writeable abstract for the Thermostat object. As with the MMControlKit struct (see the libr...
Definition thermostat.h:58