doxygen/virtual__site__handling_8h_source.html

// -*-c++-*-

#ifndef STORMM_VIRTUAL_SITE_PLACEMENT_H

#define STORMM_VIRTUAL_SITE_PLACEMENT_H


#include <cmath>

#include "copyright.h"

#include "Constants/fixed_precision.h"

#include "DataTypes/stormm_vector_types.h"

#include "Math/vector_ops.h"

#include "Numerics/split_fixed_precision.h"

#include "Structure/local_arrangement.h"

#include "Synthesis/atomgraph_synthesis.h"

#include "Synthesis/phasespace_synthesis.h"

#include "Synthesis/synthesis_abstracts.h"

#include "Synthesis/synthesis_enumerators.h"

#include "Synthesis/valence_workunit.h"

#include "Topology/atomgraph.h"

#include "Topology/atomgraph_abstracts.h"

#include "Topology/atomgraph_enumerators.h"

#include "Trajectory/coordinateframe.h"

#include "Trajectory/phasespace.h"

#include "Trajectory/trajectory_enumerators.h"

#include "local_arrangement.h"


namespace stormm {

namespace structure {


using numerics::force_scale_nonoverflow_bits;

using numerics::globalpos_scale_nonoverflow_bits;

using numerics::operator+;

using stmath::dot;

using stmath::project;

using stmath::crossProduct;

using synthesis::AtomGraphSynthesis;

using synthesis::maximum_valence_work_unit_atoms;

using synthesis::SyAtomUpdateKit;

using synthesis::SyValenceKit;

using synthesis::vwu_abstract_length;

using synthesis::VwuAbstractMap;

using topology::AtomGraph;

using topology::UnitCellType;

using topology::VirtualSiteKind;

using topology::VirtualSiteKit;

using trajectory::CoordinateCycle;

using trajectory::CoordinateFrame;

using trajectory::CoordinateFrameWriter;

using trajectory::PhaseSpace;

using trajectory::PhaseSpaceWriter;


template <typename Tcoord>

void drawVirtualSite(const int vsite_atom, const int parent_atom, const int95_t xdisp,

                     const int95_t ydisp, const int95_t zdisp, Tcoord *xcrd, Tcoord *ycrd,

                     Tcoord *zcrd, int* xcrd_ovrf, int* ycrd_ovrf, int* zcrd_ovrf);


template <typename Tcoord, typename Tcalc>

void placeVirtualSite(Tcoord* xcrd, Tcoord* ycrd, Tcoord* zcrd, const double* umat,

                      const double* invu, UnitCellType unit_cell, int vsite_atom, int parent_atom,

                      int frame2_atom, int frame3_atom, int frame4_atom,

                      VirtualSiteKind frame_type, Tcalc frame_d1, Tcalc frame_d2, Tcalc frame_d3,

                      Tcalc gpos_scale_factor = 1.0, int* xcrd_ovrf = nullptr,

                      int* ycrd_ovrf = nullptr, int* zcrd_ovrf = nullptr);


template <typename Tcoord, typename Tcalc>

void placeVirtualSites(Tcoord* xcrd, Tcoord* ycrd, Tcoord* zcrd, const double* umat,

                       const double* invu, const UnitCellType unit_cell,

                       const VirtualSiteKit<Tcalc> &vsk, Tcalc gpos_scale_factor = 1.0);


void placeVirtualSites(PhaseSpace *ps, const AtomGraph *ag, CoordinateCycle affix,

                       PrecisionModel prec = PrecisionModel::DOUBLE);


void placeVirtualSites(PhaseSpace *ps, const AtomGraph &ag, CoordinateCycle affix,

                       PrecisionModel prec = PrecisionModel::DOUBLE);


void placeVirtualSites(PhaseSpace *ps, const AtomGraph *ag,

                       PrecisionModel prec = PrecisionModel::DOUBLE);


void placeVirtualSites(PhaseSpace *ps, const AtomGraph &ag,

                       PrecisionModel prec = PrecisionModel::DOUBLE);


void placeVirtualSites(CoordinateFrame *cf, const AtomGraph *ag,

                       PrecisionModel prec = PrecisionModel::DOUBLE);


void placeVirtualSites(CoordinateFrame *cf, const AtomGraph &ag,

                       PrecisionModel prec = PrecisionModel::DOUBLE);


template <typename Tcalc>

void placeVirtualSites(PhaseSpaceWriter *psw, const VirtualSiteKit<Tcalc> vsk,

                       bool edit_alternate_image = true);


template <typename Tcalc>

void placeVirtualSites(CoordinateFrameWriter *cfw, const VirtualSiteKit<Tcalc> vsk);


template <typename Tcalc, typename Tcalc2, typename Tcalc4>

void placeVirtualSites(PsSynthesisWriter *poly_psw, const SyValenceKit<Tcalc> &poly_vk,

                       const SyAtomUpdateKit<Tcalc, Tcalc2, Tcalc4> &poly_auk);


void placeVirtualSites(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag,

                       CoordinateCycle affix, PrecisionModel prec = PrecisionModel::DOUBLE);


void placeVirtualSites(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag,

                       CoordinateCycle affix, PrecisionModel prec = PrecisionModel::DOUBLE);


void placeVirtualSites(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag,

                       PrecisionModel prec = PrecisionModel::DOUBLE);


void placeVirtualSites(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag,

                       PrecisionModel prec = PrecisionModel::DOUBLE);


template <typename Tcoord, typename Tforce, typename Tcalc>

void transmitVirtualSiteForces(const Tcoord* xcrd, const Tcoord* ycrd, const Tcoord* zcrd,

                               Tforce* xfrc, Tforce* yfrc, Tforce* zfrc, const double* umat,

                               const double* invu, UnitCellType unit_cell, int vsite_atom,

                               int parent_atom, int frame2_atom, int frame3_atom, int frame4_atom,

                               VirtualSiteKind frame_type, Tcalc frame_d1, Tcalc frame_d2,

                               Tcalc frame_d3, Tcalc gpos_scale_factor = 1.0,

                               Tcalc force_scale_factor = 1.0, const int* xcrd_ovrf = nullptr,

                               const int* ycrd_ovrf = nullptr, const int* zcrd_ovrf = nullptr,

                               int* xfrc_ovrf = nullptr, int* yfrc_ovrf = nullptr,

                               int* zfrc_ovrf = nullptr);


template <typename Tcoord, typename Tforce, typename Tcalc>

void transmitVirtualSiteForces(const Tcoord* xcrd, const Tcoord* ycrd, const Tcoord* zcrd,

                               Tforce* xfrc, Tforce* yfrc, Tforce* zfrc, const double* umat,

                               const double* invu, const UnitCellType unit_cell,

                               const VirtualSiteKit<Tcalc> &vsk, Tcalc gpos_scale_factor = 1.0,

                               Tcalc force_scale_factor = 1.0);


void transmitVirtualSiteForces(PhaseSpace *ps, const AtomGraph *ag,

                               PrecisionModel prec = PrecisionModel::DOUBLE);


void transmitVirtualSiteForces(PhaseSpace *ps, const AtomGraph &ag,

                               PrecisionModel prec = PrecisionModel::DOUBLE);


template <typename Tcalc>

void transmitVirtualSiteForces(PhaseSpaceWriter *psw, const VirtualSiteKit<Tcalc> vsk);


template <typename Tcalc, typename Tcalc2, typename Tcalc4>

void transmitVirtualSiteForces(PsSynthesisWriter *poly_psw, const SyValenceKit<Tcalc> &poly_vk,

                               const SyAtomUpdateKit<Tcalc, Tcalc2, Tcalc4> &poly_auk);


void transmitVirtualSiteForces(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag,

                               PrecisionModel prec = PrecisionModel::DOUBLE);


void transmitVirtualSiteForces(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag,

                               PrecisionModel prec = PrecisionModel::DOUBLE);


} // namespace structure

} // namespace stormm


#include "virtual_site_handling.tpp"


#endif

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::topology::AtomGraph
A struct to hold information relating to an Amber topology. This struct's member functions are limite...
Definition atomgraph.h:50

stormm::trajectory::CoordinateFrame
Store the coordinates and box information for a frame, only. This abridged struct can serve when the ...
Definition coordinateframe.h:111

stormm::trajectory::PhaseSpace
An object to complement a topology and hold positions, velocities, and forces of all particles in a s...
Definition phasespace.h:141

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::SyAtomUpdateKit
Collect the virtual site details and constraint parameters of the topology synthesis into a single ab...
Definition synthesis_abstracts.h:257

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

stormm::topology::VirtualSiteKit
Information needed for the placement of virtual sites and transmission of forces on these sites to th...
Definition atomgraph_abstracts.h:430

stormm::trajectory::CoordinateFrameWriter
Collect C-style pointers for the elements of a writable CoordinateFrame object.
Definition coordinateframe.h:30

stormm::trajectory::PhaseSpaceWriter
Collect constants and pointers to the components of a modifiable PhaseSpace object.
Definition phasespace.h:31