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_collect_gradients, task_fdiff_velocity, task_system_force,   task_extended_lagrangian, task_langevin, task_output_energy, 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.
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.
cvm::real	update ()
	Collect all forces on this colvar, integrate internal equations of motion of internal degrees of freedom; see also colvar::communicate_forces() return colvar energy if extended Lagrandian active.
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	wrap (colvarvalue &x) const
	Use the internal metrics (as from objects) to wrap a value into a standard interval.
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 combination 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).
std::vector< int >	atom_ids
	Sorted array of (zero-based) IDs for all atoms involved.
std::vector< cvm::rvector >	atomic_gradients
	Array of atomic gradients collected from all cvcs with appropriate components, rotations etc. For scalar variables only!
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.
void	build_atom_list (void)
	Initialize the sorted list of atom IDs for atoms involved in all cvcs (called when enabling task_collect_gradients).
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.
cvm::real	ext_gamma
	Friction coefficient for Langevin extended dynamics.
cvm::real	ext_sigma
	Amplitude of Gaussian white noise for Langevin extended dynamics.
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.
cvm::real	kinetic_energy
	If extended Lagrangian active: colvar energies (kinetic and harmonic potential).
cvm::real	potential_energy
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 404 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_collect_gradients  Collect atomic gradient data from all cvcs into vector atomic_gradients. 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_langevin  The extended system coordinate undergoes Langevin dynamics. task_output_energy  Output the potential and kinetic energies (for extended Lagrangian colvars only). task_Jacobian_force  Compute analytically the "force" arising from the geometric 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_collect_gradients, task_fdiff_velocity, task_system_force, task_extended_lagrangian, task_langevin, task_output_energy, 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 14 of file colvar.C. References b_inverse_gradients, b_Jacobian_force, b_linear, b_periodic, colvarmodule::boltzmann(), cvcs, colvarmodule::debug(), disable(), dist2(), enable(), expand_boundaries, ext_force_k, ext_gamma, ext_mass, ext_sigma, colvarmodule::fatal_error(), fr, initialize_components, j, kinetic_energy, colvarmodule::log(), lower_boundary, lower_wall, lower_wall_k, parse_analysis(), period, periodic_boundaries(), PI, potential_energy, task_extended_lagrangian, task_langevin, task_lower_boundary, task_lower_wall, task_output_applied_force, task_output_energy, 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+ "\", as another colvar.\n"); } // all tasks disabled by default for (size_t i = 0; i < task_ntot; i++) { tasks[i] = false; } kinetic_energy = 0.0; potential_energy = 0.0; // read the configuration and set up corresponding instances, for // each type of component implemented #define initialize_components(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_config_key)+"\" component"+ \ (cvm::debug() ? ", with configuration:\n"+def_conf \ : ".\n")); \ cvm::increase_depth(); \ cvc *cvcp = new colvar::def_class_name (def_conf); \ if (cvcp != NULL) { \ cvcs.push_back (cvcp); \ cvcp->check_keywords (def_conf, def_config_key); \ cvm::decrease_depth(); \ } else { \ cvm::fatal_error ("Error: in allocating component \"" \ def_config_key"\".\n"); \ } \ if ( (cvcp->period != 0.0) || (cvcp->wrap_center != 0.0) ) { \ if ( (cvcp->function_type != std::string ("distance_z")) && \ (cvcp->function_type != std::string ("dihedral")) && \ (cvcp->function_type != std::string ("spin_angle")) ) { \ cvm::fatal_error ("Error: invalid use of period and/or " \ "wrapAround in a \""+ \ std::string (def_config_key)+ \ "\" component.\n"+ \ "Period: "+cvm::to_str(cvcp->period) + \ " wrapAround: "+cvm::to_str(cvcp->wrap_center));\ } \ } \ 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 \""+ \ std::string (def_config_key)+ \ "\" component"+ \ (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_components ("distance", "distance", distance); initialize_components ("distance vector", "distanceVec", distance_vec); initialize_components ("distance vector " "direction", "distanceDir", distance_dir); initialize_components ("distance projection " "on an axis", "distanceZ", distance_z); initialize_components ("distance projection " "on a plane", "distanceXY", distance_xy); initialize_components ("minimum distance", "minDistance", min_distance); initialize_components ("coordination " "number", "coordNum", coordnum); initialize_components ("self-coordination " "number", "selfCoordNum", selfcoordnum); initialize_components ("angle", "angle", angle); initialize_components ("dihedral", "dihedral", dihedral); initialize_components ("hydrogen bond", "hBond", h_bond); // initialize_components ("alpha helix", "alphaDihedrals", alpha_dihedrals); initialize_components ("alpha helix", "alpha", alpha_angles); initialize_components ("dihedral principal " "component", "dihedralPC", dihedPC); initialize_components ("orientation", "orientation", orientation); initialize_components ("orientation " "angle", "orientationAngle",orientation_angle); initialize_components ("tilt", "tilt", tilt); initialize_components ("spin angle", "spinAngle", spin_angle); initialize_components ("RMSD", "rmsd", rmsd); // initialize_components ("logarithm of MSD", "logmsd", logmsd); initialize_components ("radius of " "gyration", "gyration", gyration); initialize_components ("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; // Decide whether the colvar is periodic // Used to wrap extended DOF if extendedLagrangian is on if (cvcs.size() == 1 && (cvcs[0])->b_periodic && (cvcs[0])->sup_np == 1 && (cvcs[0])->sup_coeff == 1.0 ) { this->b_periodic = true; this->period = (cvcs[0])->period; // TODO write explicit wrap() function for colvars to allow for // sup_coeff different from 1 // this->period = (cvcs[0])->period * (cvcs[0])->sup_coeff; } else { this->b_periodic = false; this->period = 0.0; } // 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 " "combination 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 combination; " "if you apply forces, the simulation may become unstable " "when the component \""+ (cvcs[i])->function_type+"\" approaches zero.\n"); } } if ((cvcs[i])->b_periodic && !b_periodic) { cvm::log ("Warning: although this component is periodic, the colvar will " "not be treated as periodic, either because the exponent is not " "1, or because multiple components are present. Make sure that " "you know what you are doing!"); } 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::real temp, tolerance, period; 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()); const bool found = get_keyval (conf, "extendedTemp", temp, cvm::temperature()); if (temp <= 0.0) { if (found) cvm::fatal_error ("Error: \"extendedTemp\" must be positive.\n"); else cvm::fatal_error ("Error: a positive temperature must be provided, either " "by enabling a thermostat, or through \"extendedTemp\".\n"); } get_keyval (conf, "extendedFluctuation", tolerance, 0.2*width); if (tolerance <= 0.0) cvm::fatal_error ("Error: \"extendedFluctuation\" must be positive.\n"); ext_force_k = cvm::boltzmann() * temp / (tolerance * tolerance); cvm::log ("Computed extended system force constant: " + cvm::to_str(ext_force_k) + " kcal/mol/U^2"); get_keyval (conf, "extendedTimeConstant", period, 40.0 * cvm::dt()); if (period <= 0.0) cvm::fatal_error ("Error: \"extendedTimeConstant\" must be positive.\n"); ext_mass = (cvm::boltzmann() * temp * period * period) / (4.0 * PI * PI * tolerance * tolerance); cvm::log ("Computed fictitious mass: " + cvm::to_str(ext_mass) + " kcal/mol/(U/fs)^2 (U: colvar unit)"); { bool b_output_energy; get_keyval (conf, "outputEnergy", b_output_energy, false); if (b_output_energy) { enable (task_output_energy); } } get_keyval (conf, "extendedLangevinDamping", ext_gamma, 0.0); if (ext_gamma < 0.0) cvm::fatal_error ("Error: \"extendedLangevinDamping\" may not be negative.\n"); if (ext_gamma != 0.0) { enable (task_langevin); ext_gamma *= 1.0e-3; // convert from ps-1 to fs-1 ext_sigma = std::sqrt(2.0 * cvm::boltzmann() * temp * ext_gamma * ext_mass / cvm::dt()); } } } { 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 650 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 550 of file colvar.h. References fb. Referenced by colvarbias::communicate_forces(). { fb += force; }

