doxygen/atomgraph__synthesis_8h_source.html

// -*-c++-*-

#ifndef STORMM_ATOMGRAPH_SYNTHESIS_H

#define STORMM_ATOMGRAPH_SYNTHESIS_H


#include "copyright.h"

#include "Accelerator/hybrid.h"

#include "Accelerator/gpu_details.h"

#include "Constants/behavior.h"

#include "Constants/generalized_born.h"

#include "DataTypes/stormm_vector_types.h"

#include "Math/reduction_enumerators.h"

#include "Math/reduction_workunit.h"

#include "Potential/energy_enumerators.h"

#include "Restraints/restraint_apparatus.h"

#include "Structure/structure_enumerators.h"

#include "Topology/atomgraph.h"

#include "Topology/atomgraph_enumerators.h"

#include "Topology/topology_util.h"

#include "UnitTesting/stopwatch.h"

#include "static_mask_synthesis.h"

#include "synthesis_abstracts.h"

#include "valence_workunit.h"


namespace stormm {

namespace synthesis {


using card::GpuDetails;

using card::Hybrid;

using card::HybridTargetLevel;

using constants::ExceptionResponse;

using energy::ValenceKernelSize;

using stmath::RdwuPerSystem;

using stmath::ReductionWorkUnit;

using restraints::RestraintApparatus;

using restraints::RestraintKit;

using structure::ApplyConstraints;

using topology::AtomGraph;

using topology::AtomicRadiusSet;

using topology::ChemicalDetailsKit;

using topology::getRealParameters;

using topology::ImplicitSolventModel;

using topology::MassForm;

using topology::UnitCellType;

using testing::StopWatch;

using namespace generalized_born_defaults;


class AtomGraphSynthesis {

public:


  AtomGraphSynthesis(const std::vector<AtomGraph*> &topologies_in,

                     const std::vector<RestraintApparatus*> &restraints_in,

                     const std::vector<int> &topology_indices_in,

                     const std::vector<int> &restraint_indices_in,

                     ExceptionResponse policy_in = ExceptionResponse::WARN,

                     const GpuDetails &gpu = null_gpu, StopWatch *timer_in = nullptr);


  AtomGraphSynthesis(const std::vector<AtomGraph*> &topologies_in,

                     const std::vector<RestraintApparatus*> &restraints_in,

                     ExceptionResponse policy_in = ExceptionResponse::WARN,

                     const GpuDetails &gpu = null_gpu,

                     StopWatch *timer_in = nullptr);


  AtomGraphSynthesis(const std::vector<AtomGraph*> &topologies_in,

                     const std::vector<int> &topology_indices_in,

                     ExceptionResponse policy_in = ExceptionResponse::WARN,

                     const GpuDetails &gpu = null_gpu, StopWatch *timer_in = nullptr);


  AtomGraphSynthesis(const std::vector<AtomGraph*> &topologies_in,

                     ExceptionResponse policy_in = ExceptionResponse::WARN,

                     const GpuDetails &gpu = null_gpu,

                     StopWatch *timer_in = nullptr);


  AtomGraphSynthesis(const AtomGraphSynthesis &original);

  AtomGraphSynthesis(AtomGraphSynthesis &&original);

  AtomGraphSynthesis& operator=(const AtomGraphSynthesis &original);

  AtomGraphSynthesis& operator=(AtomGraphSynthesis &&original);


  int getUniqueTopologyCount() const;


  const AtomGraph* getSystemTopologyPointer(int system_index) const;

  const std::vector<AtomGraph*> getSystemTopologyPointer() const;


  const std::vector<AtomGraph*>& getUniqueTopologies() const;


  std::vector<int> getTopologyIndices() const;


  RestraintApparatus* getSystemRestraintPointer(int system_index) const;


  int getSystemCount() const;


  int getAtomCount() const;

  int getAtomCount(int system_index) const;


  int getPaddedAtomCount() const;


  int getAtomOffset(int system_index) const;


  int getVirtualSiteCount() const;


  int getBondTermCount() const;


  int getAngleTermCount() const;


  int getDihedralTermCount() const;


  int getUreyBradleyTermCount() const;


  int getCharmmImproperTermCount() const;


  int getCmapTermCount() const;


  int getLJTypeCount() const;


  int getChargeTypeCount() const;


  int getBondParameterCount() const;


  int getAngleParameterCount() const;


  int getDihedralParameterCount() const;


  int getUreyBradleyParameterCount() const;


  int getCharmmImproperParameterCount() const;


  int getCmapSurfaceCount() const;


  const Hybrid<int>& getSystemAtomCounts() const;


  const Hybrid<int>& getSystemAtomOffsets() const;


  //         synthesis, as a const reference to the internal Hybrid array member variable.

  const Hybrid<int>& getDegreesOfFreedom() const;


  //         synthesis, as a const reference to the internal Hybrid array member variable.

  const Hybrid<int>& getConstrainedDegreesOfFreedom() const;


  UnitCellType getUnitCellType() const;


  ImplicitSolventModel getImplicitSolventModel() const;


  double getDielectricConstant() const;


  double getSaltConcentration() const;


  double getCoulombConstant() const;


  std::vector<AtomicRadiusSet> getPBRadiiSet() const;

  std::vector<AtomicRadiusSet> getPBRadiiSet(int low_limit, int high_limit) const;

  AtomicRadiusSet getPBRadiiSet(int index) const;


  template <typename T>

