doxygen/cellgrid_8h_source.html

// -*-c++-*-

#ifndef STORMM_CELLGRID_H

#define STORMM_CELLGRID_H


#include "copyright.h"

#include "Accelerator/core_kernel_manager.h"

#include "Accelerator/gpu_details.h"

#include "Accelerator/hybrid.h"

#include "Constants/behavior.h"

#include "Constants/fixed_precision.h"

#include "Constants/hpc_bounds.h"

#include "DataTypes/common_types.h"

#include "Math/formulas.h"

#include "Math/math_enumerators.h"

#include "Math/matrix_ops.h"

#include "Math/rounding.h"

#include "Math/series_ops.h"

#include "Math/vector_ops.h"

#include "Numerics/split_fixed_precision.h"

#include "Parsing/parsing_enumerators.h"

#include "Parsing/parse.h"

#include "Potential/energy_enumerators.h"

#include "Structure/local_arrangement.h"

#include "Structure/structure_enumerators.h"

#include "Synthesis/atomgraph_synthesis.h"

#include "Synthesis/phasespace_synthesis.h"

#include "Synthesis/synthesis_abstracts.h"

#include "Topology/atomgraph.h"

#include "Topology/atomgraph_abstracts.h"

#include "Topology/atomgraph_enumerators.h"

#include "Topology/lennard_jones_analysis.h"

#include "Topology/topology_util.h"

#include "Trajectory/coordinate_copy.h"

#include "Trajectory/coordinateframe.h"

#include "Trajectory/trajectory_enumerators.h"


namespace stormm {

namespace energy {


using card::CoreKlManager;

using card::GpuDetails;

using card::Hybrid;

using card::HybridKind;

using card::HybridTargetLevel;

using constants::CartesianDimension;

using constants::ExceptionResponse;

using constants::PrecisionModel;

using constants::UnitCellAxis;

using data_types::getStormmScalarTypeName;

using data_types::getStormmHpcVectorTypeName;

using data_types::isFloatingPointScalarType;

using numerics::force_scale_nonoverflow_bits;

using numerics::globalpos_scale_nonoverflow_bits;

using numerics::hostInt63ToLongLong;

using numerics::hostSplitFPMult;

using numerics::hostSplitFPSubtract;

using parse::NumberFormat;

using parse::realToString;

using stmath::hessianNormalWidths;

using stmath::indexingArray;

using stmath::ipowl;

using stmath::LimitApproach;

using stmath::matrixMultiply;

using stmath::minValue;

using stmath::maxValue;

using stmath::mean;

using stmath::nearestFactor;

using stmath::prefixSumInPlace;

using stmath::PrefixSumType;

using stmath::roundUp;

using structure::imageCoordinates;

using structure::ImagingMethod;

using synthesis::AtomGraphSynthesis;

using synthesis::PhaseSpaceSynthesis;

using synthesis::PsSynthesisBorders;

using synthesis::PsSynthesisReader;

using synthesis::PsSynthesisWriter;

using synthesis::SyNonbondedKit;

using topology::AtomGraph;

using topology::hasVdwProperties;

using topology::inferCombiningRule;

using topology::NonbondedKit;

using topology::UnitCellType;

using trajectory::coordCopy;

using trajectory::CoordinateCycle;

using trajectory::CoordinateFrame;

using trajectory::CoordinateFrameWriter;

using trajectory::TrajectoryKind;


constexpr size_t default_cellgrid_base_capacity = 8;

constexpr size_t cellgrid_tp_excl_allotment = 12;

constexpr size_t cellgrid_total_excl_allotment = 15;

constexpr int default_mesh_ticks = 4;

constexpr int maximum_cellgrid_cell_count = 268435456;

constexpr int maximum_xl_cell_count = 64;

constexpr double minimum_cell_width = 2.5;

constexpr double maximum_cell_width = 12.0;

constexpr int maximum_cellgrid_systems = 65536;

static const int maximum_cellgrid_span = 1023;

static const int maximum_wandering_atoms = 256;

static const int sp_charge_index_bits = 23;

static const int dp_charge_index_bits = 32;

static const int sp_charge_index_mask = 0x7ffff;

static const llint dp_charge_index_mask = 0xffffffffLL;


static const ullint required_ring_mask = 0x1018041408242028LLU;

static const uint   required_cntr_mask = 0x3f;

static const ullint prohibited_ring_mask = 0x8c80b080b0808c80LLU;

static const uint   prohibited_cntr_mask = 0xbc;


static const int std_max_migration_notes = 1920;

static const int ext_max_migration_notes = 4608;


template <typename T, typename Tacc, typename Tcalc, typename T4> struct CellGridWriter {


  CellGridWriter(NonbondedTheme theme_in, int system_count_in, int total_cell_count_in,

                 int total_chain_count_in, int mesh_ticks_in, uint cell_base_capacity_in,

                 float lpos_scale_in, float inv_lpos_scale_in, float frc_scale_in,

                 const  ullint* system_cell_grids_in, Tcalc* system_cell_umat_in,

                 T* system_cell_invu_in, T* system_pmig_invu, uint2* cell_limits_in,

                 uint2* cell_limits_alt_in, const uint* chain_limits_in,

                 const int* system_chain_bounds_in, const int* chain_system_owner_in, T4* image_in,

                 T4* image_alt_in, uchar* migration_keys_in, int* wander_count_in,

                 int* wander_count_alt_in, uint2* wanderers_in, int* nonimg_atom_idx_in,

                 int* nonimg_atom_idx_alt_in, uint* img_atom_idx_in, uint* img_atom_idx_alt_in,

                 ushort* img_atom_chn_cell_in, ushort* img_atom_chn_cell_alt_in,

                 const int* nt_groups_in, ushort* relevance_in, Tacc* xfrc_in, Tacc* yfrc_in,

                 Tacc* zfrc_in, int* xfrc_ovrf_in, int* yfrc_ovrf_in, int* zfrc_ovrf_in);


  CellGridWriter(const CellGridWriter &original) = default;

  CellGridWriter(CellGridWriter &&original) = default;


  const NonbondedTheme theme;

  const int system_count;

  const int total_cell_count;

  const int twice_cell_count;

  const int total_chain_count;

  const int mesh_ticks;

  const uint cell_base_capacity;

  const float lpos_scale;

  const float inv_lpos_scale;

  const float frc_scale;

  const ullint* system_cell_grids;

  Tcalc* system_cell_umat;

  T* system_cell_invu;

  T* system_pmig_invu;

  uint2* cell_limits;

  uint2* cell_limits_alt;

  const uint* chain_limits;

  const int* system_chain_bounds;

  const int* chain_system_owner;

  T4* image;

  T4* image_alt;

  uchar* migration_keys;

  int* wander_count;

  int* wander_count_alt;

  uint2* wanderers;

  int* nonimg_atom_idx;

  int* nonimg_atom_idx_alt;

  uint* img_atom_idx;

  uint* img_atom_idx_alt;

  ushort* img_atom_chn_cell;

  ushort* img_atom_chn_cell_alt;

  const int* nt_groups;

  ushort* relevance;

  Tacc* xfrc;

  Tacc* yfrc;

  Tacc* zfrc;

  int* xfrc_ovrf;

  int* yfrc_ovrf;

  int* zfrc_ovrf;

};


template <typename T, typename Tacc, typename Tcalc, typename T4> struct CellGridReader {


  CellGridReader(NonbondedTheme theme_in, int system_count_in, int total_cell_count_in,

                 int total_chain_count_in, int mesh_ticks_in, uint cell_base_capacity_in,

                 float lpos_scale_in, float inv_lpos_scale_in, float inv_frc_scale_in,

                 const ullint* system_cell_grids_in, const Tcalc* system_cell_umat_in,

                 const T* system_cell_invu_in, const T* system_pmig_invu_in,

                 const uint2* cell_limits_in, const uint* chain_limits_in,

                 const int* system_chain_bounds_in, const int* chain_system_owner_in,

                 const T4* image_in, const int* nonimg_atom_idx_in, const uint* img_atom_idx_in,

                 const ushort* img_atom_chn_cell_in, const int* nt_groups_in,

                 const ushort* relevance_in, const Tacc* xfrc_in, const Tacc* yfrc_in,

                 const Tacc* zfrc_in, const int* xfrc_ovrf_in, const int* yfrc_ovrf_in,

                 const int* zfrc_ovrf_in);


  CellGridReader(const CellGridWriter<T, Tacc, Tcalc, T4> &cgw);


  CellGridReader(const CellGridWriter<T, Tacc, Tcalc, T4> *cgw);


  CellGridReader(const CellGridReader &original) = default;

  CellGridReader(CellGridReader &&original) = default;


  const NonbondedTheme theme;

  const int system_count;

  const int total_cell_count;

  const int twice_cell_count;

  const int total_chain_count;

  const int mesh_ticks;

  const uint cell_base_capacity;

  const float lpos_scale;

  const float inv_lpos_scale;

  const float inv_frc_scale;

  const ullint* system_cell_grids;

  const Tcalc* system_cell_umat;

  const T* system_cell_invu;

  const T* system_pmig_invu;

  const uint2* cell_limits;

  const uint* chain_limits;

  const int* system_chain_bounds;

  const int* chain_system_owner;

  const T4* image;

  const int* nonimg_atom_idx;

  const uint* img_atom_idx;

  const ushort* img_atom_chn_cell;

  const int* nt_groups;

  const ushort* relevance;

  const Tacc* xfrc;

  const Tacc* yfrc;

  const Tacc* zfrc;

  const int* xfrc_ovrf;

  const int* yfrc_ovrf;

  const int* zfrc_ovrf;

};


struct CellOriginsWriter {

public:


