colvarbias_restraint.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 COLVARBIAS_RESTRAINT_H
#define COLVARBIAS_RESTRAINT_H
 
#include "colvarbias.h"
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4250) // Silence diamond inheritance warning
#endif
 
class colvarbias_restraint
  : public virtual colvarbias,
    public virtual colvarbias_ti
{
 
public:
 
  virtual int update();
 
  virtual int change_configuration(std::string const & /* conf */) { return COLVARS_NOT_IMPLEMENTED; }
 
  virtual cvm::real energy_difference(std::string const & /* conf */) { return 0.0; }
 
  virtual std::string const get_state_params() const;
  virtual int set_state_params(std::string const &conf);
  virtual std::ostream & write_traj_label(std::ostream &os);
  virtual std::ostream & write_traj(std::ostream &os);
 
  colvarbias_restraint(char const *key);
 
  virtual int init(std::string const &conf);
  virtual ~colvarbias_restraint();
 
 
protected:
 
  virtual cvm::real restraint_potential(size_t i) const = 0;
 
  virtual colvarvalue const restraint_force(size_t i) const = 0;
 
  virtual cvm::real d_restraint_potential_dk(size_t i) const = 0;
};
 
 
class colvarbias_restraint_centers
  : public virtual colvarbias_restraint
{
public:
 
  colvarbias_restraint_centers(char const *key);
  virtual int init(std::string const &conf);
  virtual int change_configuration(std::string const &conf);
 
protected:
 
  std::vector<colvarvalue> colvar_centers;
};
 
 
class colvarbias_restraint_k
  : public virtual colvarbias_restraint
{
public:
 
  colvarbias_restraint_k(char const *key);
  virtual int init(std::string const &conf);
  virtual int change_configuration(std::string const &conf);
 
protected:
 
  cvm::real force_k;
 
  bool check_positive_k;
};
 
 
class colvarbias_restraint_moving
  : public virtual colvarbias_restraint,
    public virtual colvardeps {
public:
 
  colvarbias_restraint_moving(char const *key)
    : colvarbias_ti(key),
      colvarbias_restraint(key) {}
  // Note: despite the diamond inheritance, most of this function gets only executed once
  virtual int init(std::string const &conf) override;
  virtual int update() override;
  virtual int change_configuration(std::string const & /* conf */) override { return COLVARS_NOT_IMPLEMENTED; }
 
  virtual std::string const get_state_params() const override;
  virtual int set_state_params(std::string const &conf) override;
 
protected:
 
  bool b_chg_centers = false;
 
  bool b_chg_force_k = false;
 
  bool b_chg_walls = false;
 
  virtual void update_k(cvm::real /* lambda */) {}
  virtual void update_centers(cvm::real /* lambda */) {}
  virtual void update_walls(cvm::real /* lambda */) {}
  virtual cvm::real dU_dlambda_k() const { return 0.0; }
  virtual cvm::real dU_dlambda_centers() const { return 0.0; }
  virtual cvm::real dU_dlambda_walls() const { return 0.0; }
 
  bool b_decoupling;
 
  int target_nstages = 0;
 
  int stage = 0;
 
  cvm::real dA_dlambda = 0.0;
 
  inline void update_stage() {
    stage = (cvmodule->step_absolute() - first_step) / target_nsteps;
    if (stage > target_nstages) {
      stage = target_nstages;
    }
  }
 
  cvm::real current_lambda() const;
 
  std::vector<cvm::real> lambda_schedule;
 
  cvm::step_number target_nsteps = 0L;
 
  cvm::step_number target_equil_steps = 0L;
 
  cvm::step_number first_step = 0L;
 
  cvm::real acc_work = 0.0;
};
 
 
class colvarbias_restraint_centers_moving
  : public virtual colvarbias_restraint_centers,
    public virtual colvarbias_restraint_moving
{
public:
 
  colvarbias_restraint_centers_moving(char const *key);
  virtual int init(std::string const &conf) override;
  virtual int change_configuration(std::string const & /* conf */) override { return COLVARS_NOT_IMPLEMENTED; }
 
  virtual std::string const get_state_params() const override;
  virtual int set_state_params(std::string const &conf) override;
  virtual std::ostream & write_traj_label(std::ostream &os) override;
  virtual std::ostream & write_traj(std::ostream &os) override;
 
protected:
 
  std::vector<colvarvalue> target_centers;
 
  std::vector<colvarvalue> initial_centers;
 
  std::vector<colvarvalue> centers_incr;
 
  void update_centers(cvm::real lambda) override;
 
  cvm::real dU_dlambda_centers() const override;
 
  bool b_output_centers;
 
  int update_acc_work();
};
 
 
class colvarbias_restraint_k_moving
  : public virtual colvarbias_restraint_k,
    public virtual colvarbias_restraint_moving
{
public:
  // Do not initialize colvarbias here to avoid diamond inheritance issues
  // because this is an intermediate class
  colvarbias_restraint_k_moving(char const *key);
  virtual int init(std::string const &conf) override;
  virtual int change_configuration(std::string const & /* conf */) override { return COLVARS_NOT_IMPLEMENTED; }
 
  virtual std::string const get_state_params() const override;
  virtual int set_state_params(std::string const &conf) override;
  virtual std::ostream & write_traj_label(std::ostream &os) override;
  virtual std::ostream & write_traj(std::ostream &os) override;
 
protected:
 
  cvm::real target_force_k;
 
  cvm::real starting_force_k;
 
  cvm::real lambda_exp;
 
  cvm::real force_k_incr;
 
  void update_k(cvm::real lambda) override;
 
  cvm::real dU_dlambda_k() const override;
 
  int update_acc_work();
};
 
 
class colvarbias_restraint_harmonic
  : public colvarbias_restraint_centers_moving,
    public colvarbias_restraint_k_moving
{
public:
  colvarbias_restraint_harmonic(colvarmodule *cvmodule_in, char const *key);
  virtual int init(std::string const &conf);
  virtual int update();
  virtual std::string const get_state_params() const;
  virtual int set_state_params(std::string const &conf);
  virtual std::ostream & write_traj_label(std::ostream &os);
  virtual std::ostream & write_traj(std::ostream &os);
  virtual int change_configuration(std::string const &conf);
  virtual cvm::real energy_difference(std::string const &conf);
 
protected:
 
  virtual cvm::real restraint_potential(size_t i) const;
  virtual colvarvalue const restraint_force(size_t i) const;
  virtual cvm::real d_restraint_potential_dk(size_t i) const;
};
 
 
class colvarbias_restraint_harmonic_walls
  : public colvarbias_restraint_k_moving
{
public:
 
  colvarbias_restraint_harmonic_walls(colvarmodule *cvmodule_in, char const *key);
  virtual int init(std::string const &conf) override;
  virtual int update() override;
  virtual int update_acc_work();
  virtual std::string const get_state_params() const override;
  virtual int set_state_params(std::string const &conf) override;
  virtual int change_configuration(std::string const &conf) override;
  virtual std::ostream & write_traj_label(std::ostream &os) override;
  virtual std::ostream & write_traj(std::ostream &os) override;
 
protected:
 
  std::vector<colvarvalue> lower_walls;
 
  std::vector<colvarvalue> upper_walls;
 
  cvm::real lower_wall_k;
 
  cvm::real upper_wall_k;
 
  std::vector<colvarvalue> target_lower_walls;
 
  std::vector<colvarvalue> initial_lower_walls;
 
  std::vector<colvarvalue> lower_walls_incr;
 
  std::vector<colvarvalue> target_upper_walls;
 
  std::vector<colvarvalue> initial_upper_walls;
 
  std::vector<colvarvalue> upper_walls_incr;
 
  cvm::real colvar_distance(size_t i) const;
 
  void update_walls(cvm::real lambda) override;
 
  cvm::real dU_dlambda_walls() const override;
 
  virtual cvm::real restraint_potential(size_t i) const override;
  virtual colvarvalue const restraint_force(size_t i) const override;
  virtual cvm::real d_restraint_potential_dk(size_t i) const override;
};
 
 
class colvarbias_restraint_linear
  : public colvarbias_restraint_centers_moving,
    public colvarbias_restraint_k_moving
{
 
public:
  colvarbias_restraint_linear(colvarmodule *cvmodule_in, char const *key);
  virtual int init(std::string const &conf);
  virtual int update();
  virtual int change_configuration(std::string const &conf);
  virtual cvm::real energy_difference(std::string const &conf);
 
  virtual std::string const get_state_params() const;
  virtual int set_state_params(std::string const &conf);
  virtual std::ostream & write_traj_label(std::ostream &os);
  virtual std::ostream & write_traj(std::ostream &os);
 
protected:
 
  virtual cvm::real restraint_potential(size_t i) const;
  virtual colvarvalue const restraint_force(size_t i) const;
  virtual cvm::real d_restraint_potential_dk(size_t i) const;
};
 
 
// TODO this could be reimplemented more cleanly as a derived class of both restraint and histogram
class colvarbias_restraint_histogram : public colvarbias {
 
public:
 
  colvarbias_restraint_histogram(colvarmodule *cvmodule_in, char const *key);
  int init(std::string const &conf);
  ~colvarbias_restraint_histogram();
 
  virtual int update();
 
  virtual int write_output_files();
  virtual std::ostream & write_traj_label(std::ostream &os);
  virtual std::ostream & write_traj(std::ostream &os);
 
protected:
 
  cvm::vector1d<cvm::real> p;
 
  cvm::vector1d<cvm::real> ref_p;
 
  cvm::vector1d<cvm::real> p_diff;
 
  cvm::real lower_boundary;
 
  cvm::real upper_boundary;
 
  cvm::real width;
 
  cvm::real gaussian_width;
 
  cvm::real force_k;
 
  bool b_write_histogram;
};
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif