colvarbias_meta.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_META_H
#define COLVARBIAS_META_H
 
#include <iosfwd>
#include <list>
#include <memory>
#include <vector>
 
#include "colvarbias.h"
 
class colvar_grid_scalar;
class colvar_grid_gradient;
 
 
 
class colvarbias_meta
  : public virtual colvarbias,
    public virtual colvarbias_ti
{
 
public:
 
  enum Communication {
    single_replica,
    multiple_replicas
  };
 
  Communication comm;
 
  colvarbias_meta(char const *key);
  ~colvarbias_meta();
 
  int init(std::string const &conf) override;
  int init_replicas_params(std::string const &conf);
  int init_well_tempered_params(std::string const &conf);
  int init_ebmeta_params(std::string const &conf);
 
  int clear_state_data() override;
 
  int update() override;
  int update_grid_params();
  int update_bias();
  int update_grid_data();
 
  int replica_share() override;
  size_t replica_share_freq() const override;
 
  int calc_energy(std::vector<colvarvalue> const *values) override;
  int calc_forces(std::vector<colvarvalue> const *values) override;
 
  std::string const get_state_params() const override;
  int set_state_params(std::string const &state_conf) override;
 
  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;
 
private:
 
  template <typename IST, typename GT>
  IST &read_grid_data_template_(IST &is, std::string const &key, GT *grid, GT *backup_grid);
 
  template <typename IST> IST &read_state_data_template_(IST &is);
 
  template <typename OST> OST &write_state_data_template_(OST &os);
 
public:
 
  void rebin_grids_after_restart();
 
  int setup_output() override;
  int write_output_files() override;
  int write_state_to_replicas() override;
  void write_pmf();
 
  class hill;
  typedef std::list<hill>::iterator hill_iter;
 
protected:
 
  cvm::real hill_width;
 
  std::vector<cvm::real> colvar_sigmas;
 
  size_t     new_hill_freq = 0;
 
  bool b_hills_traj;
 
  std::string const hills_traj_file_name() const;
 
  std::list<hill> hills;
 
  hill_iter new_hills_begin;
 
  std::list<hill> hills_off_grid;
 
  hill_iter new_hills_off_grid_begin;
 
  void recount_hills_off_grid(hill_iter h_first, hill_iter h_last);
 
  template <typename OST> OST &write_hill_template_(OST &os, colvarbias_meta::hill const &h);
 
  std::ostream &write_hill(std::ostream &os, hill const &h);
 
  cvm::memory_stream &write_hill(cvm::memory_stream &os, hill const &h);
 
  template <typename IST> IST &read_hill_template_(IST &is);
 
  std::istream & read_hill(std::istream &is);
 
  cvm::memory_stream & read_hill(cvm::memory_stream &is);
 
  std::list<hill>::const_iterator add_hill(hill const &h);
 
  std::list<hill>::const_iterator delete_hill(hill_iter &h);
 
  virtual void calc_hills(hill_iter  h_first,
                          hill_iter  h_last,
                          cvm::real &energy,
                          std::vector<colvarvalue> const *values);
 
  virtual void calc_hills_force(size_t const &i,
                                hill_iter h_first,
                                hill_iter h_last,
                                std::vector<colvarvalue> &forces,
                                std::vector<colvarvalue> const *values);
 
 
  cvm::real  hill_weight;
 
  bool       use_grids;
 
  bool       rebin_grids;
 
  bool       expand_grids;
 
  size_t     grids_freq = 0;
 
  bool       keep_hills;
 
  bool restart_keep_hills;
 
  bool       dump_fes;
 
  bool       dump_replica_fes;
 
  bool       dump_fes_save;
 
  bool       well_tempered;
 
  cvm::real  bias_temperature;
 
  bool       ebmeta;
 
  std::unique_ptr<colvar_grid_scalar> target_dist;
 
  cvm::step_number ebmeta_equil_steps;
 
 
  bool       safely_read_restart;
 
  std::shared_ptr<colvar_grid_scalar> hills_energy;
 
  std::shared_ptr<colvar_grid_gradient> hills_energy_gradients;
 
  void project_hills(hill_iter h_first, hill_iter h_last, colvar_grid_scalar *ge,
                     colvar_grid_gradient *gf, bool print_progress = false);
 
 
  // Multiple Replicas variables and functions
 
  std::string            replica_id;
 
  std::string            replica_file_name;
 
  virtual int update_replicas_registry();
 
  virtual int read_replica_files();
 
  virtual int write_replica_state_file();
 
  virtual int reopen_replica_buffer_file();
 
  std::vector<colvarbias_meta *> replicas;
 
  size_t replica_update_freq = 0;
 
  std::string            replicas_registry_file;
  std::string            replicas_registry;
  std::string            replica_list_file;
 
  std::string            replica_state_file;
  bool                   replica_state_file_in_sync;
 
  size_t                 update_status;
 
  std::string            replica_hills_file;
 
  std::streampos         replica_hills_file_pos;
 
  std::ostringstream     hills_traj_os_buf;
};
 
 
 
 
class colvarbias_meta::hill {
 
protected:
 
  cvm::step_number it;
 
  cvm::real hill_value;
 
  cvm::real sW;
 
  cvm::real W;
 
  std::vector<colvarvalue> centers;
 
  std::vector<cvm::real> sigmas;
 
  std::string replica;
 
public:
 
  friend class colvarbias_meta;
 
  hill(cvm::step_number it, cvm::real W,
       std::vector<colvarvalue> const &cv_values,
       std::vector<cvm::real> const &cv_sigmas,
       std::string const &replica = "");
 
  hill(colvarbias_meta::hill const &h);
 
  ~hill();
 
  hill & operator = (colvarbias_meta::hill const &h);
 
  inline cvm::real energy()
  {
    return W * sW * hill_value;
  }
 
  inline cvm::real energy(cvm::real const &new_weight)
  {
    return new_weight * sW * hill_value;
  }
 
  inline cvm::real const &value()
  {
    return hill_value;
  }
 
  inline void value(cvm::real const &new_value)
  {
    hill_value = new_value;
  }
 
  inline cvm::real weight()
  {
    return W * sW;
  }
 
  inline void scale(cvm::real const &new_scale_fac)
  {
    sW = new_scale_fac;
  }
 
  inline std::vector<colvarvalue> & center()
  {
    return centers;
  }
 
  inline colvarvalue & center(size_t const &i)
  {
    return centers[i];
  }
 
  inline friend bool operator < (hill const &h1, hill const &h2)
  {
    if (h1.it < h2.it) return true;
    else return false;
  }
 
  inline friend bool operator <= (hill const &h1, hill const &h2)
  {
    if (h1.it <= h2.it) return true;
    else return false;
  }
 
  inline friend bool operator > (hill const &h1, hill const &h2)
  {
    if (h1.it > h2.it) return true;
    else return false;
  }
 
  inline friend bool operator >= (hill const &h1, hill const &h2)
  {
    if (h1.it >= h2.it) return true;
    else return false;
  }
 
  inline friend bool operator == (hill const &h1, hill const &h2)
  {
    if ( (h1.it >= h2.it) && (h1.replica == h2.replica) ) return true;
    else return false;
  }
 
  std::string output_traj();
 
};
 
 
#endif