minimization.h

// -*-c++-*-
#ifndef STORMM_MINIMIZATION_H
#define STORMM_MINIMIZATION_H
 
#include <cmath>
#include "copyright.h"
#include "Constants/fixed_precision.h"
#include "Constants/generalized_born.h"
#include "DataTypes/common_types.h"
#include "Math/matrix_ops.h"
#include "Namelists/nml_minimize.h"
#include "Potential/energy_enumerators.h"
#include "Potential/scorecard.h"
#include "Potential/static_exclusionmask.h"
#include "Restraints/restraint_apparatus.h"
#include "Structure/virtual_site_handling.h"
#include "Topology/atomgraph.h"
#include "Topology/atomgraph_abstracts.h"
#include "Topology/atomgraph_enumerators.h"
#include "Trajectory/coordinateframe.h"
#include "Trajectory/phasespace.h"
#include "mm_evaluation.h"
 
namespace stormm {
namespace mm {
 
using data_types::isSignedIntegralScalarType;
using energy::EvaluateForce;
using energy::ScoreCard;
using energy::StateVariable;
using energy::StaticExclusionMask;
using energy::StaticExclusionMaskReader;
using stmath::invertSquareMatrix;
using stmath::matrixVectorMultiply;
using namelist::MinimizeControls;
using numerics::default_energy_scale_bits;
using restraints::RestraintApparatus;
using restraints::RestraintKit;
using structure::placeVirtualSites;
using structure::transmitVirtualSiteForces;
using topology::AtomGraph;
using topology::ImplicitSolventKit;
using topology::ImplicitSolventModel;
using topology::NonbondedKit;
using topology::UnitCellType;
using topology::ValenceKit;
using topology::VirtualSiteKit;
using trajectory::CoordinateFrame;
using trajectory::CoordinateFrameReader;
using trajectory::PhaseSpace;
using trajectory::PhaseSpaceWriter;
using namespace generalized_born_defaults;

template <typename Tforce, typename Tcalc>
void computeGradientMove(Tforce* xfrc, Tforce* yfrc, Tforce* zfrc, Tforce* xprv_move,
                         Tforce* yprv_move, Tforce* zprv_move, Tcalc* x_cg_temp,
                         Tcalc* y_cg_temp, Tcalc* z_cg_temp, int natom, int step, int sd_steps,
                         Tcalc force_factor = 1.0);

template <typename Tcoord, typename Tforce, typename Tcalc>
void moveParticles(Tcoord* xcrd, Tcoord* ycrd, Tcoord* zcrd, const Tforce* xmove,
                   const Tforce* ymove, const Tforce* zmove, const double* umat,
                   const double* invu, UnitCellType unit_cell, const VirtualSiteKit<Tcalc> &vsk,
                   int natom, Tcalc dist, Tcalc gpos_factor = 1.0, Tcalc force_factor = 1.0);

template <typename Tcoord, typename Tforce, typename Tcalc, typename Tcalc2, typename Tcalc4>
ScoreCard minimize(Tcoord* xcrd, Tcoord* ycrd, Tcoord* zcrd, Tforce* xfrc, Tforce* yfrc,
                   Tforce* zfrc, Tforce* xprv_move, Tforce* yprv_move, Tforce* zprv_move,
                   Tcalc* x_cg_temp, Tcalc* y_cg_temp, Tcalc* z_cg_temp,
                   const ValenceKit<Tcalc> &vk, const NonbondedKit<Tcalc> &nbk,
                   const ImplicitSolventKit<Tcalc> &isk, const NeckGeneralizedBornKit<Tcalc> &ngbk,
                   const RestraintKit<Tcalc, Tcalc2, Tcalc4> &rar,
                   const VirtualSiteKit<Tcalc> &vsk, const StaticExclusionMaskReader &ser,
                   const MinimizeControls &mincon, int nrg_scale_bits = default_energy_scale_bits,
                   Tcalc gpos_factor = 1.0, Tcalc force_factor = 1.0);
 
ScoreCard minimize(PhaseSpace *ps, const AtomGraph &ag, const RestraintApparatus &ra,
                   const StaticExclusionMask &se, const MinimizeControls &mincon,
                   int nrg_scale_bits = default_energy_scale_bits);
  
ScoreCard minimize(PhaseSpace *ps, const AtomGraph &ag, const NeckGeneralizedBornTable &ngb_tab,
                   const RestraintApparatus &ra, const StaticExclusionMask &se,
                   const MinimizeControls &mincon, int nrg_scale_bits = default_energy_scale_bits);
 
ScoreCard minimize(PhaseSpace *ps, const AtomGraph *ag, const StaticExclusionMask &se,
                   const MinimizeControls &mincon, int nrg_scale_bits = default_energy_scale_bits);
 
ScoreCard minimize(PhaseSpace *ps, const AtomGraph *ag, const NeckGeneralizedBornTable &ngb_tab,
                   const StaticExclusionMask &se, const MinimizeControls &mincon,
                   int nrg_scale_bits = default_energy_scale_bits);
 
ScoreCard minimize(PhaseSpaceWriter psw, const ValenceKit<double> &vk,
                   const NonbondedKit<double> &nbk, const ImplicitSolventKit<double> &isk,
                   const NeckGeneralizedBornKit<double> &ngbk,
                   const RestraintKit<double, double2, double4> &rar,
                   const VirtualSiteKit<double> &vsk, const StaticExclusionMaskReader &ser,
                   const MinimizeControls &mincon, int nrg_scale_bits = default_energy_scale_bits);
  
} // namespace mm
} // namespace stormm
 
#include "minimization.tpp"
 
#endif