hub_and_spoke.h

// -*-c++-*-
#ifndef STORMM_RATTLE_H
#define STORMM_RATTLE_H
 
#include "copyright.h"
#include "Constants/behavior.h"
#include "Constants/fixed_precision.h"
#include "DataTypes/common_types.h"
#include "Namelists/nml_dynamics.h"
#include "Numerics/split_fixed_precision.h"
#include "Synthesis/atomgraph_synthesis.h"
#include "Synthesis/phasespace_synthesis.h"
#include "Synthesis/synthesis_abstracts.h"
#include "Synthesis/synthesis_enumerators.h"
#include "Topology/atomgraph.h"
#include "Topology/atomgraph_abstracts.h"
#include "Trajectory/phasespace.h"
#include "Trajectory/trajectory_enumerators.h"
#include "structure_enumerators.h"
 
namespace stormm {
namespace structure {
 
using constants::PrecisionModel;
using data_types::isSignedIntegralScalarType;
using namelist::default_rattle_max_iter;
using synthesis::AtomGraphSynthesis;
using synthesis::maximum_valence_work_unit_atoms;
using synthesis::PhaseSpaceSynthesis;
using synthesis::PsSynthesisWriter;
using synthesis::SyAtomUpdateKit;
using synthesis::SyValenceKit;
using synthesis::VwuAbstractMap;
using synthesis::vwu_abstract_length;
using topology::AtomGraph;
using topology::ConstraintKit;
using trajectory::CoordinateCycle;
using trajectory::PhaseSpace;
using trajectory::PhaseSpaceWriter;

template <typename Tcoord, typename Tcalc>
void shakePositions(Tcoord* xdev, Tcoord* ydev, Tcoord* zdev, Tcoord* xvel_dev, Tcoord* yvel_dev,
                    Tcoord* zvel_dev, const Tcoord* xref, const Tcoord* yref, const Tcoord* zref,
                    const ConstraintKit<Tcalc> &cnk, Tcalc dt, Tcalc tol, int max_iter,
                    RattleMethod style, Tcalc gpos_scale_factor = 1.0,
                    Tcalc vel_scale_factor = 1.0);
 
template <typename T>
void shakePositions(PhaseSpaceWriter *psw, const ConstraintKit<T> &cnk, T dt, T tol,
                    int max_iter = default_rattle_max_iter,
                    RattleMethod style = RattleMethod::SEQUENTIAL);
 
void shakePositions(PhaseSpace *ps, const AtomGraph *ag, PrecisionModel prec, double dt,
                    double tol, int max_iter = default_rattle_max_iter,
                    RattleMethod style = RattleMethod::SEQUENTIAL);
 
void shakePositions(PhaseSpace *ps, const AtomGraph &ag, PrecisionModel prec, double dt,
                    double tol, int max_iter = default_rattle_max_iter,
                    RattleMethod style = RattleMethod::SEQUENTIAL);
 
template <typename T, typename T2, typename T4>
void shakePositions(PsSynthesisWriter *poly_psw, const SyValenceKit<T> &poly_vk,
                    const SyAtomUpdateKit<T, T2, T4> &poly_auk, T dt, T tol,
                    int max_iter = default_rattle_max_iter);
 
void shakePositions(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag,
                    PrecisionModel prec, double dt, double tol,
                    int max_iter = default_rattle_max_iter);
 
void shakePositions(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag,
                    PrecisionModel prec, double dt, double tol,
                    int max_iter = default_rattle_max_iter);

template <typename Tcoord, typename Tcalc>
void rattleVelocities(Tcoord* xvel_dev, Tcoord* yvel_dev, Tcoord *zvel_dev, const Tcoord* xcrd_ref,
                      const Tcoord* ycrd_ref, const Tcoord* zcrd_ref,
                      const ConstraintKit<Tcalc> &cnk, Tcalc dt, Tcalc tol,
                      int max_iter = default_rattle_max_iter,
                      RattleMethod style = RattleMethod::SEQUENTIAL, Tcalc gpos_scale_factor = 1.0,
                      Tcalc vel_scale_factor = 1.0);
 
template <typename Tcalc>
void rattleVelocities(PhaseSpaceWriter *psw, const ConstraintKit<Tcalc> &cnk, Tcalc dt, Tcalc tol,
                      int max_iter = default_rattle_max_iter,
                      RattleMethod style = RattleMethod::SEQUENTIAL);
 
void rattleVelocities(PhaseSpace *ps, const AtomGraph *ag, PrecisionModel prec, double dt,
                      double tol, int max_iter = default_rattle_max_iter,
                      RattleMethod style = RattleMethod::SEQUENTIAL);
 
void rattleVelocities(PhaseSpace *ps, const AtomGraph &ag, PrecisionModel prec, double dt,
                      double tol, int max_iter = default_rattle_max_iter,
                      RattleMethod style = RattleMethod::SEQUENTIAL);
 
template <typename T, typename T2, typename T4>
void rattleVelocities(PsSynthesisWriter *poly_psw, const SyValenceKit<T> &poly_vk,
                      const SyAtomUpdateKit<T, T2, T4> &poly_auk, T dt, T tol,
                      int max_iter = default_rattle_max_iter);
 
void rattleVelocities(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag,
                      PrecisionModel prec, double dt, double tol,
                      int max_iter = default_rattle_max_iter);
 
void rattleVelocities(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag,
                      PrecisionModel prec, double dt, double tol,
                      int max_iter = default_rattle_max_iter);
  
} // namespace structure
} // namespace stormm
 
#include "hub_and_spoke.tpp"
 
#endif