colvarproxy.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 COLVARPROXY_H
#define COLVARPROXY_H
 
#include <functional>
 
#include "colvarmodule.h"
#include "colvartypes.h"
#include "colvarproxy_io.h"
#include "colvarproxy_replicas.h"
#include "colvarproxy_system.h"
#include "colvarproxy_tcl.h"
#include "colvarproxy_volmaps.h"
#include "colvarproxy_gpu.h"
 
 
 
// forward declarations
class colvarscript;
 
 
class colvarproxy_atoms {
 
public:
 
#if ( defined(COLVARS_CUDA) || defined(COLVARS_HIP) )
  template <typename T>
  using allocator_type = colvars_gpu::CudaHostAllocator<T>;
#else
  template <typename T>
  using allocator_type = std::allocator<T>;
#endif
  using atom_buffer_real_t = std::vector<cvm::real, allocator_type<cvm::real>>;
  using atom_buffer_rvector_t = std::vector<cvm::rvector, allocator_type<cvm::rvector>>;
 
  colvarproxy_atoms();
 
  virtual ~colvarproxy_atoms();
 
  virtual int init_atom(int atom_number);
 
  virtual int check_atom_id(int atom_number);
 
  virtual int check_atom_name_selections_available();
 
  virtual int init_atom(cvm::residue_id const &residue,
                        std::string const     &atom_name,
                        std::string const     &segment_id);
 
  virtual int check_atom_id(cvm::residue_id const &residue,
                            std::string const     &atom_name,
                            std::string const     &segment_id);
 
  virtual void clear_atom(int index);
 
  int reset();
 
  inline int get_atom_id(int index) const
  {
    return atoms_ids[index];
  }
 
  inline cvm::real get_atom_mass(int index) const
  {
    return atoms_masses[index];
  }
 
  inline void increase_refcount(int index)
  {
    atoms_refcount[index] += 1;
  }
 
  inline cvm::real get_atom_charge(int index) const
  {
    return atoms_charges[index];
  }
 
  inline cvm::rvector get_atom_position(int index) const
  {
    return atoms_positions[index];
  }
 
  inline cvm::rvector get_atom_total_force(int index) const
  {
    return atoms_total_forces[index];
  }
 
  inline void apply_atom_force(int index, cvm::rvector const &new_force)
  {
    atoms_new_colvar_forces[index] += new_force;
  }
 
  inline cvm::rvector get_atom_velocity(int /* index */)
  {
    cvm::error("Error: reading the current velocity of an atom "
               "is not yet implemented.\n",
               COLVARS_NOT_IMPLEMENTED);
    return cvm::rvector(0.0);
  }
 
  inline std::vector<int> const *get_atom_ids() const
  {
    return &atoms_ids;
  }
 
  size_t get_num_active_atoms() const;
 
  inline atom_buffer_real_t const *get_atom_masses() const
  {
    return &atoms_masses;
  }
 
  inline atom_buffer_real_t *modify_atom_masses()
  {
    // assume that we are requesting masses to change them
    updated_masses_ = true;
    return &atoms_masses;
  }
 
  inline atom_buffer_real_t const *get_atom_charges()
  {
    return &atoms_charges;
  }
 
  inline atom_buffer_real_t *modify_atom_charges()
  {
    // assume that we are requesting charges to change them
    updated_charges_ = true;
    return &atoms_charges;
  }
 
  inline atom_buffer_rvector_t const *get_atom_positions() const
  {
    return &atoms_positions;
  }
 
  inline atom_buffer_rvector_t *modify_atom_positions()
  {
    return &atoms_positions;
  }
 
  inline atom_buffer_rvector_t const *get_atom_total_forces() const
  {
    return &atoms_total_forces;
  }
 
  inline atom_buffer_rvector_t *modify_atom_total_forces()
  {
    return &atoms_total_forces;
  }
 
  inline atom_buffer_rvector_t const *get_atom_applied_forces() const
  {
    return &atoms_new_colvar_forces;
  }
 
  inline atom_buffer_rvector_t *modify_atom_applied_forces()
  {
    return &atoms_new_colvar_forces;
  }
 
  void compute_rms_atoms_applied_force();
 
  void compute_max_atoms_applied_force();
 
  inline cvm::real rms_atoms_applied_force() const
  {
    return atoms_rms_applied_force_;
  }
 
