---

colvarbias_meta.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_META_H
#define COLVARBIAS_META_H

#include <vector>
#include <list>
#include <iosfwd>

#include "colvarbias.h"
#include "colvargrid.h"

class colvarbias_meta
  : public virtual colvarbias,
    public virtual colvarbias_ti
{

public:

  enum Communication {
    single_replica,
    multiple_replicas
  };

  Communication comm;

  colvarbias_meta(char const *key);
  virtual ~colvarbias_meta();

  virtual int init(std::string const &conf);
  virtual int init_replicas_params(std::string const &conf);
  virtual int init_well_tempered_params(std::string const &conf);
  virtual int init_ebmeta_params(std::string const &conf);

  virtual int clear_state_data();

  virtual int update();
  virtual int update_grid_params();
  virtual int update_bias();
  virtual int update_grid_data();
  virtual int replica_share();

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

  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 &os);

  virtual int setup_output();
  virtual int write_output_files();
  virtual void write_pmf();
  virtual int write_state_to_replicas();

  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;

  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,
                               colvar_grid_scalar *ge);

  std::istream & read_hill(std::istream &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;

  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;

  colvar_grid_scalar* target_dist;

  cvm::step_number ebmeta_equil_steps;


  bool       safely_read_restart;

  colvar_grid_scalar    *hills_energy;

  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;

  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;

};




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();

  friend std::ostream & operator << (std::ostream &os, hill const &h);

};


#endif

---