| version 1.16 | version 1.17 |
|---|
| |
| /// -*- c++ -*- | // -*- c++ -*- |
| | |
| #ifndef COLVAR_H | #ifndef COLVAR_H |
| #define COLVAR_H | #define COLVAR_H |
| |
| #include "colvarmodule.h" | #include "colvarmodule.h" |
| #include "colvarvalue.h" | #include "colvarvalue.h" |
| #include "colvarparse.h" | #include "colvarparse.h" |
| | #include "colvardeps.h" |
| | |
| | |
| /// \brief A collective variable (main class); to be defined, it needs | /// \brief A collective variable (main class); to be defined, it needs |
| |
| /// \link colvarvalue \endlink type, you should also add its | /// \link colvarvalue \endlink type, you should also add its |
| /// initialization line in the \link colvar \endlink constructor. | /// initialization line in the \link colvar \endlink constructor. |
| | |
| class colvar : public colvarparse { | class colvar : public colvarparse, public colvardeps { |
| | |
| public: | public: |
| | |
| |
| /// \brief Current velocity (previously set by calc() or by read_traj()) | /// \brief Current velocity (previously set by calc() or by read_traj()) |
| colvarvalue const & velocity() const; | colvarvalue const & velocity() const; |
| | |
| /// \brief Current system force (previously obtained from calc() or | /// \brief Current total force (previously obtained from calc() or |
| /// read_traj()). Note: this is calculated using the atomic forces | /// read_traj()). Note: this is calculated using the atomic forces |
| /// from the last simulation step. | /// from the last simulation step. |
| /// | /// |
| |
| /// acting on the collective variable is calculated summing those | /// acting on the collective variable is calculated summing those |
| /// from all colvar components, the bias and walls forces are | /// from all colvar components, the bias and walls forces are |
| /// subtracted. | /// subtracted. |
| colvarvalue const & system_force() const; | colvarvalue const & total_force() const; |
| | |
| /// \brief | |
| | |
| /// \brief Typical fluctuation amplitude for this collective | /// \brief Typical fluctuation amplitude for this collective |
| /// variable (e.g. local width of a free energy basin) | /// variable (e.g. local width of a free energy basin) |
| |
| /// variable. | /// variable. |
| cvm::real width; | cvm::real width; |
| | |
| /// \brief True if this \link colvar \endlink is a linear | /// \brief Implementation of the feature list for colvar |
| /// combination of \link cvc \endlink elements | static std::vector<feature *> cv_features; |
| bool b_linear; | |
| | /// \brief Implementation of the feature list accessor for colvar |
| /// \brief True if this \link colvar \endlink is a linear | std::vector<feature *> &features() { |
| /// combination of cvcs with coefficients 1 or -1 | return cv_features; |
| bool b_homogeneous; | } |
| | |
| /// \brief True if all \link cvc \endlink objects are capable | |
| /// of calculating inverse gradients | |
| bool b_inverse_gradients; | |
| | |
| /// \brief True if all \link cvc \endlink objects are capable | |
| /// of calculating Jacobian forces | |
| bool b_Jacobian_force; | |
| | |
| /// \brief Options controlling the behaviour of the colvar during | |
| /// the simulation, which are set from outside the cvcs | |
| enum task { | |
| /// \brief Gradients are calculated and temporarily stored, so | |
| /// that external forces can be applied | |
| task_gradients, | |
| /// \brief Collect atomic gradient data from all cvcs into vector | |
| /// atomic_gradients | |
| task_collect_gradients, | |
| /// \brief Calculate the velocity with finite differences | |
| task_fdiff_velocity, | |
| /// \brief The system force is calculated, projecting the atomic | |
| /// forces on the inverse gradients | |
| task_system_force, | |
| /// \brief The variable has a harmonic restraint around a moving | |
| /// center with fictitious mass; bias forces will be applied to | |
| /// the center | |
| task_extended_lagrangian, | |
| /// \brief The extended system coordinate undergoes Langevin | |
| /// dynamics | |
| task_langevin, | |
| /// \brief Output the potential and kinetic energies | |
| /// (for extended Lagrangian colvars only) | |
| task_output_energy, | |
| /// \brief Compute analytically the "force" arising from the | |
| /// geometric entropy component (for example, that from the angular | |
| /// states orthogonal to a distance vector) | |
| task_Jacobian_force, | |
| /// \brief Report the Jacobian force as part of the system force | |
| /// if disabled, apply a correction internally to cancel it | |
| task_report_Jacobian_force, | |
| /// \brief Output the value to the trajectory file (on by default) | |
| task_output_value, | |
| /// \brief Output the velocity to the trajectory file | |
| task_output_velocity, | |
| /// \brief Output the applied force to the trajectory file | |
| task_output_applied_force, | |
| /// \brief Output the system force to the trajectory file | |
| task_output_system_force, | |
| /// \brief A lower boundary is defined | |
| task_lower_boundary, | |
| /// \brief An upper boundary is defined | |
| task_upper_boundary, | |
| /// \brief Provide a discretization of the values of the colvar to | |
| /// be used by the biases or in analysis (needs lower and upper | |
| /// boundary) | |
| task_grid, | |
| /// \brief Apply a restraining potential (|x-xb|^2) to the colvar | |
| /// when it goes below the lower wall | |
| task_lower_wall, | |
| /// \brief Apply a restraining potential (|x-xb|^2) to the colvar | |
| /// when it goes above the upper wall | |
| task_upper_wall, | |
| /// \brief Compute running average | |
| task_runave, | |
| /// \brief Compute time correlation function | |
| task_corrfunc, | |
| /// \brief Value and gradients computed by user script | |
| task_scripted, | |
| /// \brief Number of possible tasks | |
| task_ntot | |
| }; | |
| | |
| /// Tasks performed by this colvar | int refresh_deps(); |
| bool tasks[task_ntot]; | |
| | |
| /// List of biases that depend on this colvar | /// List of biases that depend on this colvar |
| std::vector<colvarbias *> biases; | std::vector<colvarbias *> biases; |
| |
| /// Cached reported velocity | /// Cached reported velocity |
| colvarvalue v_reported; | colvarvalue v_reported; |
| | |
| // Options for task_extended_lagrangian | // Options for extended_lagrangian |
| /// Restraint center | /// Restraint center |
| colvarvalue xr; | colvarvalue xr; |
| /// Velocity of the restraint center | /// Velocity of the restraint center |
| |
| /// \brief Harmonic restraint force | /// \brief Harmonic restraint force |
| colvarvalue fr; | colvarvalue fr; |
| | |
| /// \brief Jacobian force, when task_Jacobian_force is enabled | /// \brief Jacobian force, when Jacobian_force is enabled |
| colvarvalue fj; | colvarvalue fj; |
| | |
| /// Cached reported system force | /// Cached reported total force |
| colvarvalue ft_reported; | colvarvalue ft_reported; |
| | |
| public: | public: |
| |
| /// the biases are updated | /// the biases are updated |
| colvarvalue fb; | colvarvalue fb; |
| | |
| /// \brief Total \em applied force; fr (if task_extended_lagrangian | /// \brief Total \em applied force; fr (if extended_lagrangian |
| /// is defined), fb (if biases are applied) and the walls' forces | /// is defined), fb (if biases are applied) and the walls' forces |
| /// (if defined) contribute to it | /// (if defined) contribute to it |
| colvarvalue f; | colvarvalue f; |
| | |
| | /// Applied force at the previous step (to be subtracted from total force if needed) |
| | colvarvalue f_old; |
| | |
| /// \brief Total force, as derived from the atomic trajectory; | /// \brief Total force, as derived from the atomic trajectory; |
| /// should equal the total system force plus \link f \endlink | /// should equal the system force plus \link f \endlink |
| colvarvalue ft; | colvarvalue ft; |
| | |
| | |
| |
| /// Constructor | /// Constructor |
| colvar(std::string const &conf); | colvar(std::string const &conf); |
| | |
| /// Enable the specified task | /// Parse the CVC configuration and allocate their data |
| int enable(colvar::task const &t); | int init_components(std::string const &conf); |
| | |
| | private: |
| | /// Parse the CVC configuration for all components of a certain type |
| | template<typename def_class_name> int init_components_type(std::string const &conf, |
| | char const *def_desc, |
| | char const *def_config_key); |
| | |
| /// Disable the specified task | public: |
| void disable(colvar::task const &t); | |
| | |
| /// Get ready for a run and possibly re-initialize internal data | /// Get ready for a run and re-initialize internal data if needed |
| void setup(); | void setup(); |
| | |
| /// Destructor | /// Destructor |
| ~colvar(); | ~colvar(); |
| | |
| | |
| /// \brief Calculate the colvar value and all the other requested | /// \brief Calculate the colvar's value and related quantities |
| /// quantities | int calc(); |
| void calc(); | |
| | /// \brief Calculate a subset of the colvar components (CVCs) currently active |
| | /// (default: all active CVCs) |
| | /// Note: both arguments refer to the sect of *active* CVCs, not all CVCs |
| | int calc_cvcs(int first = 0, size_t num_cvcs = 0); |
| | |
| | /// Ensure that the selected range of CVCs is consistent |
| | int check_cvc_range(int first_cvc, size_t num_cvcs); |
| | |
| | /// \brief Calculate the values of the given subset of CVCs |
| | int calc_cvc_values(int first, size_t num_cvcs); |
| | /// \brief Same as \link colvar::calc_cvc_values \endlink but for gradients |
| | int calc_cvc_gradients(int first, size_t num_cvcs); |
| | /// \brief Same as \link colvar::calc_cvc_values \endlink but for total forces |
| | int calc_cvc_total_force(int first, size_t num_cvcs); |
| | /// \brief Same as \link colvar::calc_cvc_values \endlink but for Jacobian derivatives/forces |
| | int calc_cvc_Jacobians(int first, size_t num_cvcs); |
| | |
| | /// \brief Collect quantities from CVCs and update aggregated data for the colvar |
| | int collect_cvc_data(); |
| | |
| | /// \brief Collect the values of the CVCs |
| | int collect_cvc_values(); |
| | /// \brief Same as \link colvar::collect_cvc_values \endlink but for gradients |
| | int collect_cvc_gradients(); |
| | /// \brief Same as \link colvar::collect_cvc_values \endlink but for total forces |
| | int collect_cvc_total_forces(); |
| | /// \brief Same as \link colvar::collect_cvc_values \endlink but for Jacobian derivatives/forces |
| | int collect_cvc_Jacobians(); |
| | /// \brief Calculate the quantities associated to the colvar (but not to the CVCs) |
| | int calc_colvar_properties(); |
| | |
| /// \brief Calculate just the value, and store it in the argument | /// Get the current applied force |
| void calc_value(colvarvalue &xn); | inline colvarvalue const applied_force() const |
| | { |
| | if (is_enabled(f_cv_extended_Lagrangian)) { |
| | return fr; |
| | } |
| | return f; |
| | } |
| | |
| /// Set the total biasing force to zero | /// Set the total biasing force to zero |
| void reset_bias_force(); | void reset_bias_force(); |
| |
| /// equations of motion of internal degrees of freedom; see also | /// equations of motion of internal degrees of freedom; see also |
| /// colvar::communicate_forces() | /// colvar::communicate_forces() |
| /// return colvar energy if extended Lagrandian active | /// return colvar energy if extended Lagrandian active |
| cvm::real update(); | cvm::real update_forces_energy(); |
| | |
| /// \brief Communicate forces (previously calculated in | /// \brief Communicate forces (previously calculated in |
| /// colvar::update()) to the external degrees of freedom | /// colvar::update()) to the external degrees of freedom |
| |
| /// \brief Enables and disables individual CVCs based on flags | /// \brief Enables and disables individual CVCs based on flags |
| int set_cvc_flags(std::vector<bool> const &flags); | int set_cvc_flags(std::vector<bool> const &flags); |
| | |
| | /// \brief Updates the flags in the CVC objects, and their number |
| | int update_cvc_flags(); |
| | |
| | protected: |
| | /// \brief Number of CVC objects with an active flag |
| | size_t n_active_cvcs; |
| | |
| | /// Sum of square coefficients for active cvcs |
| | cvm::real active_cvc_square_norm; |
| | |
| | /// Time step multiplier (for coarse-time-step colvars) |
| | /// Colvar will only be calculated at those times; biases may ignore the information and |
| | /// always update their own forces (which is typically inexpensive) especially if |
| | /// they rely on other colvars. In this case, the colvar will accumulate forces applied between |
| | /// colvar updates. Alternately they may use it to calculate "impulse" biasing |
| | /// forces at longer intervals. Impulse forces must be multiplied by the timestep factor. |
| | int time_step_factor; |
| | |
| | /// Biasing force collected between updates, to be applied at next update for coarse-time-step colvars |
| | colvarvalue f_accumulated; |
| | |
| | public: |
| | /// \brief Return the number of CVC objects with an active flag (as set by update_cvc_flags) |
| | inline size_t num_active_cvcs() const { return n_active_cvcs; } |
| | |
| | /// \brief returns time_step_factor |
| | inline int get_time_step_factor() const {return time_step_factor;} |
| | |
| /// \brief Use the internal metrics (as from \link cvc | /// \brief Use the internal metrics (as from \link cvc |
| /// \endlink objects) to calculate square distances and gradients | /// \endlink objects) to calculate square distances and gradients |
| /// | /// |
| |
| | |
| | |
| protected: | protected: |
| | |
| /// Previous value (to calculate velocities during analysis) | /// Previous value (to calculate velocities during analysis) |
| colvarvalue x_old; | colvarvalue x_old; |
| | |
| |
| class distance_inv; | class distance_inv; |
| class distance_pairs; | class distance_pairs; |
| class angle; | class angle; |
| | class dipole_angle; |
| class dihedral; | class dihedral; |
| class coordnum; | class coordnum; |
| class selfcoordnum; | class selfcoordnum; |
| | class groupcoordnum; |
| class h_bond; | class h_bond; |
| class rmsd; | class rmsd; |
| class orientation_angle; | class orientation_angle; |
| |
| std::vector<bool> cvc_flags; | std::vector<bool> cvc_flags; |
| | |
| /// \brief Initialize the sorted list of atom IDs for atoms involved | /// \brief Initialize the sorted list of atom IDs for atoms involved |
| /// in all cvcs (called when enabling task_collect_gradients) | /// in all cvcs (called when enabling f_cv_collect_gradients) |
| void build_atom_list(void); | void build_atom_list(void); |
| | |
| private: | private: |
| |
| } | } |
| | |
| | |
| inline colvarvalue const & colvar::system_force() const | inline colvarvalue const & colvar::total_force() const |
| { | { |
| return ft_reported; | return ft_reported; |
| } | } |
| |
| | |
| inline void colvar::add_bias_force(colvarvalue const &force) | inline void colvar::add_bias_force(colvarvalue const &force) |
| { | { |
| | if (cvm::debug()) { |
| | cvm::log("Adding biasing force "+cvm::to_str(force)+" to colvar \""+name+"\".\n"); |
| | } |
| fb += force; | fb += force; |
| } | } |
| | |