  inline cvm::real max_atoms_applied_force() const
  {
    return atoms_max_applied_force_;
  }
 
  inline int max_atoms_applied_force_id() const
  {
    return atoms_max_applied_force_id_;
  }
 
  inline bool modified_atom_list() const
  {
    return modified_atom_list_;
  }
 
  inline void reset_modified_atom_list()
  {
    modified_atom_list_ = false;
  }
 
  inline bool updated_masses() const
  {
    return updated_masses_;
  }
 
  inline bool updated_charges() const
  {
    return updated_charges_;
  }
 
protected:
 
  std::vector<int>          atoms_ids;
  std::vector<size_t>       atoms_refcount;
  std::vector<cvm::real, allocator_type<cvm::real>>    atoms_masses;
  std::vector<cvm::real, allocator_type<cvm::real>>    atoms_charges;
  std::vector<cvm::rvector, allocator_type<cvm::rvector>> atoms_positions;
  std::vector<cvm::rvector, allocator_type<cvm::rvector>> atoms_total_forces;
  std::vector<cvm::rvector, allocator_type<cvm::rvector>> atoms_new_colvar_forces;
 
  cvm::real atoms_rms_applied_force_;
 
  cvm::real atoms_max_applied_force_;
 
  int atoms_max_applied_force_id_;
 
  bool modified_atom_list_;
 
  bool updated_masses_, updated_charges_;
 
  int add_atom_slot(int atom_id);
 
};
 
 
class colvarproxy_atom_groups {
 
public:
 
  colvarproxy_atom_groups();
 
  virtual ~colvarproxy_atom_groups();
 
  int reset();
 
  virtual int scalable_group_coms();
 
  virtual int init_atom_group(std::vector<int> const &atoms_ids);
 
  virtual void clear_atom_group(int index);
 
  inline int get_atom_group_id(int index) const
  {
    return atom_groups_ids[index];
  }
 
  inline cvm::real get_atom_group_mass(int index) const
  {
    return atom_groups_masses[index];
  }
 
  inline cvm::real get_atom_group_charge(int index) const
  {
    return atom_groups_charges[index];
  }
 
  inline cvm::rvector get_atom_group_com(int index) const
  {
    return atom_groups_coms[index];
  }
 
  inline cvm::rvector get_atom_group_total_force(int index) const
  {
    return atom_groups_total_forces[index];
  }
 
  inline void apply_atom_group_force(int index, cvm::rvector const &new_force)
  {
    atom_groups_new_colvar_forces[index] += new_force;
  }
 
  inline cvm::rvector get_atom_group_velocity(int /* index */)
  {
    cvm::error("Error: reading the current velocity of an atom group is not yet implemented.\n",
               COLVARS_NOT_IMPLEMENTED);
    return cvm::rvector(0.0);
  }
 
  inline std::vector<int> const *get_atom_group_ids() const
  {
    return &atom_groups_ids;
  }
 
  size_t get_num_active_atom_groups() const;
 
  inline std::vector<cvm::real> *modify_atom_group_masses()
  {
    // TODO updated_masses
    return &atom_groups_masses;
  }
 
  inline std::vector<cvm::real> *modify_atom_group_charges()
  {
    // TODO updated masses
    return &atom_groups_charges;
  }
 
  inline std::vector<cvm::rvector> *modify_atom_group_positions()
  {
    return &atom_groups_coms;
  }
 
  inline std::vector<cvm::rvector> *modify_atom_group_total_forces()
  {
    return &atom_groups_total_forces;
  }
 
  inline std::vector<cvm::rvector> *modify_atom_group_applied_forces()
  {
    return &atom_groups_new_colvar_forces;
  }
 
  void compute_rms_atom_groups_applied_force();
 
  void compute_max_atom_groups_applied_force();
 
  inline cvm::real rms_atom_groups_applied_force() const
  {
    return atom_groups_rms_applied_force_;
  }
 
  inline cvm::real max_atom_groups_applied_force() const
  {
    return atom_groups_max_applied_force_;
  }
 
protected:
 
  std::vector<int>          atom_groups_ids;
  std::vector<size_t>       atom_groups_refcount;
  std::vector<cvm::real>    atom_groups_masses;
  std::vector<cvm::real>    atom_groups_charges;
  std::vector<cvm::rvector> atom_groups_coms;
  std::vector<cvm::rvector> atom_groups_total_forces;
  std::vector<cvm::rvector> atom_groups_new_colvar_forces;
 
