doxygen/background__mesh_8h_source.html

// -*-c++-*-

#ifndef STORMM_PUREMESH_H

#define STORMM_PUREMESH_H


#include <algorithm>

#include <string>

#include <vector>

#include "copyright.h"

#include "Accelerator/gpu_details.h"

#include "Accelerator/hybrid.h"

#include "Accelerator/mesh_kernel_manager.h"

#include "Constants/behavior.h"

#include "Constants/fixed_precision.h"

#include "Constants/scaling.h"

#include "Constants/symbol_values.h"

#include "DataTypes/common_types.h"

#include "DataTypes/stormm_vector_types.h"

#include "Math/matrix_ops.h"

#include "Math/one_dimensional_splines.h"

#include "Math/radial_derivatives.h"

#include "Math/rounding.h"

#include "Math/tricubic_cell.h"

#include "Math/vector_ops.h"

#include "Namelists/nml_mesh.h"

#include "Numerics/split_fixed_precision.h"

#include "Parsing/polynumeric.h"

#include "Potential/energy_enumerators.h"

#include "Reporting/reporting_enumerators.h"

#include "Topology/atomgraph.h"

#include "Trajectory/coordinateframe.h"

#include "Trajectory/coordinate_copy.h"

#include "Trajectory/coordinate_series.h"

#include "Trajectory/phasespace.h"

#include "local_arrangement.h"

#include "mesh_forcefield.h"

#include "mesh_foundation.h"

#include "mesh_parameters.h"

#include "mesh_rulers.h"

#include "structure_enumerators.h"


namespace stormm {

namespace structure {


using card::GpuDetails;

using card::Hybrid;

using card::HybridKind;

using card::HybridTargetLevel;

using card::MeshKlManager;

using constants::CartesianDimension;

using constants::PrecisionModel;

using constants::UnitCellAxis;

using data_types::getStormmScalarTypeName;

using data_types::isScalarType;

using data_types::isFloatingPointScalarType;

using data_types::isSignedIntegralScalarType;

using energy::NonbondedPotential;

using energy::cubicSoftCore;

using energy::quinticSoftCore;

using energy::VdwCombiningRule;

using parse::NumberFormat;

using namelist::default_mesh_density_averaging_order;

using namelist::default_mesh_elec_damping_range;

using namelist::default_mesh_vdw_damping_ratio;

using numerics::default_globalpos_scale_bits;

using numerics::fixedPrecisionGrid;

using review::GridFileSyntax;

using review::getEnumerationName;

using stmath::addScalarToVector;

using stmath::convertData;

using stmath::elementwiseMultiply;

using stmath::evaluateCubicSpline;

using stmath::evaluateQuinticSpline;

using stmath::fvStencilCoordinates;

using stmath::hessianNormalWidths;

using stmath::invertSquareMatrix;

using stmath::maxAbsoluteDifference;

using stmath::radialFirstDerivative;

using stmath::radialSecondDerivative;

using stmath::radialThirdDerivative;

using stmath::roundUp;

using stmath::TricubicCell;

using stmath::TricubicStencil;

using topology::AtomGraph;

using topology::NonbondedKit;

using trajectory::coordCopy;

using trajectory::CoordinateFrame;

using trajectory::CoordinateFrameReader;

using trajectory::CoordinateSeries;

using trajectory::CoordinateSeriesReader;

using trajectory::PhaseSpace;


template <typename Tdata> struct BackgroundMeshWriter {


  BackgroundMeshWriter(const MeshParamKit &measurements, GridDetail kind_in,

                       NonbondedPotential field_in, const MeshRulerKit &rulers,

                       Tdata* coeffs_in, double coeff_scale_in, double probe_radius_in,

                       double well_depth_in, double occ_cost_in, const MeshBasicsKit &mbss_in);


  BackgroundMeshWriter(const BackgroundMeshWriter<Tdata> &original) = default;

  BackgroundMeshWriter(BackgroundMeshWriter<Tdata> &&original) = default;


  const MeshParamKit dims;

  const GridDetail kind;

  const NonbondedPotential field;

  const MeshRulerKit rlrs;


  // The content of the mesh is what is actually writeable.

  Tdata* coeffs;

  const double coeff_scale;

  const float coeff_scale_f;


  // The following data is critical to producing the mesh, and can be necessary for interpreting

  // the potentials read from it.

  const double probe_radius;

  const double well_depth;

  const double occ_cost;

  const MeshBasicsKit mbss;

};


template <typename Tdata> struct BackgroundMeshReader {


  BackgroundMeshReader(const MeshParamKit &dims_in, GridDetail kind_in,

                       NonbondedPotential field_in, const MeshRulerKit &rulers,

                       const Tdata* coeffs_in, double coeff_scale_in, double probe_radius_in,

                       double well_depth_in, double occ_cost_in, const MeshBasicsKit &mbss_in);


  BackgroundMeshReader(const BackgroundMeshReader<Tdata> &original) = default;

  BackgroundMeshReader(BackgroundMeshReader<Tdata> &&original) = default;


  const MeshParamKit dims;

  const GridDetail kind;

  const NonbondedPotential field;

  const MeshRulerKit rlrs;

  const Tdata* coeffs;

  const double coeff_scale;

  const float coeff_scale_f;


  // The following data can be necessary for interpreting potentials read from the mesh.

  const double probe_radius;

  const double well_depth;

  const double occ_cost;

  const MeshBasicsKit mbss;

};


template <typename T> class BackgroundMesh {

public:


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in,

                 const MeshParameters &measurements_in = MeshParameters(),

                 const PrecisionModel build_precision_in = PrecisionModel::SINGLE);


