colvar Class Reference

A collective variable (main class); to be defined, it needs at least one object of a derived class of colvar::cvc; it calculates and returns a object. More...

#include <colvar.h>

Inheritance diagram for colvar:

List of all members.

Public Types
enum	task {   task_gradients, task_fdiff_velocity, task_system_force, task_extended_lagrangian,   task_Jacobian_force, task_report_Jacobian_force, task_output_value, task_output_velocity,   task_output_applied_force, task_output_system_force, task_lower_boundary, task_upper_boundary,   task_grid, task_lower_wall, task_upper_wall, task_runave,   task_corrfunc, task_ntot }
	Options controlling the behaviour of the colvar during the simulation, which are set from outside the cvcs. More...
Public Member Functions
colvarvalue::Type	type () const
	Type of value.
colvarvalue const &	value () const
	Current value (previously obtained from calc() or read_traj()).
colvarvalue const &	velocity () const
	Current velocity (previously obtained from calc() or read_traj()).
colvarvalue const &	system_force () const
	Current system force (previously obtained from calc() or read_traj()). Note: this is calculated using the atomic forces from the last simulation step.
int	current_bin_scalar () const
	Use the two boundaries and the width to report which bin the current value is in.
int	value_to_bin_scalar (colvarvalue const &value) const
	Use the lower boundary and the width to report which bin the provided value is in.
int	value_to_bin_scalar (colvarvalue const &value, colvarvalue const &new_offset, cvm::real const &new_width) const
	Same as the standard version, but uses another grid definition.
colvarvalue	bin_to_value_scalar (int const &i_bin) const
	Use the two boundaries and the width to report the central value corresponding to a bin index.
colvarvalue	bin_to_value_scalar (int const &i_bin, colvarvalue const &new_offset, cvm::real const &new_width) const
	Same as the standard version, but uses different parameters.
bool	periodic_boundaries () const
	Is the interval defined by the two boundaries periodic?
bool	periodic_boundaries (colvarvalue const &lb, colvarvalue const &ub) const
	Is the interval defined by the two boundaries periodic?
	colvar (std::string const &conf)
	Constructor.
void	enable (colvar::task const &t)
	Enable the specified task.
void	disable (colvar::task const &t)
	Disable the specified task.
	~colvar ()
	Destructor.
void	calc ()
	Calculate the colvar value and all the other requested quantities.
void	calc_value (colvarvalue &xn)
	Calculate just the value, and store it in the argument.
void	reset_bias_force ()
	Set the total biasing force to zero.
void	add_bias_force (colvarvalue const &force)
	Add to the total force from biases.
void	update ()
	Collect all forces on this colvar, integrate internal equations of motion of internal degrees of freedom; see also colvar::communicate_forces().
void	communicate_forces ()
	Communicate forces (previously calculated in colvar::update()) to the external degrees of freedom.
cvm::real	dist2 (colvarvalue const &x1, colvarvalue const &x2) const
	Use the internal metrics (as from objects) to calculate square distances and gradients.
colvarvalue	dist2_lgrad (colvarvalue const &x1, colvarvalue const &x2) const
	Use the internal metrics (as from objects) to calculate square distances and gradients.
colvarvalue	dist2_rgrad (colvarvalue const &x1, colvarvalue const &x2) const
	Use the internal metrics (as from objects) to calculate square distances and gradients.
cvm::real	compare (colvarvalue const &x1, colvarvalue const &x2) const
	Use the internal metrics (as from objects) to compare colvar values.
void	parse_analysis (std::string const &conf)
	Read the analysis tasks.
void	analyse ()
	Perform analysis tasks.
std::istream &	read_traj (std::istream &is)
	Read the value from a collective variable trajectory file.
std::ostream &	write_traj (std::ostream &os)
	Output formatted values to the trajectory file.
std::ostream &	write_traj_label (std::ostream &os)
	Write a label to the trajectory file (comment line).
std::istream &	read_restart (std::istream &is)
	Read the collective variable from a restart file.
std::ostream &	write_restart (std::ostream &os)
	Write the collective variable to a restart file.
size_t	n_components () const
Public Attributes
std::string	name
	Name.
cvm::real	width
	Typical fluctuation amplitude for this collective variable (e.g. local width of a free energy basin).
bool	b_linear
	True if this is a linear superposition of elements.
bool	b_inverse_gradients
	True if all objects are capable of calculating inverse gradients.
bool	b_Jacobian_force
	True if all objects are capable of calculating Jacobian forces.
bool	tasks [task_ntot]
	Tasks performed by this colvar.
colvarvalue	fb
	Bias force; reset_bias_force() should be called before the biases are updated.
colvarvalue	f
	Total applied force; fr (if task_extended_lagrangian is defined), fb (if biases are applied) and the walls' forces (if defined) contribute to it.
colvarvalue	ft
	Total force, as derived from the atomic trajectory; should equal the total system force plus .
cvm::real	period
	Period, if it is a constant.
bool	b_periodic
	Same as above, but also takes into account components with a variable period, such as distanceZ.
bool	expand_boundaries
	Expand the boundaries of multiples of width, to keep the value always within range.
colvarvalue	lower_boundary
	Location of the lower boundary.
colvarvalue	lower_wall
	Location of the lower wall.
cvm::real	lower_wall_k
	Force constant for the lower boundary potential (|x-xb|^2).
colvarvalue	upper_boundary
	Location of the upper boundary.
colvarvalue	upper_wall
	Location of the upper wall.
cvm::real	upper_wall_k
	Force constant for the upper boundary potential (|x-xb|^2).
Protected Types
enum	acf_type_e { acf_notset, acf_vel, acf_coor, acf_p2coor }
	Type of autocorrelation function (ACF). More...
Protected Member Functions
colvarvalue	fdiff_velocity (colvarvalue const &xold, colvarvalue const &xnew)
void	calc_vel_acf (std::list< colvarvalue > &v_history, colvarvalue const &v)
	Velocity ACF, scalar product between v(0) and v(t).
void	calc_coor_acf (std::list< colvarvalue > &x_history, colvarvalue const &x)
	Coordinate ACF, scalar product between x(0) and x(t) (does not work with scalar numbers).
void	calc_p2coor_acf (std::list< colvarvalue > &x_history, colvarvalue const &x)
	Coordinate ACF, second order Legendre polynomial between x(0) and x(t) (does not work with scalar numbers).
void	calc_acf ()
	Calculate the auto-correlation function (ACF).
void	write_acf (std::ostream &os)
	Save the ACF to a file.
void	calc_runave ()
	Calculate the running average and its standard deviation.
Protected Attributes
colvarvalue	x
	Value of the colvar.
colvarvalue	x_reported
	Cached reported value (x may be manipulated).
colvarvalue	v_fdiff
	Finite-difference velocity.
colvarvalue	v_reported
	Cached reported velocity.
colvarvalue	xr
	Restraint center.
colvarvalue	vr
	Velocity of the restraint center.
cvm::real	ext_mass
	Mass of the restraint center.
cvm::real	ext_force_k
	Restraint force constant.
colvarvalue	fr
	Harmonic restraint force.
colvarvalue	fj
	Jacobian force, when task_Jacobian_force is enabled.
colvarvalue	ft_reported
	Cached reported system force.
colvarvalue	x_old
	Previous value (to calculate velocities during analysis).
std::list< std::list< colvarvalue > >	acf_x_history
std::list< std::list< colvarvalue > >	acf_v_history
std::list< std::list< colvarvalue > >::iterator	acf_x_history_p
std::list< std::list< colvarvalue > >::iterator	acf_v_history_p
std::list< std::list< colvarvalue > >	x_history
	Time series of values and velocities used in running averages.
std::list< std::list< colvarvalue > >::iterator	x_history_p
std::string	acf_colvar_name
	Collective variable with which the correlation is calculated (default: itself).
size_t	acf_length
	Length of autocorrelation function (ACF).
size_t	acf_offset
	After how many steps the ACF starts.
size_t	acf_stride
	How many timesteps separate two ACF values.
size_t	acf_nframes
	Number of frames for each ACF point.
bool	acf_normalize
	Normalize the ACF to a maximum value of 1?
std::vector< cvm::real >	acf
	ACF values.
std::string	acf_outfile
	Name of the file to write the ACF.
acf_type_e	acf_type
	Type of autocorrelation function (ACF).
size_t	runave_length
	Length of running average series.
size_t	runave_stride
	Timesteps to skip between two values in the running average series.
std::ofstream	runave_os
	Name of the file to write the running average.
colvarvalue	runave
	Current value of the running average.
cvm::real	runave_variance
	Current value of the square deviation from the running average.
std::vector< cvc * >	cvcs
	Array of objects.

---

Detailed Description

