hpc_minimization.h

// -*-c++-*-
#ifndef STORMM_HPC_MINIMIZATION_H
#define STORMM_HPC_MINIMIZATION_H
 
#include "copyright.h"
#include "Accelerator/core_kernel_manager.h"
#include "Accelerator/gpu_details.h"
#include "Constants/behavior.h"
#include "Constants/fixed_precision.h"
#include "MolecularMechanics/line_minimization.h"
#include "MolecularMechanics/mm_controls.h"
#include "Namelists/nml_minimize.h"
#include "Numerics/split_fixed_precision.h"
#include "Potential/cacheresource.h"
#include "Potential/scorecard.h"
#include "Math/reduction_bridge.h"
#include "Synthesis/atomgraph_synthesis.h"
#include "Synthesis/implicit_solvent_workspace.h"
#include "Synthesis/phasespace_synthesis.h"
#include "Synthesis/static_mask_synthesis.h"
#include "UnitTesting/stopwatch.h"
 
namespace stormm {
namespace mm {
 
using card::GpuDetails;
using card::CoreKlManager;
using constants::PrecisionModel;
using energy::CacheResource;
using energy::ScoreCard;
using energy::ScoreCardWriter;
using stmath::ReductionBridge;
using stmath::ReductionKit;
using namelist::MinimizeControls;
using numerics::default_energy_scale_bits;
using numerics::AccumulationMethod;
using synthesis::AtomGraphSynthesis;
using synthesis::ImplicitSolventWorkspace;
using synthesis::ISWorkspaceKit;
using synthesis::PhaseSpaceSynthesis;
using synthesis::PsSynthesisWriter;
using synthesis::StaticExclusionMaskSynthesis;
using testing::StopWatch;

cudaFuncAttributes queryMinimizationKernelRequirements(const PrecisionModel prec);

void launchLineAdvance(PrecisionModel prec, PsSynthesisWriter *poly_psw, const ReductionKit &redk,
                       const ScoreCardWriter &scw, LinMinWriter *lmw, int move_number,
                       const int2 redu_lp);
 
void launchLineAdvance(PrecisionModel prec, PhaseSpaceSynthesis *poly_ps,
                       const AtomGraphSynthesis &poly_ag, ScoreCard *sc,
                       LineMinimization *line_record, int move_number,
                       const CoreKlManager &launcher);

void launchMinimization(PrecisionModel prec, const AtomGraphSynthesis &poly_ag,
                        const StaticExclusionMaskSynthesis &poly_se,
                        PhaseSpaceSynthesis *poly_ps, const MinimizeControls &mincon,
                        MolecularMechanicsControls *mmctrl_fe,
                        MolecularMechanicsControls *mmctrl_xe,
                        MolecularMechanicsControls *mmctrl_cdfe,
                        MolecularMechanicsControls *mmctrl_cdxe, ScoreCard *sc,
                        CacheResource *vale_fe_cache, CacheResource *vale_xe_cache,
                        CacheResource *vale_cdfe_cache, CacheResource *vale_cdxe_cache,
                        CacheResource *nonb_cache, CacheResource *nonb_cd_cache,
                        ImplicitSolventWorkspace *ism_space, ReductionBridge *rbg,
                        LineMinimization *line_record, AccumulationMethod acc_meth,
                        const GpuDetails &gpu, const CoreKlManager &launcher,
                        StopWatch *timer = nullptr,
                        const std::string &task_name = std::string(""));
 
ScoreCard launchMinimization(const AtomGraphSynthesis &poly_ag,
                             const StaticExclusionMaskSynthesis &poly_se,
                             PhaseSpaceSynthesis *poly_ps, const MinimizeControls &mincon,
                             const GpuDetails &gpu, PrecisionModel prec = PrecisionModel::SINGLE,
                             int energy_accumulation_bits = default_energy_scale_bits, 
                             StopWatch *timer = nullptr,
                             const std::string &task_name = std::string(""));
 
ScoreCard launchMinimization(const AtomGraphSynthesis &poly_ag, PhaseSpaceSynthesis *poly_ps,
                             const MinimizeControls &mincon, const GpuDetails &gpu,
                             PrecisionModel prec = PrecisionModel::SINGLE,
                             int energy_accumulation_bits = default_energy_scale_bits, 
                             StopWatch *timer = nullptr,
                             const std::string &task_name = std::string(""));
  
} // namespace mm
} // namespace stormm
 
#endif