colvarbias.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_H
#define COLVARBIAS_H
 
#include <memory>
 
#include "colvar.h"
#include "colvarparse.h"
#include "colvardeps.h"
 
class colvar_grid_scalar;
 
class colvarbias
  : public virtual colvarparse, public virtual colvardeps {
public:
 
  std::string name;
 
  std::string bias_type;
 
  std::string state_keyword;
 
  int rank;
 
  int add_colvar(std::string const &cv_name);
 
  inline size_t num_variables() const
  {
    return colvars.size();
  }
 
  inline std::vector<colvar *> *variables()
  {
    return &colvars;
  }
 
  inline colvar * variables(int i) const
  {
    return colvars[i];
  }
 
  virtual int update();
 
  virtual bool can_accumulate_data();
 
  virtual int calc_energy(std::vector<colvarvalue> const *values);
 
  virtual int calc_forces(std::vector<colvarvalue> const *values);
 
  int communicate_forces();
 
  virtual int end_of_step();
 
  virtual int change_configuration(std::string const &conf);
 
  virtual cvm::real energy_difference(std::string const &conf);
 
  // FIXME this is currently 1D only
  virtual int bin_num();
  // FIXME this is currently 1D only
  virtual int current_bin();
  virtual int bin_count(int bin_index);
  virtual int local_sample_count(int radius);
 
  virtual int replica_share();
 
  virtual size_t replica_share_freq() const;
 
  virtual void analyze() {}
 
  colvarbias(char const *key);
 
  virtual int init(std::string const &conf);
 
  virtual int init_dependencies();
 
  virtual int reset();
 
private:
 
  colvarbias();
 
  colvarbias(colvarbias &);
 
public:
 
  virtual int clear();
 
  virtual int clear_state_data();
 
  virtual ~colvarbias();
 
  virtual std::string const get_state_params() const;
 
  int check_matching_state(std::string const &conf);
 
  virtual int set_state_params(std::string const &state_conf);
 
  virtual std::ostream & write_state_data(std::ostream &os)
  {
    return os;
  }
 
  virtual cvm::memory_stream & write_state_data(cvm::memory_stream &os)
  {
    return os;
  }
 
  virtual std::istream & read_state_data(std::istream &is)
  {
    return is;
  }
 
  virtual cvm::memory_stream & read_state_data(cvm::memory_stream &is)
  {
    return is;
  }
 
  std::ostream &write_state_data_key(std::ostream &os, std::string const &key, bool header = true);
 
  cvm::memory_stream &write_state_data_key(cvm::memory_stream &os, std::string const &key,
                                           bool header = true);
 
private:
 
  template <typename IST> IST &read_state_data_key_template_(IST &is, std::string const &key);
 
public:
 
  std::istream & read_state_data_key(std::istream &is, std::string const &key);
 
  cvm::memory_stream & read_state_data_key(cvm::memory_stream &is, std::string const &key);
 
private:
 
  template <typename IST> IST & read_state_template_(IST &is);
 
public:
 
  std::ostream &write_state(std::ostream &os);
 
  cvm::memory_stream & write_state(cvm::memory_stream &os);
 
  std::istream & read_state(std::istream &is);
 
  cvm::memory_stream & read_state(cvm::memory_stream &is);
 
  int write_state_prefix(std::string const &prefix);
 
  int write_state_string(std::string &output);
 
  int read_state_prefix(std::string const &prefix);
 
  int read_state_string(char const *buffer);
 
  virtual std::ostream & write_traj_label(std::ostream &os);
 
  virtual std::ostream & write_traj(std::ostream &os);
 
  virtual int setup_output()
  {
    return COLVARS_OK;
  }
 
  size_t output_freq;
 
  virtual int write_output_files()
  {
    return COLVARS_OK;
  }
 
  std::string output_prefix;
 
  virtual int write_state_to_replicas()
  {
    return COLVARS_OK;
  }
 
  inline cvm::real get_energy()
  {
    return bias_energy;
  }
 
  static std::vector<feature *> cvb_features;
 
  virtual const std::vector<feature *> &features() const
  {
    return cvb_features;
  }
  virtual std::vector<feature *> &modify_features()
  {
    return cvb_features;
  }
  static void delete_features() {
    for (size_t i=0; i < cvb_features.size(); i++) {
      delete cvb_features[i];
    }
    cvb_features.clear();
  }
 
protected:
 
  std::vector<colvar *>    colvars;
 
  std::vector<colvarvalue> colvar_values;
 
  std::vector<colvarvalue> colvar_forces;
 
  std::vector<colvarvalue> previous_colvar_forces;
 
  cvm::real                bias_energy;
 
  bool                     b_output_energy;
 
  bool                     has_data;
 
  cvm::step_number         state_file_step;
 
  bool matching_state;
 
  colvar_grid_scalar*      biasing_force_scaling_factors;
  std::vector<int>         biasing_force_scaling_factors_bin;
};
 
 
class colvar_grid_gradient;
class colvar_grid_count;
 
class colvarbias_ti : public virtual colvarbias {
public:
 
  colvarbias_ti(char const *key);
  virtual ~colvarbias_ti();
 
  virtual int init(std::string const &conf);
  virtual int init_grids();
  virtual int update();
 
  virtual int update_system_forces(std::vector<colvarvalue> const
                                   *subtract_forces);
 
  virtual std::string const get_state_params() const;
  virtual int set_state_params(std::string const &state_conf);
  virtual std::ostream & write_state_data(std::ostream &os);
  virtual cvm::memory_stream & write_state_data(cvm::memory_stream &os);
  virtual std::istream & read_state_data(std::istream &is);
  virtual cvm::memory_stream & read_state_data(cvm::memory_stream &is);
  virtual int write_output_files();
 
protected:
 
  std::vector<colvarvalue> ti_system_forces;
 
  std::shared_ptr<colvar_grid_gradient> ti_avg_forces;
 
  std::shared_ptr<colvar_grid_count> ti_count;
 
  std::vector<int> ti_bin;
};
 
#endif