colvarcomp.h

// -*- c++ -*-
 
// This file is part of the Collective Variables module (Colvars).
// The original version of Colvars and its updates are located at:
// https://github.com/Colvars/colvars
// Please update all Colvars source files before making any changes.
// If you wish to distribute your changes, please submit them to the
// Colvars repository at GitHub.
 
#ifndef COLVARCOMP_H
#define COLVARCOMP_H
 
// Declaration of colvar::cvc base class and derived ones.
//
// Future cvc's could be declared on additional header files.
// After the declaration of a new derived class, its metric
// functions must be reimplemented as well.
// If the new cvc has no symmetry or periodicity,
// this can be done straightforwardly by using the macro:
// simple_scalar_dist_functions (derived_class)
 
#include <memory>
 
#include "colvarmodule.h"
#include "colvaratoms.h"
#include "colvar.h"
#include "colvar_geometricpath.h"
#include "colvaratoms.h"
#include "colvarproxy.h"
#include "colvar_gpu_calc.h"
 
 
class colvar::cvc
  : public colvardeps
{
public:
 
  std::string name;
 
  std::string function_type() const;
 
  std::string config_key;
 
  cvm::real sup_coeff = 1.0;
 
  int       sup_np = 1;
 
  cvm::real period = 0.0;
 
  cvm::real wrap_center = 0.0;
 
  cvc();
 
  cvc(colvarmodule *cvmodule_in);
 
  virtual ~cvc();
 
  virtual int init(std::string const &conf);
 
  int init_dependencies() override;
 
  int setup();
 
  virtual const std::vector<feature *> &features() const override
  {
    return cvc_features;
  }
 
  virtual std::vector<feature *> &modify_features() override
  {
    return cvc_features;
  }
 
  static void delete_features() {
    for (size_t i=0; i < cvc_features.size(); i++) {
      delete cvc_features[i];
    }
    cvc_features.clear();
  }
 
  virtual std::vector<std::vector<int> > get_atom_lists();
 
  virtual void read_data();
 
  virtual void calc_value() = 0;
 
  virtual void calc_gradients() {}
 
  void calc_fit_gradients();
 
  virtual void debug_gradients();
 
  virtual void collect_gradients(std::vector<int> const &atom_ids, std::vector<cvm::rvector> &atomic_gradients);
 
  virtual void calc_force_invgrads();
 
  virtual void calc_Jacobian_derivative();
 
  // TODO: Maybe this should be a feature in colvarsdep but I am still constantly confused by colvarsdep
  virtual bool has_gpu_implementation() const { return false; }
 
#if defined (COLVARS_CUDA) || defined (COLVARS_HIP)
  virtual int add_calc_value_node(
    cudaGraph_t& graph,
    std::unordered_map<std::string, cudaGraphNode_t>& nodes_map)
  { return COLVARS_NOT_IMPLEMENTED; }
 
  virtual int calc_value_after_gpu() { return COLVARS_OK; }
 
  virtual int add_calc_gradients_node(
    cudaGraph_t& graph,
    std::unordered_map<std::string, cudaGraphNode_t>& nodes_map)
  { return COLVARS_NOT_IMPLEMENTED; }
 
  virtual int add_calc_force_invgrads_node(
    cudaGraph_t& graph,
    std::unordered_map<std::string, cudaGraphNode_t>& nodes_map)
  { return COLVARS_NOT_IMPLEMENTED; }
 
  virtual int calc_force_invgrads_after_gpu() { return COLVARS_OK; }
 
  virtual int add_calc_Jacobian_derivative_node(
    cudaGraph_t& graph,
    std::unordered_map<std::string, cudaGraphNode_t>& nodes_map)
  { return COLVARS_NOT_IMPLEMENTED; }
 
  virtual int calc_Jacobian_derivative_after_gpu() { return COLVARS_OK; }
 
  virtual int debug_gradients_gpu(
    colvars_gpu::colvarmodule_gpu_calc::compute_gpu_graph_t& calc_value_graph,
    colvars_gpu::colvarmodule_gpu_calc::compute_gpu_graph_t& calc_gradients_graph);
#endif // defined (COLVARS_CUDA) || defined (COLVARS_HIP)
 
  colvarvalue const & value() const;
 
  colvarvalue const & total_force() const;
 
  colvarvalue const & Jacobian_derivative() const;
 
  virtual void apply_force(colvarvalue const &cvforce);
 
  virtual cvm::real dist2(colvarvalue const &x1,
                          colvarvalue const &x2) const;
 
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1,
                                  colvarvalue const &x2) const;
 
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1,
                                  colvarvalue const &x2) const;
 
  virtual void wrap(colvarvalue &x_unwrapped) const;
 
  std::vector<cvm::atom_group *> atom_groups;
 
  void register_atom_group(cvm::atom_group *ag);
 
  virtual colvarvalue const *get_param_grad(std::string const &param_name);
 
  virtual int set_param(std::string const &param_name, void const *new_value) override;
 
  bool b_try_scalable = true;
 
  inline void set_value(colvarvalue const &new_value, bool now=false) {
    x = new_value;
    // Cache value to be communicated to back-end between time steps
    cvmodule->proxy->set_alch_lambda(x.real_value);
    if (now) {
      // If requested (e.g. upon restarting), sync to back-end
      cvmodule->proxy->send_alch_lambda();
    }
  }
 