void colvar::analyse (   )

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

void colvar::build_atom_list (  void   )  [protected]

Initialize the sorted list of atom IDs for atoms involved in all cvcs (called when enabling task_collect_gradients). Definition at line 382 of file colvar.C. References atom_ids, atomic_gradients, cvcs, colvarmodule::debug(), j, and colvarmodule::log(). Referenced by enable(). { // If atomic gradients are requested, build full list of atom ids from all cvcs std::list<int> temp_id_list; for (size_t i = 0; i < cvcs.size(); i++) { for (size_t j = 0; j < cvcs[i]->atom_groups.size(); j++) { for (size_t k = 0; k < cvcs[i]->atom_groups[j]->size(); k++) { temp_id_list.push_back (cvcs[i]->atom_groups[j]->at(k).id); } } } temp_id_list.sort(); temp_id_list.unique(); atom_ids = std::vector<int> (temp_id_list.begin(), temp_id_list.end()); temp_id_list.clear(); atomic_gradients.resize (atom_ids.size()); if (atom_ids.size()) { if (cvm::debug()) cvm::log ("Colvar: created atom list with " + cvm::to_str(atom_ids.size()) + " atoms.\n"); } else { cvm::log ("Warning: colvar components communicated no atom IDs.\n"); } }

void colvar::calc (   )

Calculate the colvar value and all the other requested quantities. Definition at line 679 of file colvar.C. References atom_ids, atomic_gradients, cvcs, colvarmodule::debug(), colvarmodule::decrease_depth(), dist2_lgrad(), fdiff_velocity(), ft, ft_reported, colvarmodule::increase_depth(), colvarvalue::inverse(), j, colvarmodule::log(), colvarmodule::real, colvarvalue::real_value, colvarvalue::reset(), colvarmodule::rotation::rotate(), colvarmodule::step_relative(), tasks, colvarvalue::type(), v_fdiff, v_reported, value(), vr, 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 combination 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) ? std::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_collect_gradients]) { // Collect the atomic gradients inside colvar object for (int a = 0; a < atomic_gradients.size(); a++) { atomic_gradients[a].reset(); } for (size_t i = 0; i < cvcs.size(); i++) { // Coefficient: d(a * x^n) = a * n * x^(n-1) * dx cvm::real coeff = (cvcs[i])->sup_coeff * cvm::real ((cvcs[i])->sup_np) * std::pow ((cvcs[i])->value().real_value, (cvcs[i])->sup_np-1); for (size_t j = 0; j < cvcs[i]->atom_groups.size(); j++) { // If necessary, apply inverse rotation to get atomic // gradient in the laboratory frame if (cvcs[i]->atom_groups[j]->b_rotate) { cvm::rotation const rot_inv = cvcs[i]->atom_groups[j]->rot.inverse(); for (size_t k = 0; k < cvcs[i]->atom_groups[j]->size(); k++) { int a = std::lower_bound (atom_ids.begin(), atom_ids.end(), cvcs[i]->atom_groups[j]->at(k).id) - atom_ids.begin(); atomic_gradients[a] += coeff * rot_inv.rotate (cvcs[i]->atom_groups[j]->at(k).grad); } } else { for (size_t k = 0; k < cvcs[i]->atom_groups[j]->size(); k++) { int a = std::lower_bound (atom_ids.begin(), atom_ids.end(), cvcs[i]->atom_groups[j]->at(k).id) - atom_ids.begin(); atomic_gradients[a] += coeff * cvcs[i]->atom_groups[j]->at(k).grad; } } } } } } if (tasks[task_system_force]) { ft.reset(); if(!tasks[task_extended_lagrangian] && (cvm::step_relative() > 0)) { // get from the cvcs the system forces from the PREVIOUS step for (size_t i = 0; i < cvcs.size(); i++) { (cvcs[i])->calc_force_invgrads(); // linear combination 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 any silent // 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 // TODO: put it in the restart information if (cvm::step_relative() == 0) { xr = x; vr = 0.0; // (already 0; added for clarity) } // report the restraint center as "value" x_reported = xr; v_reported = vr; // the "system force" with the extended Lagrangian is just the // harmonic term acting on the extended coordinate // Note: this is the force for current timestep ft_reported = (-0.5 * ext_force_k) * this->dist2_lgrad (xr, x); } 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 1354 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 1477 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 1497 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 1546 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) << std::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 1453 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 937 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) * (std::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 1022 of file colvar.C. References cvcs. { return (cvcs[0])->compare (x1, x2); }

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

Disable the specified task. Definition at line 602 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 1004 of file colvar.C. References cvcs, and colvarvalue::dist2(). Referenced by calc_runave(), colvar(), colvarbias_harmonic::energy_difference(), colvarbias_harmonic::update(), 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 1010 of file colvar.C. References cvcs. Referenced by calc(), fdiff_velocity(), 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 1016 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 490 of file colvar.C. References atom_ids, build_atom_list(), colvarmodule::debug(), f, colvarmodule::fatal_error(), fb, fj, ft, ft_reported, colvarmodule::log(), colvarmodule::request_system_force(), task_collect_gradients, 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: // checks below do not apply to extended-system colvars if ( !tasks[task_extended_lagrangian] ) { 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 combination " "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 (!tasks[task_extended_lagrangian]) { if (!b_inverse_gradients) { cvm::fatal_error ("Error: one or more of the components of " "colvar \""+this->name+ "\" does not support system force calculation.\n"); } cvm::request_system_force(); } 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: enable (task_gradients); 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; case task_collect_gradients: if (this->type() != colvarvalue::type_scalar) cvm::fatal_error ("Collecting atomic gradients for non-scalar collective variable \""+ this->name+"\" is not yet implemented.\n"); enable (task_gradients); if (atom_ids.size() == 0) { build_atom_list(); } break; } tasks[t] = true; }

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

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

size_t colvar::n_components (   )  const [inline]

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

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

Read the analysis tasks. Definition at line 410 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 972 of file colvar.C. References 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 ( ((std::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 991 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 1037 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 1112 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 556 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 544 of file colvar.h. { return ft_reported; }

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

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

cvm::real colvar::update (   )

Collect all forces on this colvar, integrate internal equations of motion of internal degrees of freedom; see also colvar::communicate_forces() return colvar energy if extended Lagrandian active. Definition at line 827 of file colvar.C. References colvarvalue::apply_constraints(), colvarmodule::boltzmann(), cvcs, colvarmodule::debug(), colvarmodule::decrease_depth(), dist2(), dist2_lgrad(), dist2_rgrad(), colvarmodule::dt(), ext_force_k, ext_gamma, ext_mass, ext_sigma, f, fj, fr, colvarmodule::increase_depth(), kinetic_energy, colvarmodule::log(), lower_wall, lower_wall_k, potential_energy, colvarmodule::rand_gaussian(), colvarmodule::real, colvarvalue::real_value, colvarvalue::reset(), tasks, colvarmodule::temperature(), upper_wall, upper_wall_k, vr, wrap(), 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(); fj.reset(); for (size_t i = 0; i < cvcs.size(); i++) { // linear combination 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 instantaneous Jacobian force was not included in the reported system force; // instead, it is subtracted from the applied force (silent Jacobian correction) if (! tasks[task_report_Jacobian_force]) f -= fj; } if (tasks[task_extended_lagrangian]) { cvm::real dt = cvm::dt(); // the total force is applied to the fictitious mass, while the // atoms only feel the harmonic force // fr: extended coordinate force; f: colvar force applied to atomic coordinates 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: starting from x_i, f_i, v_(i-1/2) vr += (0.5 * dt) * fr / ext_mass; // Because of leapfrog, kinetic energy at time i is approximate kinetic_energy = 0.5 * ext_mass * vr * vr; potential_energy = 0.5 * ext_force_k * this->dist2(xr, x); // leap to v_(i+1/2) if (tasks[task_langevin]) { vr -= dt * ext_gamma * vr.real_value; vr += dt * ext_sigma * cvm::rand_gaussian() / ext_mass; } vr += (0.5 * dt) * fr / ext_mass; xr += dt * vr; xr.apply_constraints(); if (this->b_periodic) this->wrap (xr); } 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"); return (potential_energy + kinetic_energy); }

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

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

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

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

void colvar::wrap (  colvarvalue &  x  )  const

Use the internal metrics (as from objects) to wrap a value into a standard interval. Handles correctly symmetries and periodic boundary conditions Definition at line 1028 of file colvar.C. References cvcs. Referenced by colvarbias_harmonic::update(), and update(). { (cvcs[0])->wrap (x); return; }

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

Save the ACF to a file. Definition at line 1519 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 1169 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 1260 of file colvar.C. References potential_energy, and 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_energy]) { os << " " << std::setprecision (cvm::cv_prec) << std::setw (cvm::cv_width) << potential_energy << " " << kinetic_energy; } 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 1202 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_energy]) { os << " Ep_" << cvm::wrap_string (this->name, this_cv_width-3) << " Ek_" << 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 399 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 387 of file colvar.h. Referenced by calc_acf().

size_t colvar::acf_length [protected]

Length of autocorrelation function (ACF). Definition at line 389 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 395 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 397 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 391 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 401 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 393 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 417 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 374 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 377 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 374 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 377 of file colvar.h. Referenced by calc_acf().

std::vector<int> colvar::atom_ids

Sorted array of (zero-based) IDs for all atoms involved. Definition at line 500 of file colvar.h. Referenced by build_atom_list(), calc(), and enable().

std::vector<cvm::rvector> colvar::atomic_gradients

Array of atomic gradients collected from all cvcs with appropriate components, rotations etc. For scalar variables only! Definition at line 505 of file colvar.h. Referenced by build_atom_list(), and calc().

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 combination 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 247 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 build_atom_list(), calc(), colvar(), communicate_forces(), compare(), dist2(), dist2_lgrad(), dist2_rgrad(), n_components(), update(), wrap(), and ~colvar().

bool colvar::expand_boundaries

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

cvm::real colvar::ext_force_k [protected]

Restraint force constant. Definition at line 210 of file colvar.h. Referenced by colvar(), and update().

cvm::real colvar::ext_gamma [protected]

Friction coefficient for Langevin extended dynamics. Definition at line 212 of file colvar.h. Referenced by colvar(), and update().

cvm::real colvar::ext_mass [protected]

Mass of the restraint center. Definition at line 208 of file colvar.h. Referenced by colvar(), and update().

cvm::real colvar::ext_sigma [protected]

Amplitude of Gaussian white noise for Langevin extended dynamics. Definition at line 214 of file colvar.h. Referenced by colvar(), and update().

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 235 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 230 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 220 of file colvar.h. Referenced by enable(), and update().

colvarvalue colvar::fr [protected]

Harmonic restraint force. Definition at line 217 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 239 of file colvar.h. Referenced by calc(), and enable().

colvarvalue colvar::ft_reported [protected]

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

cvm::real colvar::kinetic_energy [protected]

If extended Lagrangian active: colvar energies (kinetic and harmonic potential). Definition at line 453 of file colvar.h. Referenced by colvar(), and update().

colvarvalue colvar::lower_boundary

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

colvarvalue colvar::lower_wall

Location of the lower wall. Definition at line 257 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 259 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 243 of file colvar.h. Referenced by colvar(), and periodic_boundaries().

cvm::real colvar::potential_energy [protected]

Definition at line 454 of file colvar.h. Referenced by colvar(), update(), and write_traj().

colvarvalue colvar::runave [protected]

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

size_t colvar::runave_length [protected]

Length of running average series. Definition at line 439 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 443 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 441 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 447 of file colvar.h. Referenced by calc_runave().

bool colvar::tasks[task_ntot]

Tasks performed by this colvar. Definition at line 153 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 262 of file colvar.h. Referenced by colvar(), and periodic_boundaries().

colvarvalue colvar::upper_wall

Location of the upper wall. Definition at line 264 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 266 of file colvar.h. Referenced by colvar(), and update().

colvarvalue colvar::v_fdiff [protected]

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

colvarvalue colvar::v_reported [protected]

Cached reported velocity. Definition at line 200 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 206 of file colvar.h. Referenced by calc(), 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 colvar().

colvarvalue colvar::x [protected]

Value of the colvar. Definition at line 180 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 380 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 383 of file colvar.h. Referenced by calc_runave().

colvarvalue colvar::x_old [protected]

Previous value (to calculate velocities during analysis). Definition at line 370 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 183 of file colvar.h. Referenced by calc(), colvar(), read_restart(), and read_traj().

colvarvalue colvar::xr [protected]

Restraint center. Definition at line 204 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

---