mm_controls.h

// -*-c++-*-
#ifndef STORMM_MM_CONTROLS_H
#define STORMM_MM_CONTROLS_H
 
#include "copyright.h"
#include "Accelerator/core_kernel_manager.h"
#include "Accelerator/gpu_details.h"
#include "Accelerator/hybrid.h"
#include "Constants/behavior.h"
#include "Potential/energy_enumerators.h"
#include "Potential/cellgrid.h"
#include "Math/reduction_enumerators.h"
#include "Namelists/nml_dynamics.h"
#include "Namelists/nml_minimize.h"
#include "Potential/energy_enumerators.h"
#include "Synthesis/atomgraph_synthesis.h"
#include "Topology/atomgraph_enumerators.h"
 
namespace stormm {
namespace mm {
 
using card::GpuDetails;
using card::CoreKlManager;
using card::Hybrid;
using card::HybridTargetLevel;
using constants::PrecisionModel;
using energy::CellGrid;
using energy::ClashResponse;
using energy::EvaluateEnergy;
using energy::EvaluateForce;
using energy::NeighborListKind;
using energy::QMapMethod;
using energy::TinyBoxPresence;
using stmath::ReductionStage;
using namelist::default_dynamics_time_step;
using namelist::default_electrostatic_cutoff;
using namelist::default_minimize_dx0;
using namelist::default_minimize_maxcyc;
using namelist::default_minimize_ncyc;
using namelist::default_rattle_tolerance;
using namelist::default_nt_warp_multiplicity;
using namelist::default_van_der_waals_cutoff;
using namelist::DynamicsControls;
using namelist::MinimizeControls;
using synthesis::AtomGraphSynthesis;
using synthesis::VwuGoal;
using topology::ImplicitSolventModel;

template <typename T> struct MMControlKit {

  MMControlKit(int step_in, int sd_cycles_in, int max_cycles_in, T initial_step_in,
               int nt_warp_mult_in, const T elec_cut_in, const T vdw_cut_in, int* vwu_progress_in,
               int* vupt_progress_in, int* vcns_progress_in, int* pupt_progress_in,
               int* gcns_progress_in, int* nbwu_progress_in, int* pmewu_progress_in,
               int* gbrwu_progress_in, int* gbdwu_progress_in, int* gtwu_progress_in,
               int* scwu_progress_in, int* rdwu_progress_in);

  MMControlKit(const MMControlKit &original) = default;
  MMControlKit(MMControlKit &&original) = default;
 
  int step;                
  const int sd_cycles;     
  const int max_cycles;    
  const T initial_step;    
  const int nt_warp_mult;  
  const T elec_cut;        
  const T vdw_cut;         
  const T elec_cut_sq;     
  const T vdw_cut_sq;      
  int* vwu_progress;       
  int* vupt_progress;      
  int* vcns_progress;      
  int* pupt_progress;      
  int* gcns_progress;      
  int* nbwu_progress;      
  int* pmewu_progress;     
  int* gbrwu_progress;     
  int* gbdwu_progress;     
  int* gtwu_progress;      
  int* scwu_progress;      
  int* rdwu_progress;      
};

class MolecularMechanicsControls {
public:

  MolecularMechanicsControls(double initial_step_in = default_minimize_dx0,
                             int sd_cycles_in = default_minimize_ncyc,
                             int max_cycles_in = default_minimize_maxcyc,
                             int nt_warp_multiplicity_in = default_nt_warp_multiplicity,
                             double electrostatic_cutoff_in = default_electrostatic_cutoff,
                             double van_der_waals_cutoff_in = default_van_der_waals_cutoff);
 
  MolecularMechanicsControls(const DynamicsControls &user_input);
                             
  MolecularMechanicsControls(const MinimizeControls &user_input);

  MolecularMechanicsControls(const MolecularMechanicsControls &original);

  MolecularMechanicsControls& operator=(const MolecularMechanicsControls &other);

  MolecularMechanicsControls(MolecularMechanicsControls &&original);

