doxygen/hpc__integration_8h_source.html

// -*-c++-*-

#ifndef STORMM_HPC_INTEGRATION_H

#define STORMM_HPC_INTEGRATION_H


#ifdef STORMM_USE_CUDA

#  include <cuda_runtime.h>

#endif

#include "copyright.h"

#include "Accelerator/core_kernel_manager.h"

#include "Constants/behavior.h"

#include "DataTypes/common_types.h"

#include "DataTypes/stormm_vector_types.h"

#include "MolecularMechanics/mm_controls.h"

#include "Numerics/numeric_enumerators.h"

#include "Potential/cacheresource.h"

#include "Potential/cellgrid.h"

#include "Potential/energy_enumerators.h"

#include "Synthesis/atomgraph_synthesis.h"

#include "Synthesis/phasespace_synthesis.h"

#include "thermostat.h"

#include "trajectory_enumerators.h"


namespace stormm {

namespace trajectory {


using card::CoreKlManager;

using constants::PrecisionModel;

using energy::CacheResource;

using energy::CacheResourceKit;

using energy::CellGrid;

using energy::CellGridReader;

using energy::ValenceKernelSize;

using mm::MolecularMechanicsControls;

using mm::MMControlKit;

using numerics::AccumulationMethod;

using synthesis::AtomGraphSynthesis;

using synthesis::PhaseSpaceSynthesis;

using synthesis::PsSynthesisWriter;

using synthesis::SyAtomUpdateKit;

using synthesis::SyValenceKit;


cudaFuncAttributes queryIntegrationKernelRequirements(PrecisionModel calc_prec,

                                                      PrecisionModel neighbor_prec,

                                                      UnitCellType unit_cell,

                                                      AccumulationMethod acc_meth,

                                                      ValenceKernelSize kwidth,

                                                      IntegrationStage process);


cudaFuncAttributes queryIntegrationKernelRequirements(PrecisionModel calc_prec,

                                                      AccumulationMethod acc_meth,

                                                      ValenceKernelSize kwidth,

                                                      IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<double> *tb_resw,

                              MMControlKit<double> *ctrl, const SyValenceKit<double> &poly_vk,

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

                              const ThermostatWriter<double> &tstw, const int2 lp,

                              IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<float> *tb_resw,

                              MMControlKit<float> *ctrl, const SyValenceKit<float> &poly_vk,

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

                              const ThermostatWriter<float> &tstw, const int2 lp,

                              AccumulationMethod acc_meth, ValenceKernelSize kwidth,

                              IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<double> *tb_resw,

                              MMControlKit<double> *ctrl,

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

                              const SyValenceKit<double> &poly_vk,

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

                              const ThermostatWriter<double> &tstw, const int2 lp,

                              IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<double> *tb_resw,

                              MMControlKit<double> *ctrl,

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

                              const SyValenceKit<double> &poly_vk,

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

                              const ThermostatWriter<double> &tstw, const int2 lp,

                              IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<double> *tb_resw,

                              MMControlKit<double> *ctrl,

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

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

                              const SyValenceKit<double> &poly_vk,

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

                              const ThermostatWriter<double> &tstw, const int2 lp,

                              IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<double> *tb_resw,

                              MMControlKit<double> *ctrl,

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

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

                              const SyValenceKit<double> &poly_vk,

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

                              const ThermostatWriter<double> &tstw, const int2 lp,

                              IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<float> *tb_resw,

                              MMControlKit<float> *ctrl,

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

                              const SyValenceKit<float> &poly_vk,

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

                              const ThermostatWriter<float> &tstw, const int2 lp,

                              AccumulationMethod acc_meth, IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<float> *tb_resw,

                              MMControlKit<float> *ctrl,

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

                              const SyValenceKit<float> &poly_vk,

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

                              const ThermostatWriter<float> &tstw, const int2 lp,

                              AccumulationMethod acc_meth, IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<float> *tb_resw,

                              MMControlKit<float> *ctrl,

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

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

                              const SyValenceKit<float> &poly_vk,

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

                              const ThermostatWriter<float> &tstw, const int2 lp,

                              AccumulationMethod acc_meth, IntegrationStage process);


void launchIntegrationProcess(PsSynthesisWriter *poly_psw, CacheResourceKit<float> *tb_resw,

                              MMControlKit<float> *ctrl,

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

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

                              const SyValenceKit<float> &poly_vk,

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

                              const ThermostatWriter<float> &tstw, const int2 lp,

                              AccumulationMethod acc_meth, IntegrationStage process);


void launchIntegrationProcess(PhaseSpaceSynthesis *poly_ps, CacheResource *tb_res, Thermostat *tst,

                              MolecularMechanicsControls *mmctrl,

                              const AtomGraphSynthesis &poly_ag, const CoreKlManager &launcher,

                              PrecisionModel prec, AccumulationMethod acc_meth,

                              IntegrationStage process);


void launchIntegrationProcess(PhaseSpaceSynthesis *poly_ps, CacheResource *tb_res, Thermostat *tst,

                              MolecularMechanicsControls *mmctrl,

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

                              const AtomGraphSynthesis &poly_ag, const CoreKlManager &launcher,

                              PrecisionModel prec, AccumulationMethod acc_meth,

                              IntegrationStage process);


void launchIntegrationProcess(PhaseSpaceSynthesis *poly_ps, CacheResource *tb_res, Thermostat *tst,

                              MolecularMechanicsControls *mmctrl,

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

                              const AtomGraphSynthesis &poly_ag, const CoreKlManager &launcher,

                              PrecisionModel prec, AccumulationMethod acc_meth,

                              IntegrationStage process);


void launchIntegrationProcess(PhaseSpaceSynthesis *poly_ps, CacheResource *tb_res, Thermostat *tst,

                              MolecularMechanicsControls *mmctrl,

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

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

                              const AtomGraphSynthesis &poly_ag, const CoreKlManager &launcher,

                              PrecisionModel prec, AccumulationMethod acc_meth,

                              IntegrationStage process);


void launchIntegrationProcess(PhaseSpaceSynthesis *poly_ps, CacheResource *tb_res, Thermostat *tst,

                              MolecularMechanicsControls *mmctrl,

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

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

                              const AtomGraphSynthesis &poly_ag, const CoreKlManager &launcher,

                              PrecisionModel prec, AccumulationMethod acc_meth,

                              IntegrationStage process);


} // namespace trajectory

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