protected:
 
  int set_function_type(std::string const &type);
 
  int update_description();
 
  cvm::atom_group *parse_group(std::string const &conf, char const *group_key,
                               bool optional = false);
 
  virtual int init_total_force_params(std::string const &conf);
 
  static std::vector<feature *> cvc_features;
 
  std::vector<std::string> function_types;
 
  colvarvalue x;
 
  colvarvalue x_old;
 
  colvarvalue ft;
 
  colvarvalue jd;
 
  void init_as_distance();
 
  void init_as_angle();
 
  void init_as_periodic_angle();
 
  void init_scalar_boundaries(cvm::real lb, cvm::real ub);
 
  colvarvalue lower_boundary;
 
  colvarvalue upper_boundary;
 
  cvm::real width = 0.0;
};
 
 
inline colvarvalue const & colvar::cvc::value() const
{
  return x;
}
 
 
inline colvarvalue const & colvar::cvc::total_force() const
{
  return ft;
}
 
 
inline colvarvalue const & colvar::cvc::Jacobian_derivative() const
{
  return jd;
}
 
 
 
 
class colvar::distance
  : public colvar::cvc
{
protected:
  cvm::atom_group  *group1 = nullptr;
  cvm::atom_group  *group2 = nullptr;
  cvm::rvector     dist_v;
public:
  distance();
  virtual ~distance() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void calc_force_invgrads();
  virtual void calc_Jacobian_derivative();
};
 
 
 
