colvarproxy_system.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 COLVARPROXY_SYSTEM_H
#define COLVARPROXY_SYSTEM_H
 
#include "colvars_system.h"
 
class colvarproxy_system {
 
public:
 
  colvarproxy_system();
 
  virtual ~colvarproxy_system();
 
  std::string units;
 
  virtual int set_unit_system(std::string const &units, bool check_only);
 
  inline cvm::real angstrom_to_internal(cvm::real l) const
  {
    return l * angstrom_value_;
  }
 
  inline cvm::real internal_to_angstrom(cvm::real l) const
  {
    return l / angstrom_value_;
  }
 
  inline cvm::real boltzmann() const
  {
    return boltzmann_;
  }
 
  inline cvm::real target_temperature() const
  {
    return target_temperature_;
  }
 
  virtual int set_target_temperature(cvm::real T);
 
  inline double dt() const
  {
    return timestep_;
  }
 
  virtual int set_integration_timestep(cvm::real dt);
 
  inline int time_step_factor() const
  {
    return time_step_factor_;
  }
 
  virtual int set_time_step_factor(int fact);
 
  virtual cvm::real rand_gaussian(void);
 
  virtual void add_energy(cvm::real energy);
 
  inline bool & use_internal_pbc() { return use_internal_pbc_; }
 
  virtual cvm::rvector position_distance(cvm::atom_pos const &pos1,
                                         cvm::atom_pos const &pos2) const;
  inline cvm::system_boundary_conditions const &get_system_boundaries() const {
    return boundaries_;
  }
 
  virtual void request_total_force(bool yesno);
 
  virtual bool total_forces_enabled() const;
 
  virtual bool total_forces_same_step() const;
 
  virtual int get_molid(int &molid);
 
  virtual int get_alch_lambda(cvm::real* lambda);
 
  void set_alch_lambda(cvm::real lambda);
 
  virtual int send_alch_lambda();
 
  virtual int request_alch_energy_freq(int const /* freq */) {
    return COLVARS_OK;
  }
 
  virtual int get_dE_dlambda(cvm::real* dE_dlambda);
 
  virtual int apply_force_dE_dlambda(cvm::real* force);
 
  virtual int get_d2E_dlambda2(cvm::real* d2E_dlambda2);
 
  cvm::real indirect_lambda_biasing_force;
 
  virtual cvm::real get_accelMD_factor() const {
    cvm::error_static("Error: accessing the reweighting factor of accelerated MD  "
               "is not yet implemented in the MD engine.\n",
               COLVARS_NOT_IMPLEMENTED);
    return 1.0;
  }
  virtual bool accelMD_enabled() const {
    return false;
  }
 
protected:
 
  cvm::real cached_alch_lambda;
 
  bool cached_alch_lambda_changed;
 
  cvm::real boltzmann_;
 
  cvm::real target_temperature_;
 
  double timestep_;
 
  int time_step_factor_ = 1;
 
  cvm::real angstrom_value_;
 
  cvm::real kcal_mol_value_;
 
  bool total_force_requested;
 
  bool use_internal_pbc_ = false;
 
  cvm::system_boundary_conditions boundaries_;
};
 
 
#endif