  int getStepNumber() const;
  
  int getSteepestDescentCycles() const;
  
  int getTotalCycles() const;

  int getNTWarpMultiplicity() const;

  double getInitialMinimizationStep() const;

  double getElectrostaticCutoff() const;
  
  double getVanDerWaalsCutoff() const;
  
  int getValenceWorkUnitProgress(int counter_index,
                                 HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  int getNonbondedWorkUnitProgress(int counter_index,
                                   HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  int getPmeWorkUnitProgress(int counter_index,
                             HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  int getReductionWorkUnitProgress(int counter_index, ReductionStage process,
                                   HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  MolecularMechanicsControls& operator=(MolecularMechanicsControls &&other);
  
  MMControlKit<double> dpData(HybridTargetLevel tier = HybridTargetLevel::HOST);

  MMControlKit<float> spData(HybridTargetLevel tier = HybridTargetLevel::HOST);

  void primeWorkUnitCounters(const CoreKlManager &launcher, EvaluateForce eval_frc,
                             EvaluateEnergy eval_nrg, ClashResponse softcore, VwuGoal purpose,
                             PrecisionModel valence_prec, PrecisionModel nonbond_prec,
                             QMapMethod qspread_approach, PrecisionModel acc_prec,
                             size_t image_coord_type, int qspread_order,
                             NeighborListKind nbgr_config, TinyBoxPresence has_tiny_box,
                             const AtomGraphSynthesis &poly_ag);
 
  void primeWorkUnitCounters(const CoreKlManager &launcher, EvaluateForce eval_frc,
                             EvaluateEnergy eval_nrg, const ClashResponse softcore,
                             VwuGoal purpose, PrecisionModel valence_prec,
                             PrecisionModel nonbond_prec, const AtomGraphSynthesis &poly_ag); 
 
  void primeWorkUnitCounters(const CoreKlManager &launcher, EvaluateForce eval_frc,
                             EvaluateEnergy eval_nrg, VwuGoal purpose, PrecisionModel valence_prec,
                             PrecisionModel nonbond_prec, const AtomGraphSynthesis &poly_ag); 
 
  void primeWorkUnitCounters(const CoreKlManager &launcher, EvaluateForce eval_frc,
                             EvaluateEnergy eval_nrg, VwuGoal purpose, PrecisionModel general_prec,
                             const AtomGraphSynthesis &poly_ag); 

  template <typename T, typename Tacc, typename Tcalc, typename T4>
  void setNTWarpMultiplicity(const CellGrid<T, Tacc, Tcalc, T4> *cg_a,
                             const CellGrid<T, Tacc, Tcalc, T4> *cg_b, const GpuDetails &gpu);
 
  template <typename T, typename Tacc, typename Tcalc, typename T4>
  void setNTWarpMultiplicity(const CellGrid<T, Tacc, Tcalc, T4> *cg_a, const GpuDetails &gpu);
 
  void setNTWarpMultiplicity(int mult_in);
  
  void incrementStep();
  
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif
  
private:
  int step_number;              
  int sd_cycles;                
  int max_cycles;               
  double initial_step;          
  int nt_warp_multiplicity;     
  double electrostatic_cutoff;  
  double van_der_waals_cutoff;  

  Hybrid<int> vwu_progress;

  Hybrid<int> velocity_update_progress;

  Hybrid<int> velocity_constraint_progress;

  Hybrid<int> position_update_progress;

  Hybrid<int> geometry_constraint_progress;
  
  Hybrid<int> nbwu_progress;

  Hybrid<int> pmewu_progress;

  Hybrid<int> gbrwu_progress;

  Hybrid<int> gbdwu_progress;
  
  Hybrid<int> gather_wu_progress;

  Hybrid<int> scatter_wu_progress;
  
  Hybrid<int> all_reduce_wu_progress;

  Hybrid<int> int_data;

  void rebasePointers();
};
 
} // namespace mm
} // namespace stormm
 
#include "mm_controls.tpp"
 
#endif