A collective variable (main class); to be defined, it needs at least one object of a derived class of colvar::cvc; it calculates and returns a object.

This class parses the configuration, defines the behaviour and stores the value () and all related data of a collective variable. How the value is calculated is defined in and its derived classes. The object contains pointers to multiple derived objects, which can be combined together into one collective variable. This makes possible to implement new collective variables at runtime based on the existing ones. Currently, this possibility is limited to a polynomial, using the coefficients cvc::sup_coeff and the exponents cvc::sup_np. In case of non-scalar variables, only exponents equal to 1 are accepted.

Please note that most of its members are objects, i.e. they can handle different data types together, and must all be set to the same type of colvar::x by using the colvarvalue::type() member function before using them together in assignments or other operations; this is usually done automatically in the constructor. If you add a new member of type, you should also add its initialization line in the constructor.

Definition at line 41 of file colvar.h.

---

Member Enumeration Documentation

enum colvar::acf_type_e [protected]

Type of autocorrelation function (ACF). Enumeration values: acf_notset  Unset type. acf_vel  Velocity ACF, scalar product between v(0) and v(t). acf_coor  Coordinate ACF, scalar product between x(0) and x(t). acf_p2coor  Coordinate ACF, second order Legendre polynomial between x(0) and x(t) (does not work with scalar numbers). Definition at line 410 of file colvar.h. { acf_notset, acf_vel, acf_coor, acf_p2coor };

enum colvar::task

Options controlling the behaviour of the colvar during the simulation, which are set from outside the cvcs. Enumeration values: task_gradients  Gradients are calculated and temporarily stored, so that external forces can be applied. task_fdiff_velocity  Calculate the velocity with finite differences. task_system_force  The system force is calculated, projecting the atomic forces on the inverse gradients. task_extended_lagrangian  The variable has a harmonic restraint around a moving center with fictitious mass; bias forces will be applied to the center. task_Jacobian_force  Compute analytically the "force" arising from the largest entropy component (for example, that from the angular states orthogonal to a distance vector). task_report_Jacobian_force  Report the Jacobian force as part of the system force if disabled, apply a correction internally to cancel it. task_output_value  Output the value to the trajectory file (on by default). task_output_velocity  Output the velocity to the trajectory file. task_output_applied_force  Output the applied force to the trajectory file. task_output_system_force  Output the system force to the trajectory file. task_lower_boundary  A lower boundary is defined. task_upper_boundary  An upper boundary is defined. task_grid  Provide a discretization of the values of the colvar to be used by the biases or in analysis (needs lower and upper boundary). task_lower_wall  Apply a restraining potential (|x-xb|^2) to the colvar when it goes below the lower wall. task_upper_wall  Apply a restraining potential (|x-xb|^2) to the colvar when it goes above the upper wall. task_runave  Compute running average. task_corrfunc  Compute time correlation function. task_ntot  Number of possible tasks. Definition at line 93 of file colvar.h. { task_gradients, task_fdiff_velocity, task_system_force, task_extended_lagrangian, task_Jacobian_force, task_report_Jacobian_force, task_output_value, task_output_velocity, task_output_applied_force, task_output_system_force, task_lower_boundary, task_upper_boundary, task_grid, task_lower_wall, task_upper_wall, task_runave, task_corrfunc, task_ntot };

---

Constructor & Destructor Documentation

colvar::colvar (  std::string const &  conf  )

