doxygen/pme__potential_8h_source.html

// -*-c++-*-

#ifndef STORMM_PME_POTENTIAL_H

#define STORMM_PME_POTENTIAL_H


#include "copyright.h"

#include "Constants/symbol_values.h"

#include "Math/series_ops.h"

#include "Math/vector_ops.h"

#include "Structure/local_arrangement.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 "local_exclusionmask.h"

#include "cellgrid.h"

#include "energy_enumerators.h"

#include "pme_util.h"

#include "scorecard.h"


namespace stormm {

namespace energy {


using stmath::findBin;

using stmath::indexingArray;

using symbols::amber_ancient_bioq;

using synthesis::AtomGraphSynthesis;

using synthesis::SyNonbondedKit;

using topology::AtomGraph;

using topology::NonbondedKit;

using trajectory::PhaseSpace;

using trajectory::PhaseSpaceWriter;


#ifdef STORMM_USE_CUDA

constexpr uint no_stagger = (0x20 << 24);

constexpr uint half_stagger = ((0x10 << 24) | (0x10 << 16) | (0x10 << 8));

constexpr uint quarter_stagger = ((0x8 << 24) | (0x18 << 16) | (0x10 << 8) | 0x8);

#endif


template <typename Tcalc>

double2 cellToCellInteractions(PhaseSpaceWriter *psw, const std::vector<int> &cell_list,

                               const std::vector<int> &cell_bounds, int ncell_a, int ncell_b,

                               int ncell_c, int cell_idx_a, int cell_idx_b, int cell_idx_c,

                               int i_pair, int j_pair, int k_pair,

                               const NonbondedKit<Tcalc> &nbk,

                               const LocalExclusionMaskReader &lemr, Tcalc elec_cutoff,

                               Tcalc vdw_cutoff, Tcalc qqew_coeff, Tcalc ljew_coeff,

                               VdwSumMethod vdw_sum = VdwSumMethod::CUTOFF,

                               EvaluateForce eval_frc = EvaluateForce::YES,

                               NonbondedTheme theme = NonbondedTheme::ALL);


template <typename Tcalc>

double2 evaluateParticleParticleEnergy(PhaseSpaceWriter *psw, const NonbondedKit<Tcalc> &nbk,

                                       const LocalExclusionMaskReader &lemr,

                                       Tcalc elec_cutoff = static_cast<Tcalc>(default_pme_cutoff),

                                       Tcalc vdw_cutoff = static_cast<Tcalc>(default_pme_cutoff),

                                       Tcalc qqew_coeff = static_cast<Tcalc>(0.0),

                                       Tcalc ljew_coeff = static_cast<Tcalc>(0.0),

                                       VdwSumMethod vdw_sum = VdwSumMethod::CUTOFF,

                                       EvaluateForce eval_frc = EvaluateForce::YES,

                                       NonbondedTheme theme = NonbondedTheme::ALL);


double2 evaluateParticleParticleEnergy(PhaseSpace *ps, const AtomGraph *ag,

                                       const LocalExclusionMask &lema,

                                       const PrecisionModel prec = PrecisionModel::SINGLE,

                                       double elec_cutoff = default_pme_cutoff,

                                       double vdw_cutoff = default_pme_cutoff,

                                       double qqew_coeff = 0.0, double ljew_coeff = 0.0,

                                       VdwSumMethod vdw_sum = VdwSumMethod::CUTOFF,

                                       EvaluateForce eval_frc = EvaluateForce::YES,

                                       NonbondedTheme theme = NonbondedTheme::ALL);


double2 evaluateParticleParticleEnergy(PhaseSpace *ps, const AtomGraph &ag,

                                       const LocalExclusionMask &lema,

                                       const PrecisionModel prec = PrecisionModel::SINGLE,

                                       double elec_cutoff = default_pme_cutoff,

                                       double vdw_cutoff = default_pme_cutoff,

                                       double qqew_coeff = 0.0, double ljew_coeff = 0.0,

                                       VdwSumMethod vdw_sum = VdwSumMethod::CUTOFF,

                                       EvaluateForce eval_frc = EvaluateForce::YES,

                                       NonbondedTheme theme = NonbondedTheme::ALL);


template <typename Tcoord, typename Tacc, typename Tcalc, typename Tcalc2, typename Tcoord4>

void evaluateParticleParticleEnergy(CellGridWriter<void, void, void, void> *cgw_v,

                                    ScoreCardWriter *scw, const PsSynthesisReader &poly_psr,

                                    const SyNonbondedKit<Tcalc, Tcalc2> &poly_nbk,

                                    const LocalExclusionMaskReader &lemr,

                                    Tcalc cutoff = static_cast<Tcalc>(default_pme_cutoff),

                                    Tcalc ew_coeff = static_cast<Tcalc>(0.0),

                                    VdwSumMethod vdw_sum = VdwSumMethod::CUTOFF,

                                    EvaluateForce eval_frc = EvaluateForce::YES,

                                    NonbondedTheme theme = NonbondedTheme::ALL);


template <typename Tcoord, typename Tacc, typename Tcalc, typename Tcoord4>

void evaluateParticleParticleEnergy(CellGrid<Tcoord, Tacc, Tcalc, Tcoord4> *cg, ScoreCard *sc,

                                    const LocalExclusionMask &lema,

                                    Tcalc cutoff = static_cast<Tcalc>(default_pme_cutoff),

                                    Tcalc ew_coeff = static_cast<Tcalc>(0.0),

                                    VdwSumMethod vdw_sum = VdwSumMethod::CUTOFF,

                                    EvaluateForce eval_frc = EvaluateForce::YES,

                                    NonbondedTheme theme = NonbondedTheme::ALL);


template <typename Tcoord, typename Tacc, typename Tcalc, typename Tcalc2, typename Tcalc4>

double2 basicTileInteractions(const std::vector<Tcalc> &a_xpos, const std::vector<Tcalc> &a_ypos,

                              const std::vector<Tcalc> &a_zpos, const std::vector<Tcalc> &b_xpos,

                              const std::vector<Tcalc> &b_ypos, const std::vector<Tcalc> &b_zpos,

                              const std::vector<Tcalc> &scl_aq, const std::vector<Tcalc> &bq,

                              const std::vector<int> &ofs_aljidx, const std::vector<int> &bljidx,

                              const std::vector<int> &top_aidx, const std::vector<int> &top_bidx,

                              const std::vector<uint> &img_aidx, const std::vector<uint> &img_bidx,

                              int system_index, int na, int nb, bool self_interaction,

                              CellGridWriter<Tcoord, Tacc, Tcalc, Tcalc4> *cgw,

                              const PsSynthesisReader &poly_psr,

                              const SyNonbondedKit<Tcalc, Tcalc2> &poly_nbk,

                              const LocalExclusionMaskReader &lemr, Tcalc elec_cutsq,

                              Tcalc vdw_cutsq, Tcalc qqew_coeff, Tcalc ljew_coeff,

                              VdwSumMethod vdw_sum, EvaluateForce eval_frc, NonbondedTheme theme);


template <typename Tcoord, typename Tacc, typename Tcalc, typename Tcalc2, typename Tcoord4>

double2 towerPlatePairInteractions(CellGridWriter<Tcoord, Tacc, Tcalc, Tcoord4> *cgw,

                                   const PsSynthesisReader &poly_psr, int system_idx, int cell_idx,

                                   const SyNonbondedKit<Tcalc, Tcalc2> &poly_nbk,

                                   const LocalExclusionMaskReader &lemr, Tcalc elec_cutoff,

                                   Tcalc vdw_cutoff, Tcalc qqew_coeff, Tcalc ljew_coeff,

                                   VdwSumMethod vdw_sum, EvaluateForce eval_frc,

                                   NonbondedTheme theme);


} // namespace energy

} // namespace stormm


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

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::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::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::ScoreCardWriter
Writeable abstract for the ScoreCard object, useful for accumulating energies in many kernels.
Definition scorecard.h:64

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::SyNonbondedKit
Collect the critical non-bonded parameters and masking information for work unit-based evaluation of ...
Definition synthesis_abstracts.h:181

stormm::topology::NonbondedKit
Information needed for non-bonded real-space calculations. Templating is used as above,...
Definition atomgraph_abstracts.h:287

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