  CellOriginsWriter(int stride_in, llint* ax_in, int* ax_ovrf_in, llint* bx_in, int* bx_ovrf_in,

                    llint* by_in, int* by_ovrf_in, llint* cx_in, int* cx_ovrf_in, llint* cy_in,

                    int* cy_ovrf_in, llint* cz_in, int* cz_ovrf_in);


  CellOriginsWriter(const CellOriginsWriter &original) = default;

  CellOriginsWriter(CellOriginsWriter &&original) = default;


  const int stride;

  llint* ax;

  llint* bx;

  llint* by;

  llint* cx;

  llint* cy;

  llint* cz;

  int* ax_ovrf;

  int* bx_ovrf;

  int* by_ovrf;

  int* cx_ovrf;

  int* cy_ovrf;

  int* cz_ovrf;

};


struct CellOriginsReader {

public:


  CellOriginsReader(int stride_in, const llint* ax_in, const int* ax_ovrf_in, const llint* bx_in,

                    const int* bx_ovrf_in, const llint* by_in, const int* by_ovrf_in,

                    const llint* cx_in, const int* cx_ovrf_in, const llint* cy_in,

                    const int* cy_ovrf_in, const llint* cz_in, const int* cz_ovrf_in);


  CellOriginsReader(const CellOriginsWriter &w);


  CellOriginsReader(const CellOriginsWriter *w);


  CellOriginsReader(const CellOriginsReader &original) = default;

  CellOriginsReader(CellOriginsReader &&original) = default;


  const int stride;

  const llint* ax;

  const llint* bx;

  const llint* by;

  const llint* cx;

  const llint* cy;

  const llint* cz;

  const int* ax_ovrf;

  const int* bx_ovrf;

  const int* by_ovrf;

  const int* cx_ovrf;

  const int* cy_ovrf;

