---

colvarbias_abf.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_ABF_H
#define COLVARBIAS_ABF_H

#include <vector>
#include <list>
#include <sstream>
#include <iomanip>

#include "colvarproxy.h"
#include "colvarbias.h"
#include "colvargrid.h"
#include "colvar_UIestimator.h"

typedef cvm::real* gradient_t;


class colvarbias_abf : public colvarbias {

public:

  colvarbias_abf(char const *key);
  virtual int init(std::string const &conf);
  virtual ~colvarbias_abf();
  virtual int update();

private:

  std::string  output_prefix;

  std::vector<std::string> input_prefix;

  bool    update_bias;
  bool    hide_Jacobian;
  bool    b_integrate;

  size_t  full_samples;
  size_t  min_samples;
  bool    b_history_files;
  bool    b_czar_window_file;
  size_t  history_freq;
  UIestimator::UIestimator eabf_UI;
  bool  b_UI_estimator;
  bool  b_CZAR_estimator;

  int   pabf_freq;
  int       integrate_iterations;
  cvm::real integrate_tol;
  int       pabf_integrate_iterations;
  cvm::real pabf_integrate_tol;

  bool                    cap_force;
  std::vector<cvm::real>  max_force;

  // Internal data and methods

  std::vector<int>  bin;
  std::vector<int> force_bin;
  std::vector<int> z_bin;

  gradient_t system_force;

  colvar_grid_gradient  *gradients;
  colvar_grid_count     *samples;
  integrate_potential   *pmf;
  colvar_grid_gradient  *z_gradients;
  colvar_grid_count     *z_samples;
  colvar_grid_gradient  *czar_gradients;
  integrate_potential   *czar_pmf;

  inline int update_system_force(size_t i)
  {
    if (colvars[i]->is_enabled(f_cv_subtract_applied_force)) {
      // this colvar is already subtracting the ABF force
      system_force[i] = colvars[i]->total_force().real_value;
    } else {
      system_force[i] = colvars[i]->total_force().real_value
        - colvar_forces[i].real_value;
        // If hideJacobian is active then total_force has an extra term of -fj
        // which is the Jacobian-compensating force at the colvar level
    }
    if (cvm::debug())
      cvm::log("ABF System force calc: cv " + cvm::to_str(i) +
               " fs " + cvm::to_str(system_force[i]) +
               " = ft " + cvm::to_str(colvars[i]->total_force().real_value) +
               " - fa " + cvm::to_str(colvar_forces[i].real_value));
    return COLVARS_OK;
  }

  // shared ABF
  bool    shared_on;
  size_t  shared_freq;
  cvm::step_number shared_last_step;
  // Share between replicas -- may be called independently of update
  virtual int replica_share();

  // Store the last set for shared ABF
  colvar_grid_gradient  *last_gradients;
  colvar_grid_count     *last_samples;

  // For Tcl implementation of selection rules.
  virtual int bin_num();
  virtual int current_bin();
  virtual int bin_count(int bin_index);

  void write_gradients_samples(const std::string &prefix, bool close = true);

  int read_gradients_samples();

  template <class T> int write_grid_to_file(T const *grid,
                                            std::string const &name,
                                            bool close);

  virtual std::istream& read_state_data(std::istream&);
  virtual std::ostream& write_state_data(std::ostream&);
  virtual int write_output_files();

  virtual int calc_energy(std::vector<colvarvalue> const *values);
};

#endif

---