  // General meshes with all available details

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in,

                 const AtomGraph *ag_in, const CoordinateFrame *cf_in,

                 double probe_radius_in, double well_depth_in, VdwCombiningRule mixing_protocol_in,

                 const MeshParameters &measurements_in = MeshParameters(),

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in,

                 const AtomGraph &ag_in, const CoordinateFrame &cf_in,

                 double probe_radius_in, double well_depth_in, VdwCombiningRule mixing_protocol_in,

                 const MeshParameters &measurements_in = MeshParameters(),

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph *ag_in,

                 const CoordinateFrame *cf_in, double buffer, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph &ag_in,

                 const CoordinateFrame &cf_in, double buffer, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph *ag_in,

                 const CoordinateFrame *cf_in, double buffer, const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph &ag_in,

                 const CoordinateFrame &cf_in, double buffer, const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph *ag_in,

                 const CoordinateFrame *cf_in, const std::vector<double> &mesh_bounds,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph &ag_in,

                 const CoordinateFrame &cf_in, const std::vector<double> &mesh_bounds,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph *ag_in,

                 const CoordinateFrame *cf_in, const std::vector<double> &mesh_bounds,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph &ag_in,

                 const CoordinateFrame &cf_in, const std::vector<double> &mesh_bounds,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  // Electrostatics-based meshes

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph *ag_in,

                 const CoordinateFrame *cf_in, double buffer, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph &ag_in,

                 const CoordinateFrame &cf_in, double buffer, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph *ag_in,

                 const CoordinateFrame *cf_in, double buffer,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph &ag_in,

                 const CoordinateFrame &cf_in, double buffer,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph *ag_in,

                 const CoordinateFrame *cf_in, const std::vector<double> &mesh_bounds,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph &ag_in,

                 const CoordinateFrame &cf_in, const std::vector<double> &mesh_bounds,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph *ag_in,

                 const CoordinateFrame *cf_in, const std::vector<double> &mesh_bounds,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph &ag_in,

                 const CoordinateFrame &cf_in, const std::vector<double> &mesh_bounds,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  // Clash-based meshes