  const int* cz_ovrf;

};


template <typename T, typename Tacc, typename Tcalc, typename T4> class CellGrid {

public:


  CellGrid(const PhaseSpaceSynthesis *poly_ps_ptr_in, const AtomGraphSynthesis *poly_ag_ptr_in,

           double cutoff_in, double padding_in, int mesh_subdivisions_in, NonbondedTheme theme_in,

           uint cell_base_capacity_in = default_cellgrid_base_capacity,

           ExceptionResponse policy_in = ExceptionResponse::WARN);


  CellGrid(const PhaseSpaceSynthesis *poly_ps_ptr_in, const AtomGraphSynthesis &poly_ag_ptr_in,

           double cutoff_in, double padding_in, int mesh_subdivisions_in, NonbondedTheme theme_in,

           uint cell_base_capacity_in = default_cellgrid_base_capacity,

           ExceptionResponse policy_in = ExceptionResponse::WARN);


  CellGrid(const PhaseSpaceSynthesis &poly_ps_ptr_in, const AtomGraphSynthesis &poly_ag_ptr_in,

           double cutoff_in, double padding_in, int mesh_subdivisions_in, NonbondedTheme theme_in,

           uint cell_base_capacity_in = default_cellgrid_base_capacity,

           ExceptionResponse policy_in = ExceptionResponse::WARN);


  CellGrid(const CellGrid &original);

  CellGrid(CellGrid &&original);

  CellGrid& operator=(const CellGrid &original);

  CellGrid& operator=(CellGrid &&original);


  int getSystemCount() const;


  int getTotalCellCount() const;


  int getCellCount(int index) const;

  int getCellCount(int index, UnitCellAxis axis) const;

  int getCellCount(int index, CartesianDimension axis) const;


  uint getCellBaseCapacity() const;


  double getCutoff() const;


  double getPadding() const;


  double getEffectiveCutoff() const;


  NonbondedTheme getTheme() const;


  TinyBoxPresence getTinyBoxPresence() const;


  CoordinateCycle getCyclePosition() const;


  int getPositionScalingBits() const;


  int getMeshSubdivisions() const;


  uint getImageIndex(int system_index, int atom_index, CoordinateCycle orientation) const;

  uint getImageIndex(int system_index, int atom_index) const;


  int4 getCellLocation(int system_index, int atom_index, CoordinateCycle orientation) const;

  int4 getCellLocation(int system_index, int atom_index) const;


  int2 getChainLocation(int system_index, int atom_index, CoordinateCycle orientation) const;

  int2 getChainLocation(int system_index, int atom_index) const;


  const PsSynthesisBorders

  getUnitCellTransforms(CoordinateCycle orientation,

                        HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  const PsSynthesisBorders

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


  const PhaseSpaceSynthesis* getCoordinateSynthesisPointer() const;


  const AtomGraphSynthesis* getTopologySynthesisPointer() const;


  CellGridWriter<T, Tacc, Tcalc, T4> data(CoordinateCycle orientation,

                                          HybridTargetLevel tier = HybridTargetLevel::HOST);


  CellGridWriter<T, Tacc, Tcalc, T4> data(HybridTargetLevel tier = HybridTargetLevel::HOST);


  const CellGridReader<T, Tacc, Tcalc, T4>

  data(CoordinateCycle orientation, HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  const CellGridReader<T, Tacc, Tcalc, T4>

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


  CellGridWriter<void, void, void, void>

  templateFreeData(CoordinateCycle orientation, HybridTargetLevel tier = HybridTargetLevel::HOST);


  CellGridWriter<void, void, void, void>

  templateFreeData(HybridTargetLevel tier = HybridTargetLevel::HOST);


  const CellGridReader<void, void, void, void>

  templateFreeData(CoordinateCycle orientation,

                   HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  const CellGridReader<void, void, void, void>

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


  const CellOriginsReader getRulers(CoordinateCycle orientation,

                                    HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  const CellOriginsReader getRulers(HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  CellOriginsWriter getRulers(CoordinateCycle orientation,

                              HybridTargetLevel tier = HybridTargetLevel::HOST);


  CellOriginsWriter getRulers(HybridTargetLevel tier = HybridTargetLevel::HOST);


  const CellGrid<T, Tacc, Tcalc, T4>* getSelfPointer() const;


#ifdef STORMM_USE_HPC

  void upload();


  void download();

#endif


  void initializeForces(HybridTargetLevel tier = HybridTargetLevel::HOST,

                        const GpuDetails &gpu = null_gpu);


  void markImageRelevance(HybridTargetLevel tier = HybridTargetLevel::HOST,

                          const GpuDetails &gpu = null_gpu);


  void contributeForces(PhaseSpaceSynthesis *dest, HybridTargetLevel tier,

                        const GpuDetails &gpu) const;


  void contributeForces(HybridTargetLevel tier = HybridTargetLevel::HOST,

                        const GpuDetails &gpu = null_gpu) const;


  void updatePositions(PhaseSpaceSynthesis *dest, HybridTargetLevel tier,

                       const GpuDetails &gpu);


  void updatePositions(HybridTargetLevel tier = HybridTargetLevel::HOST,

                       const GpuDetails &gpu = null_gpu);


  void updateCyclePosition();

  void updateCyclePosition(CoordinateCycle time_point);


private:

  int system_count;

  int total_cell_count;

  int total_chain_count;

  uint cell_base_capacity;

  double cutoff;

  double padding;

  double effective_cutoff;

  int mesh_subdivisions;

  ExceptionResponse policy;

  NonbondedTheme theme;

  TinyBoxPresence has_tiny_box;


  CoordinateCycle cycle_position;


  // The local coordinate systems for each cell are tailored to maximize the amount of information

  // that can be encoded in the fixed-precision representation with the data type implied by the

  // precision member variable (PrecisionModel::SINGLE implies 32-bit ints, PrecisionModel::DOUBLE

  // implies 64-bit long long ints).  The number of fixed precision bits is designed to accommodate

  // stacking up to two cells against the home cell along any of the simulation box axes and still

  // have any coordinates within those boxes be represented by the fixed-precision format without

  // overflow.  Furthermore, the format is designed to accommodate moderate stretching of the

  // simulation box (up to 5% in any direction).  If the simulation expands significantly, this

  // will trigger the cell grid to be rebuilt.

  int localpos_scale_bits;

  double localpos_scale;

  double localpos_inverse_scale;


  Hybrid<ullint> system_cell_grids;


  Hybrid<Tcalc> system_cell_umat;

  Hybrid<Tcalc> system_cell_umat_alt;


  Hybrid<T> system_cell_invu;

  Hybrid<T> system_cell_invu_alt;


  Hybrid<T> system_pmig_invu;

  Hybrid<T> system_pmig_invu_alt;


  Hybrid<T> particle_mesh_grid_invu;

  Hybrid<T> particle_mesh_grid_invu_alt;


  Hybrid<uint2> image_cell_limits;

  Hybrid<uint2> image_cell_limits_alt;


  Hybrid<uint> image_chain_limits;


  Hybrid<int> system_chain_bounds;


  Hybrid<int> chain_system_membership;


  Hybrid<T4> image;

  Hybrid<T4> image_alt;


  Hybrid<int> nonimaged_atom_indices;

  Hybrid<int> nonimaged_atom_indices_alt;


  Hybrid<uint> image_array_indices;

  Hybrid<uint> image_array_indices_alt;


  Hybrid<ushort> image_chain_cell_indices;

  Hybrid<ushort> image_chain_cell_indices_alt;


  Hybrid<uchar> cell_migrations;


  Hybrid<int> wandering_atom_count;

  Hybrid<int> wandering_atom_count_alt;


  Hybrid<uint2> wanderers;


  Hybrid<int> nt_work_groups;


  Hybrid<ushort> image_relevance;


  // Force accumulation arrays track the total number of atoms in the atoms or sp_atoms list.

  // These accumulators are split, with the primary accummulators being llint for double-precision

  // and int for single-precision.  The overflow accumulators are used in both cases, even if

  // accesses to them are rare.

  Hybrid<Tacc> x_force;

  Hybrid<Tacc> y_force;

  Hybrid<Tacc> z_force;

  Hybrid<int> x_force_overflow;

  Hybrid<int> y_force_overflow;

  Hybrid<int> z_force_overflow;


  // A series of rulers encodes the origins of each system's neighbor list cells.  Pointers to

  // these member variable arrays are made avialable by a second abstract of the CellGrid class,

  // the CellOriginsReader and CellOriginsWriter.  The coordinates in these rules follow the global

  // positioning fixed-precision system of the accompanying PhaseSpaceSynthesis.

  int origin_offset_stride;

  Hybrid<llint> cell_origins_ax;

  Hybrid<llint> cell_origins_bx;

  Hybrid<llint> cell_origins_by;

  Hybrid<llint> cell_origins_cx;

  Hybrid<llint> cell_origins_cy;

  Hybrid<llint> cell_origins_cz;

  Hybrid<int> cell_origins_ax_overflow;

  Hybrid<int> cell_origins_bx_overflow;

  Hybrid<int> cell_origins_by_overflow;

  Hybrid<int> cell_origins_cx_overflow;

  Hybrid<int> cell_origins_cy_overflow;

  Hybrid<int> cell_origins_cz_overflow;

  Hybrid<llint> alt_cell_origins_ax;

  Hybrid<llint> alt_cell_origins_bx;

  Hybrid<llint> alt_cell_origins_by;

  Hybrid<llint> alt_cell_origins_cx;

  Hybrid<llint> alt_cell_origins_cy;

  Hybrid<llint> alt_cell_origins_cz;

  Hybrid<int> alt_cell_origins_ax_overflow;

  Hybrid<int> alt_cell_origins_bx_overflow;

  Hybrid<int> alt_cell_origins_by_overflow;

  Hybrid<int> alt_cell_origins_cx_overflow;

  Hybrid<int> alt_cell_origins_cy_overflow;

  Hybrid<int> alt_cell_origins_cz_overflow;

  Hybrid<llint> origin_llint_data;

  Hybrid<int> origin_int_data;


  PhaseSpaceSynthesis *poly_ps_ptr;


  AtomGraphSynthesis *poly_ag_ptr;


  void validateCoordinateSynthesis() const;


  double validateEffectiveCutoff(double eff_cut_in, ExceptionResponse policy_in) const;


  void validateAtomIndex(int system_index, int atom_index, const char* caller) const;


  void computeFixedPrecisionModel(const std::vector<double> &invu_samples);


  void tallyCellPopulations(std::vector<int> *cell_populations, int system_index, int na, int nb,

                            int nc);


  void populateImage(CoordinateCycle cyc);


  void rebaseRulers();


  void allocateRulers();


  void drawNeighborListRulers();


  void prepareWorkGroups();

};


template <typename T, typename Tacc, typename Tcalc, typename T4>

void migrate(CellGridWriter<T, Tacc, Tcalc, T4> *cgw, const PsSynthesisReader &destr,

             const HybridTargetLevel tier = HybridTargetLevel::HOST,

             const GpuDetails &gpu = null_gpu);


template <typename Tsrc, typename Tcalc, typename Tcalc2>

Tcalc sourceMagnitude(NonbondedTheme requested_property, NonbondedTheme cg_content, Tsrc q,

                      bool q_is_real, int sysid, const SyNonbondedKit<Tcalc, Tcalc2> &synbk);


template <typename Tsrc>

int sourceIndex(NonbondedTheme requested_property, NonbondedTheme cg_content, Tsrc q,

                bool q_is_real);


template <typename T, typename Tacc, typename Tcalc, typename T4>

CellGridWriter<T, Tacc, Tcalc, T4> restoreType(CellGridWriter<void, void, void, void> *rasa);


template <typename T, typename Tacc, typename Tcalc, typename T4>

CellGridWriter<T, Tacc, Tcalc, T4> restoreType(CellGridWriter<void, void, void, void> &rasa);


template <typename T, typename Tacc, typename Tcalc, typename T4>

const CellGridReader<T, Tacc, Tcalc, T4>

restoreType(const CellGridReader<void, void, void, void> *rasa);


template <typename T, typename Tacc, typename Tcalc, typename T4>

const CellGridReader<T, Tacc, Tcalc, T4>

restoreType(const CellGridReader<void, void, void, void> &rasa);


template <typename T, typename Tacc, typename Tcalc, typename T4>

void contributeCellGridForces(PsSynthesisWriter *destw,

                              const CellGridReader<T, Tacc, Tcalc, T4> &cgr);


void contributeCellGridForces(PsSynthesisWriter *destw,

                              const CellGridReader<void, void, void, void> &cgr_v, size_t tc_mat,

                              size_t tc_acc,

                              const HybridTargetLevel tier = HybridTargetLevel::HOST,

                              const GpuDetails &gpu = null_gpu);


template <typename T>

int3 locateDecompositionCell(T *x, T *y, T *z, const double* umat, const double* invu,

                             double cell_na, double cell_nb, double cell_nc,

                             UnitCellType unit_cell = UnitCellType::TRICLINIC, double scale = 1.0);


template <typename T>

void locateDecompositionCell(T* x, T* y, T* z, int* cell_idx, int natom, const double* umat,

                             const double* invu, int cell_na, int cell_nb, int cell_nc,

                             UnitCellType unit_cell = UnitCellType::TRICLINIC, double scale = 1.0);


template <typename T>

void locateDecompositionCell(std::vector<T> *x, std::vector<T> *y, std::vector<T> *z,

                             std::vector<int> *cell_idx, const double* umat, const double* invu,

                             int cell_na, int cell_nb, int cell_nc,

                             UnitCellType unit_cell = UnitCellType::TRICLINIC, double scale = 1.0);


template <typename T>

void locateDecompositionCell(Hybrid<T> *x, Hybrid<T> *y, Hybrid<T> *z, Hybrid<int> *cell_idx,

                             const double* umat, const double* invu, int cell_na, int cell_nb,

                             int cell_nc, UnitCellType unit_cell = UnitCellType::TRICLINIC,

                             double scale = 1.0);


double computeMigrationRate(double effective_cutoff, double sigma);


int3 optimizeCellConfiguration(int cell_na, int cell_nb, int cell_nc, int subdivisions);


void loadRuler(int cell_count, const int95_t cell_len, const int95_t box_len, int remainder,

               llint* ruler, int* ruler_ovrf);


#ifdef STORMM_USE_HPC

cudaFuncAttributes queryMigrationKernelRequirements(PrecisionModel coord_prec,

                                                    NeighborListKind neighbor_list, int stage,

                                                    int gpos_bits);


void launchMigration(CellGridWriter<double, llint, double, double4> *cgw,

                     const CellOriginsReader &corg, const PsSynthesisReader &poly_psr,

                     const int2 bt_i, const int2 bt_ii);


void launchMigration(CellGridWriter<double, llint, double, double4> *cgw_qq,

                     CellGridWriter<double, llint, double, double4> *cgw_lj,

                     const CellOriginsReader &corg_qq, const CellOriginsReader &corg_lj,

                     const PsSynthesisReader &poly_psr, const int2 bt_i, const int2 bt_ii);


void launchMigration(CellGridWriter<float, int, float, float4> *cgw,

                     const CellOriginsReader &corg, const PsSynthesisReader &poly_psr,

                     const int2 bt_i, const int2 bt_ii);


void launchMigration(CellGridWriter<float, int, float, float4> *cgw_qq,

                     CellGridWriter<float, int, float, float4> *cgw_lj,

                     const CellOriginsReader &corg_qq, const CellOriginsReader &corg_lj,

                     const PsSynthesisReader &poly_psr, const int2 bt_i, const int2 bt_ii);


void launchMigration(CellGrid<double, llint, double, double4> *cg,

                     const PhaseSpaceSynthesis &poly_ps, const CoreKlManager &launcher);


void launchMigration(CellGrid<double, llint, double, double4> *cg_qq,

                     CellGrid<double, llint, double, double4> *cg_lj,

                     const PhaseSpaceSynthesis &poly_ps, const CoreKlManager &launcher);


void launchMigration(CellGrid<float, int, float, float4> *cg,

                     const PhaseSpaceSynthesis &poly_ps, const CoreKlManager &launcher);


void launchMigration(CellGrid<float, int, float, float4> *cg_qq,

                     CellGrid<float, int, float, float4> *cg_lj,

                     const PhaseSpaceSynthesis &poly_ps, const CoreKlManager &launcher);


void launchCellGridAction(CellGridWriter<void, void, void, void> *cgw, size_t tc_mat,

                          size_t tc_acc, const GpuDetails &gpu, CellGridAction process);


void launchCellGridAction(CellGridWriter<void, void, void, void> *cgw, size_t tc_mat,

                          size_t tc_acc, const PsSynthesisReader &poly_psr, const GpuDetails &gpu,

                          CellGridAction process);


void launchCellGridAction(const CellGridReader<void, void, void, void> &cgr, size_t tc_mat,

                          size_t tc_acc, PsSynthesisWriter *poly_psw, const GpuDetails &gpu,

                          CellGridAction process);


#endif // STORMM_USE_HPC


} // namespace energy

} // namespace stormm


#include "cellgrid.tpp"


#endif

stormm::card::CoreKlManager
A class to guide the implementation of GPU kernels, with selected thread counts per block and block c...
Definition core_kernel_manager.h:56

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::Hybrid
An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from ei...
Definition hybrid.h:202

stormm::energy::CellGrid
An object to manage the spatial decomposition of a system of particles. The general strategy is to ar...
Definition cellgrid.h:562

stormm::energy::CellGrid::getCutoff
double getCutoff() const
Get the particle-particle cutoff defining the neighbor list.

stormm::energy::CellGrid::getSystemCount
int getSystemCount() const
Get the number of systems in the object.

stormm::energy::CellGrid::getTotalCellCount
int getTotalCellCount() const
Get the total number of cells allocated in the object.

stormm::energy::CellGrid::data
CellGridWriter< T, Tacc, Tcalc, T4 > data(CoordinateCycle orientation, HybridTargetLevel tier=HybridTargetLevel::HOST)
Obtain the object's abstract in order to access its members in C-programming fashion,...

stormm::energy::CellGrid::getCellCount
int getCellCount(int index) const
Get the number of cells allotted to any one system.

stormm::energy::CellGrid::getRulers
const CellOriginsReader getRulers(CoordinateCycle orientation, HybridTargetLevel tier=HybridTargetLevel::HOST) const
Obtain the object's rulers for determining the origins of each neighbor list cell in terms of the fix...

stormm::energy::CellGrid::updatePositions
void updatePositions(PhaseSpaceSynthesis *dest, HybridTargetLevel tier, const GpuDetails &gpu)
Update the positions and cells of residence for all particles based on the current positions in the a...

stormm::energy::CellGrid::markImageRelevance
void markImageRelevance(HybridTargetLevel tier=HybridTargetLevel::HOST, const GpuDetails &gpu=null_gpu)
Compute whether various atoms may be within range of the tower when they are in the plate of various ...

stormm::energy::CellGrid::getCoordinateSynthesisPointer
const PhaseSpaceSynthesis * getCoordinateSynthesisPointer() const
Get a const pointer to the coordinate synthesis served by this object.

stormm::energy::CellGrid::getTinyBoxPresence
TinyBoxPresence getTinyBoxPresence() const
Get the presence of a tiny unit cell anywhere in the synthesis.

stormm::energy::CellGrid::updateCyclePosition
void updateCyclePosition()
Update the object's cycle position as it participates in the WHITE:BLACK tick-tock mechanics of other...

stormm::energy::CellGrid::CellGrid
CellGrid(const PhaseSpaceSynthesis *poly_ps_ptr_in, const AtomGraphSynthesis *poly_ag_ptr_in, double cutoff_in, double padding_in, int mesh_subdivisions_in, NonbondedTheme theme_in, uint cell_base_capacity_in=default_cellgrid_base_capacity, ExceptionResponse policy_in=ExceptionResponse::WARN)
The constructor accepts an associated PhaseSpaceSynthesis object and a precision model....

stormm::energy::CellGrid::contributeForces
void contributeForces(PhaseSpaceSynthesis *dest, HybridTargetLevel tier, const GpuDetails &gpu) const
Contribute forces accumulated in the cell grid back to a coordinate synthesis with its own force accu...

stormm::energy::CellGrid::getPositionScalingBits
int getPositionScalingBits() const
Get the number of bits in the fixed-precision format.

stormm::energy::CellGrid::getChainLocation
int2 getChainLocation(int system_index, int atom_index, CoordinateCycle orientation) const
Get the chain index of an atom based on its system and topological atom index. The chain index is ret...

stormm::energy::CellGrid::getCellBaseCapacity
uint getCellBaseCapacity() const
Get the base capacity of any particular cell in the grid. All systems' cells share the same base capa...

stormm::energy::CellGrid::getTopologySynthesisPointer
const AtomGraphSynthesis * getTopologySynthesisPointer() const
Get a const pointer to the topology synthesis served by this object.

stormm::energy::CellGrid::initializeForces
void initializeForces(HybridTargetLevel tier=HybridTargetLevel::HOST, const GpuDetails &gpu=null_gpu)
Initialize forces for the cell grid, on the CPU host or GPU device. This standalone feature provides ...

stormm::energy::CellGrid::getImageIndex
uint getImageIndex(int system_index, int atom_index, CoordinateCycle orientation) const
Find the image location of an atom based on its system and topological atom number.

stormm::energy::CellGrid::getCellLocation
int4 getCellLocation(int system_index, int atom_index, CoordinateCycle orientation) const
Find the cell grid location of an atom based on its system and topological atom number....

stormm::energy::CellGrid::templateFreeData
CellGridWriter< void, void, void, void > templateFreeData(CoordinateCycle orientation, HybridTargetLevel tier=HybridTargetLevel::HOST)
Obtain the object's abstract with templating removed. Overloading and descriptions of parameters foll...

stormm::energy::CellGrid::getUnitCellTransforms
const PsSynthesisBorders getUnitCellTransforms(CoordinateCycle orientation, HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a miniature abstract of the underlying coordinate synthesis containing pointers to the arays of u...

stormm::energy::CellGrid::getCyclePosition
CoordinateCycle getCyclePosition() const
Get the position in the time cycle.

stormm::energy::CellGrid::getSelfPointer
const CellGrid< T, Tacc, Tcalc, T4 > * getSelfPointer() const
Get a pointer to the object itself, useful if the object is only available by const reference.

stormm::energy::CellGrid::getPadding
double getPadding() const
Get the padding incorporated into each neighbor list cell.

stormm::energy::CellGrid::getEffectiveCutoff
double getEffectiveCutoff() const
Get the effective cutoff.

stormm::energy::CellGrid::CellGrid
CellGrid(const CellGrid &original)
The presence of POINTER-kind Hybrid objects in the cell origin rulers invalidates the default copy an...

stormm::energy::CellGrid::getTheme
NonbondedTheme getTheme() const
Get the non-bonded theme of this cell grid–does it hold atoms with only electrostatic or van-der Waal...

stormm::energy::CellGrid::getMeshSubdivisions
int getMeshSubdivisions() const
Get the number of mesh elements spanning each spatial decomposition cell. The "mesh" refers to a part...

stormm::synthesis::AtomGraphSynthesis
A collection of one or more AtomGraph objects, with similar components arranged in contiguous arrays ...
Definition atomgraph_synthesis.h:55

stormm::synthesis::PhaseSpaceSynthesis
A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulation...
Definition phasespace_synthesis.h:325

stormm::data_types::int2
Definition stormm_vector_types.h:22

stormm::data_types::int3
Definition stormm_vector_types.h:27

stormm::data_types::int4
Definition stormm_vector_types.h:33

stormm::data_types::int95_t
A mixed tuple for 95-bit integer accumulation. This is the proper way to take double-precision floati...
Definition stormm_vector_types.h:265

stormm::data_types::uint2
Definition stormm_vector_types.h:40

stormm::energy::CellGridReader
Read-only abstract for the CellGrid object. This is unused in typical MD applications,...
Definition cellgrid.h:296

stormm::energy::CellGridReader::image
const T4 * image
The array of atom coordinates and property information.
Definition cellgrid.h:387

stormm::energy::CellGridReader::CellGridReader
CellGridReader(NonbondedTheme theme_in, int system_count_in, int total_cell_count_in, int total_chain_count_in, int mesh_ticks_in, uint cell_base_capacity_in, float lpos_scale_in, float inv_lpos_scale_in, float inv_frc_scale_in, const ullint *system_cell_grids_in, const Tcalc *system_cell_umat_in, const T *system_cell_invu_in, const T *system_pmig_invu_in, const uint2 *cell_limits_in, const uint *chain_limits_in, const int *system_chain_bounds_in, const int *chain_system_owner_in, const T4 *image_in, const int *nonimg_atom_idx_in, const uint *img_atom_idx_in, const ushort *img_atom_chn_cell_in, const int *nt_groups_in, const ushort *relevance_in, const Tacc *xfrc_in, const Tacc *yfrc_in, const Tacc *zfrc_in, const int *xfrc_ovrf_in, const int *yfrc_ovrf_in, const int *zfrc_ovrf_in)
As is other abstracts, the constructor takes a list of inputs for all member variables.

stormm::energy::CellGridReader::system_cell_umat
const Tcalc * system_cell_umat
Definition cellgrid.h:351

stormm::energy::CellGridReader::xfrc_ovrf
const int * xfrc_ovrf
Overflow bits for xfrc.
Definition cellgrid.h:415

stormm::energy::CellGridReader::total_cell_count
const int total_cell_count
The total number of decomposition cells across all systems.
Definition cellgrid.h:329

stormm::energy::CellGridReader::lpos_scale
const float lpos_scale
Definition cellgrid.h:341

stormm::energy::CellGridReader::inv_frc_scale
const float inv_frc_scale
Definition cellgrid.h:347

stormm::energy::CellGridReader::CellGridReader
CellGridReader(const CellGridReader &original)=default
The const-ness of all members implicitly deletes the copy and move assignment operators,...

stormm::energy::CellGridReader::system_chain_bounds
const int * system_chain_bounds
Definition cellgrid.h:377

stormm::energy::CellGridReader::yfrc_ovrf
const int * yfrc_ovrf
Overflow bits for yfrc.
Definition cellgrid.h:416

stormm::energy::CellGridReader::xfrc
const Tacc * xfrc
Accumulated Cartesian X forces on all imaged particles.
Definition cellgrid.h:412

stormm::energy::CellGridReader::twice_cell_count
const int twice_cell_count
Twice the number of decomposition cells across all systems.
Definition cellgrid.h:330

stormm::energy::CellGridReader::relevance
const ushort * relevance
Definition cellgrid.h:408

stormm::energy::CellGridReader::system_cell_invu
const T * system_cell_invu
Definition cellgrid.h:354

stormm::energy::CellGridReader::nonimg_atom_idx
const int * nonimg_atom_idx
Definition cellgrid.h:388

stormm::energy::CellGridReader::zfrc
const Tacc * zfrc
Accumulated Cartesian Z forces on all imaged particles.
Definition cellgrid.h:414

stormm::energy::CellGridReader::img_atom_chn_cell
const ushort * img_atom_chn_cell
Definition cellgrid.h:400

stormm::energy::CellGridReader::inv_lpos_scale
const float inv_lpos_scale
Definition cellgrid.h:345

stormm::energy::CellGridReader::yfrc
const Tacc * yfrc
Accumulated Cartesian Y forces on all imaged particles.
Definition cellgrid.h:413

stormm::energy::CellGridReader::cell_limits
const uint2 * cell_limits
Definition cellgrid.h:360

stormm::energy::CellGridReader::cell_base_capacity
const uint cell_base_capacity
Definition cellgrid.h:337

stormm::energy::CellGridReader::nt_groups
const int * nt_groups
Definition cellgrid.h:403

stormm::energy::CellGridReader::system_cell_grids
const ullint * system_cell_grids
Definition cellgrid.h:349

stormm::energy::CellGridReader::img_atom_idx
const uint * img_atom_idx
Definition cellgrid.h:395

stormm::energy::CellGridReader::mesh_ticks
const int mesh_ticks
Definition cellgrid.h:334

stormm::energy::CellGridReader::theme
const NonbondedTheme theme
Definition cellgrid.h:326

stormm::energy::CellGridReader::zfrc_ovrf
const int * zfrc_ovrf
Overflow bits for zfrc.
Definition cellgrid.h:417

stormm::energy::CellGridReader::system_count
const int system_count
Number of systems whose spatial decompositions are stored.
Definition cellgrid.h:328

stormm::energy::CellGridReader::chain_limits
const uint * chain_limits
Definition cellgrid.h:371

stormm::energy::CellGridReader::system_pmig_invu
const T * system_pmig_invu
Definition cellgrid.h:357

stormm::energy::CellGridReader::chain_system_owner
const int * chain_system_owner
Definition cellgrid.h:384

stormm::energy::CellGridReader::total_chain_count
const int total_chain_count
Definition cellgrid.h:331

stormm::energy::CellGridWriter
Writeable abstract for the CellGrid object, able to receive new coordinates or accumulate forces.
Definition cellgrid.h:137

stormm::energy::CellGridWriter::nt_groups
const int * nt_groups
Definition cellgrid.h:273

stormm::energy::CellGridWriter::theme
const NonbondedTheme theme
Definition cellgrid.h:162

stormm::energy::CellGridWriter::system_pmig_invu
T * system_pmig_invu
Definition cellgrid.h:194

stormm::energy::CellGridWriter::CellGridWriter
CellGridWriter(const CellGridWriter &original)=default
The presence of const array sizing members implicitly deletes the copy and move assignment operators,...

stormm::energy::CellGridWriter::zfrc
Tacc * zfrc
Accumulators for Cartesian Z forces on imaged particles.
Definition cellgrid.h:284

stormm::energy::CellGridWriter::CellGridWriter
CellGridWriter(NonbondedTheme theme_in, int system_count_in, int total_cell_count_in, int total_chain_count_in, int mesh_ticks_in, uint cell_base_capacity_in, float lpos_scale_in, float inv_lpos_scale_in, float frc_scale_in, const ullint *system_cell_grids_in, Tcalc *system_cell_umat_in, T *system_cell_invu_in, T *system_pmig_invu, uint2 *cell_limits_in, uint2 *cell_limits_alt_in, const uint *chain_limits_in, const int *system_chain_bounds_in, const int *chain_system_owner_in, T4 *image_in, T4 *image_alt_in, uchar *migration_keys_in, int *wander_count_in, int *wander_count_alt_in, uint2 *wanderers_in, int *nonimg_atom_idx_in, int *nonimg_atom_idx_alt_in, uint *img_atom_idx_in, uint *img_atom_idx_alt_in, ushort *img_atom_chn_cell_in, ushort *img_atom_chn_cell_alt_in, const int *nt_groups_in, ushort *relevance_in, Tacc *xfrc_in, Tacc *yfrc_in, Tacc *zfrc_in, int *xfrc_ovrf_in, int *yfrc_ovrf_in, int *zfrc_ovrf_in)
As is other abstracts, the constructor takes a list of inputs for all member variables.

stormm::energy::CellGridWriter::img_atom_chn_cell
ushort * img_atom_chn_cell
Definition cellgrid.h:268

stormm::energy::CellGridWriter::total_chain_count
const int total_chain_count
Definition cellgrid.h:167

stormm::energy::CellGridWriter::zfrc_ovrf
int * zfrc_ovrf
Overflow bits for zfrc.
Definition cellgrid.h:287

stormm::energy::CellGridWriter::img_atom_chn_cell_alt
ushort * img_atom_chn_cell_alt
Definition cellgrid.h:271

stormm::energy::CellGridWriter::wander_count_alt
int * wander_count_alt
Definition cellgrid.h:242

stormm::energy::CellGridWriter::wanderers
uint2 * wanderers
Definition cellgrid.h:247

stormm::energy::CellGridWriter::wander_count
int * wander_count
Definition cellgrid.h:239

stormm::energy::CellGridWriter::yfrc
Tacc * yfrc
Accumulators for Cartesian Y forces on imaged particles.
Definition cellgrid.h:283

stormm::energy::CellGridWriter::nonimg_atom_idx_alt
int * nonimg_atom_idx_alt
Definition cellgrid.h:259

stormm::energy::CellGridWriter::chain_limits
const uint * chain_limits
Definition cellgrid.h:210

stormm::energy::CellGridWriter::mesh_ticks
const int mesh_ticks
Definition cellgrid.h:170

stormm::energy::CellGridWriter::image_alt
T4 * image_alt
Definition cellgrid.h:229

stormm::energy::CellGridWriter::xfrc
Tacc * xfrc
Accumulators for Cartesian X forces on imaged particles.
Definition cellgrid.h:282

stormm::energy::CellGridWriter::cell_limits_alt
uint2 * cell_limits_alt
Definition cellgrid.h:208

stormm::energy::CellGridWriter::system_chain_bounds
const int * system_chain_bounds
Definition cellgrid.h:216

stormm::energy::CellGridWriter::img_atom_idx
uint * img_atom_idx
Definition cellgrid.h:261

stormm::energy::CellGridWriter::total_cell_count
const int total_cell_count
The total number of decomposition cells across all systems.
Definition cellgrid.h:165

stormm::energy::CellGridWriter::system_cell_grids
const ullint * system_cell_grids
Definition cellgrid.h:185

stormm::energy::CellGridWriter::migration_keys
uchar * migration_keys
Definition cellgrid.h:235

stormm::energy::CellGridWriter::relevance
ushort * relevance
Definition cellgrid.h:278

stormm::energy::CellGridWriter::xfrc_ovrf
int * xfrc_ovrf
Overflow bits for xfrc.
Definition cellgrid.h:285

stormm::energy::CellGridWriter::nonimg_atom_idx
int * nonimg_atom_idx
Definition cellgrid.h:252

stormm::energy::CellGridWriter::yfrc_ovrf
int * yfrc_ovrf
Overflow bits for yfrc.
Definition cellgrid.h:286

stormm::energy::CellGridWriter::twice_cell_count
const int twice_cell_count
Twice the number of decomposition cells across all systems.
Definition cellgrid.h:166

stormm::energy::CellGridWriter::cell_limits
uint2 * cell_limits
Definition cellgrid.h:197

stormm::energy::CellGridWriter::chain_system_owner
const int * chain_system_owner
Definition cellgrid.h:223

stormm::energy::CellGridWriter::system_count
const int system_count
Number of systems whose spatial decompositions are stored.
Definition cellgrid.h:164

stormm::energy::CellGridWriter::inv_lpos_scale
const float inv_lpos_scale
Definition cellgrid.h:181

stormm::energy::CellGridWriter::lpos_scale
const float lpos_scale
Definition cellgrid.h:177

stormm::energy::CellGridWriter::img_atom_idx_alt
uint * img_atom_idx_alt
Definition cellgrid.h:266

stormm::energy::CellGridWriter::system_cell_umat
Tcalc * system_cell_umat
Definition cellgrid.h:188

stormm::energy::CellGridWriter::image
T4 * image
Definition cellgrid.h:226

stormm::energy::CellGridWriter::cell_base_capacity
const uint cell_base_capacity
Definition cellgrid.h:173

stormm::energy::CellGridWriter::system_cell_invu
T * system_cell_invu
Definition cellgrid.h:191

stormm::energy::CellGridWriter::frc_scale
const float frc_scale
Definition cellgrid.h:183

stormm::energy::CellOriginsReader
Definition cellgrid.h:459

stormm::energy::CellOriginsReader::bx_ovrf
const int * bx_ovrf
Overflow bits for projection of the unit cell B axis along Cartesian X.
Definition cellgrid.h:496

stormm::energy::CellOriginsReader::by
const llint * by
Projection of the unit cell B axis along Cartesian Y.
Definition cellgrid.h:491

stormm::energy::CellOriginsReader::ax
const llint * ax
Definition cellgrid.h:487

stormm::energy::CellOriginsReader::cy_ovrf
const int * cy_ovrf
Overflow bits for projection of the unit cell C axis along Cartesian Y.
Definition cellgrid.h:499

stormm::energy::CellOriginsReader::bx
const llint * bx
Projection of the unit cell B axis along Cartesian X.
Definition cellgrid.h:490

stormm::energy::CellOriginsReader::cz_ovrf
const int * cz_ovrf
Overflow bits for projection of the unit cell C axis along Cartesian Z.
Definition cellgrid.h:500

stormm::energy::CellOriginsReader::cz
const llint * cz
Projection of the unit cell C axis along Cartesian z.
Definition cellgrid.h:494

stormm::energy::CellOriginsReader::ax_ovrf
const int * ax_ovrf
Overflow bits for projection of the unit cell A axis along Cartesian X.
Definition cellgrid.h:495

stormm::energy::CellOriginsReader::cx_ovrf
const int * cx_ovrf
Overflow bits for projection of the unit cell C axis along Cartesian X.
Definition cellgrid.h:498

stormm::energy::CellOriginsReader::cx
const llint * cx
Projection of the unit cell C axis along Cartesian X.
Definition cellgrid.h:492

stormm::energy::CellOriginsReader::CellOriginsReader
CellOriginsReader(const CellOriginsReader &original)=default
The presence of the const member "stride" invalidates the copy and move assignment operators....

stormm::energy::CellOriginsReader::CellOriginsReader
CellOriginsReader(int stride_in, const llint *ax_in, const int *ax_ovrf_in, const llint *bx_in, const int *bx_ovrf_in, const llint *by_in, const int *by_ovrf_in, const llint *cx_in, const int *cx_ovrf_in, const llint *cy_in, const int *cy_ovrf_in, const llint *cz_in, const int *cz_ovrf_in)
The constructor takes a list of valus for all member variables. As with many other abstracts,...
Definition cellgrid.cpp:20

stormm::energy::CellOriginsReader::by_ovrf
const int * by_ovrf
Overflow bits for projection of the unit cell B axis along Cartesian Y.
Definition cellgrid.h:497

stormm::energy::CellOriginsReader::cy
const llint * cy
Projection of the unit cell C axis along Cartesian Y.
Definition cellgrid.h:493

stormm::energy::CellOriginsReader::stride
const int stride
The stride taken between systems in any of the arrays below.
Definition cellgrid.h:486

stormm::energy::CellOriginsWriter
Definition cellgrid.h:421

stormm::energy::CellOriginsWriter::CellOriginsWriter
CellOriginsWriter(int stride_in, llint *ax_in, int *ax_ovrf_in, llint *bx_in, int *bx_ovrf_in, llint *by_in, int *by_ovrf_in, llint *cx_in, int *cx_ovrf_in, llint *cy_in, int *cy_ovrf_in, llint *cz_in, int *cz_ovrf_in)
The constructor takes a list of valus for all member variables. There is only one sizing constant–all...
Definition cellgrid.cpp:10

stormm::energy::CellOriginsWriter::bx
llint * bx
Projection of the unit cell B axis along Cartesian X.
Definition cellgrid.h:445

stormm::energy::CellOriginsWriter::CellOriginsWriter
CellOriginsWriter(const CellOriginsWriter &original)=default
The presence of the const member "stride" invalidates the copy and move assignment operators....

stormm::energy::CellOriginsWriter::stride
const int stride
The stride taken between systems in any of the arrays below.
Definition cellgrid.h:441

stormm::energy::CellOriginsWriter::ax
llint * ax
Definition cellgrid.h:442

stormm::energy::CellOriginsWriter::cx_ovrf
int * cx_ovrf
Overflow bits for projection of the unit cell C axis along Cartesian X.
Definition cellgrid.h:453

stormm::energy::CellOriginsWriter::ax_ovrf
int * ax_ovrf
Overflow bits for projection of the unit cell A axis along Cartesian X.
Definition cellgrid.h:450

stormm::energy::CellOriginsWriter::bx_ovrf
int * bx_ovrf
Overflow bits for projection of the unit cell B axis along Cartesian X.
Definition cellgrid.h:451

stormm::energy::CellOriginsWriter::by
llint * by
Projection of the unit cell B axis along Cartesian Y.
Definition cellgrid.h:446

stormm::energy::CellOriginsWriter::cy_ovrf
int * cy_ovrf
Overflow bits for projection of the unit cell C axis along Cartesian Y.
Definition cellgrid.h:454

stormm::energy::CellOriginsWriter::cx
llint * cx
Projection of the unit cell C axis along Cartesian X.
Definition cellgrid.h:447

stormm::energy::CellOriginsWriter::cy
llint * cy
Projection of the unit cell C axis along Cartesian Y.
Definition cellgrid.h:448

stormm::energy::CellOriginsWriter::by_ovrf
int * by_ovrf
Overflow bits for projection of the unit cell B axis along Cartesian Y.
Definition cellgrid.h:452

stormm::energy::CellOriginsWriter::cz
llint * cz
Projection of the unit cell C axis along Cartesian z.
Definition cellgrid.h:449

stormm::energy::CellOriginsWriter::cz_ovrf
int * cz_ovrf
Overflow bits for projection of the unit cell C axis along Cartesian Z.
Definition cellgrid.h:455

stormm::synthesis::PsSynthesisBorders
A read-only abstract for the system demarcations in the object. This information is sometimes critica...
Definition phasespace_synthesis.h:61

stormm::synthesis::PsSynthesisReader
The reader for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dyna...
Definition phasespace_synthesis.h:199

stormm::synthesis::PsSynthesisWriter
The writer for a PhaseSpaceSynthesis object, containing all of the data relevant for propagating dyna...
Definition phasespace_synthesis.h:87

stormm::synthesis::SyNonbondedKit
Collect the critical non-bonded parameters and masking information for work unit-based evaluation of ...
Definition synthesis_abstracts.h:181