// \brief Colvar component: distance vector between centers of mass
// of two groups (\link colvarvalue::type_3vector \endlink type,
// range (-*:*)x(-*:*)x(-*:*))
class colvar::distance_vec
  : public colvar::distance
{
public:
  distance_vec();
  virtual ~distance_vec() {}
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
class colvar::distance_dir
  : public colvar::distance
{
public:
  distance_dir();
  virtual ~distance_dir() {}
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
 
class colvar::distance_z
  : public colvar::cvc
{
protected:
  cvm::atom_group  *main = nullptr;
  cvm::atom_group  *ref1 = nullptr;
  cvm::atom_group  *ref2 = nullptr;
  cvm::rvector axis;
  cvm::real axis_norm;
  cvm::rvector     dist_v;
  bool fixed_axis = true;
public:
  distance_z();
  virtual ~distance_z() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void calc_force_invgrads();
  virtual void calc_Jacobian_derivative();
};
 
 
 
class colvar::distance_xy
  : public colvar::distance_z
{
protected:
  cvm::rvector dist_v_ortho;
  cvm::rvector v12, v13;
public:
  distance_xy();
  virtual ~distance_xy() {}
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void calc_force_invgrads();
  virtual void calc_Jacobian_derivative();
};
 
 
class colvar::polar_phi
  : public colvar::cvc
{
protected:
  cvm::atom_group *atoms = nullptr;
  cvm::real r, theta, phi;
 
public:
  polar_phi();
  virtual ~polar_phi() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
class colvar::polar_theta
  : public colvar::cvc
{
public:
  polar_theta();
  virtual ~polar_theta() {}
  virtual int init(std::string const &conf);
protected:
  cvm::atom_group *atoms = nullptr;
  cvm::real r, theta, phi;
public:
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
class colvar::distance_inv
  : public colvar::cvc
{
protected:
  cvm::atom_group  *group1 = nullptr;
  cvm::atom_group  *group2 = nullptr;
  int exponent = 6;
public:
  distance_inv();
  virtual ~distance_inv() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
 
class colvar::distance_pairs
  : public colvar::cvc
{
protected:
  cvm::atom_group  *group1 = nullptr;
  cvm::atom_group  *group2 = nullptr;
public:
  distance_pairs();
  virtual ~distance_pairs() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
class colvar::dipole_magnitude
  : public colvar::cvc
{
protected:
  cvm::atom_group *atoms = nullptr;
  cvm::atom_pos dipoleV;
public:
  dipole_magnitude();
  virtual ~dipole_magnitude() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
 
class colvar::gyration
  : public colvar::cvc
{
protected:
  cvm::atom_group *atoms = nullptr;
public:
  gyration();
  virtual ~gyration() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void calc_force_invgrads();
  virtual void calc_Jacobian_derivative();
};
 
 
 
class colvar::inertia
  : public colvar::gyration
{
public:
  inertia();
  virtual ~inertia() {}
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
 
class colvar::inertia_z
  : public colvar::inertia
{
protected:
  cvm::rvector axis;
public:
  inertia_z();
  virtual ~inertia_z() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
 
class colvar::eigenvector
  : public colvar::cvc
{
protected:
 
  cvm::atom_group *atoms = nullptr;
 
  std::vector<cvm::atom_pos>  ref_pos;
 
  std::vector<cvm::rvector>   eigenvec;
 
  cvm::real                   eigenvec_invnorm2;
 
public:
 
  eigenvector();
  virtual ~eigenvector() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void calc_force_invgrads();
  virtual void calc_Jacobian_derivative();
};
 
 
 
class colvar::angle
  : public colvar::cvc
{
protected:
  cvm::atom_group  *group1 = nullptr;
  cvm::atom_group  *group2 = nullptr;
  cvm::atom_group  *group3 = nullptr;
  cvm::rvector r21, r23;
  cvm::real r21l, r23l;
  cvm::rvector dxdr1, dxdr3;
 
  bool b_1site_force = false;
public:
 
  angle();
  angle(cvm::atom_group::simple_atom const &a1,
        cvm::atom_group::simple_atom const &a2,
        cvm::atom_group::simple_atom const &a3);
  virtual ~angle() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void calc_force_invgrads();
  virtual void calc_Jacobian_derivative();
};
 
 
 
class colvar::dipole_angle
  : public colvar::cvc
{
protected:
 
  cvm::atom_group  *group1 = nullptr;
  cvm::atom_group  *group2 = nullptr;
  cvm::atom_group  *group3 = nullptr;
  cvm::rvector r21, r23;
  cvm::real r21l, r23l;
  cvm::rvector dxdr1, dxdr3;
 
  bool b_1site_force = false;
public:
 
  dipole_angle();
  virtual ~dipole_angle() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
 
class colvar::dihedral
  : public colvar::cvc
{
protected:
 
  cvm::atom_group  *group1 = nullptr;
  cvm::atom_group  *group2 = nullptr;
  cvm::atom_group  *group3 = nullptr;
  cvm::atom_group  *group4 = nullptr;
  cvm::rvector r12, r23, r34;
 
  bool b_1site_force = false;
 
public:
 
  dihedral(cvm::atom_group::simple_atom const &a1,
           cvm::atom_group::simple_atom const &a2,
           cvm::atom_group::simple_atom const &a3,
           cvm::atom_group::simple_atom const &a4);
  dihedral();
  virtual ~dihedral() {}
  virtual int init(std::string  const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void calc_force_invgrads();
  virtual void calc_Jacobian_derivative();
};
 
 
 
class colvar::coordnum
  : public colvar::cvc
{
protected:
  cvm::atom_group  *group1 = nullptr;
  cvm::atom_group  *group2 = nullptr;
  cvm::real     r0;
  cvm::rvector  r0_vec;
  bool b_anisotropic = false;
  int en = 6;
  int ed = 12;
 
  bool b_group2_center_only = false;
 
  cvm::real tolerance = 0.0;
 
  int pairlist_freq = 100;
 
  bool *pairlist = nullptr;
 
public:
 
  coordnum();
  virtual ~coordnum();
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
 
  enum {
    ef_null = 0,
    ef_gradients = 1,
    ef_anisotropic = (1<<8),
    ef_use_pairlist = (1<<9),
    ef_rebuild_pairlist = (1<<10)
  };
 
  template<int flags>
  static cvm::real switching_function(cvm::real const &r0,
                                      cvm::rvector const &inv_r0_vec,
                                      cvm::rvector const &inv_r0sq_vec,
                                      int en,
                                      int ed,
                                      const cvm::real a1x,
                                      const cvm::real a1y,
                                      const cvm::real a1z,
                                      const cvm::real a2x,
                                      const cvm::real a2y,
                                      const cvm::real a2z,
                                      cvm::real& g1x,
                                      cvm::real& g1y,
                                      cvm::real& g1z,
                                      cvm::real& g2x,
                                      cvm::real& g2y,
                                      cvm::real& g2z,
                                      bool **pairlist_elem,
                                      cvm::real tolerance,
                                      colvarmodule *cvmodule_in);
 
  template<int flags> int compute_coordnum();
 
  template<int flags> void main_loop(bool **pairlist_elem);
 
};
 
 
 
class colvar::selfcoordnum
  : public colvar::cvc
{
protected:
  cvm::atom_group  *group1 = nullptr;
  cvm::real     r0;
  int en = 6;
  int ed = 12;
  cvm::real tolerance = 0.0;
  int pairlist_freq = 100;
 
  bool *pairlist = nullptr;
 
public:
 
  selfcoordnum();
  ~selfcoordnum();
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
 
  template<int flags> int compute_selfcoordnum();
};
 
 
 
class colvar::groupcoordnum
  : public colvar::distance
{
protected:
  cvm::real     r0;
  cvm::rvector  r0_vec;
  bool b_anisotropic = false;
  int en = 6;
  int ed = 12;
public:
  groupcoordnum();
  virtual ~groupcoordnum() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
 
class colvar::h_bond
  : public colvar::cvc
{
protected:
  cvm::real     r0;
  int en = 6;
  int ed = 8;
public:
  h_bond(cvm::atom_group::simple_atom const &acceptor,
         cvm::atom_group::simple_atom const &donor,
         cvm::real r0, int en, int ed);
  h_bond();
  virtual ~h_bond() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
class colvar::alpha_angles
  : public colvar::cvc
{
protected:
 
  cvm::real theta_ref = 88.0;
 
  cvm::real theta_tol = 15.0;
 
  std::vector<angle *> theta;
 
  std::vector<h_bond *>   hb;
 
  cvm::real hb_coeff = 0.5;
 
  cvm::real r0;
 
  int en = 6;
 
  int ed = 8;
 
public:
 
  alpha_angles();
  virtual ~alpha_angles();
  virtual int init(std::string const &conf);
  void calc_value();
  void calc_gradients();
  void collect_gradients(std::vector<int> const &atom_ids, std::vector<cvm::rvector> &atomic_gradients);
  void apply_force(colvarvalue const &force);
};
 
 
 
class colvar::dihedPC
  : public colvar::cvc
{
protected:
 
  std::vector<dihedral *> theta;
  std::vector<cvm::real> coeffs;
 
public:
 
  dihedPC();
  virtual ~dihedPC();
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void collect_gradients(std::vector<int> const &atom_ids, std::vector<cvm::rvector> &atomic_gradients);
  virtual void apply_force(colvarvalue const &force);
};
 
 
 
class colvar::orientation
  : public colvar::cvc
{
protected:
  cvm::atom_group  *          atoms = nullptr;
  cvm::atom_pos              atoms_cog;
 
  cvm::ag_vector_real_t ref_pos_soa;
  size_t num_ref_pos;
 
  cvm::ag_vector_real_t shifted_pos_soa;
  size_t num_shifted_pos;
 
  cvm::rotation              rot;
 
  cvm::quaternion            ref_quat;
 
  struct rotation_derivative_impl_;
  std::unique_ptr<rotation_derivative_impl_> rot_deriv_impl;
 
public:
 
  orientation();
  virtual ~orientation();
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
class colvar::orientation_angle
  : public colvar::orientation
{
public:
 
  orientation_angle();
  virtual ~orientation_angle() {}
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
 
class colvar::orientation_proj
  : public colvar::orientation_angle
{
public:
 
  orientation_proj();
  virtual ~orientation_proj() {}
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
 
class colvar::tilt
  : public colvar::orientation_proj
{
protected:
 
  cvm::rvector axis;
 
public:
 
  tilt();
  virtual ~tilt() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
 
class colvar::spin_angle
  : public colvar::tilt
{
public:
 
  spin_angle();
  virtual ~spin_angle() {}
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
class colvar::euler_phi
  : public colvar::orientation_angle
{
public:
  euler_phi();
  virtual ~euler_phi() {}
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
class colvar::euler_psi
  : public colvar::orientation_angle
{
public:
  euler_psi();
  virtual ~euler_psi() {}
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
class colvar::euler_theta
  : public colvar::orientation_angle
{
public:
  euler_theta();
  virtual ~euler_theta() {}
  virtual void calc_value();
  virtual void calc_gradients();
};
 
 
class colvar::rmsd
  : public colvar::cvc
{
protected:
 
  // TODO: transfrom ref_pos to soa
  cvm::atom_group  *          atoms = nullptr;
 
  size_t num_ref_pos = 0;
  cvm::ag_vector_real_t  ref_pos_soa;
 
#if defined (COLVARS_CUDA) || defined (COLVARS_HIP)
  cvm::real* d_ref_pos_soa;
  cvm::real* d_permutation_msds;
  unsigned int* d_tbcounts;
  cvm::real* h_rmsd;
  size_t* h_best_perm_index;
  cvm::real* d_ft;
  cvm::real* h_ft;
  cvm::real* d_jd;
  cvm::real* h_jd;
  unsigned int* d_tbcount_ft;
  unsigned int* d_tbcount_jd;
#endif // defined (COLVARS_CUDA) || defined (COLVARS_HIP)
 
  size_t n_permutations = 1;
  cvm::ag_vector_real_t permutation_msds;
 
  size_t best_perm_index = 0;
 
  int init_permutation(std::vector<cvm::atom_pos>& ref_pos, std::string const &conf);
 
public:
  rmsd();
  bool has_gpu_implementation() const override;
#if defined (COLVARS_CUDA) || defined (COLVARS_HIP)
  int add_calc_value_node(
    cudaGraph_t& graph,
    std::unordered_map<std::string, cudaGraphNode_t>& nodes_map) override;
  int calc_value_after_gpu() override;
  int add_calc_gradients_node(
    cudaGraph_t& graph,
    std::unordered_map<std::string, cudaGraphNode_t>& nodes_map) override;
  int add_calc_force_invgrads_node(
    cudaGraph_t& graph,
    std::unordered_map<std::string, cudaGraphNode_t>& nodes_map) override;
  int calc_force_invgrads_after_gpu() override;
  int add_calc_Jacobian_derivative_node(
    cudaGraph_t& graph,
    std::unordered_map<std::string, cudaGraphNode_t>& nodes_map) override;
  int calc_Jacobian_derivative_after_gpu() override;
#endif // defined (COLVARS_CUDA) || defined (COLVARS_HIP)
  virtual ~rmsd();
  virtual int init(std::string const &conf) override;
  virtual void calc_value() override;
  virtual void calc_gradients() override;
  virtual void calc_force_invgrads() override;
  virtual void calc_Jacobian_derivative() override;
};
 
 
 
// \brief Colvar component: flat vector of Cartesian coordinates
// Mostly useful to compute scripted colvar values
class colvar::cartesian
  : public colvar::cvc
{
protected:
  cvm::atom_group  *          atoms = nullptr;
  std::vector<size_t> axes;
public:
  cartesian();
  virtual ~cartesian() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1,
                          colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1,
                                  colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1,
                                  colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
// \brief Colvar component: alch_lambda
// To communicate value with back-end in lambda-dynamics
class colvar::alch_lambda
  : public colvar::cvc
{
protected:
  // No atom groups needed
public:
  alch_lambda();
  int init_alchemy(int time_step_factor);
  virtual ~alch_lambda() {}
  virtual void calc_value();
  virtual void calc_force_invgrads();
  virtual void calc_Jacobian_derivative();
  virtual void apply_force(colvarvalue const &force);
};
 
 
// \brief Colvar component: alch_Flambda
// To communicate force on lambda with back-end in lambda-dynamics
class colvar::alch_Flambda
  : public colvar::cvc
{
protected:
  // No atom groups needed
public:
  alch_Flambda();
  virtual ~alch_Flambda() {}
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void apply_force(colvarvalue const &force);
};
 
 
class colvar::CartesianBasedPath
  : public colvar::cvc
{
protected:
    virtual void computeDistanceBetweenReferenceFrames(std::vector<cvm::real>& result);
    virtual void computeDistanceToReferenceFrames(std::vector<cvm::real>& result);
    cvm::atom_group *atoms = nullptr;
    bool has_user_defined_fitting = false;
    std::vector<std::vector<cvm::atom_pos>> reference_frames;
    std::vector<std::vector<cvm::atom_pos>> reference_fitting_frames;
    std::vector<cvm::atom_group*> comp_atoms;
    size_t total_reference_frames = 0;
public:
    CartesianBasedPath();
    virtual ~CartesianBasedPath();
    virtual int init(std::string const &conf);
    virtual void calc_value() = 0;
    virtual void apply_force(colvarvalue const &force);
};
 
class colvar::gspath
  : public colvar::CartesianBasedPath, public GeometricPathCV::GeometricPathBase<cvm::atom_pos, cvm::real, GeometricPathCV::path_sz::S>
{
private:
    // Optimal rotation for compute v3
    cvm::rotation rot_v3;
protected:
    virtual void prepareVectors();
    virtual void updateDistanceToReferenceFrames();
public:
    gspath();
    virtual ~gspath() {}
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
 
 
class colvar::gzpath
  : public colvar::CartesianBasedPath, public GeometricPathCV::GeometricPathBase<cvm::atom_pos, cvm::real, GeometricPathCV::path_sz::Z>
{
private:
    // Optimal rotation for compute v3, v4
    cvm::rotation rot_v3;
    cvm::rotation rot_v4;
protected:
    virtual void prepareVectors();
    virtual void updateDistanceToReferenceFrames();
public:
    gzpath();
    virtual ~gzpath() {}
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
class colvar::linearCombination
  : public colvar::cvc
{
protected:
    std::vector<colvar::cvc*> cv;
    bool use_explicit_gradients;
protected:
    cvm::real getPolynomialFactorOfCVGradient(size_t i_cv) const;
public:
    linearCombination();
    virtual ~linearCombination();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1,
                          colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1,
                                  colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1,
                                  colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
class colvar::customColvar
  : public colvar::linearCombination
{
protected:
    bool use_custom_function = false;
#ifdef LEPTON
    std::vector<Lepton::CompiledExpression *> value_evaluators;
    std::vector<Lepton::CompiledExpression *> gradient_evaluators;
    std::vector<double *> value_eval_var_refs;
    std::vector<double *> grad_eval_var_refs;
    double dev_null = 0.0;
#endif
public:
    customColvar();
    virtual ~customColvar();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
 
class colvar::CVBasedPath
  : public colvar::cvc
{
protected:
    std::vector<colvar::cvc*> cv;
    std::vector<std::vector<colvarvalue>> ref_cv;
    bool use_explicit_gradients;
    size_t total_reference_frames = 0;
protected:
    virtual void computeDistanceToReferenceFrames(std::vector<cvm::real>& result);
    virtual void computeDistanceBetweenReferenceFrames(std::vector<cvm::real>& result) const;
    cvm::real getPolynomialFactorOfCVGradient(size_t i_cv) const;
public:
    CVBasedPath();
    virtual ~CVBasedPath();
    virtual int init(std::string const &conf);
    virtual void calc_value() = 0;
    virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1, colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
class colvar::gspathCV
  : public colvar::CVBasedPath, public GeometricPathCV::GeometricPathBase<colvarvalue, cvm::real, GeometricPathCV::path_sz::S>
{
protected:
    virtual void updateDistanceToReferenceFrames();
    virtual void prepareVectors();
public:
    gspathCV();
    virtual ~gspathCV();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
 
 
class colvar::gzpathCV
  : public colvar::CVBasedPath, public GeometricPathCV::GeometricPathBase<colvarvalue, cvm::real, GeometricPathCV::path_sz::Z>
{
protected:
    virtual void updateDistanceToReferenceFrames();
    virtual void prepareVectors();
public:
    gzpathCV();
    virtual ~gzpathCV();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
struct ArithmeticPathImpl;
 
class colvar::aspath
  : public colvar::CartesianBasedPath
{
private:
    std::unique_ptr<ArithmeticPathImpl> impl_;
    friend struct ArithmeticPathImpl;
public:
    aspath();
    virtual ~aspath();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
class colvar::azpath
  : public colvar::CartesianBasedPath
{
private:
    std::unique_ptr<ArithmeticPathImpl> impl_;
    friend struct ArithmeticPathImpl;
public:
    azpath();
    virtual ~azpath();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
class colvar::aspathCV
  : public colvar::CVBasedPath
{
private:
    std::unique_ptr<ArithmeticPathImpl> impl_;
    friend struct ArithmeticPathImpl;
public:
    aspathCV();
    virtual ~aspathCV();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
 
class colvar::azpathCV
  : public colvar::CVBasedPath
{
private:
    std::unique_ptr<ArithmeticPathImpl> impl_;
    friend struct ArithmeticPathImpl;
public:
    azpathCV();
    virtual ~azpathCV();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
};
 
// forward declaration
namespace neuralnetworkCV {
    class neuralNetworkCompute;
}
 
 
class colvar::neuralNetwork
  : public linearCombination
{
protected:
    std::unique_ptr<neuralnetworkCV::neuralNetworkCompute> nn;
    size_t m_output_index = 0;
public:
    neuralNetwork();
    virtual ~neuralNetwork();
    virtual int init(std::string const &conf);
    virtual void calc_value();
    virtual void calc_gradients();
    virtual void apply_force(colvarvalue const &force);
  virtual cvm::real dist2(colvarvalue const &x1,
                          colvarvalue const &x2) const;
  virtual colvarvalue dist2_lgrad(colvarvalue const &x1,
                                  colvarvalue const &x2) const;
  virtual colvarvalue dist2_rgrad(colvarvalue const &x1,
                                  colvarvalue const &x2) const;
  virtual void wrap(colvarvalue &x_unwrapped) const;
};
 
 
// \brief Colvar component: total value of a scalar map
// (usually implemented as a grid by the simulation engine)
class colvar::map_total
  : public colvar::cvc
{
public:
 
  map_total();
  virtual ~map_total() {}
  virtual int init(std::string const &conf);
  virtual void calc_value();
  virtual void calc_gradients();
  virtual void apply_force(colvarvalue const &force);
 
protected:
 
  std::string volmap_name;
 
  int volmap_id = -1;
 
  int volmap_index = -1;
 
  cvm::atom_group *atoms = nullptr;
 
  std::vector<cvm::real> atom_weights;
};
 
 
 
#endif