Constructor. Definition at line 13 of file colvar.C. References b_inverse_gradients, b_Jacobian_force, b_linear, b_periodic, cvcs, colvarmodule::debug(), disable(), dist2(), enable(), expand_boundaries, ext_force_k, ext_mass, colvarmodule::fatal_error(), fr, initialize_forcepars, j, colvarmodule::log(), lower_boundary, lower_wall, lower_wall_k, parse_analysis(), period, periodic_boundaries(), task_extended_lagrangian, task_lower_boundary, task_lower_wall, task_output_applied_force, task_output_system_force, task_output_value, task_output_velocity, task_upper_boundary, task_upper_wall, tasks, colvarvalue::type(), type(), upper_boundary, upper_wall, upper_wall_k, vr, width, x, x_reported, and xr. { cvm::log ("Initializing a new collective variable.\n"); get_keyval (conf, "name", this->name, (std::string ("colvar")+cvm::to_str (cvm::colvars.size()+1))); for (std::vector<colvar *>::iterator cvi = cvm::colvars.begin(); cvi < cvm::colvars.end(); cvi++) { if ((*cvi)->name == this->name) cvm::fatal_error ("Error: this colvar has the same name, \""+this->name+ "\", of another colvar.\n"); } // all tasks disabled by default for (size_t i = 0; i < task_ntot; i++) { tasks[i] = false; } // read the configuration and set up corresponding instances, for // each type of forcepar implemented #define initialize_forcepars(def_desc,def_config_key,def_class_name) \ { \ size_t def_count = 0; \ std::string def_conf = ""; \ size_t pos = 0; \ while ( this->key_lookup (conf, \ def_config_key, \ def_conf, \ pos) ) { \ if (!def_conf.size()) continue; \ cvm::log ("Initializing " \ "a new \""+std::string (def_desc)+"\" component"+ \ (cvm::debug() ? ", with configuration:\n"+def_conf \ : ".\n")); \ cvm::increase_depth(); \ cvc *cvdp = new colvar::def_class_name (def_conf); \ cvdp->check_keywords (def_conf, def_config_key); \ cvm::decrease_depth(); \ if (cvdp != NULL) \ cvcs.push_back (cvdp); \ else cvm::fatal_error ("Error: in allocating component \"" \ def_config_key"\".\n"); \ if ( ! cvcs.back()->name.size()) \ cvcs.back()->name = std::string (def_config_key)+ \ (cvm::to_str (++def_count)); \ if (cvm::debug()) \ cvm::log ("Done initializing a component of type \""+ \ std::string (def_desc)+"\""+ \ (cvm::debug() ? \ ", named \""+cvcs.back()->name+"\"" \ : "")+".\n"); \ def_conf = ""; \ if (cvm::debug()) \ cvm::log ("Parsed "+cvm::to_str (cvcs.size())+ \ " components at this time.\n"); \ } \ } initialize_forcepars ("distance", "distance", distance); // initialize_forcepars ("distance vector", "distanceVec", distance_vec); initialize_forcepars ("distance vector " "direction", "distanceDir", distance_dir); initialize_forcepars ("distance projection " "on an axis", "distanceZ", distance_z); initialize_forcepars ("distance projection " "on a plane", "distanceXY", distance_xy); initialize_forcepars ("minimum distance", "minDistance", min_distance); initialize_forcepars ("coordination " "number", "coordnum", coordnum); initialize_forcepars ("angle", "angle", angle); initialize_forcepars ("dihedral", "dihedral", dihedral); initialize_forcepars ("hydrogen bond", "hBond", h_bond); initialize_forcepars ("alpha helix", "alphaDihedrals", alpha_dihedrals); initialize_forcepars ("alpha helix", "alpha", alpha_angles); initialize_forcepars ("orientation", "orientation", orientation); initialize_forcepars ("orientation " "angle", "orientationAngle",orientation_angle); initialize_forcepars ("RMSD", "rmsd", rmsd); initialize_forcepars ("logarithm of MSD", "logmsd", logmsd); initialize_forcepars ("radius of " "gyration", "gyration", gyration); initialize_forcepars ("eigenvector", "eigenvector", eigenvector); if (!cvcs.size()) cvm::fatal_error ("Error: no valid components were provided " "for this collective variable.\n"); cvm::log ("All components initialized.\n"); // this is set false if any of the components has an exponent // different from 1 in the polynomial b_linear = true; // these will be set to false if any of the cvcs has them false b_inverse_gradients = true; b_Jacobian_force = true; this->period = 0.0; b_periodic = false; // check the available features of each cvc for (size_t i = 0; i < cvcs.size(); i++) { if ((cvcs[i])->sup_np != 1) { if (cvm::debug() && b_linear) cvm::log ("Warning: You are using a non-linear polynomial " "superposition to define this collective variable, " "some biasing methods may be unavailable.\n"); b_linear = false; if ((cvcs[i])->sup_np < 0) { cvm::log ("Warning: you chose a negative exponent in the superposition; " "if you apply forces, the simulation may become unstable " "when the component \""+ (cvcs[i])->function_type+"\" approaches zero.\n"); } } this->b_periodic = (cvcs[i])->b_periodic; this->period = (cvcs[i])->period; if (this->b_periodic && (cvcs.size() > 1)) { cvm::fatal_error ("Error: superposition of periodic " "components is unsupported.\n"); } if (! (cvcs[i])->b_inverse_gradients) b_inverse_gradients = false; if (! (cvcs[i])->b_Jacobian_derivative) b_Jacobian_force = false; for (size_t j = i; j < cvcs.size(); j++) { if ( (cvcs[i])->type() != (cvcs[j])->type() ) { cvm::fatal_error ("ERROR: you are definining this collective variable " "by using components of different types, \""+ colvarvalue::type_desc[(cvcs[i])->type()]+ "\" and \""+ colvarvalue::type_desc[(cvcs[j])->type()]+ "\". " "You must use the same type in order to " " sum them together.\n"); } } } { colvarvalue::Type const value_type = (cvcs[0])->type(); if (cvm::debug()) cvm::log ("This collective variable is a "+ colvarvalue::type_desc[value_type]+", corresponding to "+ cvm::to_str (colvarvalue::dof_num[value_type])+ " internal degrees of freedom.\n"); x.type (value_type); x_reported.type (value_type); } get_keyval (conf, "width", width, 1.0); if (width <= 0.0) cvm::fatal_error ("Error: \"width\" must be positive.\n"); lower_boundary.type (this->type()); lower_wall.type (this->type()); upper_boundary.type (this->type()); upper_wall.type (this->type()); if (this->type() == colvarvalue::type_scalar) { if (get_keyval (conf, "lowerBoundary", lower_boundary, lower_boundary)) { enable (task_lower_boundary); } get_keyval (conf, "lowerWallConstant", lower_wall_k, 0.0); if (lower_wall_k > 0.0) { get_keyval (conf, "lowerWall", lower_wall, lower_boundary); enable (task_lower_wall); } if (get_keyval (conf, "upperBoundary", upper_boundary, upper_boundary)) { enable (task_upper_boundary); } get_keyval (conf, "upperWallConstant", upper_wall_k, 0.0); if (upper_wall_k > 0.0) { get_keyval (conf, "upperWall", upper_wall, upper_boundary); enable (task_upper_wall); } } // consistency checks for boundaries and walls if (tasks[task_lower_boundary] && tasks[task_upper_boundary]) { if (lower_boundary >= upper_boundary) { cvm::fatal_error ("Error: the upper boundary, "+ cvm::to_str (upper_boundary)+ ", is not higher than the lower boundary, "+ cvm::to_str (lower_boundary)+".\n"); } } if (tasks[task_lower_wall] && tasks[task_upper_wall]) { if (lower_wall >= upper_wall) { cvm::fatal_error ("Error: the upper wall, "+ cvm::to_str (upper_wall)+ ", is not higher than the lower wall, "+ cvm::to_str (lower_wall)+".\n"); } if (dist2 (lower_wall, upper_wall) < 1.0E-12) { cvm::log ("Lower wall and upper wall are equal " "in the periodic domain of the colvar: disabling walls.\n"); disable (task_lower_wall); disable (task_upper_wall); } } get_keyval (conf, "expandBoundaries", expand_boundaries, false); if (expand_boundaries && periodic_boundaries()) { cvm::fatal_error ("Error: trying to expand boundaries that already " "cover a whole period of a periodic colvar.\n"); } { bool b_extended_lagrangian; get_keyval (conf, "extendedLagrangian", b_extended_lagrangian, false); if (b_extended_lagrangian) { cvm::log ("Enabling the extended lagrangian term for colvar \""+ this->name+"\".\n"); enable (task_extended_lagrangian); xr.type (this->type()); vr.type (this->type()); fr.type (this->type()); get_keyval (conf, "extendedForceConstant", ext_force_k, 1.0); if (ext_force_k <= 0.0) cvm::fatal_error ("Error: \"extended_force_constant\" must be positive.\n"); get_keyval (conf, "extendedFictitiousMass", ext_mass, 1.0); if (ext_mass <= 0.0) cvm::fatal_error ("Error: \"extended_fictitious_mass\" must be positive.\n"); } } //{ // bool b_jacobian_force; // get_keyval (conf, "JacobianForce", b_jacobian_force, false); // if (b_jacobian_force) { // enable (task_Jacobian_force); // } //} { bool b_output_value; get_keyval (conf, "outputValue", b_output_value, true); if (b_output_value) { enable (task_output_value); } } { bool b_output_velocity; get_keyval (conf, "outputVelocity", b_output_velocity, false); if (b_output_velocity) { enable (task_output_velocity); } } { bool b_output_system_force; get_keyval (conf, "outputSystemForce", b_output_system_force, false); if (b_output_system_force) { enable (task_output_system_force); } } { bool b_output_applied_force; get_keyval (conf, "outputAppliedForce", b_output_applied_force, false); if (b_output_applied_force) { enable (task_output_applied_force); } } if (cvm::b_analysis) parse_analysis (conf); if (cvm::debug()) cvm::log ("Done initializing collective variable \""+this->name+"\".\n"); }

colvar::~colvar (   )

Destructor. Definition at line 542 of file colvar.C. References acf, acf_outfile, cvcs, colvarmodule::fatal_error(), colvarmodule::log(), runave_os, and write_acf(). { if (cvm::b_analysis) { if (acf.size()) { cvm::log ("Writing acf to file \""+acf_outfile+"\".\n"); std::ofstream acf_os (acf_outfile.c_str()); if (! acf_os.good()) cvm::fatal_error ("Cannot open file \""+acf_outfile+"\".\n"); write_acf (acf_os); acf_os.close(); } if (runave_os.good()) { runave_os.close(); } } for (size_t i = 0; i < cvcs.size(); i++) { delete cvcs[i]; } }

---

Member Function Documentation

void colvar::add_bias_force (  colvarvalue const &  force  )  [inline]

Add to the total force from biases. Definition at line 571 of file colvar.h. References fb. Referenced by colvarbias::communicate_forces(). { fb += force; }

void colvar::analyse (   )

Perform analysis tasks. Definition at line 1147 of file colvar.C. References calc_acf(), calc_runave(), and tasks. { if (tasks[task_runave]) { calc_runave(); } if (tasks[task_corrfunc]) { calc_acf(); } }

colvarvalue colvar::bin_to_value_scalar (  int const &  i_bin, colvarvalue const &  new_offset, cvm::real const &  new_width )  const [inline]

Same as the standard version, but uses different parameters. Definition at line 563 of file colvar.h. References colvarvalue::real_value. { return new_offset.real_value + new_width * (0.5 + i_bin); }

colvarvalue colvar::bin_to_value_scalar (  int const &  i_bin  )  const [inline]

Use the two boundaries and the width to report the central value corresponding to a bin index. Definition at line 558 of file colvar.h. References lower_boundary, colvarvalue::real_value, and width. { return lower_boundary.real_value + width * (0.5 + i_bin); }

void colvar::calc (   )

Calculate the colvar value and all the other requested quantities. Definition at line 571 of file colvar.C. References cvcs, colvarmodule::debug(), colvarmodule::decrease_depth(), fdiff_velocity(), ft, ft_reported, colvarmodule::increase_depth(), colvarmodule::log(), colvarmodule::real, colvarvalue::reset(), colvarmodule::step_relative(), tasks, colvarvalue::type(), v_fdiff, v_reported, x, x_old, x_reported, and xr. { if (cvm::debug()) cvm::log ("Calculating colvar \""+this->name+"\".\n"); // calculate the value of the colvar x.reset(); if (x.type() == colvarvalue::type_scalar) { // scalar variable, polynomial superposition allowed for (size_t i = 0; i < cvcs.size(); i++) { cvm::increase_depth(); (cvcs[i])->calc_value(); cvm::decrease_depth(); if (cvm::debug()) cvm::log ("Colvar component no. "+cvm::to_str (i+1)+ " within colvar \""+this->name+"\" has value "+ cvm::to_str ((cvcs[i])->value(), cvm::cv_width, cvm::cv_prec)+".\n"); x += (cvcs[i])->sup_coeff * ( ((cvcs[i])->sup_np != 1) ? ::pow ((cvcs[i])->value().real_value, (cvcs[i])->sup_np) : (cvcs[i])->value().real_value ); } } else { for (size_t i = 0; i < cvcs.size(); i++) { cvm::increase_depth(); (cvcs[i])->calc_value(); cvm::decrease_depth(); if (cvm::debug()) cvm::log ("Colvar component no. "+cvm::to_str (i+1)+ " within colvar \""+this->name+"\" has value "+ cvm::to_str ((cvcs[i])->value(), cvm::cv_width, cvm::cv_prec)+".\n"); x += (cvcs[i])->sup_coeff * (cvcs[i])->value(); } } if (cvm::debug()) cvm::log ("Colvar \""+this->name+"\" has value "+ cvm::to_str (x, cvm::cv_width, cvm::cv_prec)+".\n"); if (tasks[task_gradients]) { // calculate the gradients for (size_t i = 0; i < cvcs.size(); i++) { cvm::increase_depth(); (cvcs[i])->calc_gradients(); cvm::decrease_depth(); } } if (tasks[task_system_force] && (cvm::step_relative() > 0)) { // get from the cvcs the system forces from the PREVIOUS step ft.reset(); for (size_t i = 0; i < cvcs.size(); i++) { (cvcs[i])->calc_force_invgrads(); // linear superposition is assumed cvm::increase_depth(); ft += (cvcs[i])->system_force() / ((cvcs[i])->sup_coeff * cvm::real (cvcs.size())); cvm::decrease_depth(); } } if (tasks[task_report_Jacobian_force]) { // add the Jacobian force to the system force, and don't apply the // correction internally: biases such as colvarbias_abf will handle it ft += fj; } if (tasks[task_fdiff_velocity]) { // calculate the velocity by finite differences if (cvm::step_relative() == 0) x_old = x; else { v_fdiff = fdiff_velocity (x_old, x); v_reported = v_fdiff; } } if (tasks[task_extended_lagrangian]) { // initialize the restraint center in the first step to the value // just calculated from the cvcs; XX TODO: put it in the // restart information if (cvm::step_relative() == 0) xr = x; // report the restraint center as "value" x_reported = xr; v_reported = vr; // the "system force" with the extended lagrangian is just the // harmonic term ft_reported = fr; } else { x_reported = x; ft_reported = ft; } if (cvm::debug()) cvm::log ("Done calculating colvar \""+this->name+"\".\n"); }

void colvar::calc_acf (   )  [protected]

Calculate the auto-correlation function (ACF). Definition at line 1176 of file colvar.C. References acf, acf_colvar_name, acf_coor, acf_length, acf_nframes, acf_offset, acf_p2coor, acf_v_history, acf_v_history_p, acf_vel, acf_x_history, acf_x_history_p, calc_coor_acf(), calc_p2coor_acf(), calc_vel_acf(), colvarmodule::colvar_p(), colvarmodule::fatal_error(), fdiff_velocity(), history_add_value(), history_incr(), colvarmodule::log(), name, tasks, type(), v_fdiff, v_reported, value(), velocity(), and x_old. Referenced by analyse(). { // using here an acf_stride-long list of vectors for either // coordinates (acf_x_history) or velocities (acf_v_history); each vector can // contain up to acf_length values, which are contiguous in memory // representation but separated by acf_stride in the time series; // the pointer to each vector is changed at every step if (! (acf_x_history.size() || acf_v_history.size()) ) { // first-step operations colvar *cfcv = (acf_colvar_name.size() ? cvm::colvar_p (acf_colvar_name) : this); if (cfcv->type() != this->type()) cvm::fatal_error ("Error: correlation function between \""+cfcv->name+ "\" and \""+this->name+"\" cannot be calculated, " "because their value types are different.\n"); acf_nframes = 0; cvm::log ("Colvar \""+this->name+"\": initializing ACF calculation.\n"); if (acf.size() < acf_length+1) acf.resize (acf_length+1, 0.0); switch (acf_type) { case acf_vel: // allocate space for the velocities history for (size_t i = 0; i < acf_stride; i++) { acf_v_history.push_back (std::list<colvarvalue>()); } acf_v_history_p = acf_v_history.begin(); break; case acf_coor: case acf_p2coor: // allocate space for the coordinates history for (size_t i = 0; i < acf_stride; i++) { acf_x_history.push_back (std::list<colvarvalue>()); } acf_x_history_p = acf_x_history.begin(); break; default: break; } } else { colvar *cfcv = (acf_colvar_name.size() ? cvm::colvar_p (acf_colvar_name) : this); switch (acf_type) { case acf_vel: if (tasks[task_fdiff_velocity]) { // calc() should do this already, but this only happens in a // simulation; better do it again in case a trajectory is // being read v_reported = v_fdiff = fdiff_velocity (x_old, cfcv->value()); } calc_vel_acf ((*acf_v_history_p), cfcv->velocity()); // store this value in the history history_add_value (acf_length+acf_offset, *acf_v_history_p, cfcv->velocity()); // if stride is larger than one, cycle among different histories history_incr (acf_v_history, acf_v_history_p); break; case acf_coor: calc_coor_acf ((*acf_x_history_p), cfcv->value()); history_add_value (acf_length+acf_offset, *acf_x_history_p, cfcv->value()); history_incr (acf_x_history, acf_x_history_p); break; case acf_p2coor: calc_p2coor_acf ((*acf_x_history_p), cfcv->value()); history_add_value (acf_length+acf_offset, *acf_x_history_p, cfcv->value()); history_incr (acf_x_history, acf_x_history_p); break; default: break; } } if (tasks[task_fdiff_velocity]) { // set it for the next step x_old = x; } }

void colvar::calc_coor_acf (  std::list< colvarvalue > &  x_history, colvarvalue const &  x )  [protected]

Coordinate ACF, scalar product between x(0) and x(t) (does not work with scalar numbers). Definition at line 1299 of file colvar.C. References acf, acf_length, acf_nframes, colvarvalue::inner_opt(), and colvarvalue::norm2(). Referenced by calc_acf(). { // same as above but for coordinates if (x_list.size() >= acf_length+acf_offset) { std::list<colvarvalue>::iterator xs_i = x_list.begin(); std::vector<cvm::real>::iterator acf_i = acf.begin(); for (size_t i = 0; i < acf_offset; i++) xs_i++; *(acf_i++) += x.norm2(); colvarvalue::inner_opt (x, xs_i, x_list.end(), acf_i); acf_nframes++; } }

void colvar::calc_p2coor_acf (  std::list< colvarvalue > &  x_history, colvarvalue const &  x )  [protected]

Coordinate ACF, second order Legendre polynomial between x(0) and x(t) (does not work with scalar numbers). Definition at line 1319 of file colvar.C. References acf, acf_length, acf_nframes, and colvarvalue::p2leg_opt(). Referenced by calc_acf(). { // same as above but with second order Legendre polynomial instead // of just the scalar product if (x_list.size() >= acf_length+acf_offset) { std::list<colvarvalue>::iterator xs_i = x_list.begin(); std::vector<cvm::real>::iterator acf_i = acf.begin(); for (size_t i = 0; i < acf_offset; i++) xs_i++; // value of P2(0) = 1 *(acf_i++) += 1.0; colvarvalue::p2leg_opt (x, xs_i, x_list.end(), acf_i); acf_nframes++; } }

void colvar::calc_runave (   )  [protected]

Calculate the running average and its standard deviation. Definition at line 1368 of file colvar.C. References acf_nframes, colvarvalue::apply_constraints(), colvarmodule::debug(), dist2(), history_add_value(), colvarmodule::log(), colvarmodule::real, colvarvalue::reset(), runave, runave_length, runave_os, runave_variance, colvarmodule::step_relative(), colvarvalue::type(), x, x_history, and x_history_p. Referenced by analyse(). { if (!x_history.size()) { runave.type (x.type()); runave.reset(); // first-step operations if (cvm::debug()) cvm::log ("Colvar \""+this->name+ "\": initializing running average calculation.\n"); acf_nframes = 0; x_history.push_back (std::list<colvarvalue>()); x_history_p = x_history.begin(); } else { if ( (cvm::step_relative() % runave_stride) == 0) { if ((*x_history_p).size() >= runave_length-1) { runave = x; for (std::list<colvarvalue>::iterator xs_i = (*x_history_p).begin(); xs_i != (*x_history_p).end(); xs_i++) { runave += (*xs_i); } runave *= 1.0 / cvm::real (runave_length); runave.apply_constraints(); runave_variance = 0.0; runave_variance += this->dist2 (x, runave); for (std::list<colvarvalue>::iterator xs_i = (*x_history_p).begin(); xs_i != (*x_history_p).end(); xs_i++) { runave_variance += this->dist2 (x, (*xs_i)); } runave_variance *= 1.0 / cvm::real (runave_length-1); runave_os << std::setw (cvm::it_width) << cvm::step_relative() << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << runave << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << ::sqrt (runave_variance) << "\n"; } history_add_value (runave_length, *x_history_p, x); } } }

void colvar::calc_value (  colvarvalue &  xn  )

Calculate just the value, and store it in the argument.

void colvar::calc_vel_acf (  std::list< colvarvalue > &  v_history, colvarvalue const &  v )  [protected]

Velocity ACF, scalar product between v(0) and v(t). Definition at line 1275 of file colvar.C. References acf, acf_length, acf_nframes, colvarvalue::inner_opt(), and colvarvalue::norm2(). Referenced by calc_acf(). { // loop over stored velocities and add to the ACF, but only the // length is sufficient to hold an entire row of ACF values if (v_list.size() >= acf_length+acf_offset) { std::list<colvarvalue>::iterator vs_i = v_list.begin(); std::vector<cvm::real>::iterator acf_i = acf.begin(); for (size_t i = 0; i < acf_offset; i++) vs_i++; // current vel with itself *(acf_i++) += v.norm2(); // inner products of previous velocities with current (acf_i and // vs_i are updated) colvarvalue::inner_opt (v, vs_i, v_list.end(), acf_i); acf_nframes++; } }

void colvar::communicate_forces (   )

Communicate forces (previously calculated in colvar::update()) to the external degrees of freedom. Definition at line 780 of file colvar.C. References cvcs, colvarmodule::debug(), colvarmodule::decrease_depth(), f, colvarmodule::increase_depth(), colvarmodule::log(), colvarvalue::type(), value(), and x. { if (cvm::debug()) cvm::log ("Communicating forces from colvar \""+this->name+"\".\n"); if (x.type() == colvarvalue::type_scalar) { for (size_t i = 0; i < cvcs.size(); i++) { cvm::increase_depth(); (cvcs[i])->apply_force (f * (cvcs[i])->sup_coeff * cvm::real ((cvcs[i])->sup_np) * (::pow ((cvcs[i])->value().real_value, (cvcs[i])->sup_np-1)) ); cvm::decrease_depth(); } } else { for (size_t i = 0; i < cvcs.size(); i++) { cvm::increase_depth(); (cvcs[i])->apply_force (f * (cvcs[i])->sup_coeff); cvm::decrease_depth(); } } if (cvm::debug()) cvm::log ("Done communicating forces from colvar \""+this->name+"\".\n"); }

cvm::real colvar::compare (  colvarvalue const &  x1, colvarvalue const &  x2 )  const

Use the internal metrics (as from objects) to compare colvar values. Handles correctly symmetries and periodic boundary conditions Definition at line 865 of file colvar.C. References cvcs. { return (cvcs[0])->compare (x1, x2); }

int colvar::current_bin_scalar (   )  const [inline]

Use the two boundaries and the width to report which bin the current value is in. Definition at line 540 of file colvar.h. References value_to_bin_scalar(). { return this->value_to_bin_scalar (this->value()); }

void colvar::disable (  colvar::task const &  t  )

Disable the specified task. Definition at line 494 of file colvar.C. References task_corrfunc, task_extended_lagrangian, task_fdiff_velocity, task_gradients, task_grid, task_Jacobian_force, task_lower_boundary, task_lower_wall, task_ntot, task_output_applied_force, task_output_system_force, task_output_value, task_output_velocity, task_report_Jacobian_force, task_runave, task_system_force, task_upper_boundary, task_upper_wall, and tasks. Referenced by colvar(). { // check dependencies switch (t) { case task_gradients: disable (task_upper_wall); disable (task_lower_wall); disable (task_output_applied_force); disable (task_system_force); disable (task_Jacobian_force); break; case task_system_force: disable (task_output_system_force); break; case task_Jacobian_force: disable (task_report_Jacobian_force); break; case task_fdiff_velocity: disable (task_output_velocity); break; case task_lower_boundary: case task_upper_boundary: disable (task_grid); break; case task_extended_lagrangian: case task_report_Jacobian_force: case task_output_value: case task_output_velocity: case task_output_applied_force: case task_output_system_force: case task_runave: case task_corrfunc: case task_grid: case task_lower_wall: case task_upper_wall: case task_ntot: break; } tasks[t] = false; }

cvm::real colvar::dist2 (  colvarvalue const &  x1, colvarvalue const &  x2 )  const

Use the internal metrics (as from objects) to calculate square distances and gradients. Handles correctly symmetries and periodic boundary conditions Definition at line 847 of file colvar.C. References cvcs, and colvarvalue::dist2(). Referenced by calc_runave(), colvar(), periodic_boundaries(), and update(). { return (cvcs[0])->dist2 (x1, x2); }

colvarvalue colvar::dist2_lgrad (  colvarvalue const &  x1, colvarvalue const &  x2 )  const

Use the internal metrics (as from objects) to calculate square distances and gradients. Handles correctly symmetries and periodic boundary conditions Definition at line 853 of file colvar.C. References cvcs. Referenced by fdiff_velocity(), colvarbias_harmonic::update(), and update(). { return (cvcs[0])->dist2_lgrad (x1, x2); }

colvarvalue colvar::dist2_rgrad (  colvarvalue const &  x1, colvarvalue const &  x2 )  const

Use the internal metrics (as from objects) to calculate square distances and gradients. Handles correctly symmetries and periodic boundary conditions Definition at line 859 of file colvar.C. References cvcs. Referenced by update(). { return (cvcs[0])->dist2_rgrad (x1, x2); }

void colvar::enable (  colvar::task const &  t  )

Enable the specified task. Definition at line 401 of file colvar.C. References colvarmodule::debug(), f, colvarmodule::fatal_error(), fb, fj, ft, ft_reported, colvarmodule::log(), task_corrfunc, task_extended_lagrangian, task_fdiff_velocity, task_gradients, task_grid, task_Jacobian_force, task_lower_boundary, task_lower_wall, task_ntot, task_output_applied_force, task_output_system_force, task_output_value, task_output_velocity, task_report_Jacobian_force, task_runave, task_system_force, task_upper_boundary, task_upper_wall, tasks, type(), colvarvalue::type(), v_fdiff, v_reported, and x_old. Referenced by colvarbias::add_colvar(), colvar(), and parse_analysis(). { switch (t) { case task_output_system_force: enable (task_system_force); break; case task_report_Jacobian_force: enable (task_Jacobian_force); enable (task_system_force); if (cvm::debug()) cvm::log ("Adding the Jacobian force to the system force, " "rather than applying its opposite silently.\n"); break; case task_Jacobian_force: enable (task_gradients); if (!b_Jacobian_force) cvm::fatal_error ("Error: colvar \""+this->name+ "\" does not have Jacobian forces implemented.\n"); if (!b_linear) cvm::fatal_error ("Error: colvar \""+this->name+ "\" must be defined as a linear superposition " "to calculate the Jacobian force.\n"); if (cvm::debug()) cvm::log ("Enabling calculation of the Jacobian force " "on this colvar.\n"); fj.type (this->type()); break; case task_system_force: if (!b_inverse_gradients) cvm::fatal_error ("Error: one or more of the components of " "colvar \""+this->name+ "\" is unable to calculate system forces.\n"); ft.type (this->type()); ft_reported.type (this->type()); break; case task_output_applied_force: case task_lower_wall: case task_upper_wall: // all of the above require gradients enable (task_gradients); break; case task_fdiff_velocity: x_old.type (this->type()); v_fdiff.type (this->type()); v_reported.type (this->type()); break; case task_output_velocity: enable (task_fdiff_velocity); break; case task_grid: if (this->type() != colvarvalue::type_scalar) cvm::fatal_error ("Cannot calculate a grid for collective variable, \""+ this->name+"\", because its value is not a scalar number.\n"); break; case task_extended_lagrangian: v_reported.type (this->type()); break; case task_lower_boundary: case task_upper_boundary: if (this->type() != colvarvalue::type_scalar) { cvm::fatal_error ("Error: this colvar is not a scalar value " "and cannot produce a grid.\n"); } break; case task_output_value: case task_runave: case task_corrfunc: case task_ntot: break; case task_gradients: f.type (this->type()); fb.type (this->type()); break; } tasks[t] = true; }

colvarvalue colvar::fdiff_velocity (  colvarvalue const &  xold, colvarvalue const &  xnew )  [inline, protected]

Definition at line 179 of file colvar.h. References dist2_lgrad(). Referenced by calc(), and calc_acf(). { // using the gradient of the square distance to calculate the // velocity (non-scalar variables automatically taken into // account) return ( ( (cvm::dt > 0.0) ? (1.0/cvm::dt) : 1.0 ) * 0.5 * dist2_lgrad (xnew, xold) ); }

size_t colvar::n_components (   )  const [inline]

Definition at line 496 of file colvar.h. References cvcs. { return cvcs.size(); }

void colvar::parse_analysis (  std::string const &  conf  )

Read the analysis tasks. Definition at line 321 of file colvar.C. References acf_length, acf_normalize, acf_offset, acf_outfile, acf_stride, acf_type, colvarmodule::colvar_p(), enable(), colvarmodule::fatal_error(), colvarmodule::log(), colvarvalue::output_width(), runave_length, runave_os, runave_stride, task_corrfunc, task_fdiff_velocity, task_runave, colvarparse::to_lower_cppstr(), colvarmodule::wrap_string(), and x. Referenced by colvar(). { // if (cvm::debug()) // cvm::log ("Parsing analysis flags for collective variable \""+ // this->name+"\".\n"); runave_length = 0; bool b_runave = false; if (get_keyval (conf, "runAve", b_runave) && b_runave) { enable (task_runave); get_keyval (conf, "runAveLength", runave_length, 1000); get_keyval (conf, "runAveStride", runave_stride, 1); if ((cvm::restart_out_freq % runave_stride) != 0) cvm::fatal_error ("Error: runAveStride must be commensurate with the restart frequency.\n"); std::string runave_outfile; get_keyval (conf, "runAveOutputFile", runave_outfile, std::string (cvm::output_prefix+"."+ this->name+".runave.traj")); size_t const this_cv_width = x.output_width (cvm::cv_width); runave_os.open (runave_outfile.c_str()); runave_os << "# " << cvm::wrap_string ("step", cvm::it_width-2) << " " << cvm::wrap_string ("running average", this_cv_width) << " " << cvm::wrap_string ("running stddev", this_cv_width) << "\n"; } acf_length = 0; bool b_acf = false; if (get_keyval (conf, "corrFunc", b_acf) && b_acf) { enable (task_corrfunc); std::string acf_colvar_name; get_keyval (conf, "corrFuncWithColvar", acf_colvar_name, this->name); if (acf_colvar_name == this->name) { cvm::log ("Calculating auto-correlation function.\n"); } else { cvm::log ("Calculating correlation function with \""+ this->name+"\".\n"); } std::string acf_type_str; get_keyval (conf, "corrFuncType", acf_type_str, to_lower_cppstr (std::string ("velocity"))); if (acf_type_str == to_lower_cppstr (std::string ("coordinate"))) { acf_type = acf_coor; } else if (acf_type_str == to_lower_cppstr (std::string ("velocity"))) { acf_type = acf_vel; enable (task_fdiff_velocity); if (acf_colvar_name.size()) (cvm::colvar_p (acf_colvar_name))->enable (task_fdiff_velocity); } else if (acf_type_str == to_lower_cppstr (std::string ("coordinate_p2"))) { acf_type = acf_p2coor; } else { cvm::fatal_error ("Unknown type of correlation function, \""+ acf_type_str+"\".\n"); } get_keyval (conf, "corrFuncOffset", acf_offset, 0); get_keyval (conf, "corrFuncLength", acf_length, 1000); get_keyval (conf, "corrFuncStride", acf_stride, 1); if ((cvm::restart_out_freq % acf_stride) != 0) cvm::fatal_error ("Error: corrFuncStride must be commensurate with the restart frequency.\n"); get_keyval (conf, "corrFuncNormalize", acf_normalize, true); get_keyval (conf, "corrFuncOutputFile", acf_outfile, std::string (cvm::output_prefix+"."+this->name+ ".corrfunc.dat")); } }

bool colvar::periodic_boundaries (  colvarvalue const &  lb, colvarvalue const &  ub )  const

Is the interval defined by the two boundaries periodic? Definition at line 815 of file colvar.C. References dist2(), colvarmodule::fatal_error(), period, and tasks. { if ( (!tasks[task_lower_boundary]) || (!tasks[task_upper_boundary]) ) { cvm::fatal_error ("Error: requesting to histogram the " "collective variable \""+this->name+"\", but a " "pair of lower and upper boundaries must be " "defined.\n"); } if (period > 0.0) { if ( ((::sqrt (this->dist2 (lb, ub))) / this->width) < 1.0E-10 ) { return true; } } return false; }

bool colvar::periodic_boundaries (   )  const

Is the interval defined by the two boundaries periodic? Definition at line 834 of file colvar.C. References colvarmodule::fatal_error(), lower_boundary, tasks, and upper_boundary. Referenced by colvar(). { if ( (!tasks[task_lower_boundary]) || (!tasks[task_upper_boundary]) ) { cvm::fatal_error ("Error: requesting to histogram the " "collective variable \""+this->name+"\", but a " "pair of lower and upper boundaries must be " "defined.\n"); } return periodic_boundaries (lower_boundary, upper_boundary); }

std::istream & colvar::read_restart (  std::istream &  is  )

Read the collective variable from a restart file. Definition at line 875 of file colvar.C. References colvarmodule::fatal_error(), colvarmodule::log(), name, tasks, colvarvalue::type(), v_fdiff, v_reported, vr, x, x_reported, and xr. { size_t const start_pos = is.tellg(); std::string conf; if ( !(is >> colvarparse::read_block ("colvar", conf)) ) { // this is not a colvar block is.clear(); is.seekg (start_pos, std::ios::beg); is.setstate (std::ios::failbit); return is; } { std::string check_name = ""; if ( (get_keyval (conf, "name", check_name, std::string (""), colvarparse::parse_silent)) && (check_name != name) ) { cvm::fatal_error ("Error: the state file does not match the " "configuration file, at colvar \""+name+"\".\n"); } if (check_name.size() == 0) { cvm::fatal_error ("Error: Collective variable in the " "restart file without any identifier.\n"); } } if ( !(get_keyval (conf, "x", x, colvarvalue (x.type()), colvarparse::parse_silent)) ) { cvm::log ("Error: restart file does not contain " "the value of the colvar \""+ name+"\" .\n"); } else { cvm::log ("Restarting collective variable \""+name+"\" from value: "+ cvm::to_str (x)+"\n"); } if (tasks[colvar::task_extended_lagrangian]) { if ( !(get_keyval (conf, "extended_x", xr, colvarvalue (x.type()), colvarparse::parse_silent)) && !(get_keyval (conf, "extended_v", vr, colvarvalue (x.type()), colvarparse::parse_silent)) ) { cvm::log ("Error: restart file does not contain " "\"extended_x\" or \"extended_v\" for the colvar \""+ name+"\", but you requested \"extendedLagrangian\".\n"); } } if (tasks[task_extended_lagrangian]) { x_reported = xr; } else { x_reported = x; } if (tasks[task_output_velocity]) { if ( !(get_keyval (conf, "v", v_fdiff, colvarvalue (x.type()), colvarparse::parse_silent)) ) { cvm::log ("Error: restart file does not contain " "the velocity for the colvar \""+ name+"\", but you requested \"outputVelocity\".\n"); } if (tasks[task_extended_lagrangian]) { v_reported = vr; } else { v_reported = v_fdiff; } } return is; }

std::istream & colvar::read_traj (  std::istream &  is  )

Read the value from a collective variable trajectory file. Definition at line 950 of file colvar.C. References ft_reported, colvarmodule::log(), tasks, v_reported, and x_reported. { size_t const start_pos = is.tellg(); if (tasks[task_output_value]) { if (!(is >> x)) { cvm::log ("Error: in reading the value of colvar \""+ this->name+"\" from trajectory.\n"); is.clear(); is.seekg (start_pos, std::ios::beg); is.setstate (std::ios::failbit); return is; } if (tasks[task_extended_lagrangian]) { is >> xr; x_reported = xr; } else { x_reported = x; } } if (tasks[task_output_velocity]) { is >> v_fdiff; if (tasks[task_extended_lagrangian]) { is >> vr; v_reported = vr; } else { v_reported = v_fdiff; } } if (tasks[task_output_system_force]) { is >> ft; if (tasks[task_extended_lagrangian]) { is >> fr; ft_reported = fr; } else { ft_reported = ft; } } if (tasks[task_output_applied_force]) { is >> f; } return is; }

void colvar::reset_bias_force (   )  [inline]

Set the total biasing force to zero. Definition at line 576 of file colvar.h. References fb, and colvarvalue::reset(). { fb.reset(); }

colvarvalue const & colvar::system_force (   )  const [inline]

Current system force (previously obtained from calc() or read_traj()). Note: this is calculated using the atomic forces from the last simulation step. Total atom forces are read from the MD program, the total force acting on the collective variable is calculated summing those from all colvar components, the bias and walls forces are subtracted. Definition at line 533 of file colvar.h. { return ft_reported; }

colvarvalue::Type colvar::type (   )  const [inline]

Type of value. Definition at line 515 of file colvar.h. References colvarvalue::type(), and x. Referenced by colvarbias::add_colvar(), calc_acf(), colvar(), colvarbias_harmonic::colvarbias_harmonic(), and enable(). { return x.type(); }

void colvar::update (   )

Collect all forces on this colvar, integrate internal equations of motion of internal degrees of freedom; see also colvar::communicate_forces(). Definition at line 678 of file colvar.C. References colvarvalue::apply_constraints(), colvarmodule::boltzmann(), cvcs, colvarmodule::debug(), colvarmodule::decrease_depth(), dist2(), dist2_lgrad(), dist2_rgrad(), f, fj, fr, colvarmodule::increase_depth(), colvarmodule::log(), lower_wall, lower_wall_k, colvarmodule::real, colvarvalue::reset(), tasks, colvarmodule::temperature(), upper_wall, upper_wall_k, vr, x, x_old, and xr. { if (cvm::debug()) cvm::log ("Updating colvar \""+this->name+"\".\n"); // set to zero the applied force f.reset(); // add the biases' force, which at this point should already have // been summed over each bias using this colvar f += fb; if (tasks[task_lower_wall] || tasks[task_upper_wall]) { // wall force colvarvalue fw (this->type()); // if the two walls are applied concurrently, decide which is the // closer one (on a periodic colvar, both walls may be applicable // at the same time) if ( (!tasks[task_upper_wall]) || (this->dist2 (x, lower_wall) < this->dist2 (x, upper_wall)) ) { cvm::real const grad = this->dist2_lgrad (x, lower_wall); if (grad < 0.0) { fw = -0.5 * lower_wall_k * grad; if (cvm::debug()) cvm::log ("Applying a lower wall force ("+ cvm::to_str (fw)+") to \""+this->name+"\".\n"); f += fw; } } else { cvm::real const grad = this->dist2_lgrad (x, upper_wall); if (grad > 0.0) { fw = -0.5 * upper_wall_k * grad; if (cvm::debug()) cvm::log ("Applying an upper wall force ("+ cvm::to_str (fw)+") to \""+this->name+"\".\n"); f += fw; } } } if (tasks[task_Jacobian_force]) { cvm::increase_depth(); for (size_t i = 0; i < cvcs.size(); i++) { (cvcs[i])->calc_Jacobian_derivative(); } cvm::decrease_depth(); // JH - here we could compute the dot product of the cvc inverse gradient // with the colvar gradient, and renormalize. fj.reset(); for (size_t i = 0; i < cvcs.size(); i++) { // linear superposition is assumed fj += 1.0 / ( cvm::real (cvcs.size()) * cvm::real ((cvcs[i])->sup_coeff) ) * (cvcs[i])->Jacobian_derivative(); } fj *= cvm::boltzmann() * cvm::temperature(); // the Jacobian force has not been added to the system force, so // it's now subtracted from the applied force if (! tasks[task_report_Jacobian_force]) f -= fj; } if (tasks[task_extended_lagrangian]) { // the total force is applied on the fictitious mass, while the // atoms only feel the harmonic force fr = f; fr += (-0.5 * ext_force_k) * this->dist2_lgrad (xr, x); f = (-0.5 * ext_force_k) * this->dist2_rgrad (xr, x); // leap frog vr += (0.5 * cvm::dt) * fr / ext_mass; xr += cvm::dt * vr; // if the colvarvalue is set to a type with constraints, apply // them xr.apply_constraints(); vr += (0.5 * cvm::dt) * fr / ext_mass; } if (tasks[task_fdiff_velocity]) { // set it for the next step x_old = x; } if (cvm::debug()) cvm::log ("Done updating colvar \""+this->name+"\".\n"); }

colvarvalue const & colvar::value (   )  const [inline]

Current value (previously obtained from calc() or read_traj()). Definition at line 521 of file colvar.h. Referenced by calc_acf(), and communicate_forces(). { return x_reported; }

int colvar::value_to_bin_scalar (  colvarvalue const &  value, colvarvalue const &  new_offset, cvm::real const &  new_width )  const [inline]

Same as the standard version, but uses another grid definition. Definition at line 550 of file colvar.h. References colvarvalue::real_value. { return (int) ::floor ( (value.real_value - new_offset.real_value) / new_width ); }

int colvar::value_to_bin_scalar (  colvarvalue const &  value  )  const [inline]

Use the lower boundary and the width to report which bin the provided value is in. Definition at line 545 of file colvar.h. References lower_boundary, and colvarvalue::real_value. Referenced by current_bin_scalar(). { return (int) ::floor ( (value.real_value - lower_boundary.real_value) / width ); }

colvarvalue const & colvar::velocity (   )  const [inline]

Current velocity (previously obtained from calc() or read_traj()). Definition at line 527 of file colvar.h. Referenced by calc_acf(). { return v_reported; }

void colvar::write_acf (  std::ostream &  os  )  [protected]

Save the ACF to a file. Definition at line 1341 of file colvar.C. References acf, acf_nframes, acf_normalize, acf_stride, colvarmodule::log(), name, and colvarmodule::real. Referenced by ~colvar(). { if (!acf_nframes) cvm::log ("Warning: ACF was not calculated (insufficient frames).\n"); os.setf (std::ios::scientific, std::ios::floatfield); os << "# Autocorrelation function for collective variable \"" << this->name << "\"\n"; // one frame is used for normalization, the statistical sample is // hence decreased os << "# nframes = " << (acf_normalize ? acf_nframes - 1 : acf_nframes) << "\n"; cvm::real const acf_norm = acf.front() / cvm::real (acf_nframes); std::vector<cvm::real>::iterator acf_i; size_t it = acf_offset; for (acf_i = acf.begin(); acf_i != acf.end(); acf_i++) { os << std::setw (cvm::it_width) << acf_stride * (it++) << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << ( acf_normalize ? (*acf_i)/(acf_norm * cvm::real (acf_nframes)) : (*acf_i)/(cvm::real (acf_nframes)) ) << "\n"; } }

std::ostream & colvar::write_restart (  std::ostream &  os  )

Write the collective variable to a restart file. Definition at line 1007 of file colvar.C. References name, tasks, v_reported, vr, x, and xr. { os << "colvar {\n" << " name " << name << "\n" << " x " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << x << "\n"; if (tasks[task_output_velocity]) { os << " v " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << v_reported << "\n"; } if (tasks[task_extended_lagrangian]) { os << " extended_x " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << xr << "\n" << " extended_v " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << vr << "\n"; } os << "}\n\n"; return os; }

std::ostream & colvar::write_traj (  std::ostream &  os  )

Output formatted values to the trajectory file. Definition at line 1091 of file colvar.C. References tasks. { os << " "; if (tasks[task_output_value]) { if (tasks[task_extended_lagrangian]) { os << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << x; } os << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << x_reported; } if (tasks[task_output_velocity]) { if (tasks[task_extended_lagrangian]) { os << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << v_fdiff; } os << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << v_reported; } if (tasks[task_output_system_force]) { if (tasks[task_extended_lagrangian]) { os << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << ft; } os << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << ft_reported; } if (tasks[task_output_applied_force]) { os << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << f; } return os; }

std::ostream & colvar::write_traj_label (  std::ostream &  os  )

Write a label to the trajectory file (comment line). Definition at line 1040 of file colvar.C. References colvarvalue::output_width(), tasks, colvarmodule::wrap_string(), and x. { size_t const this_cv_width = x.output_width (cvm::cv_width); os << " "; if (tasks[task_output_value]) { os << " " << cvm::wrap_string (this->name, this_cv_width); if (tasks[task_extended_lagrangian]) { // restraint center os << " r_" << cvm::wrap_string (this->name, this_cv_width-2); } } if (tasks[task_output_velocity]) { os << " v_" << cvm::wrap_string (this->name, this_cv_width-2); if (tasks[task_extended_lagrangian]) { // restraint center os << " vr_" << cvm::wrap_string (this->name, this_cv_width-3); } } if (tasks[task_output_system_force]) { os << " fs_" << cvm::wrap_string (this->name, this_cv_width-2); if (tasks[task_extended_lagrangian]) { // restraint center os << " fr_" << cvm::wrap_string (this->name, this_cv_width-3); } } if (tasks[task_output_applied_force]) { os << " fa_" << cvm::wrap_string (this->name, this_cv_width-2); } return os; }

---

Member Data Documentation

std::vector<cvm::real> colvar::acf [protected]

ACF values. Definition at line 405 of file colvar.h. Referenced by calc_acf(), calc_coor_acf(), calc_p2coor_acf(), calc_vel_acf(), write_acf(), and ~colvar().

std::string colvar::acf_colvar_name [protected]

Collective variable with which the correlation is calculated (default: itself). Definition at line 393 of file colvar.h. Referenced by calc_acf().

size_t colvar::acf_length [protected]

Length of autocorrelation function (ACF). Definition at line 395 of file colvar.h. Referenced by calc_acf(), calc_coor_acf(), calc_p2coor_acf(), calc_vel_acf(), and parse_analysis().

size_t colvar::acf_nframes [protected]

Number of frames for each ACF point. Definition at line 401 of file colvar.h. Referenced by calc_acf(), calc_coor_acf(), calc_p2coor_acf(), calc_runave(), calc_vel_acf(), and write_acf().

bool colvar::acf_normalize [protected]

Normalize the ACF to a maximum value of 1? Definition at line 403 of file colvar.h. Referenced by parse_analysis(), and write_acf().

size_t colvar::acf_offset [protected]

After how many steps the ACF starts. Definition at line 397 of file colvar.h. Referenced by calc_acf(), and parse_analysis().

std::string colvar::acf_outfile [protected]

Name of the file to write the ACF. Definition at line 407 of file colvar.h. Referenced by parse_analysis(), and ~colvar().

size_t colvar::acf_stride [protected]

How many timesteps separate two ACF values. Definition at line 399 of file colvar.h. Referenced by parse_analysis(), and write_acf().

acf_type_e colvar::acf_type [protected]

Type of autocorrelation function (ACF). Definition at line 423 of file colvar.h. Referenced by parse_analysis().

std::list< std::list<colvarvalue> > colvar::acf_v_history [protected]

Time series of values and velocities used in correlation functions Definition at line 380 of file colvar.h. Referenced by calc_acf().

std::list< std::list<colvarvalue> >::iterator colvar::acf_v_history_p [protected]

Time series of values and velocities used in correlation functions (pointers)x Definition at line 383 of file colvar.h. Referenced by calc_acf().

std::list< std::list<colvarvalue> > colvar::acf_x_history [protected]

Time series of values and velocities used in correlation functions Definition at line 380 of file colvar.h. Referenced by calc_acf().

std::list< std::list<colvarvalue> >::iterator colvar::acf_x_history_p [protected]

Time series of values and velocities used in correlation functions (pointers)x Definition at line 383 of file colvar.h. Referenced by calc_acf().

bool colvar::b_inverse_gradients

True if all objects are capable of calculating inverse gradients. Definition at line 85 of file colvar.h. Referenced by colvar(), and colvar::cvc::cvc().

bool colvar::b_Jacobian_force

True if all objects are capable of calculating Jacobian forces. Definition at line 89 of file colvar.h. Referenced by colvar().

bool colvar::b_linear

True if this is a linear superposition of elements. Definition at line 81 of file colvar.h. Referenced by colvar().

bool colvar::b_periodic

Same as above, but also takes into account components with a variable period, such as distanceZ. Definition at line 232 of file colvar.h. Referenced by colvar(), and colvar::cvc::cvc().

std::vector<cvc *> colvar::cvcs [protected]

Array of objects. Definition at line 492 of file colvar.h. Referenced by calc(), colvar(), communicate_forces(), compare(), dist2(), dist2_lgrad(), dist2_rgrad(), n_components(), update(), and ~colvar().

bool colvar::expand_boundaries

Expand the boundaries of multiples of width, to keep the value always within range. Definition at line 237 of file colvar.h. Referenced by colvar().

cvm::real colvar::ext_force_k [protected]

Restraint force constant. Definition at line 200 of file colvar.h. Referenced by colvar().

cvm::real colvar::ext_mass [protected]

Mass of the restraint center. Definition at line 198 of file colvar.h. Referenced by colvar().

colvarvalue colvar::f

Total applied force; fr (if task_extended_lagrangian is defined), fb (if biases are applied) and the walls' forces (if defined) contribute to it. Definition at line 220 of file colvar.h. Referenced by communicate_forces(), enable(), and update().

colvarvalue colvar::fb

Bias force; reset_bias_force() should be called before the biases are updated. Definition at line 215 of file colvar.h. Referenced by add_bias_force(), enable(), and reset_bias_force().

colvarvalue colvar::fj [protected]

Jacobian force, when task_Jacobian_force is enabled. Definition at line 205 of file colvar.h. Referenced by enable(), and update().

colvarvalue colvar::fr [protected]

Harmonic restraint force. Definition at line 202 of file colvar.h. Referenced by colvar(), and update().

colvarvalue colvar::ft

Total force, as derived from the atomic trajectory; should equal the total system force plus . Definition at line 224 of file colvar.h. Referenced by calc(), and enable().

colvarvalue colvar::ft_reported [protected]

Cached reported system force. Definition at line 208 of file colvar.h. Referenced by calc(), enable(), and read_traj().

colvarvalue colvar::lower_boundary

Location of the lower boundary. Definition at line 240 of file colvar.h. Referenced by bin_to_value_scalar(), colvar(), periodic_boundaries(), and value_to_bin_scalar().

colvarvalue colvar::lower_wall

Location of the lower wall. Definition at line 242 of file colvar.h. Referenced by colvar(), and update().

cvm::real colvar::lower_wall_k

Force constant for the lower boundary potential (|x-xb|^2). Definition at line 244 of file colvar.h. Referenced by colvar(), and update().

std::string colvar::name

Name. Definition at line 46 of file colvar.h. Referenced by colvarbias::add_colvar(), calc_acf(), read_restart(), write_acf(), and write_restart().

cvm::real colvar::period

Period, if it is a constant. Definition at line 228 of file colvar.h. Referenced by colvar(), and periodic_boundaries().

colvarvalue colvar::runave [protected]

Current value of the running average. Definition at line 451 of file colvar.h. Referenced by calc_runave().

size_t colvar::runave_length [protected]

Length of running average series. Definition at line 445 of file colvar.h. Referenced by calc_runave(), and parse_analysis().

std::ofstream colvar::runave_os [protected]

Name of the file to write the running average. Definition at line 449 of file colvar.h. Referenced by calc_runave(), parse_analysis(), and ~colvar().

size_t colvar::runave_stride [protected]

Timesteps to skip between two values in the running average series. Definition at line 447 of file colvar.h. Referenced by parse_analysis().

cvm::real colvar::runave_variance [protected]

Current value of the square deviation from the running average. Definition at line 453 of file colvar.h. Referenced by calc_runave().

bool colvar::tasks[task_ntot]

Tasks performed by this colvar. Definition at line 144 of file colvar.h. Referenced by analyse(), calc(), calc_acf(), colvar(), disable(), enable(), periodic_boundaries(), read_restart(), read_traj(), update(), write_restart(), write_traj(), and write_traj_label().

colvarvalue colvar::upper_boundary

Location of the upper boundary. Definition at line 247 of file colvar.h. Referenced by colvar(), and periodic_boundaries().

colvarvalue colvar::upper_wall

Location of the upper wall. Definition at line 249 of file colvar.h. Referenced by colvar(), and update().

cvm::real colvar::upper_wall_k

Force constant for the upper boundary potential (|x-xb|^2). Definition at line 251 of file colvar.h. Referenced by colvar(), and update().

colvarvalue colvar::v_fdiff [protected]

Finite-difference velocity. Definition at line 177 of file colvar.h. Referenced by calc(), calc_acf(), enable(), and read_restart().

colvarvalue colvar::v_reported [protected]

Cached reported velocity. Definition at line 190 of file colvar.h. Referenced by calc(), calc_acf(), enable(), read_restart(), read_traj(), and write_restart().

colvarvalue colvar::vr [protected]

Velocity of the restraint center. Definition at line 196 of file colvar.h. Referenced by colvar(), read_restart(), update(), and write_restart().

cvm::real colvar::width

Typical fluctuation amplitude for this collective variable (e.g. local width of a free energy basin). In metadynamics calculations, , this value is used to calculate the width of a gaussian. In ABF calculations, , it is used to calculate the grid spacing in the direction of this collective variable. Definition at line 77 of file colvar.h. Referenced by bin_to_value_scalar(), and colvar().

colvarvalue colvar::x [protected]

Value of the colvar. Definition at line 171 of file colvar.h. Referenced by calc(), calc_runave(), colvar(), communicate_forces(), parse_analysis(), read_restart(), type(), update(), write_restart(), and write_traj_label().

std::list< std::list<colvarvalue> > colvar::x_history [protected]

Time series of values and velocities used in running averages. Definition at line 386 of file colvar.h. Referenced by calc_runave().

std::list< std::list<colvarvalue> >::iterator colvar::x_history_p [protected]

Time series of values and velocities used in correlation functions (pointers)x Definition at line 389 of file colvar.h. Referenced by calc_runave().

colvarvalue colvar::x_old [protected]

Previous value (to calculate velocities during analysis). Definition at line 376 of file colvar.h. Referenced by calc(), calc_acf(), enable(), and update().

colvarvalue colvar::x_reported [protected]

Cached reported value (x may be manipulated). Definition at line 174 of file colvar.h. Referenced by calc(), colvar(), read_restart(), and read_traj().

colvarvalue colvar::xr [protected]

Restraint center. Definition at line 194 of file colvar.h. Referenced by calc(), colvar(), read_restart(), update(), and write_restart().

---

The documentation for this class was generated from the following files:

• colvar.h
• colvar.C

---