---

colvarbias.h

Go to the documentation of this file.

// -*- 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 "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();
  // FIXME this is currently 1D only
  virtual int bin_count(int bin_index);
  virtual int replica_share();

  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;

  virtual int set_state_params(std::string const &state_conf);

  virtual std::ostream & write_state_data(std::ostream &os)
  {
    return os;
  }

  virtual std::istream & read_state_data(std::istream &is)
  {
    return is;
  }

  std::istream & read_state_data_key(std::istream &is, char const *key);

  std::ostream & write_state(std::ostream &os);

  std::istream & read_state(std::istream &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 clear_state_data();

  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 std::istream & read_state_data(std::istream &is);
  virtual int write_output_files();

protected:

  std::vector<colvarvalue> ti_system_forces;

  colvar_grid_gradient *ti_avg_forces;

  colvar_grid_count *ti_count;

  std::vector<int> ti_bin;
};

#endif

---