  cvm::real atom_groups_rms_applied_force_;
 
  cvm::real atom_groups_max_applied_force_;
 
  int add_atom_group_slot(int atom_group_id);
};
 
 
#if defined(_OPENMP)
#include <omp.h>
#else
struct omp_lock_t;
#endif
 
class colvarproxy_smp {
 
public:
 
  enum class smp_mode_t {cvcs, inner_loop, gpu, none};
 
  colvarproxy_smp();
 
  virtual ~colvarproxy_smp();
 
  virtual smp_mode_t get_smp_mode() const;
 
  virtual std::vector<smp_mode_t> get_available_smp_modes() const;
 
  virtual smp_mode_t get_preferred_smp_mode() const;
 
  virtual int set_smp_mode(smp_mode_t mode);
 
  virtual int smp_loop(int n_items, std::function<int (int)> const &worker);
 
  virtual int smp_biases_loop();
 
  virtual int smp_biases_script_loop();
 
  virtual int smp_thread_id();
 
  virtual int smp_num_threads();
 
  virtual int smp_lock();
 
  virtual int smp_trylock();
 
  virtual int smp_unlock();
 
protected:
 
  omp_lock_t *omp_lock_state;
 
  smp_mode_t smp_mode;
};
 
 
class colvarproxy_script {
 
public:
 
  colvarproxy_script();
 
  virtual ~colvarproxy_script();
 
  colvarscript *script;
 
  bool have_scripts;
 
  virtual int run_force_callback();
 
  virtual int run_colvar_callback(
                std::string const &name,
                std::vector<const colvarvalue *> const &cvcs,
                colvarvalue &value);
 
  virtual int run_colvar_gradient_callback(
                std::string const &name,
                std::vector<const colvarvalue *> const &cvcs,
                std::vector<cvm::matrix2d<cvm::real> > &gradient);
};
 
 
 
class colvarproxy
  : public colvarproxy_system,
    public colvarproxy_atoms,
    public colvarproxy_atom_groups,
    public colvarproxy_volmaps,
    public colvarproxy_smp,
    public colvarproxy_replicas,
    public colvarproxy_script,
    public colvarproxy_tcl,
    public colvarproxy_io,
    public colvarproxy_gpu
{
 
public:
 
  colvarmodule *colvars;
 
  colvarproxy();
 
  virtual ~colvarproxy() override;
 
  inline std::string const &engine_name() const
  {
    return engine_name_;
  }
 
  bool io_available() override;
 
  virtual int request_deletion();
 
  inline bool delete_requested() const
  {
    return b_delete_requested;
  }
 
  virtual int reset();
 
  virtual int parse_module_config();
 
  virtual int load_atoms_pdb(char const *filename, cvm::atom_group &atoms,
                             std::string const &pdb_field, double pdb_field_value);
 
 
  virtual int load_coords_pdb(char const *filename, std::vector<cvm::atom_pos> &pos,
                              std::vector<int> const &sorted_ids, std::string const &pdb_field,
                              double pdb_field_value);
 
  virtual int setup();
 
  inline bool engine_ready() const
  {
    return engine_ready_;
  }
 
  void add_config(std::string const &cmd, std::string const &conf);
 
  virtual int update_input();
 
  virtual int update_output();
 
  int end_of_step();
 
  virtual void log(std::string const &message);
 
  virtual void error(std::string const &message);
 
  void add_error_msg(std::string const &message);
 
  std::string const & get_error_msgs();
 
  void clear_error_msgs();
 
  inline bool simulation_running() const
  {
    return b_simulation_running;
  }
 
  inline bool simulation_continuing() const
  {
    return b_simulation_continuing;
  }
 
  int post_run();
 
  void print_input_atomic_data();
 
  void print_output_atomic_data();
 
  int get_version_from_string(char const *version_string);
 
  int version_number() const
  {
    return version_int;
  }
 
protected:
 
  bool engine_ready_;
 
  std::string error_output;
 
  bool b_simulation_running;
 
  bool b_simulation_continuing;
 
  bool b_delete_requested;
 
  int version_int;
 
  size_t features_hash;
 
protected:
 
  std::string engine_name_ = "standalone";
 
  void *config_queue_;
 
};
 
 
#endif