colvarbias_abf.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_ABF_H
#define COLVARBIAS_ABF_H
 
#include <vector>
#include <list>
#include <sstream>
#include <iomanip>
#include <memory>
 
#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);
  int init(std::string const &conf) override;
  ~colvarbias_abf() override;
  int update() override;
 
private:
 
  std::vector<std::string> input_prefix;
 
  bool    update_bias;
  bool    hide_Jacobian;
  bool    b_integrate;
 
  size_t  full_samples;
  size_t  min_samples;
  cvm::step_number history_last_step;
  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;
 
  std::shared_ptr<colvar_grid_gradient> gradients;
  std::shared_ptr<colvar_grid_count>    samples;
  std::shared_ptr<integrate_potential>  pmf;
  std::shared_ptr<colvar_grid_gradient> z_gradients;
  std::shared_ptr<colvar_grid_count>    z_samples;
  std::shared_ptr<colvar_grid_gradient> czar_gradients;
  std::shared_ptr<integrate_potential>  czar_pmf;
 
  int update_system_force();
 
  int calc_biasing_force(std::vector<cvm::real> &force);
 
  cvm::real smoothing_factor(cvm::real weight);
 
  // shared ABF
  bool    shared_on;
  size_t  shared_freq;
  cvm::step_number shared_last_step;
 
  // Share between replicas -- may be called independently of update
  int replica_share() override;
 
  // Share data needed for CZAR between replicas - called before output only
  int replica_share_CZAR();
 
  size_t replica_share_freq() const override;
 
  // Data just after the last share (start of cycle) in shared ABF
  std::unique_ptr<colvar_grid_gradient> last_gradients;
  std::shared_ptr<colvar_grid_count>    last_samples;
  // eABF/CZAR local data last shared
  std::unique_ptr<colvar_grid_gradient> last_z_gradients;
  std::shared_ptr<colvar_grid_count>    last_z_samples;
  // ABF data from local replica only in shared ABF
  std::shared_ptr<colvar_grid_gradient> local_gradients;
  std::shared_ptr<colvar_grid_count>    local_samples;
  std::unique_ptr<integrate_potential>  local_pmf;
  // eABF/CZAR data collected from all replicas in shared eABF on replica 0
  // if non-shared, aliases of regular CZAR grids, for output purposes
  std::shared_ptr<colvar_grid_gradient> global_z_gradients;
  std::shared_ptr<colvar_grid_count>    global_z_samples;
  std::shared_ptr<colvar_grid_gradient> global_czar_gradients;
  std::shared_ptr<integrate_potential>  global_czar_pmf;
 
 
  // For Tcl implementation of selection rules.
  int bin_num() override;
  int current_bin() override;
  int bin_count(int bin_index) override;
  int local_sample_count(int radius) override;
 
  void write_gradients_samples(const std::string &prefix, bool close = true, bool local = false);
 
  int read_gradients_samples();
 
  template <class T> int write_grid_to_file(T const *grid,
                                            std::string const &name,
                                            bool close);
 
private:
 
  template <typename OST> OST &write_state_data_template_(OST &os);
 
  template <typename IST> IST &read_state_data_template_(IST &is);
 
public:
 
  std::ostream &write_state_data(std::ostream &os) override;
 
  cvm::memory_stream &write_state_data(cvm::memory_stream &os) override;
 
  std::istream &read_state_data(std::istream &is) override;
 
  cvm::memory_stream &read_state_data(cvm::memory_stream &is) override;
 
  int write_output_files() override;
 
  int calc_energy(std::vector<colvarvalue> const *values) override;
};
#endif