  BackgroundMesh(GridDetail kind_in, double probe_radius_in, VdwCombiningRule mixing_protocol_in,

                 const AtomGraph *ag_in, const CoordinateFrame *cf_in, double buffer,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, double probe_radius_in, VdwCombiningRule mixing_protocol_in,

                 const AtomGraph &ag_in, const CoordinateFrame &cf_in, double buffer,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, double probe_radius_in, VdwCombiningRule mixing_protocol_in,

                 const AtomGraph *ag_in, const CoordinateFrame *cf_in, double buffer,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, double probe_radius_in, VdwCombiningRule mixing_protocol_in,

                 const AtomGraph &ag_in, const CoordinateFrame &cf_in, double buffer,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, double probe_radius_in, VdwCombiningRule mixing_protocol_in,

                 const AtomGraph *ag_in, const CoordinateFrame *cf_in,

                 const std::vector<double> &mesh_bounds, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, double probe_radius_in, VdwCombiningRule mixing_protocol_in,

                 const AtomGraph &ag_in, const CoordinateFrame &cf_in,

                 const std::vector<double> &mesh_bounds, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, double probe_radius_in, VdwCombiningRule mixing_protocol_in,

                 const AtomGraph *ag_in, const CoordinateFrame *cf_in,

                 const std::vector<double> &mesh_bounds, const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(GridDetail kind_in, double probe_radius_in, VdwCombiningRule mixing_protocol_in,

                 const AtomGraph &ag_in, const CoordinateFrame &cf_in,

                 const std::vector<double> &mesh_bounds, const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  // General meshes with all available details

  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in,

                 const AtomGraph &ag_in, const CoordinateSeries<Tcoord> &cs_in,

                 double probe_radius_in, double well_depth_in, VdwCombiningRule mixing_protocol_in,

                 const MeshParameters &measurements_in = MeshParameters(),

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, double buffer, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, double buffer,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, const std::vector<double> &mesh_bounds,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, double probe_radius_in,

                 double well_depth_in, VdwCombiningRule mixing_protocol_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, const std::vector<double> &mesh_bounds,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 const std::vector<double> &probe_epsilon = {},

                 double clash_distance_in = default_mesh_elec_damping_range,

                 double clash_ratio_in = default_mesh_vdw_damping_ratio,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  // Electrostatics-based meshes

  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, double buffer, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, double buffer,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, const std::vector<double> &mesh_bounds,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, const std::vector<double> &mesh_bounds,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 double clash_distance_in = default_mesh_elec_damping_range,

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  // Clash-based meshes

  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, double probe_radius_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, double buffer, double spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, double probe_radius_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, double buffer,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, double probe_radius_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, const std::vector<double> &mesh_bounds,

                 double spacing, int scale_bits_in = default_globalpos_scale_bits,

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  template <typename Tcoord>

  BackgroundMesh(GridDetail kind_in, double probe_radius_in, const AtomGraph &ag_in,

                 const CoordinateSeries<Tcoord> &cs_in, const std::vector<double> &mesh_bounds,

                 const std::vector<double> &spacing,

                 int scale_bits_in = default_globalpos_scale_bits,

                 int averaging_order = default_mesh_density_averaging_order,

                 const std::vector<double> &probe_sigma = {},

                 PrecisionModel prec = PrecisionModel::SINGLE,

                 const MeshKlManager &launcher = MeshKlManager(),

                 HybridTargetLevel availability = HybridTargetLevel::HOST);


  BackgroundMesh(const BackgroundMesh<T> &original) = default;

  BackgroundMesh(BackgroundMesh<T> &&original) = default;

  BackgroundMesh& operator=(const BackgroundMesh<T> &original) = default;

  BackgroundMesh& operator=(BackgroundMesh<T> &&original) = default;


  const MeshParameters& getDimensions() const;


  const MeshFoundation& getMolecularBasis() const;

  MeshFoundation* getMolecularBasis();


  const AtomGraph* getTopologyPointer() const;


  const CoordinateFrame* getCoordinatePointer() const;


  template <typename Tcoord>

  const CoordinateSeries<Tcoord>* getEnsemblePointer() const;


  size_t getEnsembleTypeCode() const;


  GridDetail getMeshKind() const;


  NonbondedPotential getNonbondedPotential() const;


  double getProbeRadius() const;


  double getWellDepth() const;


  double getClashDistance() const;


  double getClashRatio() const;


  double getOcclusionPenalty() const;


  VdwCombiningRule getCombiningRule() const;


  PrecisionModel getBuildPrecision() const;


  double getCoefficientScalingFactor() const;


  int getCoefficientScalingBits() const;


  const BackgroundMeshReader<T> data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  BackgroundMeshWriter<T> data(HybridTargetLevel tier = HybridTargetLevel::HOST);


  const BackgroundMeshReader<void>

  templateFreeData(HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  BackgroundMeshWriter<void>

  templateFreeData(HybridTargetLevel tier = HybridTargetLevel::HOST);


#ifdef STORMM_USE_HPC

#  ifdef STORMM_USE_CUDA

  BackgroundMeshWriter<void> deviceViewToTemplateFreeHostData();

  const BackgroundMeshReader<void> deviceViewToTemplateFreeHostData() const;

#  endif

#endif


  const MeshFFKit<T>

  getNonbondedKit(HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  const MeshFFKit<double>

  getReferenceNonbondedKit(HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  const MeshFFKit<void>

  templateFreeNonbondedKit(HybridTargetLevel tier = HybridTargetLevel::HOST) const;


#ifdef STORMM_USE_HPC

#  ifdef STORMM_USE_CUDA

  const MeshFFKit<double> deviceViewToReferenceNonbondedKit() const;


  const MeshFFKit<void> deviceViewToTemplateFreeNonbondedKit() const;

#  endif

  void upload();


  void download();


  void uploadFrame();


  void downloadFrame();


  void uploadForceField();


  void downloadForceField();

#endif


  void setMeshParameters(const AtomGraph *ag_in, const CoordinateFrame *cf_in, double padding,

                         double spacing, int scale_bits_in = -100);


  void setMeshParameters(const AtomGraph *ag_in, const CoordinateFrame *cf_in, double padding,

                         const std::vector<double> &spacing, int scale_bits_in = -100);


  void setMeshParameters(double padding, double spacing, int scale_bits_in = -100);


  void setMeshParameters(double padding, const std::vector<double> &spacing,

                         int scale_bits_in = -100);


  void setMeshParameters(const std::vector<double> &mesh_bounds, double spacing,

                         int scale_bits_in = -100);


  void setMeshParameters(const std::vector<double> &mesh_bounds,

                         const std::vector<double> &spacing, int scale_bits_in = -100);


  void setProbeRadius(double probe_radius_in);


  void setWellDepth(double well_depth_in);


  void setOcclusionPenalty(double occlusion_penalty_in);


  void validateCombiningRule(VdwCombiningRule mixing_protocol_in,

                             const std::vector<double> &probe_sigma,

                             const std::vector<double> &probe_epsilon);


  void setCoefficientScalingBits(int scaling_bits_in);


  void computeField(const MeshKlManager &launcher = MeshKlManager(),

                    PrecisionModel prec = PrecisionModel::SINGLE,

                    HybridTargetLevel availability = HybridTargetLevel::HOST,

                    const std::vector<double> &probe_sigma = {},

                    const std::vector<double> &probe_epsilon = {});


private:


  MeshParameters measurements;


  GridDetail kind;


  NonbondedPotential field;


  double probe_radius;


  double well_depth;


  double occlusion_penalty;


  PrecisionModel build_precision;


  MeshRulers tick_marks;


  MeshForceField<T> nonbonded_model;


  Hybrid<T> coefficients;


  // Mesh coefficients may come in fixed-precision format.  These coefficients mirror contents of

  // other templated classes to track the conversion.

  int coefficient_scale_bits;

  double coefficient_scale;

  double inverse_coefficient_scale;


  MeshFoundation basis;


  void allocate();


  void setNonbondedModel(VdwCombiningRule mixing_protocol_in, double clash_ratio_in,

                         double clash_distance_in, const std::vector<double> &probe_sigma,

                         const std::vector<double> &probe_epsilon);


  void validateMeshKind() const;


  void validateScalingBits() const;


  void colorOcclusionMesh(const MeshKlManager &launcher,

                          PrecisionModel prec = PrecisionModel::SINGLE,

                          HybridTargetLevel availability = HybridTargetLevel::HOST,

                          const std::vector<double> &probe_sigma = {});


  void mapOccupancyField(const MeshKlManager &launcher,

                         PrecisionModel prec = PrecisionModel::SINGLE,

                         HybridTargetLevel availability = HybridTargetLevel::HOST,

                         const std::vector<double> &probe_sigma = {});


  void computeCoefficients(const std::vector<double> &u_grid,

                           const std::vector<double> &dudx_grid,

                           const std::vector<double> &dudy_grid,

                           const std::vector<double> &dudz_grid,

                           const std::vector<double> &dudxx_grid,

                           const std::vector<double> &dudxy_grid,

                           const std::vector<double> &dudxz_grid,

                           const std::vector<double> &dudyy_grid,

                           const std::vector<double> &dudyz_grid,

                           const std::vector<double> &dudxxx_grid,

                           const std::vector<double> &dudxxy_grid,

                           const std::vector<double> &dudxxz_grid,

                           const std::vector<double> &dudxyy_grid,

                           const std::vector<double> &dudxyz_grid,

                           const TricubicStencil &tc_weights);


  void computeCoefficients(const std::vector<double> &u_grid,

                           const std::vector<double> &dudx_grid,

                           const std::vector<double> &dudy_grid,

                           const std::vector<double> &dudz_grid,

                           const std::vector<double> &dudxy_grid,

                           const std::vector<double> &dudxz_grid,

                           const std::vector<double> &dudyz_grid,

                           const std::vector<double> &dudxyz_grid,

                           const TricubicStencil &tc_weights);


  template <typename Tcalc, typename Tcalc2, typename Tcalc3, typename Tcalc4>

  void colorNonbondedField(const NonbondedKit<Tcalc> &nbk, const TricubicStencil &tc_weights,

                           const std::vector<double> &sigma_table = {},

                           const std::vector<double> &eps_table = {});


  void mapPureNonbondedPotential(const MeshKlManager &launcher,

                                 PrecisionModel prec = PrecisionModel::SINGLE,

                                 HybridTargetLevel availability = HybridTargetLevel::HOST,

                                 const std::vector<double> &sigma_table = {},

                                 const std::vector<double> &eps_table = {});

};


template <typename T> BackgroundMeshWriter<T> restoreType(BackgroundMeshWriter<void> *rasa);

template <typename T> BackgroundMeshWriter<T> restoreType(const BackgroundMeshWriter<void> &rasa);

template <typename T> BackgroundMeshReader<T> restoreType(const BackgroundMeshReader<void> *rasa);

template <typename T> BackgroundMeshReader<T> restoreType(const BackgroundMeshReader<void> &rasa);


template <typename Ttarget, typename Tcontrib>

void checkMeshCompatibility(const BackgroundMeshWriter<Ttarget> &target,

                            const BackgroundMeshReader<Tcontrib> &contrib);


template <typename Tcalc4, typename Tcalc2, typename Tcalc>

Tcalc2 evalElecCSC(const Tcalc4 abcd, Tcalc r, Tcalc rswitch, Tcalc q);


template <typename Tcalc4, typename Tcalc2, typename Tcalc>

Tcalc evalElecCSCND(const Tcalc4 abcd, Tcalc r, Tcalc rswitch, Tcalc q);


template <typename Tcalc4, typename Tcalc2, typename Tcalc>

Tcalc2 evalLennardJonesCSC(const Tcalc4 abcd, Tcalc r, Tcalc rswitch, Tcalc lja, Tcalc ljb);


template <typename Tcalc4, typename Tcalc2, typename Tcalc>

Tcalc evalLennardJonesCSCND(const Tcalc4 abcd, Tcalc r, Tcalc rswitch, Tcalc lja, Tcalc ljb);


#ifdef STORMM_USE_HPC

void launchColorOcclusionMesh(BackgroundMeshWriter<void> *bgmw, const AtomGraph *ag,

                              const CoordinateFrameReader &cfr, PrecisionModel prec,

                              const MeshKlManager &launcher);

#endif


void accumulateOcclusionMesh(BackgroundMeshWriter<llint> *target,

                             const BackgroundMeshReader<llint> &contribution);


void accumulateOcclusionMesh(BackgroundMesh<llint> *target,

                             const BackgroundMesh<llint> &contribution,

                             const GpuDetails &gpu = null_gpu,

                             HybridTargetLevel availability = HybridTargetLevel::HOST);


#ifdef STORMM_USE_HPC

void launchAccOcclusionMesh(BackgroundMeshWriter<llint> *target,

                            const BackgroundMeshReader<llint> &contribution,

                            const GpuDetails &gpu);

#endif


template <typename T>

void accumulateNonbondedFieldMesh(BackgroundMeshWriter<llint> *target,

                                  const BackgroundMeshReader<void> &contribution,

                                  size_t ct_contrib, const GpuDetails &gpu);


template <typename T>

void accumulateNonbondedFieldMesh(BackgroundMesh<llint> *target,

                                  const BackgroundMesh<T> &contribution,

                                  const GpuDetails &gpu, HybridTargetLevel availability);


#ifdef STORMM_USE_HPC

void launchColorNonbondedFieldMesh(BackgroundMeshWriter<void> *target, size_t ct_targ,

                                   const MeshFFKit<double> &mnbk, PrecisionModel prec,

                                   const double* stn_xfrm, const AtomGraph *ag,

                                   const CoordinateFrameReader &cfr,

                                   const MeshKlManager &launcher,

                                   const HybridTargetLevel availability = HybridTargetLevel::HOST);


void launchAccNonbondedFieldMesh(BackgroundMeshWriter<llint> *target,

                                 const BackgroundMeshReader<void> &contribution,

                                 const size_t ct_contrib, const GpuDetails &gpu);

#endif


template <typename T>

void inferPatchBoundary(std::vector<T> *u_patch, int dim_a, int dim_b, int dim_c, int start_a,

                        int start_b, int start_c, int end_a, int end_b, int end_c, int inc_a,

                        int inc_b, int inc_c);


template <typename T>

void transferPatchResult(const std::vector<T> &patch, int patch_dim_a, int patch_dim_b,

                         int patch_dim_c, BackgroundMeshWriter<T> *occfieldw, int a_index,

                         int b_index, int c_index, int readout_a_start, int readout_b_start,

                         int readout_c_start, int element_offset);


template <typename T>

void patchNumericDeriv(BackgroundMeshWriter<T> *occfieldw, int a_index, int b_index, int c_index,

                       T max_occlusion);


template <typename T>

void occlusionFieldDerivatives(BackgroundMesh<T> *occfield, const GpuDetails &gpu,

                               HybridTargetLevel availability);


#ifdef STORMM_USE_HPC

void launchOccFieldDerivativeCalc(BackgroundMeshWriter<void> *bgmw, size_t ct_mesh);

#endif


} // namespace structure

} // namespace stormm


#include "background_mesh.tpp"

#include "background_mesh_freefunc.tpp"


#endif

stormm::card::GpuDetails
Pertinent aspects of one particular GPU. Condensing the data for each GPU in this manner helps to ens...
Definition gpu_details.h:27

stormm::card::MeshKlManager
Collect and dispense the launch parameters for various mesh-based kernels. The launches for these ker...
Definition mesh_kernel_manager.h:29

stormm::review::BackgroundMesh::BackgroundMesh
BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const MeshParameters &measurements_in=MeshParameters(), const PrecisionModel build_precision_in=PrecisionModel::SINGLE)
The constructor takes all dimension parameters plus an indication of what type of potential,...

stormm::structure::BackgroundMesh
A workspace for constructing a pure potential mesh based on the frozen atoms of a large molecule....
Definition background_mesh.h:195

stormm::structure::BackgroundMesh::templateFreeData
const BackgroundMeshReader< void > templateFreeData(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get an abstract of the mesh with any templating removed.

stormm::structure::BackgroundMesh::setCoefficientScalingBits
void setCoefficientScalingBits(int scaling_bits_in)
Set the number of bits after the decimal to be used in fixed-precision representations of coordinates...

stormm::structure::BackgroundMesh::setProbeRadius
void setProbeRadius(double probe_radius_in)
Set the probe radius, meaning either the Lennard-Jones potential sigma radius or the clash probe radi...

stormm::structure::BackgroundMesh::getReferenceNonbondedKit
const MeshFFKit< double > getReferenceNonbondedKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get the abstract of the mesh in double precision.

stormm::structure::BackgroundMesh::getTopologyPointer
const AtomGraph * getTopologyPointer() const
Get a const pointer to the topology responsible for creating this mesh.

stormm::structure::BackgroundMesh::getEnsembleTypeCode
size_t getEnsembleTypeCode() const
Get the codified data type of the ensemble.

stormm::structure::BackgroundMesh::getNonbondedKit
const MeshFFKit< T > getNonbondedKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get the abstract of the mesh in the precision of the mesh's coefficient data.

stormm::structure::BackgroundMesh::getNonbondedPotential
NonbondedPotential getNonbondedPotential() const
Get the non-bonded potential expressed on the mesh. This will return an error if the mesh is not asso...

stormm::structure::BackgroundMesh::getEnsemblePointer
const CoordinateSeries< Tcoord > * getEnsemblePointer() const
Get a const reference to the array of structures (each stored as a CoordinateFrame) reponsible for cr...

stormm::structure::BackgroundMesh::getCombiningRule
VdwCombiningRule getCombiningRule() const
Get the mixing protocol used for van-der Waals (as expressed by the Lennard-Jones model) interactions...

stormm::structure::BackgroundMesh::getProbeRadius
double getProbeRadius() const
Get the probe radius. Valid for all types of meshes.

stormm::structure::BackgroundMesh::setWellDepth
void setWellDepth(double well_depth_in)
Set the Lennard-Jones well depth for the probe that will generate the potential. This includes a vali...

stormm::structure::BackgroundMesh::getOcclusionPenalty
double getOcclusionPenalty() const
Get the penalty associated with a collision on an occlusion mesh.

stormm::structure::BackgroundMesh::BackgroundMesh
BackgroundMesh(GridDetail kind_in, NonbondedPotential field_in, const MeshParameters &measurements_in=MeshParameters(), const PrecisionModel build_precision_in=PrecisionModel::SINGLE)
The constructor takes all dimension parameters plus an indication of what type of potential,...

stormm::structure::BackgroundMesh::setMeshParameters
void setMeshParameters(const AtomGraph *ag_in, const CoordinateFrame *cf_in, double padding, double spacing, int scale_bits_in=-100)
Set the dimensions of the mesh. Variants of this member function that do not include a coordinate poi...

stormm::structure::BackgroundMesh::templateFreeNonbondedKit
const MeshFFKit< void > templateFreeNonbondedKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a template-free form of the of the mesh nonbonded abstract in the mesh coefficient data type,...

stormm::structure::BackgroundMesh::getCoefficientScalingBits
int getCoefficientScalingBits() const
Get the number of bits after the decimal in fixed-precision mesh coefficient representations.

stormm::structure::BackgroundMesh::getClashDistance
double getClashDistance() const
Get the absolute distance at which softcore electrostatic interactions take over. This is provided fo...

stormm::structure::BackgroundMesh::getCoefficientScalingFactor
double getCoefficientScalingFactor() const
Get the scaling factor for mesh coefficients in fixed-precision representations.

stormm::structure::BackgroundMesh::getDimensions
const MeshParameters & getDimensions() const
Get an object describing the mesh dimensions.

stormm::structure::BackgroundMesh::setOcclusionPenalty
void setOcclusionPenalty(double occlusion_penalty_in)
Set the penalty associated with striking occupied volume on an occlusion mesh. This is intended to be...

stormm::structure::BackgroundMesh::data
const BackgroundMeshReader< T > data(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get an abstract of the mesh.

stormm::structure::BackgroundMesh::getClashRatio
double getClashRatio() const
Get the ratio of the van-der Waals (Lennard-Jones) sigma parameter for interacting pairs of particles...

stormm::structure::BackgroundMesh::getCoordinatePointer
const CoordinateFrame * getCoordinatePointer() const
Get a const pointer to the coordinates responsible for creating this mesh.

stormm::structure::BackgroundMesh::getMeshKind
GridDetail getMeshKind() const
Get the type of mesh.

stormm::structure::BackgroundMesh::BackgroundMesh
BackgroundMesh(const BackgroundMesh< T > &original)=default
Copy and move constructors as well as assignment operators can be set to their defaults because the o...

stormm::structure::BackgroundMesh::computeField
void computeField(const MeshKlManager &launcher=MeshKlManager(), PrecisionModel prec=PrecisionModel::SINGLE, HybridTargetLevel availability=HybridTargetLevel::HOST, const std::vector< double > &probe_sigma={}, const std::vector< double > &probe_epsilon={})
Compute the appropriate field for the mesh. This is called automatically by the constructor if enough...

stormm::structure::BackgroundMesh::getWellDepth
double getWellDepth() const
Get the non-bonded probe well depth. This is valid only for non-bonded fields, in particular those as...

stormm::structure::BackgroundMesh::getBuildPrecision
PrecisionModel getBuildPrecision() const
Get the precisionmodel under which the mesh was calculated.

stormm::structure::BackgroundMesh::validateCombiningRule
void validateCombiningRule(VdwCombiningRule mixing_protocol_in, const std::vector< double > &probe_sigma, const std::vector< double > &probe_epsilon)
Check the combining rule that will be used to make the probe interact with the receptor on any mesh (...

stormm::structure::BackgroundMesh::getMolecularBasis
const MeshFoundation & getMolecularBasis() const
Get the collection of molecular details underlying the mesh, including the topology and associated co...

stormm::structure::MeshFoundation
A small object to hold the essential descriptors of the molecule.
Definition mesh_foundation.h:50

stormm::structure::MeshKlManager
Collect and dispense the launch parameters for various mesh-based kernels. The launches for these ker...
Definition mesh_kernel_manager.h:29

stormm::structure::MeshParameters
Encode the critical dimensions of a regular, rectilinear mesh. The locations of mesh points as well a...
Definition mesh_parameters.h:121

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::CoordinateFrame
Store the coordinates and box information for a frame, only. This abridged struct can serve when the ...
Definition coordinateframe.h:111

stormm::trajectory::CoordinateSeries
Store the coordinates and box information for a series of frames, in one of several levels of precisi...
Definition coordinate_series.h:137

stormm::review::BackgroundMeshReader::BackgroundMeshReader
BackgroundMeshReader(const MeshParamKit &dims_in, GridDetail kind_in, NonbondedPotential field_in, const MeshRulerKit &rulers, const Tdata *coeffs_in, double coeff_scale_in, double probe_radius_in, double well_depth_in, double occ_cost_in, const MeshBasicsKit &mbss_in)
The constructor takes arguments for all member variables.

stormm::structure::BackgroundMeshReader
The templated, writeable abstract of a BackgroundMesh object.
Definition background_mesh.h:142

stormm::structure::BackgroundMeshReader::coeffs
const Tdata * coeffs
Definition background_mesh.h:163

stormm::structure::BackgroundMeshReader::well_depth
const double well_depth
Definition background_mesh.h:181

stormm::structure::BackgroundMeshReader::dims
const MeshParamKit dims
Dimensions of the mesh. These are pre-established.
Definition background_mesh.h:159

stormm::structure::BackgroundMeshReader::field
const NonbondedPotential field
The field described by the mesh, also pre-established.
Definition background_mesh.h:161

stormm::structure::BackgroundMeshReader::mbss
const MeshBasicsKit mbss
Definition background_mesh.h:184

stormm::structure::BackgroundMeshReader::probe_radius
const double probe_radius
Definition background_mesh.h:178

stormm::structure::BackgroundMeshReader::coeff_scale_f
const float coeff_scale_f
Single-precision variant of coeff_scale.
Definition background_mesh.h:175

stormm::structure::BackgroundMeshReader::coeff_scale
const double coeff_scale
Definition background_mesh.h:168

stormm::structure::BackgroundMeshReader::occ_cost
const double occ_cost
Energetic penalty of an occlusion interaction.
Definition background_mesh.h:183

stormm::structure::BackgroundMeshReader::kind
const GridDetail kind
The type of mesh, also pre-established.
Definition background_mesh.h:160

stormm::structure::BackgroundMeshReader::rlrs
const MeshRulerKit rlrs
Coordinate series for tick marks along each mesh axis.
Definition background_mesh.h:162

stormm::structure::BackgroundMeshReader::BackgroundMeshReader
BackgroundMeshReader(const MeshParamKit &dims_in, GridDetail kind_in, NonbondedPotential field_in, const MeshRulerKit &rulers, const Tdata *coeffs_in, double coeff_scale_in, double probe_radius_in, double well_depth_in, double occ_cost_in, const MeshBasicsKit &mbss_in)
The constructor takes arguments for all member variables.

stormm::structure::BackgroundMeshReader::BackgroundMeshReader
BackgroundMeshReader(const BackgroundMeshReader< Tdata > &original)=default
The default copy and move constructors will be valid for this object. Const members negate the use of...

stormm::structure::BackgroundMeshWriter
The templated, writeable abstract of a BackgroundMesh object.
Definition background_mesh.h:93

stormm::structure::BackgroundMeshWriter::BackgroundMeshWriter
BackgroundMeshWriter(const BackgroundMeshWriter< Tdata > &original)=default
The default copy and move constructors will be valid for this object. Const members negate the use of...

stormm::structure::BackgroundMeshWriter::coeffs
Tdata * coeffs
Definition background_mesh.h:116

stormm::structure::BackgroundMeshWriter::occ_cost
const double occ_cost
Energetic penalty of an occlusion interaction.
Definition background_mesh.h:135

stormm::structure::BackgroundMeshWriter::probe_radius
const double probe_radius
Definition background_mesh.h:130

stormm::structure::BackgroundMeshWriter::kind
const GridDetail kind
The type of mesh, also pre-established.
Definition background_mesh.h:111

stormm::structure::BackgroundMeshWriter::mbss
const MeshBasicsKit mbss
Definition background_mesh.h:136

stormm::structure::BackgroundMeshWriter::dims
const MeshParamKit dims
Dimensions of the mesh. These are pre-established.
Definition background_mesh.h:110

stormm::structure::BackgroundMeshWriter::well_depth
const double well_depth
Definition background_mesh.h:133

stormm::structure::BackgroundMeshWriter::field
const NonbondedPotential field
The field described by the mesh, also pre-established.
Definition background_mesh.h:112

stormm::structure::BackgroundMeshWriter::coeff_scale_f
const float coeff_scale_f
Single-precision variant of coeff_scale.
Definition background_mesh.h:126

stormm::structure::BackgroundMeshWriter::coeff_scale
const double coeff_scale
Definition background_mesh.h:120

stormm::structure::BackgroundMeshWriter::BackgroundMeshWriter
BackgroundMeshWriter(const MeshParamKit &measurements, GridDetail kind_in, NonbondedPotential field_in, const MeshRulerKit &rulers, Tdata *coeffs_in, double coeff_scale_in, double probe_radius_in, double well_depth_in, double occ_cost_in, const MeshBasicsKit &mbss_in)
The constructor takes arguments for all member variables.

stormm::structure::BackgroundMeshWriter::rlrs
const MeshRulerKit rlrs
Coordinate series for tick marks along each mesh axis.
Definition background_mesh.h:113

stormm::structure::MeshBasicsKit
Abstract for the MeshFoundation object to encapsulate pointers to its data on the host or the device.
Definition mesh_foundation.h:29

stormm::structure::MeshFFKit
An object to store the probe's specific non-bonded parameters and softcore function coefficients used...
Definition mesh_forcefield.h:35

stormm::structure::MeshParamKit
The abstract of a MeshParameters object is read-only (modify the original to get a new abstract if th...
Definition mesh_parameters.h:61

stormm::structure::MeshRulerKit
Definition mesh_rulers.h:21

stormm::trajectory::CoordinateFrameReader
Collect C-style pointers for the elements of a read-only CoordinateFrame object.
Definition coordinateframe.h:65