doxygen/hpc__pme__potential_8h_source.html

// -*-c++-*-

#ifndef STORMM_HPC_PME_POTENTIAL_H

#define STORMM_HPC_PME_POTENTIAL_H


#ifdef STORMM_USE_CUDA

#  include <cuda_runtime.h>

#endif

#include "copyright.h"

#include "Accelerator/core_kernel_manager.h"

#include "Constants/behavior.h"

#include "MolecularMechanics/mm_controls.h"

#include "Synthesis/phasespace_synthesis.h"

#include "Synthesis/synthesis_abstracts.h"

#include "energy_enumerators.h"

#include "local_exclusionmask.h"

#include "pme_potential.h"

#include "ppitable.h"

#include "scorecard.h"

#include "tile_manager.h"


namespace stormm {

namespace energy {


using card::CoreKlManager;

using constants::PrecisionModel;

using mm::MMControlKit;

using mm::MolecularMechanicsControls;

using synthesis::SyNonbondedKit;

using synthesis::PsSynthesisBorders;


#ifdef STORMM_USE_CUDA

cudaFuncAttributes

queryDDPMEPairsKernelRequirements(NeighborListKind neighbor_layout, EvaluateForce eval_frc,

                                  EvaluateEnergy eval_nrg, TinyBoxPresence has_tiny_box,

                                  ClashResponse clash_handling);


cudaFuncAttributes

queryDFPMEPairsKernelRequirements(NeighborListKind neighbor_layout, EvaluateForce eval_frc,

                                  EvaluateEnergy eval_nrg, TinyBoxPresence has_tiny_box,

                                  ClashResponse clash_handling);


cudaFuncAttributes

queryFDPMEPairsKernelRequirements(NeighborListKind neighbor_layout, EvaluateForce eval_frc,

                                  EvaluateEnergy eval_nrg, TinyBoxPresence has_tiny_box,

                                  ClashResponse clash_handling);


cudaFuncAttributes

queryFFPMEPairsKernelRequirements(NeighborListKind neighbor_layout, EvaluateForce eval_frc,

                                  EvaluateEnergy eval_nrg, TinyBoxPresence has_tiny_box,

                                  ClashResponse clash_handling);


cudaFuncAttributes

queryPMEPairsKernelRequirements(PrecisionModel coord_prec, PrecisionModel calc_prec,

                                NeighborListKind neighbor_layout, EvaluateForce eval_frc,

                                EvaluateEnergy eval_nrg, TinyBoxPresence has_tiny_box,

                                ClashResponse clash_handling);

#endif


void launchPMEPairs(const SyNonbondedKit<double, double2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<double, double4> &nrg_tab,

                    CellGridWriter<double, llint, double, double4> *cgw, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<double> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<double, double2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<double, double4> &nrg_tab,

                    const PsSynthesisBorders &sysbrd,

                    CellGridWriter<double, llint, double, double4> *cgw, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<double> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<double, double2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<double, double4> &nrg_tab,

                    CellGridWriter<float, int, float, float4> *cgw, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<double> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<double, double2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<double, double4> &nrg_tab,

                    const PsSynthesisBorders &sysbrd,

                    CellGridWriter<float, int, float, float4> *cgw, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<double> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<double, double2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<double, double4> &nrg_tab,

                    CellGridWriter<double, llint, double, double4> *cgw_qq,

                    CellGridWriter<double, llint, double, double4> *cgw_lj, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<double> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<double, double2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<double, double4> &nrg_tab,

                    const PsSynthesisBorders &sysbrd,

                    CellGridWriter<double, llint, double, double4> *cgw_qq,

                    CellGridWriter<double, llint, double, double4> *cgw_lj, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<double> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<double, double2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<double, double4> &nrg_tab,

                    CellGridWriter<float, int, float, float4> *cgw_qq,

                    CellGridWriter<float, int, float, float4> *cgw_lj, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<double> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<double, double2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<double, double4> &nrg_tab,

                    const PsSynthesisBorders &sysbrd,

                    CellGridWriter<float, int, float, float4> *cgw_qq,

                    CellGridWriter<float, int, float, float4> *cgw_lj, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<double> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<float, float2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<float, float4> &nrg_tab,

                    CellGridWriter<float, int, float, float4> *cgw, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<float> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<float, float2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<float, float4> &nrg_tab,

                    const PsSynthesisBorders &sysbrd,

                    CellGridWriter<float, int, float, float4> *cgw, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<float> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<float, float2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<float, float4> &nrg_tab,

                    CellGridWriter<double, llint, double, double4> *cgw, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<float> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<float, float2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<float, float4> &nrg_tab,

                    const PsSynthesisBorders &sysbrd,

                    CellGridWriter<double, llint, double, double4> *cgw, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<float> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<float, float2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<float, float4> &nrg_tab,

                    CellGridWriter<float, int, float, float4> *cgw_qq,

                    CellGridWriter<float, int, float, float4> *cgw_lj, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<float> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<float, float2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<float, float4> &nrg_tab,

                    const PsSynthesisBorders &sysbrd,

                    CellGridWriter<float, int, float, float4> *cgw_qq,

                    CellGridWriter<float, int, float, float4> *cgw_lj, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<float> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<float, float2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<float, float4> &nrg_tab,

                    CellGridWriter<double, llint, double, double4> *cgw_qq,

                    CellGridWriter<double, llint, double, double4> *cgw_lj, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<float> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(const SyNonbondedKit<float, float2> &poly_nbk,

                    const LocalExclusionMaskReader &lemr, const PPIKit<float, float4> &nrg_tab,

                    const PsSynthesisBorders &sysbrd,

                    CellGridWriter<double, llint, double, double4> *cgw_qq,

                    CellGridWriter<double, llint, double, double4> *cgw_lj, TilePlan *tlpn,

                    ScoreCardWriter *scw, MMControlKit<float> *ctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, int2 bt_tp, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(PrecisionModel prec, const LocalExclusionMask &lem,

                    const PPITable &pairs_tbl, CellGrid<double, llint, double, double4> *cg,

                    TileManager *tlmn, ScoreCard *sc, MolecularMechanicsControls *mmctrl,

                    EvaluateForce eval_frc, EvaluateEnergy eval_nrg,

                    const CoreKlManager &launcher, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(PrecisionModel prec, const LocalExclusionMask &lem,

                    const PPITable &pairs_tbl, CellGrid<double, llint, double, double4> *cg_qq,

                    CellGrid<double, llint, double, double4> *cg_lj, TileManager *tlmn,

                    ScoreCard *sc, MolecularMechanicsControls *mmctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, const CoreKlManager &launcher,

                    double clash_distance = 0.0, double clash_ratio = 0.0);


void launchPMEPairs(PrecisionModel prec, const LocalExclusionMask &lem,

                    const PPITable &pairs_tbl, CellGrid<float, int, float, float4> *cg,

                    TileManager *tlmn, ScoreCard *sc, MolecularMechanicsControls *mmctrl,

                    EvaluateForce eval_frc, EvaluateEnergy eval_nrg,

                    const CoreKlManager &launcher, double clash_distance = 0.0,

                    double clash_ratio = 0.0);


void launchPMEPairs(PrecisionModel prec, const LocalExclusionMask &lem,

                    const PPITable &pairs_tbl, CellGrid<float, int, float, float4> *cg_qq,

                    CellGrid<float, int, float, float4> *cg_lj, TileManager *tlmn, ScoreCard *sc,

                    MolecularMechanicsControls *mmctrl, EvaluateForce eval_frc,

                    EvaluateEnergy eval_nrg, 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::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::LocalExclusionMask
The local exclusion mask is an generalized form of the ForwardExclusionMask, listing all exclusions i...
Definition local_exclusionmask.h:208

stormm::energy::PPITable
A tabulated non-bonded potential, with or without exclusions, to be used in the context of particle-p...
Definition ppitable.h:163

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::TileManager
When tiles are loaded for what could be partial batches of atoms, it is critical for threads of the w...
Definition tile_manager.h:88

stormm::mm::MolecularMechanicsControls
A collection of contol data for molecular mechanics simulations, conveying the current step number,...
Definition mm_controls.h:100

stormm::energy::CellGridWriter
Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces.
Definition cellgrid.h:137

stormm::energy::LocalExclusionMaskReader
A lean, read-only abstract for the LocalExclusionMask class.
Definition local_exclusionmask.h:100

stormm::energy::PPIKit
Abstract for the particle-particle interaction table, with pointers to energies and forces and sizing...
Definition ppitable.h:37

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

stormm::energy::TilePlan
The abstract of the TileManager contains pointers to direct the relative indexing of atom reads and t...
Definition tile_manager.h:20

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::PsSynthesisBorders
A read-only abstract for the system demarcations in the object. This information is sometimes critica...
Definition phasespace_synthesis.h:61

stormm::synthesis::SyNonbondedKit
Collect the critical non-bonded parameters and masking information for work unit-based evaluation of ...
Definition synthesis_abstracts.h:181