settle.h

// -*-c++-*-
#ifndef STORMM_SETTLE_H
#define STORMM_SETTLE_H
 
#include <typeinfo>
#include <typeindex>
#include <unistd.h>
#include "copyright.h"
#include "Constants/behavior.h"
#include "Constants/fixed_precision.h"
#include "DataTypes/common_types.h"
#include "DataTypes/stormm_vector_types.h"
#include "Math/vector_ops.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 "global_manipulation.h"
 
namespace stormm {
namespace structure {
 
using constants::PrecisionModel;
using data_types::isSignedIntegralScalarType;
using numerics::globalpos_scale_nonoverflow_bits;
using numerics::velocity_scale_nonoverflow_bits;
using stmath::crossProduct;
using stmath::normalize;
using synthesis::AtomGraphSynthesis;
using synthesis::maximum_valence_work_unit_atoms;
using synthesis::PhaseSpaceSynthesis;
using synthesis::SyValenceKit;
using synthesis::SyAtomUpdateKit;
using synthesis::vwu_abstract_length;
using synthesis::VwuAbstractMap;
using topology::AtomGraph;
using topology::ConstraintKit;
using trajectory::PhaseSpace;
using trajectory::PhaseSpaceWriter;
  
template <typename Tcoord, typename Tcalc>
void settleGroupVelocity(int oxy_idx, int hd1_idx, int hd2_idx, Tcalc m_o, Tcalc m_h, Tcalc m_oh,
                         const Tcoord* xcrd, const Tcoord* ycrd, const Tcoord* zcrd, Tcoord* xvel,
                         Tcoord* yvel, Tcoord* zvel, const int* xcrd_ovrf = nullptr,
                         const int* ycrd_ovrf = nullptr, const int* zcrd_ovrf = nullptr,
                         int* xvel_ovrf = nullptr, int* yvel_ovrf = nullptr,
                         int* zvel_ovrf = nullptr, Tcalc gpos_scale = 1.0, Tcalc vel_scale = 1.0);

template <typename Tcoord, typename Tcalc>
void settleVelocities(const Tcoord* xcrd, const Tcoord* ycrd, const Tcoord* zcrd, Tcoord* xvel,
                      Tcoord* yvel, Tcoord* zvel, const ConstraintKit<Tcalc> &cnst,
                      const int* xcrd_ovrf = nullptr, const int* ycrd_ovrf = nullptr,
                      const int* zcrd_ovrf = nullptr, int* xvel_ovrf = nullptr,
                      int* yvel_ovrf = nullptr, int* zvel_ovrf = nullptr, Tcalc gpos_scale = 1.0,
                      Tcalc vel_scale = 1.0);
 
template <typename Tcalc>
void settleVelocities(PhaseSpaceWriter *psw, const ConstraintKit<Tcalc> &cnst);
 
template <typename Tcalc, typename Tcalc2, typename Tcalc4>
void settleVelocities(PsSynthesisWriter *poly_psw, const SyValenceKit<Tcalc> &poly_vk,
                      const SyAtomUpdateKit<Tcalc, Tcalc2, Tcalc4> &poly_auk);
 
void settleVelocities(PhaseSpace *ps, const AtomGraph *ag, PrecisionModel prec);
 
void settleVelocities(PhaseSpace *ps, const AtomGraph &ag, PrecisionModel prec);
 
void settleVelocities(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag,
                      PrecisionModel prec = PrecisionModel::SINGLE);  
 
void settleVelocities(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag,
                      PrecisionModel prec = PrecisionModel::SINGLE);  

template <typename Tcoord, typename Tcalc>
void updateSettlePVC(int atm_idx, Tcalc p_to_v_factor, Tcalc r_adj, Tcoord r_ref, int r_ref_ovrf,
                     Tcoord* r_dev, int* r_dev_ovrf, Tcoord* v_dev, int* v_dev_ovrf);
  
template <typename Tcoord, typename Tcalc, typename Tcalc3>
void settleGroupPosition(int oxy_idx, int hd1_idx, int hd2_idx, Tcalc frac_heavy, Tcalc frac_light,
                         Tcalc ra, Tcalc rb, Tcalc rc, const Tcoord* xcrd, const Tcoord* ycrd,
                         const Tcoord* zcrd, Tcoord* xalt, Tcoord* yalt, Tcoord* zalt,
                         Tcoord* vxalt, Tcoord* vyalt, Tcoord* vzalt, Tcalc dt,
                         const int* xcrd_ovrf = nullptr, const int* ycrd_ovrf = nullptr,
                         const int* zcrd_ovrf = nullptr, int* xalt_ovrf = nullptr,
                         int* yalt_ovrf = nullptr, int* zalt_ovrf = nullptr,
                         int* vxalt_ovrf = nullptr, int* vyalt_ovrf = nullptr,
                         int* vzalt_ovrf = nullptr, Tcalc gpos_scale = 1.0, Tcalc vel_scale = 1.0);
  
template <typename Tcoord, typename Tcalc, typename Tcalc3>
void settlePositions(const Tcoord* xcrd, const Tcoord* ycrd, const Tcoord* zcrd, Tcoord* xalt,
                     Tcoord* yalt, Tcoord* zalt, Tcoord* vxalt, Tcoord* vyalt, Tcoord* vzalt,
                     const ConstraintKit<Tcalc> &cnst, Tcalc dt, const int* xcrd_ovrf = nullptr,
                     const int* ycrd_ovrf = nullptr, const int* zcrd_ovrf = nullptr,
                     int* xalt_ovrf = nullptr, int* yalt_ovrf = nullptr, int* zalt_ovrf = nullptr,
                     int* vxalt_ovrf = nullptr, int* vyalt_ovrf = nullptr,
                     int* vzalt_ovrf = nullptr, Tcalc gpos_scale = 1.0, Tcalc vel_scale = 1.0);
 
template <typename Tcalc, typename Tcalc3>
void settlePositions(PhaseSpaceWriter *psw, const ConstraintKit<Tcalc> &cnst, Tcalc dt);
 
void settlePositions(PhaseSpace *ps, const AtomGraph *ag, double dt,
                     PrecisionModel prec = PrecisionModel::DOUBLE);
 
void settlePositions(PhaseSpace *ps, const AtomGraph &ag, double dt,
                     PrecisionModel prec = PrecisionModel::DOUBLE);
 
template <typename Tcalc, typename Tcalc2, typename Tcalc3, typename Tcalc4>
void settlePositions(PsSynthesisWriter *poly_psw, const SyValenceKit<Tcalc> &poly_vk,
                     const SyAtomUpdateKit<Tcalc, Tcalc2, Tcalc4> &poly_auk, Tcalc dt);
 
void settlePositions(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis *poly_ag, double dt,
                     const PrecisionModel prec = PrecisionModel::SINGLE);
 
void settlePositions(PhaseSpaceSynthesis *poly_ps, const AtomGraphSynthesis &poly_ag, double dt,
                     const PrecisionModel prec = PrecisionModel::SINGLE);

template <typename T>
void idealizeSettleReference(PhaseSpaceWriter *psw, const ConstraintKit<T> &cnst);
 
void idealizeSettleReference(PhaseSpace *ps, const AtomGraph *ag,
                             PrecisionModel prec = PrecisionModel::DOUBLE);
 
void idealizeSettleReference(PhaseSpace *ps, const AtomGraph &ag,
                             PrecisionModel prec = PrecisionModel::DOUBLE);
 
} // namespace structure
} // namespace stormm
 
#include "settle.tpp"
 
#endif