hpc_nonbonded_potential.h

// -*-c++-*-
#ifndef STORMM_NONBONDED_POTENTIAL_CUH
#define STORMM_NONBONDED_POTENTIAL_CUH
 
#include "copyright.h"
#include "Accelerator/core_kernel_manager.h"
#include "Accelerator/gpu_details.h"
#include "Constants/behavior.h"
#include "MolecularMechanics/mm_controls.h"
#include "Potential/energy_enumerators.h"
#include "Synthesis/implicit_solvent_workspace.h"
#include "Synthesis/phasespace_synthesis.h"
#include "Synthesis/static_mask_synthesis.h"
#include "Synthesis/synthesis_abstracts.h"
#include "Synthesis/synthesis_enumerators.h"
#include "Topology/atomgraph_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::ImplicitSolventWorkspace;
using synthesis::ISWorkspaceKit;
using synthesis::NbwuKind;
using synthesis::PhaseSpaceSynthesis;
using synthesis::PsSynthesisWriter;
using synthesis::SeMaskSynthesisReader;
using synthesis::StaticExclusionMaskSynthesis;
using synthesis::SyNonbondedKit;
using synthesis::VwuGoal;
using topology::ImplicitSolventModel;
using trajectory::Thermostat;
using trajectory::ThermostatWriter;

cudaFuncAttributes queryNonbondedKernelRequirements(PrecisionModel prec, NbwuKind kind,
                                                    EvaluateForce eval_frc,
                                                    EvaluateEnergy eval_nrg,
                                                    AccumulationMethod acc_meth,
                                                    ImplicitSolventModel igb,
                                                    ClashResponse collision_handling);

cudaFuncAttributes queryBornRadiiKernelRequirements(PrecisionModel prec, NbwuKind kind,
                                                    AccumulationMethod acc_meth,
                                                    ImplicitSolventModel igb);

cudaFuncAttributes queryBornDerivativeKernelRequirements(PrecisionModel prec, NbwuKind kind,
                                                         AccumulationMethod acc_meth,
                                                         ImplicitSolventModel igb);

void launchNonbonded(NbwuKind kind, const SyNonbondedKit<double, double2> &poly_nbk,
                     const SeMaskSynthesisReader &poly_ser, MMControlKit<double> *ctrl,
                     PsSynthesisWriter *poly_psw, ThermostatWriter<double> *tstw,
                     ScoreCardWriter *scw, CacheResourceKit<double> *gmem_r,
                     ISWorkspaceKit<double> *iswk, EvaluateForce eval_force,
                     EvaluateEnergy eval_energy, const int2 bt, const int2 gbr_bt,
                     const int2 gbd_bt, double clash_minimum_distance = 0.0,
                     double clash_ratio = 0.0);
 
void launchNonbonded(NbwuKind kind, const SyNonbondedKit<float, float2> &poly_nbk,
                     const SeMaskSynthesisReader &poly_ser, MMControlKit<float> *ctrl,
                     PsSynthesisWriter *poly_psw, ThermostatWriter<float> *tstw,
                     ScoreCardWriter *scw, CacheResourceKit<float> *gmem_r,
                     ISWorkspaceKit<float> *iswk, EvaluateForce eval_force,
                     EvaluateEnergy eval_energy, AccumulationMethod force_sum, const int2 bt,
                     const int2 gbr_bt, const int2 gbd_bt, float clash_minimum_distance = 0.0f,
                     float clash_ratio = 0.0f);
 
void launchNonbonded(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,
                     const StaticExclusionMaskSynthesis &poly_se,
                     MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,
                     Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,
                     ImplicitSolventWorkspace *ism_space, EvaluateForce eval_force,
                     EvaluateEnergy eval_energy, AccumulationMethod force_sum,
                     const CoreKlManager &launcher, double clash_minimum_distance = 0.0,
                     double clash_ratio = 0.0);
 
void launchNonbonded(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,
                     const StaticExclusionMaskSynthesis &poly_se,
                     MolecularMechanicsControls *mmctrl, PhaseSpaceSynthesis *poly_ps,
                     Thermostat *heat_bath, ScoreCard *sc, CacheResource *tb_space,
                     ImplicitSolventWorkspace *ism_space, EvaluateForce eval_force,
                     EvaluateEnergy eval_energy, const CoreKlManager &launcher,
                     double clash_minimum_distance = 0.0, double clash_ratio = 0.0);
 
} // namespace energy
} // namespace stormm
 
#endif