map_density.h

// -*-c++-*-
#ifndef STORMM_MAP_DENSITY_H
#define STORMM_MAP_DENSITY_H
 
#include "copyright.h"
#include "Accelerator/core_kernel_manager.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "Math/bspline.h"
#include "Math/math_enumerators.h"
#include "Math/rounding.h"
#include "MolecularMechanics/mm_controls.h"
#include "Numerics/split_fixed_precision.h"
#include "Structure/local_arrangement.h"
#include "Structure/structure_enumerators.h"
#include "Synthesis/atomgraph_synthesis.h"
#include "Synthesis/synthesis_abstracts.h"
#include "cellgrid.h"
#include "energy_enumerators.h"
#include "pmigrid.h"
 
namespace stormm {
namespace energy {
 
using card::CoreKlManager;
using data_types::isFloatingPointScalarType;
using mm::MolecularMechanicsControls;
using mm::MMControlKit;
using numerics::hostDoubleToInt63;
using numerics::hostDoubleToInt95;
using stmath::bSpline;
using stmath::bSplineNoUnity;
using stmath::BSplineUnity;
using stmath::roundUp;
using structure::imageCoordinates;
using structure::ImagingMethod;
using synthesis::AtomGraphSynthesis;
using synthesis::SyNonbondedKit;
using topology::AtomGraph;
using topology::NonbondedKit;
using trajectory::CoordinateFrame;
using trajectory::CoordinateFrameReader;

void matchThemes(NonbondedTheme pm_theme, NonbondedTheme cg_theme);
  
template <typename Tcalc, typename Tgrid>
void particleAlignment(Tcalc x, Tcalc y, Tcalc z, Tcalc inv_lpos_scale, const Tcalc* umat,
                       int cg_mesh_ticks, int cell_i, int cell_j, int cell_k, Tgrid *a_cof,
                       Tgrid *b_cof, Tgrid *c_cof, int bspline_order, int *grid_a, int *grid_b,
                       int *grid_c);

template <typename Tcalc, typename Tgrid>
void spreadDensity(const Tcalc* a_cof, const Tcalc* b_cof, const Tcalc* c_cof, int bspline_order,
                   int grid_root_a, int grid_root_b, int grid_root_c, const uint4 grid_dims,
                   FFTMode fft_staging, Tgrid* grid_data, int* overflow = nullptr,
                   Tcalc mesh_scaling_factor = 1.0);

template <typename T, typename Tacc, typename Tcalc, typename Tcalc2, typename T4>
void accumulateCellDensity(PMIGridWriter *pm_wrt, int sysid, int cell_i, int cell_j, int cell_k,
                           const CellGridReader<T, Tacc, Tcalc, T4> &cgr,
                           const SyNonbondedKit<Tcalc, Tcalc2> &synbk);
 
template <typename T, typename Tacc, typename Tcalc, typename Tcalc2, typename T4>
void accumulateCellDensity(PMIGridAccumulator *pm_acc, int sysid, int cell_i, int cell_j,
                           int cell_k, const CellGridReader<T, Tacc, Tcalc, T4> &cgr,
                           const SyNonbondedKit<Tcalc, Tcalc2> &synbk);

template <typename T, typename Tacc, typename Tcalc, typename T4>
void mapDensity(PMIGrid *pm, const CellGrid<T, Tacc, Tcalc, T4> *cg,
                const AtomGraphSynthesis *poly_ag);
 
template <typename T, typename Tacc, typename Tcalc, typename T4>
void mapDensity(PMIGrid *pm, const CellGrid<T, Tacc, Tcalc, T4> &cg,
                const AtomGraphSynthesis &poly_ag);
 
#ifdef STORMM_USE_HPC
void mapDensity(PMIGridWriter *pm_wrt, PMIGridAccumulator *pm_acc, MMControlKit<double> *ctrl,
                const CellGridReader<void, void, void, void> &v_cgr, size_t cg_tmat,
                const SyNonbondedKit<double, double2> &synbk, int block_count, const int2 lp,
                QMapMethod approach, PMIGrid *pm);
 
void mapDensity(PMIGridWriter *pm_wrt, PMIGridAccumulator *pm_acc, MMControlKit<float> *ctrl,
                const CellGridReader<void, void, void, void> &v_cgr, size_t cg_tmat,
                const SyNonbondedKit<float, float2> &synbk, int block_count, const int2 lp,
                QMapMethod approach, PMIGrid *pm);
 
template <typename T, typename Tacc, typename Tcalc, typename T4>
void mapDensity(PMIGrid *pm, MolecularMechanicsControls *mm_ctrl,
                const CellGrid<T, Tacc, Tcalc, T4> *cg, const AtomGraphSynthesis *poly_ag,
                const CoreKlManager &launcher, QMapMethod approach);
#endif
 
void mapDensity(PMIGrid *pm, const AtomGraphSynthesis *poly_ag);
 
void mapDensity(PMIGrid *pm, const AtomGraphSynthesis &poly_ag);
 
template <typename Tcalc>
std::vector<Tcalc> mapDensity(const CoordinateFrameReader &cfr, const NonbondedKit<Tcalc> &nbk,
                              NonbondedTheme theme, FFTMode fft_staging, int grid_dim_a,
                              int grid_dim_b, int grid_dim_c, int order = default_bspline_order,
                              BSplineUnity unification = BSplineUnity::CENTER_FILL);
 
std::vector<double> mapDensity(const CoordinateFrame *cf, const AtomGraph *ag,
                               NonbondedTheme theme, FFTMode fft_staging, int grid_dim_a = -1,
                               int grid_dim_b = -1, int grid_dim_c = -1,
                               int order = default_bspline_order);
 
std::vector<double> mapDensity(const CoordinateFrame &cf, const AtomGraph &ag,
                               NonbondedTheme theme, FFTMode fft_staging, int grid_dim_a = -1,
                               int grid_dim_b = -1, int grid_dim_c = -1,
                               int order = default_bspline_order);

template <typename T, typename T4>
void unrollMapDensityCall(PMIGrid *pm, size_t cg_tacc, size_t cg_tcalc,
                          const AtomGraphSynthesis *poly_ag);
 
template <typename T, typename Tacc, typename T4>
void unrollMapDensityCall(PMIGrid *pm, size_t cg_tcalc, const AtomGraphSynthesis *poly_ag);
 
#ifdef STORMM_USE_HPC
void launchShrAccDensityKernel(PMIGridWriter *pm_wrt, bool overflow, MMControlKit<double> *ctrl,
                               const CellGridReader<void, void, void, void> &v_cgr, size_t cg_tmat,
                               const SyNonbondedKit<double, double2> &synbk, const int2 lp);
  
void launchShrAccDensityKernel(PMIGridWriter *pm_wrt, bool overflow, MMControlKit<float> *ctrl,
                               const CellGridReader<void, void, void, void> &v_cgr, size_t cg_tmat,
                               const SyNonbondedKit<float, float2> &synbk, const int2 lp);
 
void launchGenPrpDensityKernel(PMIGridAccumulator *pm_acc,
                               const CellGridReader<void, void, void, void> &v_cgr, size_t cg_tmat,
                               const SyNonbondedKit<double, double2> &synbk, const int2 lp);
  
void launchGenPrpDensityKernel(PMIGridAccumulator *pm_acc,
                               const CellGridReader<void, void, void, void> &v_cgr, size_t cg_tmat,
                               const SyNonbondedKit<float, float2> &synbk, const int2 lp);
#endif
 
} // namespace energy
} // namespace stormm
 
#include "map_density.tpp"
 
#endif