|
|
std::string | function_type () const |
| | String identifier for the type of collective variable.
|
|
| cvc () |
| | Constructor.
|
|
| cvc (colvarmodule *cvmodule_in) |
|
virtual | ~cvc () |
| | Destructor.
|
| virtual int | init (std::string const &conf) |
|
virtual int | init_gpu () |
| | Initialize GPU data.
|
| int | init_dependencies () override |
| | Initialize dependency tree.
|
|
int | setup () |
| | After construction, set data related to dependency handling.
|
| virtual const std::vector< feature * > & | features () const override |
| | Implementation of the feature list accessor for colvar.
|
| virtual std::vector< feature * > & | modify_features () override |
|
virtual std::vector< std::vector< int > > | get_atom_lists () |
| | Get vector of vectors of atom IDs for all atom groups.
|
|
virtual void | read_data () |
| | Obtain data needed for the calculation for the backend.
|
|
virtual int | read_data_gpu () |
| virtual void | calc_value ()=0 |
| | Calculate the variable.
|
|
virtual int | calc_value_gpu () |
| virtual int | calc_value_after_gpu () |
| | CPU-side calculation after the graph in add_calc_value_node is done on GPU.
|
| virtual void | calc_gradients () |
| | Calculate the atomic gradients, to be reused later in order to apply forces.
|
|
virtual int | calc_gradients_gpu () |
| virtual int | calc_gradients_after_gpu () |
| | CPU-side calculation after the graph in add_calc_gradients_node is done on GPU.
|
|
void | calc_fit_gradients () |
| | Calculate the atomic fit gradients.
|
|
int | calc_fit_gradients_gpu () |
| virtual void | debug_gradients () |
| | Calculate finite-difference gradients alongside the analytical ones, for each Cartesian component.
|
| virtual void | collect_gradients (std::vector< int > const &atom_ids, std::vector< cvm::rvector > &atomic_gradients) |
| | Calculate atomic gradients and add them to the corresponding item in gradient vector May be overridden by CVCs that do not store their gradients in the classic way, see dihedPC.
|
| virtual void | calc_force_invgrads () |
| | Calculate the total force from the system using the inverse atomic gradients.
|
|
virtual int | calc_force_invgrads_gpu () |
| virtual int | calc_force_invgrads_after_gpu () |
| | CPU-side calculation after the graph in add_calc_force_invgrads_node is done on GPU.
|
| virtual void | calc_Jacobian_derivative () |
| | Calculate the divergence of the inverse atomic gradients.
|
|
virtual int | calc_Jacobian_derivative_gpu () |
| virtual int | calc_Jacobian_derivative_after_gpu () |
| | CPU-side calculation after the graph in add_calc_Jacobian_derivative_node is done on GPU.
|
| virtual int | debug_gradients_gpu () |
| | Calculate finite-difference gradients alongside the analytical ones, for each Cartesian component on GPU.
|
|
const cudaEvent_t & | get_event (event_type type) const |
| | Getter of a specific CUDA event.
|
|
colvarvalue const & | value () const |
| | Return the previously calculated value.
|
|
colvarvalue const & | total_force () const |
| | Return the previously calculated total force.
|
|
colvarvalue const & | Jacobian_derivative () const |
| | Return the previously calculated divergence of the inverse atomic gradients.
|
| virtual void | apply_force (colvarvalue const &cvforce) |
| | Apply the collective variable force, by communicating the atomic forces to the simulation program (Note: the ft member is not altered by this function).
|
|
virtual int | begin_apply_force_from_cpu_to_gpu () |
| | Function to clean the staged atom group forces.
|
| virtual cvm::real | dist2 (colvarvalue const &x1, colvarvalue const &x2) const |
| virtual colvarvalue | dist2_lgrad (colvarvalue const &x1, colvarvalue const &x2) const |
| | Gradient(with respect to x1) of the square distance (can be redefined to transparently implement constraints, symmetries and periodicities).
|
| virtual colvarvalue | dist2_rgrad (colvarvalue const &x1, colvarvalue const &x2) const |
| | Gradient(with respect to x2) of the square distance (can be redefined to transparently implement constraints, symmetries and periodicities).
|
| virtual void | wrap (colvarvalue &x_unwrapped) const |
| | Wrap value (for periodic/symmetric cvcs).
|
|
void | register_atom_group (cvm::atom_group *ag) |
| | Store a pointer to new atom group, and list as child for dependencies.
|
|
virtual colvarvalue const * | get_param_grad (std::string const ¶m_name) |
| | Pointer to the gradient of parameter param_name.
|
| virtual int | set_param (std::string const ¶m_name, void const *new_value) override |
| | Set the named parameter to the given value.
|
| void | set_value (colvarvalue const &new_value, bool now=false) |
|
| colvardeps (object_t type_in) |
|
| colvardeps (object_t type_in, colvarmodule *cvmodule_in) |
|
object_t | get_object_type () const |
|
void | init_gpu () |
| | Function to initialize the GPU stream and event.
|
| virtual int | proxy_gpu_buffers_reallocated () |
| | Function to call when proxy buffer pointers are changed (re-allocated).
|
|
int | get_time_step_factor () const |
| | returns time_step_factor
|
|
void | init_feature (int feature_id, const char *description, feature_type type) |
| | Pair a numerical feature ID with a description and type.
|
|
const cudaStream_t & | get_stream () const |
| | Get the GPU stream.
|
|
bool | is_not_set (int id) |
|
bool | is_dynamic (int id) |
|
bool | is_static (int id) |
|
bool | is_user (int id) |
|
void | add_child (colvardeps *child) |
|
void | remove_child (colvardeps *child) |
| void | remove_all_children () |
|
bool | is_enabled (int f=f_cv_active) const |
|
bool | is_available (int f=f_cv_active) const |
| void | provide (int feature_id, bool truefalse=true) |
|
void | set_enabled (int feature_id, bool truefalse=true) |
| | Enable or disable, depending on flag value.
|
| int | enable (int f, bool dry_run=false, bool toplevel=true, bool error=false) |
| int | disable (int f) |
| void | free_children_deps () |
|
void | restore_children_deps () |
| | re-enable children features (to be used when object becomes active)
|
| int | decr_ref_count (int f) |
| virtual void | do_feature_side_effects (int) |
|
void | require_feature_self (int f, int g) |
| | Make feature f require feature g within the same object.
|
|
void | exclude_feature_self (int f, int g) |
| | Make features f and g mutually exclusive within the same object.
|
|
void | require_feature_children (int f, int g) |
| | Make feature f require feature g within children.
|
|
void | require_feature_alt (int f, int g, int h) |
| | Make feature f require either g or h within the same object.
|
|
void | require_feature_alt (int f, int g, int h, int i) |
| | Make feature f require any of g, h, or i within the same object.
|
|
void | require_feature_alt (int f, int g, int h, int i, int j) |
| | Make feature f require any of g, h, i, or j within the same object.
|
|
void | print_state () |
| | print all enabled features and those of children, for debugging
|
|
std::vector< colvardeps * > | get_parents () const |
| | Return the parents.
|
|
std::vector< colvardeps * > | get_children () const |
| | Return the children.
|
|
colvarmodule * | get_cvmodule () |
| | colvarparse (colvarmodule *cvmodule_in) |
| | Default constructor.
|
|
void | clear () |
| | Set the object ready to parse a new configuration string.
|
|
void | set_string (std::string const &conf) |
| | Set a new config string for this object.
|
|
| ~colvarparse () override |
| | Default destructor.
|
|
std::string const & | get_config () const |
| | Get the configuration string (includes comments).
|
|
int | check_keywords (std::string &conf, char const *key) |
| | Check that all the keywords within "conf" are in the list of allowed keywords; this will invoke strip_values() first and then loop over all words.
|
|
void | clear_keyword_registry () |
| | Use this after parsing a config string (note that check_keywords() calls it already).
|
|
bool | get_keyval (std::string const &conf, char const *key, int &value, int const &def_value=0, Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, size_t &value, size_t const &def_value=0, Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, long &value, long const &def_value=0, Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, cvm::step_number &value, cvm::step_number const &def_value=0, Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::string &value, std::string const &def_value=std::string(""), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, cvm::real &value, cvm::real const &def_value=0.0, Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, cvm::rvector &value, cvm::rvector const &def_value=cvm::rvector(), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, cvm::quaternion &value, cvm::quaternion const &def_value=cvm::quaternion(), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, colvarvalue &value, colvarvalue const &def_value=colvarvalue(colvarvalue::type_notset), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, bool &value, bool const &def_value=false, Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::vector< int > &values, std::vector< int > const &def_values=std::vector< int >(0, 0), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::vector< size_t > &values, std::vector< size_t > const &def_values=std::vector< size_t >(0, 0), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::vector< long > &values, std::vector< long > const &def_values=std::vector< long >(0, 0), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::vector< std::string > &values, std::vector< std::string > const &def_values=std::vector< std::string >(0, std::string("")), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::vector< cvm::real > &values, std::vector< cvm::real > const &def_values=std::vector< cvm::real >(0, 0.0), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::vector< cvm::rvector > &values, std::vector< cvm::rvector > const &def_values=std::vector< cvm::rvector >(0, cvm::rvector()), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::vector< cvm::quaternion > &values, std::vector< cvm::quaternion > const &def_values=std::vector< cvm::quaternion >(0, cvm::quaternion()), Parse_Mode const parse_mode=parse_normal) |
|
bool | get_keyval (std::string const &conf, char const *key, std::vector< colvarvalue > &values, std::vector< colvarvalue > const &def_values=std::vector< colvarvalue >(0, colvarvalue(colvarvalue::type_notset)), Parse_Mode const parse_mode=parse_normal) |
| bool | key_lookup (std::string const &conf, char const *key, std::string *data=nullptr, size_t *save_pos=nullptr) |
| | Low-level function for parsing configuration strings; automatically adds the requested keyword to the list of valid ones.
|
| std::istream & | read_config_line (std::istream &is, std::string &line) |
| | Reads a configuration line, adds it to config_string, and returns the stream.
|
| int | check_ascii (std::string const &conf) |
| | Check that a config string contains non-ASCII characters.
|
|
template<> |
| int | _get_keyval_scalar_value_ (std::string const &key_str, std::string const &data, bool &value, bool const &) |
|
template<> |
| int | _get_keyval_scalar_novalue_ (std::string const &key_str, bool &value, Parse_Mode const &parse_mode) |
|
int | param_exists (std::string const ¶m_name) |
| | Whether the parameter param_name exists.
|
|
virtual std::vector< std::string > | get_param_names () |
| | Get a copy of the names of registered parameters.
|
|
virtual std::vector< std::string > | get_param_grad_names () |
| | Get a copy of the names of registered parameter gradients.
|
|
virtual void const * | get_param_ptr (std::string const ¶m_name) |
| | Pointer to the parameter param_name.
|
|
virtual void const * | get_param_grad_ptr (std::string const ¶m_name) |
| | Pointer to the gradient of parameter param_name.
|
|
virtual cvm::real | get_param (std::string const ¶m_name) |
| | Value of the parameter param_name (must be a scalar).
|
|
|
int | set_function_type (std::string const &type) |
| | Set the value of function_type and its dependencies.
|
|
int | update_description () |
| | Update the description string based on name and type.
|
|
cvm::atom_group * | parse_group (std::string const &conf, char const *group_key, bool optional=false) |
| | Parse a group definition.
|
|
virtual int | init_total_force_params (std::string const &conf) |
| | Parse options pertaining to total force calculation.
|
|
void | init_as_distance () |
| | Set data types for a scalar distance (convenience function).
|
|
void | init_as_angle () |
| | Set data types for a bounded angle (0° to 180°).
|
|
void | init_as_periodic_angle () |
| | Set data types for a periodic angle (-180° to 180°).
|
|
void | init_scalar_boundaries (cvm::real lb, cvm::real ub) |
| | Set two scalar boundaries (convenience function).
|
|
bool | get_keyval_feature (colvarparse *cvp, std::string const &conf, char const *key, int feature_id, bool const &def_value, colvarparse::Parse_Mode const parse_mode=colvarparse::parse_normal) |
| | Parse a keyword and enable a feature accordingly.
|
|
bool | get_key_string_value (std::string const &conf, char const *key, std::string &data) |
| | Get the string value of a keyword, and save it for later parsing.
|
|
bool | get_key_string_multi_value (std::string const &conf, char const *key, std::vector< std::string > &data) |
| | Get multiple strings from repeated instances of a same keyword.
|
|
template<typename TYPE> |
| bool | _get_keyval_scalar_ (std::string const &conf, char const *key, TYPE &value, TYPE const &def_value, Parse_Mode const &parse_mode) |
| | Template for single-value keyword parsers.
|
|
template<typename TYPE> |
| bool | _get_keyval_vector_ (std::string const &conf, char const *key, std::vector< TYPE > &values, std::vector< TYPE > const &def_values, Parse_Mode const &parse_mode) |
| | Template for multiple-value keyword parsers.
|
|
template<typename TYPE> |
| int | _get_keyval_scalar_value_ (std::string const &key_str, std::string const &data, TYPE &value, TYPE const &def_value) |
| | Extract the value of a variable from a string.
|
|
template<typename TYPE> |
| int | _get_keyval_scalar_novalue_ (std::string const &key_str, TYPE &value, Parse_Mode const &parse_mode) |
| | Handle the case where the user provides a keyword without value.
|
|
template<typename TYPE> |
| void | mark_key_set_user (std::string const &key_str, TYPE const &value, Parse_Mode const &parse_mode) |
| | Record that the keyword has just been user-defined.
|
|
template<typename TYPE> |
| void | mark_key_set_default (std::string const &key_str, TYPE const &def_value, Parse_Mode const &parse_mode) |
| | Record that the keyword has just been set to its default value.
|
|
void | error_key_required (std::string const &key_str, Parse_Mode const &parse_mode) |
| | Raise error condition due to the keyword being required!
|
|
bool | key_already_set (std::string const &key_str) |
| | True if the keyword has been set already.
|
|
void | add_keyword (char const *key) |
| | Add a new valid keyword to the list.
|
|
void | strip_values (std::string &conf) |
| | Remove all the values from the config string.
|
|
| colvarparams () |
| | Default constructor.
|
|
virtual | ~colvarparams () |
| | Default destructor.
|
|
void | register_param (std::string const ¶m_name, void *param_ptr) |
| | Register the given parameter.
|
|
void | register_param_grad (std::string const ¶m_name, colvarvalue *param_grad_ptr) |
| | Register the gradient of the given parameter.
|
Colvar component (base class for collective variables).
A colvar::cvc object (or an object of a cvc-derived class) implements the calculation of a collective variable, its gradients and any other related physical quantities that depend on microscopic degrees of freedom.
No restriction is set to what kind of calculation a colvar::cvc object performs (usually an analytical function of atomic coordinates). The only constraints are that:
- The value is calculated by the calc_value() method, and is an object of colvarvalue class. This provides a transparent way to treat scalar and non-scalar variables alike, and allows an automatic selection of the applicable algorithms.
- The object provides an implementation apply_force() to apply forces to atoms. Typically, one or more or colvarmodule::atom_group objects are used, but this is not a requirement for as long as the colvar::cvc object communicates with the simulation program.
If you wish to implement a new collective variable component, you should write your own class by inheriting directly from colvar::cvc, or one of its derived classes (for instance, colvar::distance is frequently used, because it provides useful data and function members for any colvar based on two atom groups).
The steps are:
- Declare the new class as a derivative of colvar::cvc in the file colvarcomp.h
- Implement the new class in a file named colvarcomp_<something>.cpp
- Declare the name of the new class inside the colvar class in colvar.h (see "list of available components")
- Add a call for the new class in colvar::init_components() (file: colvar.cpp)