  std::vector<T> getPartialCharges(HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  template <typename T>

  std::vector<T> getPartialCharges(int system_index,

                                   HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  template <typename T>

  std::vector<T> getPartialCharges(int system_index, int low_index, int high_index,

                                   HybridTargetLevel tier = HybridTargetLevel::HOST) const;


  template <typename T> std::vector<T> getAtomicMasses(HybridTargetLevel tier) const;

  template <typename T> std::vector<T> getAtomicMasses(HybridTargetLevel tier,

                                                       int system_index) const;

  template <typename T> std::vector<T> getAtomicMasses(HybridTargetLevel tier, int system_index,

                                                       int low_index, int high_index) const;


  int getValenceWorkUnitCount() const;


  int2 getValenceWorkUnitSize() const;


  ValenceKernelSize getValenceThreadBlockSize() const;


  const Hybrid<int2>& getValenceWorkUnitAbstracts() const;


  NbwuKind getNonbondedWorkType() const;


  int getNonbondedWorkUnitCount() const;


  int getRandomCacheDepth() const;


  int getReductionWorkUnitCount() const;


  RdwuPerSystem getRdwuPerSystem() const;


  const Hybrid<int>& getReductionWorkUnitAbstracts() const;


  SyValenceKit<double>

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


  SyValenceKit<float>

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


  SyRestraintKit<double, double2, double4>

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


  SyRestraintKit<float, float2, float4>

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


  SyNonbondedKit<double, double2>

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


  SyNonbondedKit<float, float2>

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


  SyAtomUpdateKit<double, double2, double4>

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


  SyAtomUpdateKit<float, float2, float4>

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


  const AtomGraphSynthesis* getSelfPointer() const;


#ifdef STORMM_USE_HPC

  void upload();


  void download();

#endif


  void loadNonbondedWorkUnits(const StaticExclusionMaskSynthesis &poly_se,

                              InitializationTask init_request = InitializationTask::NONE,

                              int random_cache_depth = 0, const GpuDetails &gpu = null_gpu);


  void setImplicitSolventModel();


  void setImplicitSolventModel(ImplicitSolventModel igb_in,

                               const NeckGeneralizedBornKit<double> &ngbk,

                               const std::vector<AtomicRadiusSet> &radii_sets_in,

                               double dielectric_in = 80.0, double saltcon_in = 0.0,

                               ExceptionResponse policy = ExceptionResponse::WARN);


  void setImplicitSolventModel(ImplicitSolventModel igb_in,

                               const NeckGeneralizedBornKit<double> &ngbk,

                               AtomicRadiusSet radii_set = AtomicRadiusSet::NONE,

                               double dielectric_in = 80.0, double saltcon_in = 0.0,

                               ExceptionResponse policy = ExceptionResponse::WARN);


  void setImplicitSolventModel(ImplicitSolventModel igb_in,

                               const NeckGeneralizedBornTable &ngb_tab,

                               const std::vector<AtomicRadiusSet> &radii_sets_in,

                               double dielectric_in = 80.0, double saltcon_in = 0.0,

                               ExceptionResponse policy = ExceptionResponse::WARN);


  void setImplicitSolventModel(ImplicitSolventModel igb_in,

                               const NeckGeneralizedBornTable &ngb_tab,

                               AtomicRadiusSet radii_set = AtomicRadiusSet::NONE,

                               double dielectric_in = 80.0, double saltcon_in = 0.0,

                               ExceptionResponse policy = ExceptionResponse::WARN);


private:


  // The first member variables pertain to totals across all systems: atoms, potential function

  // terms, and sizes of composite parameter arrays that span all topologies

  ExceptionResponse policy;

  int topology_count;

  int restraint_network_count;

  int system_count;

  int total_atoms;

  int total_virtual_sites;

  int total_bond_terms;

  int total_angl_terms;

  int total_dihe_terms;

  int total_ubrd_terms;

  int total_cimp_terms;

  int total_cmap_terms;

  int total_lj_types;

  int total_charge_types;

  int total_bond_params;

  int total_angl_params;

  int total_dihe_params;

  int total_ubrd_params;

  int total_cimp_params;

  int total_cmap_surfaces;

  int total_attn14_params;

  int total_vste_params;

  int total_position_restraints;

  int total_distance_restraints;

  int total_angle_restraints;

  int total_dihedral_restraints;


  // The presence of periodic boundaries or an implicit solvent must be common to all systems, as

  // must the cutoff and other run parameters, although these are contained in other data

  // structres.  If an implicit solvent model is in effect, its parameters are taken as common to

  // all systems.  Other facets of the the system behavior, such as bond constraints, must also

  // be common to all systems.

  UnitCellType periodic_box_class;

  ImplicitSolventModel gb_style;

  double dielectric_constant;

  double is_kappa;

  double salt_concentration;

  double gb_offset;

  double gb_neckscale;

  double gb_neckcut;

  double coulomb_constant;

  ApplyConstraints use_shake;

  ApplyConstraints use_settle;

  int largest_constraint_group;

  char4 water_residue_name;


  std::vector<AtomicRadiusSet> pb_radii_sets;


  std::vector<AtomGraph*> topologies;


  std::vector<RestraintApparatus*> restraint_networks;


  std::vector<RestraintApparatus> restraint_dummies;


  Hybrid<int> topology_indices;


  Hybrid<int> restraint_indices;


  // The following arrays are POINTER-kind objects, each directed at a segment of a data array

  // for storing critical topology sizes.  There is one of each of these numbers for every

  // system in this work plan: each of the Hybrid arrays that follows is system_count in length.

  // All of the descriptions below follow from the eponymous member variables in the AtomGraph

  // object and should be taken to mean "... for each topology in the work plan." The pointers

  // target the ARRAY-kind object int_system_data, at intervals of the number of systems in the

  // work plan, with no padding for the warp size.  If these POINTER-kind objects list bounds, the

  // bounds themselves will reflect padding for the HPC warp size.

  Hybrid<int> atom_counts;

  Hybrid<int> residue_counts;

  Hybrid<int> molecule_counts;

  Hybrid<int> largest_residue_sizes;

  Hybrid<int> last_solute_residues;

  Hybrid<int> last_solute_atoms;

  Hybrid<int> first_solvent_molecules;


  // Valence term and off-center particle quantities

  Hybrid<int> ubrd_term_counts;

  Hybrid<int> cimp_term_counts;

  Hybrid<int> cmap_term_counts;

  Hybrid<int> bond_term_counts;

  Hybrid<int> angl_term_counts;

  Hybrid<int> dihe_term_counts;

  Hybrid<int> virtual_site_counts;


  // Restraint tallies for each system

  Hybrid<int> posn_restraint_counts;

  Hybrid<int> bond_restraint_counts;

  Hybrid<int> angl_restraint_counts;

  Hybrid<int> dihe_restraint_counts;


  // Information relevant to non-bonded calculations

  Hybrid<int> lj_type_counts;

  Hybrid<int> total_exclusion_counts;


  // Information relevant to the MD propagation algorithm

  Hybrid<int> rigid_water_counts;

  Hybrid<int> bond_constraint_counts;

  Hybrid<int> degrees_of_freedom;

  Hybrid<int> cnst_degrees_of_freedom;

  Hybrid<int> nonrigid_particle_counts;


  // The following are bounds arrays for the larger data arrays below: more segments of memory,

  // each the number of systems in length.  The contents of these arrays are, with some

  // exceptions, prefix sums over the associated counts arrays above, taking into account zero

  // padding for the stuff they are providing indices into.  A series of systems with atom counts

  // 31, 59, and 78 with an HPC warp size of 32 would generate an atom bounds array stating 0, 32,

  // and 96.  There is no capping value, and the (k+1)th bound minus the kth bounds does not

  // provide information on the exact number associated with the kth system.  Programs should read

  // the exact number of atoms or force field terms per system and the starting bound from one of

  // the arrays below.  The arrays for valence terms spanning all systems provide the global

  // indices of atoms in unified (but not re-ordered) arrays of atom descriptors and also

  // coordinates.  In this sense, these arrays are intermediates between the valence work units

  // that follow and the original AtomGraph objects used to construct this AtomGraphSynthesis.

  Hybrid<int> atom_offsets;

  Hybrid<int> atom_bit_offsets;

  Hybrid<int> residue_offsets;

  Hybrid<int> molecule_offsets;

  Hybrid<int> ubrd_term_offsets;

  Hybrid<int> cimp_term_offsets;

  Hybrid<int> cmap_term_offsets;

  Hybrid<int> bond_term_offsets;

  Hybrid<int> angl_term_offsets;

  Hybrid<int> dihe_term_offsets;

  Hybrid<int> virtual_site_offsets;

  Hybrid<int> posn_restraint_offsets;

  Hybrid<int> bond_restraint_offsets;

  Hybrid<int> angl_restraint_offsets;

  Hybrid<int> dihe_restraint_offsets;

  Hybrid<int> sett_group_offsets;

  Hybrid<int> cnst_group_offsets;

  Hybrid<int> nb_exclusion_offsets;

  Hybrid<int> lennard_jones_abc_offsets;


  Hybrid<int> int_system_data;


  // Maps of each system and its distinguishable parts.  From here onwards, the AtomGraphSynthesis

  // keeps a combination of POINTER-kind and ARRAY-kind Hybrid Object member variables, whatever is

  // most convenient for grouping and storing data as it is produced.  As above, many of the

  // names match what is in the AtomGraph object.  The arrays are laid out such that each system's

  // details occur in one contiguous stretch, padded by blank elements up to a multiple of the

  // HPC warp size.  Some of these arrays are indices themselves, but will still need a bounds

  // array, i.e. the point at which to start reading residue limits for the kth system.  Bounds

  // arrays for individual systems within each of these objects are written into the collected

  // integer system data array above, accessed through one of the preceding Hybrid POINTER-kind

  // objects.


  // Atom and residue details

  Hybrid<int2> residue_limits;

  Hybrid<int> atom_struc_numbers;

  Hybrid<int> residue_numbers;

  Hybrid<int2> molecule_limits;

  Hybrid<int> atomic_numbers;

  Hybrid<int> mobile_atoms;

  Hybrid<int> molecule_membership;

  Hybrid<int> molecule_contents;

  Hybrid<double> atomic_charges;

  Hybrid<double> atomic_masses;

  Hybrid<double> inverse_atomic_masses;

  Hybrid<float> sp_atomic_charges;

  Hybrid<float> sp_atomic_masses;

  Hybrid<float> sp_inverse_atomic_masses;

  Hybrid<char4> atom_names;

  Hybrid<char4> atom_types;

  Hybrid<char4> residue_names;

  Hybrid<int> chem_int_data;

  Hybrid<int2> chem_int2_data;

  Hybrid<double> chem_double_data;

  Hybrid<float> chem_float_data;

  Hybrid<char4> chem_char4_data;


  // Valence parameter maps and bounds, showing how the parameters of each unique topology map to

  // those of the consensus tables in the synthesis.

  Hybrid<int> ubrd_param_map;

  Hybrid<int2> ubrd_param_map_bounds;

  Hybrid<int> cimp_param_map;

  Hybrid<int2> cimp_param_map_bounds;

  Hybrid<int> cmap_param_map;

  Hybrid<int2> cmap_param_map_bounds;

  Hybrid<int> bond_param_map;

  Hybrid<int2> bond_param_map_bounds;

  Hybrid<int> angl_param_map;

  Hybrid<int2> angl_param_map_bounds;

  Hybrid<int> dihe_param_map;

  Hybrid<int2> dihe_param_map_bounds;

  Hybrid<int> attn14_param_map;

  Hybrid<int2> attn14_param_map_bounds;

  Hybrid<int> vste_param_map;

  Hybrid<int2> vste_param_map_bounds;

  Hybrid<int> sett_param_map;

  Hybrid<int2> sett_param_map_bounds;

  Hybrid<int> cnst_param_map;

  Hybrid<int2> cnst_param_map_bounds;


  // CHARMM and basic force field valence term details.  Each of these objects points into one of

  // the data arrays at the bottom of the section.

  Hybrid<double> ubrd_stiffnesses;

  Hybrid<double> ubrd_equilibria;

  Hybrid<double> cimp_stiffnesses;

  Hybrid<double> cimp_phase_angles;

  Hybrid<int> cmap_surface_dimensions;

  Hybrid<int> cmap_surface_bounds;

  Hybrid<int> cmap_patch_bounds;

  Hybrid<double> cmap_surfaces;

  Hybrid<double> cmap_patches;

  Hybrid<float> sp_ubrd_stiffnesses;

  Hybrid<float> sp_ubrd_equilibria;

  Hybrid<float> sp_cimp_stiffnesses;

  Hybrid<float> sp_cimp_phase_angles;

  Hybrid<float> sp_cmap_surfaces;

  Hybrid<float> sp_cmap_patches;


  // Basic force field valence term details, consensus tables form all topologies

  Hybrid<double> bond_stiffnesses;

  Hybrid<double> bond_equilibria;

  Hybrid<double> angl_stiffnesses;

  Hybrid<double> angl_equilibria;

  Hybrid<double> dihe_amplitudes;

  Hybrid<double> dihe_periodicities;

  Hybrid<double> dihe_phase_angles;

  Hybrid<double> attn14_elec_factors;

  Hybrid<double> attn14_vdw_factors;

  Hybrid<float> sp_bond_stiffnesses;

  Hybrid<float> sp_bond_equilibria;

  Hybrid<float> sp_angl_stiffnesses;

  Hybrid<float> sp_angl_equilibria;

  Hybrid<float> sp_dihe_amplitudes;

  Hybrid<float> sp_dihe_periodicities;

  Hybrid<float> sp_dihe_phase_angles;

  Hybrid<float> sp_attn14_elec_factors;

  Hybrid<float> sp_attn14_vdw_factors;

  Hybrid<double> valparam_double_data;

  Hybrid<float> valparam_float_data;

  Hybrid<int> valparam_int_data;

  Hybrid<int2> valparam_int2_data;


  // Valence term indexing arrays, all of them indexing atoms in the synthesis list, updated from

  // the indexing in their original topologies and parameters in the condensed tables of the

  // synthesis.  All of the following arrays are POINTER-kind objects targeting valence_int_data.

  Hybrid<int> ubrd_i_atoms;

  Hybrid<int> ubrd_k_atoms;

  Hybrid<int> ubrd_param_idx;

  Hybrid<int> cimp_i_atoms;

  Hybrid<int> cimp_j_atoms;

  Hybrid<int> cimp_k_atoms;

  Hybrid<int> cimp_l_atoms;

  Hybrid<int> cimp_param_idx;

  Hybrid<int> cmap_i_atoms;

  Hybrid<int> cmap_j_atoms;

  Hybrid<int> cmap_k_atoms;

  Hybrid<int> cmap_l_atoms;

  Hybrid<int> cmap_m_atoms;

  Hybrid<int> cmap_param_idx;

  Hybrid<int> bond_i_atoms;

  Hybrid<int> bond_j_atoms;

  Hybrid<int> bond_param_idx;

  Hybrid<int> angl_i_atoms;

  Hybrid<int> angl_j_atoms;

  Hybrid<int> angl_k_atoms;

  Hybrid<int> angl_param_idx;

  Hybrid<int> dihe_i_atoms;

  Hybrid<int> dihe_j_atoms;

  Hybrid<int> dihe_k_atoms;

  Hybrid<int> dihe_l_atoms;

  Hybrid<int> dihe_param_idx;

  Hybrid<int> valence_int_data;


  // Non-bonded parameter indexing and van-der Waals tables

  Hybrid<int> charge_indices;

  Hybrid<int> lennard_jones_indices;

  Hybrid<double> charge_parameters;

  Hybrid<double2> lennard_jones_ab_coeff;

  Hybrid<double> lennard_jones_c_coeff;

  Hybrid<double> lennard_jones_14_a_coeff;

  Hybrid<double> lennard_jones_14_b_coeff;

  Hybrid<double> lennard_jones_14_c_coeff;

  Hybrid<double> lennard_jones_sigma;

  Hybrid<double> lennard_jones_14_sigma;

  Hybrid<float> sp_charge_parameters;

  Hybrid<float2> sp_lennard_jones_ab_coeff;

  Hybrid<float> sp_lennard_jones_c_coeff;

  Hybrid<float> sp_lennard_jones_14_a_coeff;

  Hybrid<float> sp_lennard_jones_14_b_coeff;

  Hybrid<float> sp_lennard_jones_14_c_coeff;

  Hybrid<float> sp_lennard_jones_sigma;

  Hybrid<float> sp_lennard_jones_14_sigma;


  // Implicit solvent model parameters.  Like the atomic partial charges arrays, most of these will

  // target chem_double_data, chem_float_data, and (in the case of the indices) chem_int_data,

  // for convenience.  The neck tables are their own ARRAY-type objects to expedite applying a

  // new implicit solvent model to an existing synthesis.

  int neck_table_size;

  Hybrid<int> neck_gb_indices;

  Hybrid<double> atomic_pb_radii;

  Hybrid<double> gb_screening_factors;

  Hybrid<double> gb_alpha_parameters;

  Hybrid<double> gb_beta_parameters;

  Hybrid<double> gb_gamma_parameters;

  Hybrid<double2> neck_limit_tables;

  Hybrid<float> sp_atomic_pb_radii;

  Hybrid<float> sp_gb_screening_factors;

  Hybrid<float> sp_gb_alpha_parameters;

  Hybrid<float> sp_gb_beta_parameters;

  Hybrid<float> sp_gb_gamma_parameters;

  Hybrid<float2> sp_neck_limit_tables;


  // NMR restraint terms and details: these function exactly like other parameter sets and are

  // indexed by lists of atoms in the bond work units arrays.  They can be included in the

  // synthesis of AtomGraphs due to their nature as potential terms, whereas the original

  // topologies had to be read from files that did not contain such terms.

  Hybrid<int2> rposn_step_bounds;

  Hybrid<int2> rbond_step_bounds;

  Hybrid<int2> rangl_step_bounds;

  Hybrid<int2> rdihe_step_bounds;

  Hybrid<double2> rposn_init_k;

  Hybrid<double2> rposn_final_k;

  Hybrid<double4> rposn_init_r;

  Hybrid<double4> rposn_final_r;

  Hybrid<double2> rposn_init_xy;

  Hybrid<double> rposn_init_z;

  Hybrid<double2> rposn_final_xy;

  Hybrid<double> rposn_final_z;

  Hybrid<double2> rbond_init_k;

  Hybrid<double2> rbond_final_k;

  Hybrid<double4> rbond_init_r;

  Hybrid<double4> rbond_final_r;

  Hybrid<double2> rangl_init_k;

  Hybrid<double2> rangl_final_k;

  Hybrid<double4> rangl_init_r;

  Hybrid<double4> rangl_final_r;

  Hybrid<double2> rdihe_init_k;

  Hybrid<double2> rdihe_final_k;

  Hybrid<double4> rdihe_init_r;

  Hybrid<double4> rdihe_final_r;

  Hybrid<float2> sp_rposn_init_k;

  Hybrid<float2> sp_rposn_final_k;

  Hybrid<float4> sp_rposn_init_r;

  Hybrid<float4> sp_rposn_final_r;

  Hybrid<float2> sp_rposn_init_xy;

  Hybrid<float> sp_rposn_init_z;

  Hybrid<float2> sp_rposn_final_xy;

  Hybrid<float> sp_rposn_final_z;

  Hybrid<float2> sp_rbond_init_k;

  Hybrid<float2> sp_rbond_final_k;

  Hybrid<float4> sp_rbond_init_r;

  Hybrid<float4> sp_rbond_final_r;

  Hybrid<float2> sp_rangl_init_k;

  Hybrid<float2> sp_rangl_final_k;

  Hybrid<float4> sp_rangl_init_r;

  Hybrid<float4> sp_rangl_final_r;

  Hybrid<float2> sp_rdihe_init_k;

  Hybrid<float2> sp_rdihe_final_k;

  Hybrid<float4> sp_rdihe_init_r;

  Hybrid<float4> sp_rdihe_final_r;

  Hybrid<double> nmr_double_data;

  Hybrid<double2> nmr_double2_data;

  Hybrid<double4> nmr_double4_data;

  Hybrid<float> nmr_float_data;

  Hybrid<float2> nmr_float2_data;

  Hybrid<float4> nmr_float4_data;


  // Restraint indexing arrays, offering atom indices in the concatenated atom and restraint

  // parameter arrays of the synthesis.  The Hybrid objects in this section are POINTER-kind

  // objects targeting the nmr_int_data array, much like the parameters in the preceding section

  // target nmr_[type]_data.

  Hybrid<int> rposn_atoms;

  Hybrid<int> rposn_kr_param_idx;

  Hybrid<int> rposn_xyz_param_idx;

  Hybrid<int> rbond_i_atoms;

  Hybrid<int> rbond_j_atoms;

  Hybrid<int> rbond_param_idx;

  Hybrid<int> rangl_i_atoms;

  Hybrid<int> rangl_j_atoms;

  Hybrid<int> rangl_k_atoms;

  Hybrid<int> rangl_param_idx;

  Hybrid<int> rdihe_i_atoms;

  Hybrid<int> rdihe_j_atoms;

  Hybrid<int> rdihe_k_atoms;

  Hybrid<int> rdihe_l_atoms;

  Hybrid<int> rdihe_param_idx;

  Hybrid<int> rposn_kr_param_map;

  Hybrid<int> rposn_xyz_param_map;

  Hybrid<int2> rposn_param_map_bounds;

  Hybrid<int> rbond_param_map;

  Hybrid<int2> rbond_param_map_bounds;

  Hybrid<int> rangl_param_map;

  Hybrid<int2> rangl_param_map_bounds;

  Hybrid<int> rdihe_param_map;

  Hybrid<int2> rdihe_param_map_bounds;

  Hybrid<int> nmr_int_data;

  Hybrid<int2> nmr_int2_data;


  // Virtual site details: virtual sites are considered parameters, which like valence terms apply

  // to a small group of atoms and index into a table of parameters including the frame type and

  // up to three dimensional measurements.

  Hybrid<double4> virtual_site_parameters;

  Hybrid<float4> sp_virtual_site_parameters;

  Hybrid<int> virtual_site_atoms;

  Hybrid<int> virtual_site_frame1_atoms;

  Hybrid<int> virtual_site_frame2_atoms;

  Hybrid<int> virtual_site_frame3_atoms;

  Hybrid<int> virtual_site_frame4_atoms;

  Hybrid<int> virtual_site_parameter_indices;

  Hybrid<int> vsite_int_data;


  // SETTLE constraint group parameter sets and atom indices

  Hybrid<double4> settle_group_geometry;

  Hybrid<double4> settle_group_masses;

  Hybrid<float4> sp_settle_group_geometry;

  Hybrid<float4> sp_settle_group_masses;

  Hybrid<int4> settle_group_indexing;


  // Constraint group parameter sets and atom indices

  Hybrid<int> constraint_group_indices;

  Hybrid<int2> constraint_group_bounds;

  Hybrid<int> constraint_group_param_idx;

  Hybrid<int> constraint_param_bounds;

  Hybrid<double2> constraint_group_params;

  Hybrid<float2> sp_constraint_group_params;


  // Valence work units (VWUs): work units providing instruction sets for the GPU to operate on a

  // continuous, non-rearranged list of atoms and implement all valence terms.  Each VWU pertains

  // to one and only one individual topology from the list and each topology will have at least one

  // VWU, or more depending on what is needed to cover all of its atoms.  The VWU imports a list of

  // atoms, then computes a series of bond, angle, dihedral, and other force field terms based on

  // the cached atoms.  Forces are accumulated on all atoms in __shared__ memory and then

  // contributed back to the global arrays.

  int total_valence_work_units;

  int2 valence_work_unit_size;


  ValenceKernelSize valence_thread_block_size;


  Hybrid<int2> vwu_instruction_sets;


  Hybrid<int> vwu_import_lists;


  Hybrid<uint2> vwu_manipulation_masks;


  Hybrid<uint2> cbnd_instructions;


  Hybrid<uint2> angl_instructions;


  Hybrid<uint2> cdhe_instructions;


  Hybrid<uint> cdhe_overtones;


  Hybrid<uint2> cmap_instructions;


  Hybrid<uint> infr14_instructions;


  Hybrid<uint2> rposn_instructions;


  Hybrid<uint2> rbond_instructions;


  Hybrid<uint2> rangl_instructions;


  Hybrid<uint2> rdihe_instructions;


  Hybrid<uint2> vste_instructions;


  Hybrid<uint2> sett_instructions;


  Hybrid<uint2> cnst_instructions;


  // Instructions for evaluating energy terms--these are stored as extra arrays, as they will only

  // be called when evaluating energies, and offer a compact format in which each interaction in

  // the list is a bit in a bitstring, (1) indicating that the work unit should contribute the

  // interaction to its sum, (0) indicating that the work unit should omit the interaction.

  // All of these are POINTER-kind objects targeting insr_uint_data.

  Hybrid<uint> accumulate_cbnd_energy;

  Hybrid<uint> accumulate_angl_energy;

  Hybrid<uint> accumulate_cdhe_energy;

  Hybrid<uint> accumulate_cmap_energy;

  Hybrid<uint> accumulate_infr14_energy;

  Hybrid<uint> accumulate_rposn_energy;

  Hybrid<uint> accumulate_rbond_energy;

  Hybrid<uint> accumulate_rangl_energy;

  Hybrid<uint> accumulate_rdihe_energy;


  Hybrid<uint> insr_uint_data;


  Hybrid<uint2> insr_uint2_data;


  // Non-bonded work units (NBWUs): the synthesis also stores information on how to carry out

  // non-bonded tiles (or domain decomposition workloads, depending on the nature of the boundary

  // conditions).  These are less detailed, overall, than the valence work units.

  int total_nonbonded_work_units;

  NbwuKind nonbonded_work_type;


  Hybrid<int> nonbonded_abstracts;


  Hybrid<uint2> nbwu_instructions;


  // Reduction work units.  Various processes in molecular mechanics require system-wide

  // accumulations of particular quantities, and a collection of any number of systems of any size

  // requires a sophisticated system to make that happen efficiently.  The reduction work units

  // are an ecumenical solution to all such reductions, but they may need to combine with different

  // substrates to do a specific process.

  int total_reduction_work_units;

  RdwuPerSystem rdwu_per_system;


  Hybrid<int> reduction_abstracts;


  StopWatch* timer;


  void rebasePointers();


  std::vector<int> createDummyRestraints(const std::vector<int> &restraint_indices_in,

                                         const std::vector<int> &topology_indices_in);


  std::vector<int> checkTopologyList(const std::vector<int> &topology_indices_in);


  std::vector<int> checkRestraintList(const std::vector<int> &restraint_indices_in,

                                      const std::vector<int> &topology_indices_in,

                                      const std::vector<int> &topology_index_rebase);


  void checkCommonSettings();


  void buildAtomAndTermArrays(const std::vector<int> &topology_indices_in,

                              const std::vector<int> &topology_index_rebase,

                              const std::vector<int> &new_restraint_indices,

                              const std::vector<int> &restraint_index_rebase);


  void condenseParameterTables();


  void extendLJMatrices();


  int mapUniqueRestraintKRSeries(int order, const std::vector<int> &network_table_offsets,

                                 std::vector<int> *synthesis_index,

                                 std::vector<int2> *filtered_step_bounds,

                                 std::vector<double2> *filtered_init_keq,

                                 std::vector<double2> *filtered_finl_keq,

                                 std::vector<double4> *filtered_init_r,

                                 std::vector<double4> *filtered_finl_r);


  void condenseRestraintNetworks();


  int setVwuAbstractLimits(int item_counter, int vwu_counter, VwuAbstractMap slot,

                           int item_quantity);


  void loadValenceWorkUnits(int2 vwu_atom_limits =  { maximum_valence_work_unit_atoms,

                                                      maximum_valence_work_unit_atoms });


  void loadReductionWorkUnits(const GpuDetails &gpu = null_gpu);


  void importImplicitSolventAtomParameters(int system_index);


  void setImplicitSolventNeckParameters(const NeckGeneralizedBornTable &ngb_tab);

  void setImplicitSolventNeckParameters();

};


} // namespace synthesis

} // namespace stormm


#include "atomgraph_synthesis.tpp"


#endif

stormm::card::AtomGraphSynthesis::AtomGraphSynthesis
AtomGraphSynthesis(const std::vector< AtomGraph * > &topologies_in, const std::vector< RestraintApparatus * > &restraints_in, const std::vector< int > &topology_indices_in, const std::vector< int > &restraint_indices_in, ExceptionResponse policy_in=ExceptionResponse::WARN, const GpuDetails &gpu=null_gpu, StopWatch *timer_in=nullptr)
The constructor takes a series of topologies and NMR restraints. The NMR restraints point to specific...
Definition ag_synthesis_constructors.cpp:11

stormm::card::AtomGraphSynthesis::getSystemTopologyPointer
const AtomGraph * getSystemTopologyPointer(int system_index) const
Get a topology pointer for a specific system contained within the synthesis.
Definition ag_synthesis_mechanics.cpp:2768

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::generalized_born_defaults::NeckGeneralizedBornTable
Object to hold a complex array of constants referenced by various GB calculations using the "neck" fo...
Definition generalized_born.h:151

stormm::synthesis::AtomGraphSynthesis::getBondParameterCount
int getBondParameterCount() const
Get the number of unique harmonic bond parameter sets.
Definition ag_synthesis_mechanics.cpp:2889

stormm::synthesis::AtomGraphSynthesis::getBondTermCount
int getBondTermCount() const
Get the total number of bond terms across all systems, including replicas.
Definition ag_synthesis_mechanics.cpp:2849

stormm::synthesis::AtomGraphSynthesis::getTopologyIndices
std::vector< int > getTopologyIndices() const
Get a const reference to the list of all topology indices, indicating the topologies describing each ...
Definition ag_synthesis_mechanics.cpp:2793

stormm::synthesis::AtomGraphSynthesis::getLJTypeCount
int getLJTypeCount() const
Get the number of unique atom types (a parameter, not an extensive quantity dependent on the number o...
Definition ag_synthesis_mechanics.cpp:2879

stormm::synthesis::AtomGraphSynthesis::getPBRadiiSet
std::vector< AtomicRadiusSet > getPBRadiiSet() const
Get the name of the PB radii set for one or more systems.
Definition ag_synthesis_mechanics.cpp:2964

stormm::synthesis::AtomGraphSynthesis::getDoublePrecisionRestraintKit
SyRestraintKit< double, double2, double4 > getDoublePrecisionRestraintKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a minimal kit with double-precision parameter detail for computing valence interactions for all s...
Definition ag_synthesis_mechanics.cpp:3109

stormm::synthesis::AtomGraphSynthesis::getUnitCellType
UnitCellType getUnitCellType() const
Get the unit cell type that will be taken for all systems (TRICLINIC subsumes ORTHORHOMBIC in a sort ...
Definition ag_synthesis_mechanics.cpp:2939

stormm::synthesis::AtomGraphSynthesis::getRandomCacheDepth
int getRandomCacheDepth() const
Get the depth of the random numbers cache that the non-bonded work units of this topology synthesis w...
Definition ag_synthesis_mechanics.cpp:3024

stormm::synthesis::AtomGraphSynthesis::getDoublePrecisionNonbondedKit
SyNonbondedKit< double, double2 > getDoublePrecisionNonbondedKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a minimal kit with double-precision real numbers for computing non-bonded interactions for all sy...
Definition ag_synthesis_mechanics.cpp:3159

stormm::synthesis::AtomGraphSynthesis::getSaltConcentration
double getSaltConcentration() const
Get the salt concentration (supporting the implicit solvent model) for all systems.
Definition ag_synthesis_mechanics.cpp:2954

stormm::synthesis::AtomGraphSynthesis::getAtomCount
int getAtomCount() const
Get the number of atoms in one or more systems.
Definition ag_synthesis_mechanics.cpp:2813

stormm::synthesis::AtomGraphSynthesis::getUniqueTopologies
const std::vector< AtomGraph * > & getUniqueTopologies() const
Get a const reference to the list of all pointers for unique topologies making up this synthesis.
Definition ag_synthesis_mechanics.cpp:2788

stormm::synthesis::AtomGraphSynthesis::getValenceWorkUnitCount
int getValenceWorkUnitCount() const
Get the overall number of valence work units needed to account for interactions in all systems.
Definition ag_synthesis_mechanics.cpp:2994

stormm::synthesis::AtomGraphSynthesis::getSystemAtomCounts
const Hybrid< int > & getSystemAtomCounts() const
Get the sizes of all individual systems as a const reference to the Hybrid array member variable.
Definition ag_synthesis_mechanics.cpp:2919

stormm::synthesis::AtomGraphSynthesis::getDihedralParameterCount
int getDihedralParameterCount() const
Get the number of unique cosine-based dihedral parameter sets.
Definition ag_synthesis_mechanics.cpp:2899

stormm::synthesis::AtomGraphSynthesis::setImplicitSolventModel
void setImplicitSolventModel()
Apply an implicit solvent model to the synthesis. Any mode of operation other than taking the origina...
Definition ag_synthesis_mechanics.cpp:3419

stormm::synthesis::AtomGraphSynthesis::AtomGraphSynthesis
AtomGraphSynthesis(const std::vector< AtomGraph * > &topologies_in, const std::vector< RestraintApparatus * > &restraints_in, const std::vector< int > &topology_indices_in, const std::vector< int > &restraint_indices_in, ExceptionResponse policy_in=ExceptionResponse::WARN, const GpuDetails &gpu=null_gpu, StopWatch *timer_in=nullptr)
The constructor takes a series of topologies and NMR restraints. The NMR restraints point to specific...
Definition ag_synthesis_constructors.cpp:11

stormm::synthesis::AtomGraphSynthesis::getConstrainedDegreesOfFreedom
const Hybrid< int > & getConstrainedDegreesOfFreedom() const
Get the numbers of constrained degrees of freedom for all individual systems in the.
Definition ag_synthesis_mechanics.cpp:2934

stormm::synthesis::AtomGraphSynthesis::getUniqueTopologyCount
int getUniqueTopologyCount() const
Get the number of unique topologies described by the synthesis.
Definition ag_synthesis_mechanics.cpp:2763

stormm::synthesis::AtomGraphSynthesis::getImplicitSolventModel
ImplicitSolventModel getImplicitSolventModel() const
Get the implicit solvent model in use across all systems.
Definition ag_synthesis_mechanics.cpp:2944

stormm::synthesis::AtomGraphSynthesis::getAtomOffset
int getAtomOffset(int system_index) const
Get the starting point for atoms of a specific system in the lineup of all topologies.
Definition ag_synthesis_mechanics.cpp:2834

stormm::synthesis::AtomGraphSynthesis::getNonbondedWorkType
NbwuKind getNonbondedWorkType() const
Get the type of non-bonded work required by systems in this synthesis.
Definition ag_synthesis_mechanics.cpp:3014

stormm::synthesis::AtomGraphSynthesis::getSinglePrecisionValenceKit
SyValenceKit< float > getSinglePrecisionValenceKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a minimal kit with single-precision parameter detail for computing valence interactions for all s...
Definition ag_synthesis_mechanics.cpp:3082

stormm::synthesis::AtomGraphSynthesis::getSelfPointer
const AtomGraphSynthesis * getSelfPointer() const
Get a const pointer to the object itself, useful for retrieving a valid pointer when the object is av...
Definition ag_synthesis_mechanics.cpp:3230

stormm::synthesis::AtomGraphSynthesis::getDihedralTermCount
int getDihedralTermCount() const
Get the total number of cosine-based dihedral terms across all systems and replicas.
Definition ag_synthesis_mechanics.cpp:2859

stormm::synthesis::AtomGraphSynthesis::getCmapSurfaceCount
int getCmapSurfaceCount() const
Get the number of unique CMAP surfaces.
Definition ag_synthesis_mechanics.cpp:2914

stormm::synthesis::AtomGraphSynthesis::getDoublePrecisionAtomUpdateKit
SyAtomUpdateKit< double, double2, double4 > getDoublePrecisionAtomUpdateKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a minimal kit with double-precision real numbers for updating atom and virtual site positions bas...
Definition ag_synthesis_mechanics.cpp:3201

stormm::synthesis::AtomGraphSynthesis::getChargeTypeCount
int getChargeTypeCount() const
Get the number of unique charge parameters.
Definition ag_synthesis_mechanics.cpp:2884

stormm::synthesis::AtomGraphSynthesis::getCoulombConstant
double getCoulombConstant() const
Get the fundamental Coulomb constant defining the electrostatics of all systems.
Definition ag_synthesis_mechanics.cpp:2959

stormm::synthesis::AtomGraphSynthesis::getSystemAtomOffsets
const Hybrid< int > & getSystemAtomOffsets() const
Get the starting locations of all individual systems as a const reference to the Hybrid array member ...
Definition ag_synthesis_mechanics.cpp:2924

stormm::synthesis::AtomGraphSynthesis::getAtomicMasses
std::vector< T > getAtomicMasses(HybridTargetLevel tier) const
Get the masses (or inverse masses) of atoms in the synthesis.

stormm::synthesis::AtomGraphSynthesis::getPartialCharges
std::vector< T > getPartialCharges(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get partial charges stored within the synthesis.

stormm::synthesis::AtomGraphSynthesis::getUreyBradleyTermCount
int getUreyBradleyTermCount() const
Get the total number of Urey-Bradley terms across all systems and replicas.
Definition ag_synthesis_mechanics.cpp:2864

stormm::synthesis::AtomGraphSynthesis::getNonbondedWorkUnitCount
int getNonbondedWorkUnitCount() const
Get the number of non-bonded work units serving systems in this synthesis.
Definition ag_synthesis_mechanics.cpp:3019

stormm::synthesis::AtomGraphSynthesis::getSinglePrecisionNonbondedKit
SyNonbondedKit< float, float2 > getSinglePrecisionNonbondedKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a minimal kit with single-precision real numbers for computing non-bonded interactions for all sy...
Definition ag_synthesis_mechanics.cpp:3179

stormm::synthesis::AtomGraphSynthesis::getPaddedAtomCount
int getPaddedAtomCount() const
Get the entire padded number of atoms covering all systems.
Definition ag_synthesis_mechanics.cpp:2828

stormm::synthesis::AtomGraphSynthesis::getSystemCount
int getSystemCount() const
Get the number of systems that this synthesis describes.
Definition ag_synthesis_mechanics.cpp:2808

stormm::synthesis::AtomGraphSynthesis::getSinglePrecisionAtomUpdateKit
SyAtomUpdateKit< float, float2, float4 > getSinglePrecisionAtomUpdateKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a minimal kit with single-precision real numbers for updating atom and virtual site positions bas...
Definition ag_synthesis_mechanics.cpp:3215

stormm::synthesis::AtomGraphSynthesis::getSystemRestraintPointer
RestraintApparatus * getSystemRestraintPointer(int system_index) const
Get a restraint apparatus pointer for a sepcific system contained within the synthesis.
Definition ag_synthesis_mechanics.cpp:2798

stormm::synthesis::AtomGraphSynthesis::getDielectricConstant
double getDielectricConstant() const
Get the dielectric constant (supporting the implicit solvent model) for all systems.
Definition ag_synthesis_mechanics.cpp:2949

stormm::synthesis::AtomGraphSynthesis::getDegreesOfFreedom
const Hybrid< int > & getDegreesOfFreedom() const
Get the numbers of unconstrained degrees of freedom for all individual systems in the.
Definition ag_synthesis_mechanics.cpp:2929

stormm::synthesis::AtomGraphSynthesis::getAngleParameterCount
int getAngleParameterCount() const
Get the number of unique harmonic bond angle parameter sets.
Definition ag_synthesis_mechanics.cpp:2894

stormm::synthesis::AtomGraphSynthesis::getCharmmImproperTermCount
int getCharmmImproperTermCount() const
Get the total number of CHARMM improper terms across all systems and replicas.
Definition ag_synthesis_mechanics.cpp:2869

stormm::synthesis::AtomGraphSynthesis::getValenceThreadBlockSize
ValenceKernelSize getValenceThreadBlockSize() const
Get the necessary thread block size for evaluating the valence work units.
Definition ag_synthesis_mechanics.cpp:3004

stormm::synthesis::AtomGraphSynthesis::getCharmmImproperParameterCount
int getCharmmImproperParameterCount() const
Get the number of unique CHARMM improper parameter sets.
Definition ag_synthesis_mechanics.cpp:2909

stormm::synthesis::AtomGraphSynthesis::getUreyBradleyParameterCount
int getUreyBradleyParameterCount() const
Get the number of unique Urey-Bradley harmonic angle parameter sets.
Definition ag_synthesis_mechanics.cpp:2904

stormm::synthesis::AtomGraphSynthesis::getReductionWorkUnitAbstracts
const Hybrid< int > & getReductionWorkUnitAbstracts() const
Get the reduction work unit abstracts (this is not required for valence or non-bonded work units as t...
Definition ag_synthesis_mechanics.cpp:3049

stormm::synthesis::AtomGraphSynthesis::getDoublePrecisionValenceKit
SyValenceKit< double > getDoublePrecisionValenceKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a minimal kit with double-precision parameter detail for computing valence interactions for all s...
Definition ag_synthesis_mechanics.cpp:3055

stormm::synthesis::AtomGraphSynthesis::getSinglePrecisionRestraintKit
SyRestraintKit< float, float2, float4 > getSinglePrecisionRestraintKit(HybridTargetLevel tier=HybridTargetLevel::HOST) const
Get a minimal kit with single-precision parameter detail for computing valence interactions for all s...
Definition ag_synthesis_mechanics.cpp:3134

stormm::synthesis::AtomGraphSynthesis::loadNonbondedWorkUnits
void loadNonbondedWorkUnits(const StaticExclusionMaskSynthesis &poly_se, InitializationTask init_request=InitializationTask::NONE, int random_cache_depth=0, const GpuDetails &gpu=null_gpu)
Construct non-bonded work units for all unique topologies (there are no restraints for non-bonded int...
Definition ag_synthesis_mechanics.cpp:2668

stormm::synthesis::AtomGraphSynthesis::getCmapTermCount
int getCmapTermCount() const
Get the total number of CMAP terms across all systems and replicas.
Definition ag_synthesis_mechanics.cpp:2874

stormm::synthesis::AtomGraphSynthesis::getRdwuPerSystem
RdwuPerSystem getRdwuPerSystem() const
Get a qualitative assessment of the number of reduction work units assigned to any one system.
Definition ag_synthesis_mechanics.cpp:3044

stormm::synthesis::AtomGraphSynthesis::getValenceWorkUnitSize
int2 getValenceWorkUnitSize() const
Get the maximum size of valence work units, whether for organic molecules or solvent (rigid water) re...
Definition ag_synthesis_mechanics.cpp:2999

stormm::synthesis::AtomGraphSynthesis::getVirtualSiteCount
int getVirtualSiteCount() const
Get the total number of virtual sites across all systems, including replicas.
Definition ag_synthesis_mechanics.cpp:2844

stormm::synthesis::AtomGraphSynthesis::getReductionWorkUnitCount
int getReductionWorkUnitCount() const
Get the number of reduction work units spanning all systems.
Definition ag_synthesis_mechanics.cpp:3039

stormm::synthesis::AtomGraphSynthesis::getValenceWorkUnitAbstracts
const Hybrid< int2 > & getValenceWorkUnitAbstracts() const
Get the abstracts (condensed lists of import and instruction set limits) for the valence work units s...
Definition ag_synthesis_mechanics.cpp:3009

stormm::synthesis::AtomGraphSynthesis::getAngleTermCount
int getAngleTermCount() const
Get the total number of bond angle terms across all systems, including replicas.
Definition ag_synthesis_mechanics.cpp:2854

stormm::synthesis::AtomGraph
A struct to hold information relating to an Amber topology. This struct's member functions are limite...
Definition atomgraph.h:50

stormm::synthesis::RestraintApparatus
A collection of all restraints pertaining to a specific topology for the purposes of one simulation,...
Definition restraint_apparatus.h:109

stormm::synthesis::StaticExclusionMaskSynthesis
An exclusion mask object for a compilation of systems. All systems are represented in full detail,...
Definition static_mask_synthesis.h:54

stormm::testing::StopWatch
Object for managing calls to the C-standard function gettimeofday(), calculating deltas and categoriz...
Definition stopwatch.h:23

stormm::data_types::char4
Definition stormm_vector_types.h:141

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

stormm::generalized_born_defaults::NeckGeneralizedBornKit
Abstract for the NeckGeneralizedBornTable object, in single- or double-precision.
Definition generalized_born.h:130

stormm::synthesis::SyAtomUpdateKit
Collect the virtual site details and constraint parameters of the topology synthesis into a single ab...
Definition synthesis_abstracts.h:257

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

stormm::synthesis::SyRestraintKit
Collect the critical restraint parameters and masking information for work unit-based evaluation of t...
Definition synthesis_abstracts.h:100

stormm::synthesis::SyValenceKit
Collect the critical valence parameters and indexing information for work unit-based evaluation of th...
Definition synthesis_abstracts.h:19