jianmu
/
lammps
forked from lijiext/lammps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@15200 f3b2605a-c512-4ea7-a41b-209d697bcdaa

This commit is contained in:
sjplimp 2016-06-17 23:07:51 +00:00
parent e5fb28a6a0
commit 2fcd26f6c4
33 changed files with 824 additions and 544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

368
lib/colvars/colvar.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvarvalue.h"
@ -19,11 +19,11 @@ bool compare(colvar::cvc *i, colvar::cvc *j) {
colvar::colvar(std::string const &conf)
: colvarparse(conf)
{
size_t i;
cvm::log("Initializing a new collective variable.\n");
int error_code = COLVARS_OK;
get_keyval(conf, "name", this->name,
(std::string("colvar")+cvm::to_str(cvm::colvars.size()+1)));
(std::string("colvar")+cvm::to_str(cvm::colvars.size()+1)));
if (cvm::colvar_by_name(this->name) != NULL) {
cvm::error("Error: this colvar cannot have the same name, \""+this->name+
@ -43,141 +43,9 @@ colvar::colvar(std::string const &conf)
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); \
if (cvm::get_error()) { \
cvm::error("Error: in setting up component \"" \
def_config_key"\".\n"); \
return; \
} \
cvm::decrease_depth(); \
} else { \
cvm::error("Error: in allocating component \"" \
def_config_key"\".\n", \
MEMORY_ERROR); \
return; \
} \
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::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), \
INPUT_ERROR); \
return; \
} \
} \
if ( ! cvcs.back()->name.size()){ \
std::ostringstream s; \
s << def_config_key << std::setfill('0') << std::setw(4) << ++def_count;\
cvcs.back()->name = s.str(); \
/* pad cvc number for correct ordering when sorting by name */\
} \
cvcs.back()->setup(); \
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"); \
} \
}
cvm::combine_errors(error_code, init_components(conf));
initialize_components("distance", "distance", distance);
initialize_components("distance vector", "distanceVec", distance_vec);
initialize_components("Cartesian coordinates", "cartesian", cartesian);
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("average distance weighted by inverse power",
"distanceInv", distance_inv);
initialize_components("N1xN2-long vector of pairwise distances",
"distancePairs", distance_pairs);
initialize_components("coordination "
"number", "coordNum", coordnum);
initialize_components("self-coordination "
"number", "selfCoordNum", selfcoordnum);
initialize_components("angle", "angle", angle);
initialize_components("dipole angle", "dipoleAngle", dipole_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("orientation "
"projection", "orientationProj",orientation_proj);
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("moment of "
"inertia", "inertia", inertia);
initialize_components("moment of inertia around an axis",
"inertiaZ", inertia_z);
initialize_components("eigenvector", "eigenvector", eigenvector);
if (!cvcs.size()) {
cvm::error("Error: no valid components were provided "
"for this collective variable.\n",
INPUT_ERROR);
return;
}
n_active_cvcs = cvcs.size();
cvm::log("All components initialized.\n");
// Store list of children cvcs for dependency checking purposes
for (i = 0; i < cvcs.size(); i++) {
add_child(cvcs[i]);
}
size_t i;
// Setup colvar as scripted function of components
if (get_keyval(conf, "scriptedFunction", scripted_function,
@ -540,6 +408,215 @@ colvar::colvar(std::string const &conf)
}
// read the configuration and set up corresponding instances, for
// each type of component implemented
template<typename def_class_name> int colvar::init_components_type(std::string const &conf,
char const *def_desc,
char const *def_config_key)
{
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 def_class_name(def_conf);
if (cvcp != NULL) {
cvcs.push_back(cvcp);
cvcp->check_keywords(def_conf, def_config_key);
if (cvm::get_error()) {
cvm::error("Error: in setting up component \""+
std::string(def_config_key)+"\".\n", INPUT_ERROR);
return INPUT_ERROR;
}
cvm::decrease_depth();
} else {
cvm::error("Error: in allocating component \""+
std::string(def_config_key)+"\".\n",
MEMORY_ERROR);
return MEMORY_ERROR;
}
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::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),
INPUT_ERROR);
return INPUT_ERROR;
}
}
if ( ! cvcs.back()->name.size()) {
std::ostringstream s;
s << def_config_key << std::setfill('0') << std::setw(4) << ++def_count;
cvcs.back()->name = s.str();
/* pad cvc number for correct ordering when sorting by name */
}
cvcs.back()->setup();
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");
}
}
return COLVARS_OK;
}
int colvar::init_components(std::string const &conf)
{
int error_code = COLVARS_OK;
cvm::combine_errors(error_code,
init_components_type<distance>(conf,
"distance", "distance"));
cvm::combine_errors(error_code,
init_components_type<distance_vec>(conf,
"distance vector", "distanceVec"));
cvm::combine_errors(error_code,
init_components_type<cartesian>(conf,
"Cartesian coordinates", "cartesian"));
cvm::combine_errors(error_code,
init_components_type<distance_dir>(conf,
"distance vector "
"direction", "distanceDir"));
cvm::combine_errors(error_code,
init_components_type<distance_z>(conf,
"distance projection "
"on an axis", "distanceZ"));
cvm::combine_errors(error_code,
init_components_type<distance_xy>(conf,
"distance projection "
"on a plane", "distanceXY"));
cvm::combine_errors(error_code,
init_components_type<distance_inv>(conf,
"average distance "
"weighted by inverse power",
"distanceInv"));
cvm::combine_errors(error_code,
init_components_type<distance_pairs>(conf,
"N1xN2-long vector "
"of pairwise distances",
"distancePairs"));
cvm::combine_errors(error_code,
init_components_type<coordnum>(conf,
"coordination "
"number", "coordNum"));
cvm::combine_errors(error_code,
init_components_type<selfcoordnum>(conf,
"self-coordination "
"number", "selfCoordNum"));
cvm::combine_errors(error_code,
init_components_type<angle>(conf,
"angle", "angle"));
cvm::combine_errors(error_code,
init_components_type<dipole_angle>(conf,
"dipole angle", "dipoleAngle"));
cvm::combine_errors(error_code,
init_components_type<dihedral>(conf,
"dihedral", "dihedral"));
cvm::combine_errors(error_code,
init_components_type<h_bond>(conf,
"hydrogen bond", "hBond"));
// cvm::combine_errors(error_code, init_components_type<alpha_dihedrals>(conf, "alpha helix", "alphaDihedrals"));
cvm::combine_errors(error_code,
init_components_type<alpha_angles>(conf,
"alpha helix", "alpha"));
cvm::combine_errors(error_code,
init_components_type<dihedPC>(conf,
"dihedral "
"principal component", "dihedralPC"));
cvm::combine_errors(error_code,
init_components_type<orientation>(conf,
"orientation", "orientation"));
cvm::combine_errors(error_code,
init_components_type<orientation_angle>(conf,
"orientation "
"angle", "orientationAngle"));
cvm::combine_errors(error_code,
init_components_type<orientation_proj>(conf,
"orientation "
"projection", "orientationProj"));
cvm::combine_errors(error_code,
init_components_type<tilt>(conf,
"tilt", "tilt"));
cvm::combine_errors(error_code,
init_components_type<spin_angle>(conf,
"spin angle", "spinAngle"));
cvm::combine_errors(error_code,
init_components_type<rmsd>(conf,
"RMSD", "rmsd"));
// cvm::combine_errors(error_code, init_components_type <logmsd>(conf,"logarithm of MSD", "logmsd"));
cvm::combine_errors(error_code,
init_components_type<gyration>(conf,
"radius of "
"gyration", "gyration"));
cvm::combine_errors(error_code,
init_components_type<inertia>(conf,
"moment of "
"inertia", "inertia"));
cvm::combine_errors(error_code,
init_components_type<inertia_z>(conf,
"moment of inertia around an axis",
"inertiaZ"));
cvm::combine_errors(error_code,
init_components_type<eigenvector>(conf,
"eigenvector", "eigenvector"));
if (!cvcs.size() || (error_code != COLVARS_OK)) {
cvm::error("Error: no valid components were provided "
"for this collective variable.\n",
INPUT_ERROR);
return INPUT_ERROR;
}
n_active_cvcs = cvcs.size();
cvm::log("All components initialized.\n");
// Store list of children cvcs for dependency checking purposes
for (size_t i = 0; i < cvcs.size(); i++) {
add_child(cvcs[i]);
}
return COLVARS_OK;
}
int colvar::refresh_deps()
{
// If enabled features are changed upstream, the features below should be refreshed
@ -959,18 +1036,7 @@ int colvar::calc_cvc_sys_forces(int first_cvc, size_t num_cvcs)
size_t const cvc_max_count = num_cvcs ? num_cvcs : num_active_cvcs();
size_t i, cvc_count;
if (is_enabled(f_cv_system_force) && !is_enabled(f_cv_extended_Lagrangian)) {
// If extended Lagrangian is enabled, system force calculation is trivial
// and done together with integration of the extended coordinate.
if (is_enabled(f_cv_scripted)) {
// TODO see if this could reasonably be done in a generic way
// from generic inverse gradients
cvm::error("System force is not implemented for "
"scripted colvars.", COLVARS_NOT_IMPLEMENTED);
return COLVARS_NOT_IMPLEMENTED;
}
if (is_enabled(f_cv_system_force_calc)) {
if (cvm::debug())
cvm::log("Calculating system force of colvar \""+this->name+"\".\n");
@ -1001,9 +1067,7 @@ int colvar::calc_cvc_sys_forces(int first_cvc, size_t num_cvcs)
int colvar::collect_cvc_sys_forces()
{
if (is_enabled(f_cv_system_force) && !is_enabled(f_cv_extended_Lagrangian)) {
// If extended Lagrangian is enabled, system force calculation is trivial
// and done together with integration of the extended coordinate.
if (is_enabled(f_cv_system_force_calc)) {
ft.reset();
if (cvm::step_relative() > 0) {

15
lib/colvars/colvar.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVAR_H
#define COLVAR_H
@ -220,7 +220,18 @@ public:
/// Constructor
colvar(std::string const &conf);
/// Get ready for a run and possibly re-initialize internal data
/// Parse the CVC configuration and allocate their data
int init_components(std::string const &conf);
private:
/// Parse the CVC configuration for all components of a certain type
template<typename def_class_name> int init_components_type(std::string const &conf,
char const *def_desc,
char const *def_config_key);
public:
/// Get ready for a run and re-initialize internal data if needed
void setup();
/// Destructor

72
lib/colvars/colvaratoms.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvarparse.h"
@ -96,9 +96,9 @@ cvm::atom_group::~atom_group()
index = -1;
}
if (ref_pos_group) {
delete ref_pos_group;
ref_pos_group = NULL;
if (fitting_group) {
delete fitting_group;
fitting_group = NULL;
}
}
@ -183,7 +183,7 @@ int cvm::atom_group::init()
b_rotate = false;
b_user_defined_fit = false;
b_fit_gradients = false;
ref_pos_group = NULL;
fitting_group = NULL;
noforce = false;
@ -598,23 +598,31 @@ int cvm::atom_group::parse_fitting_options(std::string const &group_conf)
cvm::error("Error: centerReference or rotateReference "
"cannot be defined for a dummy atom.\n");
bool b_ref_pos_group = false;
if (key_lookup(group_conf, "refPositionsGroup")) {
b_ref_pos_group = true;
cvm::log("Warning: keyword \"refPositionsGroup\" is deprecated: please use \"fittingGroup\" instead.\n");
}
if (b_ref_pos_group || key_lookup(group_conf, "fittingGroup")) {
// instead of this group, define another group to compute the fit
if (ref_pos_group) {
if (fitting_group) {
cvm::error("Error: the atom group \""+
key+"\" has already a reference group "
"for the rototranslational fit, which was communicated by the "
"colvar component. You should not use refPositionsGroup "
"colvar component. You should not use fittingGroup "
"in this case.\n");
}
cvm::log("Within atom group \""+key+"\":\n");
ref_pos_group = new atom_group(group_conf, "refPositionsGroup");
fitting_group = b_ref_pos_group ?
new atom_group(group_conf, "refPositionsGroup") :
new atom_group(group_conf, "fittingGroup");
// regardless of the configuration, fit gradients must be calculated by refPositionsGroup
ref_pos_group->b_fit_gradients = this->b_fit_gradients;
// regardless of the configuration, fit gradients must be calculated by fittingGroup
fitting_group->b_fit_gradients = this->b_fit_gradients;
}
atom_group *group_for_fit = ref_pos_group ? ref_pos_group : this;
atom_group *group_for_fit = fitting_group ? fitting_group : this;
get_keyval(group_conf, "refPositions", ref_pos, ref_pos);
@ -678,7 +686,7 @@ int cvm::atom_group::parse_fitting_options(std::string const &group_conf)
"\" will be aligned to a fixed orientation given by the reference positions provided. "
"If the internal structure of the group changes too much (i.e. its RMSD is comparable "
"to its radius of gyration), the optimal rotation and its gradients may become discontinuous. "
"If that happens, use refPositionsGroup (or a different definition for it if already defined) "
"If that happens, use fittingGroup (or a different definition for it if already defined) "
"to align the coordinates.\n");
// initialize rot member data
rot.request_group1_gradients(group_for_fit->size());
@ -741,8 +749,8 @@ void cvm::atom_group::read_positions()
ai->read_position();
}
if (ref_pos_group)
ref_pos_group->read_positions();
if (fitting_group)
fitting_group->read_positions();
}
@ -754,8 +762,8 @@ int cvm::atom_group::calc_required_properties()
if (!is_enabled(f_ag_scalable)) {
if (b_center || b_rotate) {
if (ref_pos_group) {
ref_pos_group->calc_center_of_geometry();
if (fitting_group) {
fitting_group->calc_center_of_geometry();
}
calc_apply_roto_translation();
@ -763,8 +771,8 @@ int cvm::atom_group::calc_required_properties()
// update COM and COG after fitting
calc_center_of_geometry();
calc_center_of_mass();
if (ref_pos_group) {
ref_pos_group->calc_center_of_geometry();
if (fitting_group) {
fitting_group->calc_center_of_geometry();
}
}
}
@ -779,25 +787,25 @@ void cvm::atom_group::calc_apply_roto_translation()
{
// store the laborarory-frame COGs for when they are needed later
cog_orig = this->center_of_geometry();
if (ref_pos_group) {
ref_pos_group->cog_orig = ref_pos_group->center_of_geometry();
if (fitting_group) {
fitting_group->cog_orig = fitting_group->center_of_geometry();
}
if (b_center) {
// center on the origin first
cvm::atom_pos const rpg_cog = ref_pos_group ?
ref_pos_group->center_of_geometry() : this->center_of_geometry();
cvm::atom_pos const rpg_cog = fitting_group ?
fitting_group->center_of_geometry() : this->center_of_geometry();
apply_translation(-1.0 * rpg_cog);
if (ref_pos_group) {
ref_pos_group->apply_translation(-1.0 * rpg_cog);
if (fitting_group) {
fitting_group->apply_translation(-1.0 * rpg_cog);
}
}
if (b_rotate) {
// rotate the group (around the center of geometry if b_center is
// true, around the origin otherwise)
rot.calc_optimal_rotation(ref_pos_group ?
ref_pos_group->positions() :
rot.calc_optimal_rotation(fitting_group ?
fitting_group->positions() :
this->positions(),
ref_pos);
@ -805,8 +813,8 @@ void cvm::atom_group::calc_apply_roto_translation()
for (ai = this->begin(); ai != this->end(); ai++) {
ai->pos = rot.rotate(ai->pos);
}
if (ref_pos_group) {
for (ai = ref_pos_group->begin(); ai != ref_pos_group->end(); ai++) {
if (fitting_group) {
for (ai = fitting_group->begin(); ai != fitting_group->end(); ai++) {
ai->pos = rot.rotate(ai->pos);
}
}
@ -815,8 +823,8 @@ void cvm::atom_group::calc_apply_roto_translation()
if (b_center) {
// align with the center of geometry of ref_pos
apply_translation(ref_pos_cog);
if (ref_pos_group) {
ref_pos_group->apply_translation(ref_pos_cog);
if (fitting_group) {
fitting_group->apply_translation(ref_pos_cog);
}
}
// update of COM and COG is done from the calling routine
@ -953,7 +961,7 @@ void cvm::atom_group::calc_fit_gradients()
if (cvm::debug())
cvm::log("Calculating fit gradients.\n");
atom_group *group_for_fit = ref_pos_group ? ref_pos_group : this;
atom_group *group_for_fit = fitting_group ? fitting_group : this;
if (b_center) {
// add the center of geometry contribution to the gradients
@ -1141,7 +1149,7 @@ void cvm::atom_group::apply_colvar_force(cvm::real const &force)
if ((b_center || b_rotate) && b_fit_gradients) {
atom_group *group_for_fit = ref_pos_group ? ref_pos_group : this;
atom_group *group_for_fit = fitting_group ? fitting_group : this;
// Fit gradients are already calculated in "laboratory" frame
for (size_t j = 0; j < group_for_fit->size(); j++) {

8
lib/colvars/colvaratoms.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARATOMS_H
#define COLVARATOMS_H
@ -299,7 +299,7 @@ public:
/// \brief If b_center or b_rotate is true, use this group to
/// define the transformation (default: this group itself)
atom_group *ref_pos_group;
atom_group *fitting_group;
/// Total mass of the atom group
cvm::real total_mass;
@ -346,8 +346,8 @@ public:
{
for (cvm::atom_iter ai = atoms.begin(); ai != atoms.end(); ai++)
ai->reset_data();
if (ref_pos_group)
ref_pos_group->reset_atoms_data();
if (fitting_group)
fitting_group->reset_atoms_data();
}
/// \brief Recompute all mutable quantities that are required to compute CVCs

2
lib/colvars/colvarbias.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvarvalue.h"

2
lib/colvars/colvarbias.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARBIAS_H
#define COLVARBIAS_H

16
lib/colvars/colvarbias_abf.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvar.h"
@ -8,8 +8,11 @@
colvarbias_abf::colvarbias_abf(std::string const &conf, char const *key)
: colvarbias(conf, key),
force(NULL),
gradients(NULL),
samples(NULL)
samples(NULL),
last_gradients(NULL),
last_samples(NULL)
{
// TODO relax this in case of VMD plugin
if (cvm::temperature() == 0.0)
@ -60,10 +63,10 @@ colvarbias_abf::colvarbias_abf(std::string const &conf, char const *key)
if (update_bias) {
// Request calculation of system force (which also checks for availability)
enable(f_cvb_get_system_force);
if(enable(f_cvb_get_system_force)) return;
}
if (apply_bias) {
enable(f_cvb_apply_force);
if(enable(f_cvb_apply_force)) return;
}
for (size_t i = 0; i < colvars.size(); i++) {
@ -151,7 +154,10 @@ colvarbias_abf::~colvarbias_abf()
last_gradients = NULL;
}
delete [] force;
if (force) {
delete [] force;
force = NULL;
}
if (cvm::n_abf_biases > 0)
cvm::n_abf_biases -= 1;

2
lib/colvars/colvarbias_histogram.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvar.h"

10
lib/colvars/colvarbias_meta.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include <iostream>
#include <sstream>
@ -41,10 +41,10 @@ colvarbias_meta::colvarbias_meta(std::string const &conf, char const *key)
if (cvm::n_abf_biases > 0)
cvm::log("Warning: running ABF and metadynamics together is not recommended unless applyBias is off for ABF.\n");
get_keyval(conf, "hillWeight", hill_weight, 0.01);
if (hill_weight == 0.0)
cvm::log("Warning: hillWeight has been set to zero, "
"this bias will have no effect.\n");
get_keyval(conf, "hillWeight", hill_weight, 0.0);
if (hill_weight <= 0.0) {
cvm::error("Error: hillWeight must be provided, and a positive number.\n", INPUT_ERROR);
}
get_keyval(conf, "newHillFrequency", new_hill_freq, 1000);

2
lib/colvars/colvarbias_meta.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARBIAS_META_H
#define COLVARBIAS_META_H

2
lib/colvars/colvarbias_restraint.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvarvalue.h"

2
lib/colvars/colvarbias_restraint.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARBIAS_RESTRAINT_H
#define COLVARBIAS_RESTRAINT_H

17
lib/colvars/colvarcomp.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvarvalue.h"
@ -68,6 +68,7 @@ cvm::atom_group *colvar::cvc::parse_group(std::string const &conf,
group->key = group_key;
if (b_try_scalable) {
// TODO rewrite this logic in terms of dependencies
if (is_available(f_cvc_scalable_com) && is_available(f_cvc_com_based)) {
enable(f_cvc_scalable_com);
enable(f_cvc_scalable);
@ -109,10 +110,6 @@ int colvar::cvc::setup()
add_child((cvm::deps *) atom_groups[i]);
}
if (b_try_scalable && is_available(f_cvc_scalable)) {
enable(f_cvc_scalable);
}
return COLVARS_OK;
}
@ -134,7 +131,7 @@ void colvar::cvc::read_data()
atoms.reset_atoms_data();
atoms.read_positions();
atoms.calc_required_properties();
// each atom group will take care of its own ref_pos_group, if defined
// each atom group will take care of its own fitting_group, if defined
}
//// Don't try to get atom velocities, as no back-end currently implements it
@ -179,7 +176,7 @@ void colvar::cvc::debug_gradients(cvm::atom_group *group)
// cvm::log("gradients = "+cvm::to_str (gradients)+"\n");
cvm::atom_group *group_for_fit = group->ref_pos_group ? group->ref_pos_group : group;
cvm::atom_group *group_for_fit = group->fitting_group ? group->fitting_group : group;
cvm::atom_pos fit_gradient_sum, gradient_sum;
// print the values of the fit gradients
@ -190,7 +187,7 @@ void colvar::cvc::debug_gradients(cvm::atom_group *group)
// fit_gradients are in the simulation frame: we should print them in the rotated frame
cvm::log("Fit gradients:\n");
for (j = 0; j < group_for_fit->fit_gradients.size(); j++) {
cvm::log((group->ref_pos_group ? std::string("refPosGroup") : group->key) +
cvm::log((group->fitting_group ? std::string("refPosGroup") : group->key) +
"[" + cvm::to_str(j) + "] = " +
(group->b_rotate ?
cvm::to_str(rot_0.rotate(group_for_fit->fit_gradients[j])) :
@ -231,8 +228,8 @@ void colvar::cvc::debug_gradients(cvm::atom_group *group)
}
}
if ((group->b_fit_gradients) && (group->ref_pos_group != NULL)) {
cvm::atom_group *ref_group = group->ref_pos_group;
if ((group->b_fit_gradients) && (group->fitting_group != NULL)) {
cvm::atom_group *ref_group = group->fitting_group;
group->read_positions();
group->calc_required_properties();

21
lib/colvars/colvarcomp.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARCOMP_H
#define COLVARCOMP_H
@ -293,12 +293,7 @@ inline void colvar::cvc::wrap(colvarvalue &x) const
/// \brief Colvar component: distance between the centers of mass of
/// two groups (colvarvalue::type_scalar type, range [0:*))
///
/// This class also serves as the template for many collective
/// variables with two atom groups: in this case, the
/// distance::distance() constructor should be called on the same
/// configuration string, to make the same member data and functions
/// available to the derived object
class colvar::distance
: public colvar::cvc
{
@ -315,7 +310,7 @@ protected:
/// coupling to other colvars (see e.g. Ciccotti et al., 2005)
bool b_1site_force;
public:
distance(std::string const &conf, bool twogroups = true);
distance(std::string const &conf);
distance();
virtual inline ~distance() {}
virtual void calc_value();
@ -764,9 +759,13 @@ public:
/// \brief Colvar component: coordination number between two groups
/// (colvarvalue::type_scalar type, range [0:N1*N2])
class colvar::coordnum
: public colvar::distance
: public colvar::cvc
{
protected:
/// First atom group
cvm::atom_group *group1;
/// Second atom group
cvm::atom_group *group2;
/// \brief "Cutoff" for isotropic calculation (default)
cvm::real r0;
/// \brief "Cutoff vector" for anisotropic calculation
@ -819,9 +818,11 @@ public:
/// \brief Colvar component: self-coordination number within a group
/// (colvarvalue::type_scalar type, range [0:N*(N-1)/2])
class colvar::selfcoordnum
: public colvar::distance
: public colvar::cvc
{
protected:
/// First atom group
cvm::atom_group *group1;
/// \brief "Cutoff" for isotropic calculation (default)
cvm::real r0;
/// Integer exponent of the function numerator

2
lib/colvars/colvarcomp_angles.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvar.h"

41
lib/colvars/colvarcomp_coordnums.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include <cmath>
@ -71,31 +71,29 @@ cvm::real colvar::coordnum::switching_function(cvm::rvector const &r0_vec,
}
colvar::coordnum::coordnum(std::string const &conf)
: distance(conf), b_anisotropic(false), b_group2_center_only(false)
: cvc(conf), b_anisotropic(false), b_group2_center_only(false)
{
function_type = "coordnum";
x.type(colvarvalue::type_scalar);
// group1 and group2 are already initialized by distance()
group1 = parse_group(conf, "group1");
group2 = parse_group(conf, "group2");
if (group1->b_dummy)
cvm::fatal_error("Error: only group2 is allowed to be a dummy atom\n");
bool const b_isotropic = get_keyval(conf, "cutoff", r0,
cvm::real(4.0 * cvm::unit_angstrom()));
// need to specify this explicitly because the distance() constructor
// has set it to true
feature_states[f_cvc_inv_gradient]->available = false;
if (get_keyval(conf, "cutoff3", r0_vec, cvm::rvector(4.0 * cvm::unit_angstrom(),
4.0 * cvm::unit_angstrom(),
4.0 * cvm::unit_angstrom()))) {
if (b_isotropic) {
cvm::error("Error: cannot specify \"cutoff\" and \"cutoff3\" at the same time.\n",
INPUT_ERROR);
}
bool const b_scale = get_keyval(conf, "cutoff", r0,
cvm::real(4.0 * cvm::unit_angstrom()));
if (get_keyval(conf, "cutoff3", r0_vec,
cvm::rvector(4.0, 4.0, 4.0), parse_silent)) {
if (b_scale)
cvm::fatal_error("Error: cannot specify \"scale\" and "
"\"scale3\" at the same time.\n");
b_anisotropic = true;
// remove meaningless negative signs
if (r0_vec.x < 0.0) r0_vec.x *= -1.0;
@ -107,7 +105,7 @@ colvar::coordnum::coordnum(std::string const &conf)
get_keyval(conf, "expDenom", ed, int(12));
if ( (en%2) || (ed%2) ) {
cvm::fatal_error("Error: odd exponents provided, can only use even ones.\n");
cvm::error("Error: odd exponents provided, can only use even ones.\n", INPUT_ERROR);
}
get_keyval(conf, "group2CenterOnly", b_group2_center_only, group2->b_dummy);
@ -289,17 +287,12 @@ void colvar::h_bond::apply_force(colvarvalue const &force)
colvar::selfcoordnum::selfcoordnum(std::string const &conf)
: distance(conf, false)
: cvc(conf)
{
function_type = "selfcoordnum";
x.type(colvarvalue::type_scalar);
// group1 is already initialized by distance()
// need to specify this explicitly because the distance() constructor
// has set it to true
feature_states[f_cvc_inv_gradient]->available = false;
group1 = parse_group(conf, "group1");
get_keyval(conf, "cutoff", r0, cvm::real(4.0 * cvm::unit_angstrom()));
get_keyval(conf, "expNumer", en, int(6) );

18
lib/colvars/colvarcomp_distances.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include <cmath>
@ -10,10 +10,7 @@
// "twogroup" flag defaults to true; set to false by selfCoordNum
// (only distance-derived component based on only one group)
colvar::distance::distance(std::string const &conf, bool twogroups)
colvar::distance::distance(std::string const &conf)
: cvc(conf)
{
function_type = "distance";
@ -24,13 +21,12 @@ colvar::distance::distance(std::string const &conf, bool twogroups)
if (get_keyval(conf, "forceNoPBC", b_no_PBC, false)) {
cvm::log("Computing distance using absolute positions (not minimal-image)");
}
if (twogroups && get_keyval(conf, "oneSiteSystemForce", b_1site_force, false)) {
if (get_keyval(conf, "oneSiteSystemForce", b_1site_force, false)) {
cvm::log("Computing system force on group 1 only");
}
group1 = parse_group(conf, "group1");
if (twogroups) {
group2 = parse_group(conf, "group2");
}
group2 = parse_group(conf, "group2");
x.type(colvarvalue::type_scalar);
}
@ -789,7 +785,7 @@ colvar::rmsd::rmsd(std::string const &conf)
}
bool b_Jacobian_derivative = true;
if (atoms->ref_pos_group != NULL && b_Jacobian_derivative) {
if (atoms->fitting_group != NULL && b_Jacobian_derivative) {
cvm::log("The option \"refPositionsGroup\" (alternative group for fitting) was enabled: "
"Jacobian derivatives of the RMSD will not be calculated.\n");
b_Jacobian_derivative = false;
@ -798,7 +794,7 @@ colvar::rmsd::rmsd(std::string const &conf)
// the following is a simplified version of the corresponding atom group options;
// we need this because the reference coordinates defined inside the atom group
// may be used only for fitting, and even more so if ref_pos_group is used
// may be used only for fitting, and even more so if fitting_group is used
if (get_keyval(conf, "refPositions", ref_pos, ref_pos)) {
cvm::log("Using reference positions from configuration file to calculate the variable.\n");
if (ref_pos.size() != atoms->size()) {

2
lib/colvars/colvarcomp_protein.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include <cmath>

2
lib/colvars/colvarcomp_rotations.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include <cmath>

16
lib/colvars/colvardeps.cpp
View File

@ -196,7 +196,7 @@ int cvm::deps::enable(int feature_id,
void cvm::deps::init_cvb_requires() {
int i;
if (features().size() == 0) {
for (i = 0; i < f_cv_ntot; i++) {
for (i = 0; i < f_cvb_ntot; i++) {
features().push_back(new feature);
}
}
@ -362,11 +362,15 @@ void cvm::deps::init_cvc_requires() {
f_description(f_cvc_Jacobian, "Jacobian");
f_req_self(f_cvc_Jacobian, f_cvc_inv_gradient);
f_description(f_cvc_scalable, "scalable calculation");
f_description(f_cvc_scalable_com, "scalable calculation of centers of mass");
f_description(f_cvc_com_based, "depends on group centers of mass");
f_description(f_cvc_scalable, "scalable calculation");
f_req_self(f_cvc_scalable, f_cvc_scalable_com);
f_description(f_cvc_scalable_com, "scalable calculation of centers of mass");
f_req_self(f_cvc_scalable_com, f_cvc_com_based);
// TODO only enable this when f_ag_scalable can be turned on for a pre-initialized group
// f_req_children(f_cvc_scalable, f_ag_scalable);
// f_req_children(f_cvc_scalable_com, f_ag_scalable_com);
@ -380,9 +384,9 @@ void cvm::deps::init_cvc_requires() {
}
// Features that are implemented by all cvcs by default
// Each cvc specifies what other features are available
feature_states[f_cvc_active]->available = true;
feature_states[f_cvc_gradient]->available = true;
// Each cvc specifies what other features are available
feature_states[f_cvc_scalable_com]->available = (proxy->scalable_group_coms() == COLVARS_OK);
feature_states[f_cvc_scalable]->available = feature_states[f_cvc_scalable_com]->available;
}
@ -399,7 +403,7 @@ void cvm::deps::init_ag_requires() {
f_description(f_ag_active, "active");
f_description(f_ag_center, "translational fit");
f_description(f_ag_rotate, "rotational fit");
f_description(f_ag_ref_pos_group, "reference positions group");
f_description(f_ag_fitting_group, "reference positions group");
f_description(f_ag_fit_gradient_group, "fit gradient for main group");
f_description(f_ag_fit_gradient_ref, "fit gradient for reference group");
f_description(f_ag_atom_forces, "atomic forces");
@ -413,7 +417,7 @@ void cvm::deps::init_ag_requires() {
// f_description(f_ag_min_msd_fit, "minimum MSD fit")
// f_req_self(f_ag_min_msd_fit, f_ag_center)
// f_req_self(f_ag_min_msd_fit, f_ag_rotate)
// f_req_exclude(f_ag_min_msd_fit, f_ag_ref_pos_group)
// f_req_exclude(f_ag_min_msd_fit, f_ag_fitting_group)
}
// Initialize feature_states for each instance

4
lib/colvars/colvardeps.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
@ -238,7 +238,7 @@ public:
f_ag_active,
f_ag_center,
f_ag_rotate,
f_ag_ref_pos_group,
f_ag_fitting_group,
/// Perform a standard minimum msd fit for given atoms
/// ie. not using refpositionsgroup
// f_ag_min_msd_fit,

2
lib/colvars/colvargrid.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include "colvarmodule.h"
#include "colvarvalue.h"

2
lib/colvars/colvargrid.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARGRID_H
#define COLVARGRID_H

2
lib/colvars/colvarmodule.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include <sstream>
#include <string.h>

7
lib/colvars/colvarmodule.h
View File

@ -1,16 +1,19 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARMODULE_H
#define COLVARMODULE_H
#ifndef COLVARS_VERSION
#define COLVARS_VERSION "2016-05-23"
#define COLVARS_VERSION "2016-06-14"
#endif
#ifndef COLVARS_DEBUG
#define COLVARS_DEBUG false
#endif
/*! \mainpage Main page
*/
/// \file colvarmodule.h
/// \brief Collective variables main module
///

560
lib/colvars/colvarparse.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
#include <sstream>
#include <iostream>
@ -17,235 +17,280 @@ size_t colvarparse::dummy_pos = 0;
// definition of single-value keyword parsers
#define _get_keyval_scalar_string_(TYPE) \
\
bool colvarparse::get_keyval(std::string const &conf, \
char const *key, \
TYPE &value, \
TYPE const &def_value, \
Parse_Mode const parse_mode) \
{ \
std::string data; \
bool b_found = false, b_found_any = false; \
size_t save_pos = 0, found_count = 0; \
\
do { \
std::string data_this = ""; \
b_found = key_lookup(conf, key, data_this, save_pos); \
if (b_found) { \
if (!b_found_any) \
b_found_any = true; \
found_count++; \
data = data_this; \
} \
} while (b_found); \
\
if (found_count > 1) \
cvm::log("Warning: found more than one instance of \""+ \
std::string(key)+"\".\n"); \
\
if (data.size()) { \
std::istringstream is(data); \
TYPE x(def_value); \
if (is >> x) { \
value = x; \
} else { \
cvm::error("Error: in parsing \""+ \
std::string(key)+"\".\n", INPUT_ERROR); \
} \
if (parse_mode != parse_silent) { \
cvm::log("# "+std::string(key)+" = "+ \
cvm::to_str(value)+"\n"); \
} \
} else { \
\
if (b_found_any) { \
cvm::error("Error: improper or missing value " \
"for \""+std::string(key)+"\".\n", INPUT_ERROR); \
} \
value = def_value; \
if (parse_mode != parse_silent) { \
cvm::log("# "+std::string(key)+" = \""+ \
cvm::to_str(def_value)+"\" [default]\n"); \
} \
} \
\
return b_found_any; \
template<typename TYPE> bool colvarparse::_get_keyval_scalar_(std::string const &conf,
char const *key,
TYPE &value,
TYPE const &def_value,
Parse_Mode const parse_mode)
{
std::string data;
bool b_found = false, b_found_any = false;
size_t save_pos = 0, found_count = 0;
do {
std::string data_this = "";
b_found = key_lookup(conf, key, data_this, save_pos);
if (b_found) {
if (!b_found_any)
b_found_any = true;
found_count++;
data = data_this;
}
} while (b_found);
if (found_count > 1)
cvm::log("Warning: found more than one instance of \""+
std::string(key)+"\".\n");
if (data.size()) {
std::istringstream is(data);
TYPE x(def_value);
if (is >> x) {
value = x;
} else {
cvm::error("Error: in parsing \""+
std::string(key)+"\".\n", INPUT_ERROR);
}
if (parse_mode != parse_silent) {
cvm::log("# "+std::string(key)+" = "+
cvm::to_str(value)+"\n");
}
} else {
if (b_found_any) {
cvm::error("Error: improper or missing value "
"for \""+std::string(key)+"\".\n", INPUT_ERROR);
}
value = def_value;
if (parse_mode != parse_silent) {
cvm::log("# "+std::string(key)+" = "+
cvm::to_str(def_value)+" [default]\n");
}
}
return b_found_any;
}
#define _get_keyval_scalar_(TYPE) \
\
bool colvarparse::get_keyval(std::string const &conf, \
char const *key, \
TYPE &value, \
TYPE const &def_value, \
Parse_Mode const parse_mode) \
{ \
std::string data; \
bool b_found = false, b_found_any = false; \
size_t save_pos = 0, found_count = 0; \
\
do { \
std::string data_this = ""; \
b_found = key_lookup(conf, key, data_this, save_pos); \
if (b_found) { \
if (!b_found_any) \
b_found_any = true; \
found_count++; \
data = data_this; \
} \
} while (b_found); \
\
if (found_count > 1) \
cvm::log("Warning: found more than one instance of \""+ \
std::string(key)+"\".\n"); \
\
if (data.size()) { \
std::istringstream is(data); \
size_t data_count = 0; \
TYPE x(def_value); \
while (is >> x) { \
value = x; \
data_count++; \
} \
if (data_count == 0) \
cvm::error("Error: in parsing \""+ \
std::string(key)+"\".\n", INPUT_ERROR); \
if (data_count > 1) { \
cvm::error("Error: multiple values " \
"are not allowed for keyword \""+ \
std::string(key)+"\".\n", INPUT_ERROR); \
} \
if (parse_mode != parse_silent) { \
cvm::log("# "+std::string(key)+" = "+ \
cvm::to_str(value)+"\n"); \
} \
} else { \
\
if (b_found_any) { \
cvm::error("Error: improper or missing value " \
"for \""+std::string(key)+"\".\n", INPUT_ERROR); \
} \
value = def_value; \
if (parse_mode != parse_silent) { \
cvm::log("# "+std::string(key)+" = "+ \
cvm::to_str(def_value)+" [default]\n"); \
} \
} \
\
return b_found_any; \
bool colvarparse::_get_keyval_scalar_string_(std::string const &conf,
char const *key,
std::string &value,
std::string const &def_value,
Parse_Mode const parse_mode)
{
std::string data;
bool b_found = false, b_found_any = false;
size_t save_pos = 0, found_count = 0;
do {
std::string data_this = "";
b_found = key_lookup(conf, key, data_this, save_pos);
if (b_found) {
if (!b_found_any)
b_found_any = true;
found_count++;
data = data_this;
}
} while (b_found);
if (found_count > 1)
cvm::log("Warning: found more than one instance of \""+
std::string(key)+"\".\n");
if (data.size()) {
std::istringstream is(data);
size_t data_count = 0;
std::string x(def_value);
while (is >> x) {
value = x;
data_count++;
}
if (data_count == 0)
cvm::error("Error: in parsing \""+
std::string(key)+"\".\n", INPUT_ERROR);
if (data_count > 1) {
cvm::error("Error: multiple values "
"are not allowed for keyword \""+
std::string(key)+"\".\n", INPUT_ERROR);
}
if (parse_mode != parse_silent) {
cvm::log("# "+std::string(key)+" = \""+
cvm::to_str(value)+"\"\n");
}
} else {
if (b_found_any) {
cvm::error("Error: improper or missing value "
"for \""+std::string(key)+"\".\n", INPUT_ERROR);
}
value = def_value;
if (parse_mode != parse_silent) {
cvm::log("# "+std::string(key)+" = \""+
cvm::to_str(def_value)+"\" [default]\n");
}
}
// definition of multiple-value keyword parsers
#define _get_keyval_vector_(TYPE) \
\
bool colvarparse::get_keyval(std::string const &conf, \
char const *key, \
std::vector<TYPE> &values, \
std::vector<TYPE> const &def_values, \
Parse_Mode const parse_mode) \
{ \
std::string data; \
bool b_found = false, b_found_any = false; \
size_t save_pos = 0, found_count = 0; \
\
do { \
std::string data_this = ""; \
b_found = key_lookup(conf, key, data_this, save_pos); \
if (b_found) { \
if (!b_found_any) \
b_found_any = true; \
found_count++; \
data = data_this; \
} \
} while (b_found); \
\
if (found_count > 1) \
cvm::log("Warning: found more than one instance of \""+ \
std::string(key)+"\".\n"); \
\
if (data.size()) { \
std::istringstream is(data); \
\
if (values.size() == 0) { \
\
std::vector<TYPE> x; \
if (def_values.size()) \
x = def_values; \
else \
x.assign(1, TYPE()); \
\
for (size_t i = 0; \
( is >> x[ ((i<x.size()) ? i : x.size()-1) ] ); \
i++) { \
values.push_back(x[ ((i<x.size()) ? i : x.size()-1) ]); \
} \
\
} else { \
\
size_t i = 0; \
for ( ; i < values.size(); i++) { \
TYPE x(values[i]); \
if (is >> x) { \
values[i] = x; \
} else { \
cvm::error("Error: in parsing \""+ \
std::string(key)+"\".\n", INPUT_ERROR); \
} \
} \
} \
\
if (parse_mode != parse_silent) { \
cvm::log("# "+std::string(key)+" = "+ \
cvm::to_str(values)+"\n"); \
} \
\
} else { \
\
if (b_found_any) { \
cvm::error("Error: improper or missing values for \""+ \
std::string(key)+"\".\n", INPUT_ERROR); \
} \
\
for (size_t i = 0; i < values.size(); i++) \
values[i] = def_values[ (i > def_values.size()) ? 0 : i ]; \
\
if (parse_mode != parse_silent) { \
cvm::log("# "+std::string(key)+" = "+ \
cvm::to_str(def_values)+" [default]\n"); \
} \
} \
\
return b_found_any; \
}
// single-value keyword parsers
_get_keyval_scalar_(int);
_get_keyval_scalar_(size_t);
_get_keyval_scalar_(long);
_get_keyval_scalar_string_(std::string);
_get_keyval_scalar_(cvm::real);
_get_keyval_scalar_(cvm::rvector);
_get_keyval_scalar_(cvm::quaternion);
_get_keyval_scalar_(colvarvalue);
return b_found_any;
}
// multiple-value keyword parsers
_get_keyval_vector_(int);
_get_keyval_vector_(size_t);
_get_keyval_vector_(long);
_get_keyval_vector_(std::string);
_get_keyval_vector_(cvm::real);
_get_keyval_vector_(cvm::rvector);
_get_keyval_vector_(cvm::quaternion);
_get_keyval_vector_(colvarvalue);
template<typename TYPE> bool colvarparse::_get_keyval_vector_(std::string const &conf,
char const *key,
std::vector<TYPE> &values,
std::vector<TYPE> const &def_values,
Parse_Mode const parse_mode)
{
std::string data;
bool b_found = false, b_found_any = false;
size_t save_pos = 0, found_count = 0;
do {
std::string data_this = "";
b_found = key_lookup(conf, key, data_this, save_pos);
if (b_found) {
if (!b_found_any)
b_found_any = true;
found_count++;
data = data_this;
}
} while (b_found);
if (found_count > 1)
cvm::log("Warning: found more than one instance of \""+
std::string(key)+"\".\n");
if (data.size()) {
std::istringstream is(data);
if (values.size() == 0) {
std::vector<TYPE> x;
if (def_values.size())
x = def_values;
else
x.assign(1, TYPE());
for (size_t i = 0;
( is >> x[ ((i<x.size()) ? i : x.size()-1) ] );
i++) {
values.push_back(x[ ((i<x.size()) ? i : x.size()-1) ]);
}
} else {
size_t i = 0;
for ( ; i < values.size(); i++) {
TYPE x(values[i]);
if (is >> x) {
values[i] = x;
} else {
cvm::error("Error: in parsing \""+
std::string(key)+"\".\n", INPUT_ERROR);
}
}
}
if (parse_mode != parse_silent) {
cvm::log("# "+std::string(key)+" = "+
cvm::to_str(values)+"\n");
}
} else {
if (b_found_any) {
cvm::error("Error: improper or missing values for \""+
std::string(key)+"\".\n", INPUT_ERROR);
}
for (size_t i = 0; i < values.size(); i++)
values[i] = def_values[ (i > def_values.size()) ? 0 : i ];
if (parse_mode != parse_silent) {
cvm::log("# "+std::string(key)+" = "+
cvm::to_str(def_values)+" [default]\n");
}
}
return b_found_any;
}
// single-value keyword parsers
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
int &value,
int const &def_value,
Parse_Mode const parse_mode)
{
return _get_keyval_scalar_<int>(conf, key, value, def_value, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
size_t &value,
size_t const &def_value,
Parse_Mode const parse_mode)
{
return _get_keyval_scalar_<size_t>(conf, key, value, def_value, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
long &value,
long const &def_value,
Parse_Mode const parse_mode)
{
return _get_keyval_scalar_<long>(conf, key, value, def_value, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::string &value,
std::string const &def_value,
Parse_Mode const parse_mode)
{
return _get_keyval_scalar_string_(conf, key, value, def_value, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
cvm::real &value,
cvm::real const &def_value,
Parse_Mode const parse_mode)
{
return _get_keyval_scalar_<cvm::real>(conf, key, value, def_value, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
cvm::rvector &value,
cvm::rvector const &def_value,
Parse_Mode const parse_mode)
{
return _get_keyval_scalar_<cvm::rvector>(conf, key, value, def_value, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
cvm::quaternion &value,
cvm::quaternion const &def_value,
Parse_Mode const parse_mode)
{
return _get_keyval_scalar_<cvm::quaternion>(conf, key, value, def_value, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
colvarvalue &value,
colvarvalue const &def_value,
Parse_Mode const parse_mode)
{
return _get_keyval_scalar_<colvarvalue>(conf, key, value, def_value, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
@ -309,6 +354,81 @@ bool colvarparse::get_keyval(std::string const &conf,
}
// multiple-value keyword parsers
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::vector<int> &values,
std::vector<int> const &def_values,
Parse_Mode const parse_mode)
{
return _get_keyval_vector_<int>(conf, key, values, def_values, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::vector<size_t> &values,
std::vector<size_t> const &def_values,
Parse_Mode const parse_mode)
{
return _get_keyval_vector_<size_t>(conf, key, values, def_values, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::vector<long> &values,
std::vector<long> const &def_values,
Parse_Mode const parse_mode)
{
return _get_keyval_vector_<long>(conf, key, values, def_values, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::vector<std::string> &values,
std::vector<std::string> const &def_values,
Parse_Mode const parse_mode)
{
return _get_keyval_vector_<std::string>(conf, key, values, def_values, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::vector<cvm::real> &values,
std::vector<cvm::real> const &def_values,
Parse_Mode const parse_mode)
{
return _get_keyval_vector_<cvm::real>(conf, key, values, def_values, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::vector<cvm::rvector> &values,
std::vector<cvm::rvector> const &def_values,
Parse_Mode const parse_mode)
{
return _get_keyval_vector_<cvm::rvector>(conf, key, values, def_values, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::vector<cvm::quaternion> &values,
std::vector<cvm::quaternion> const &def_values,
Parse_Mode const parse_mode)
{
return _get_keyval_vector_<cvm::quaternion>(conf, key, values, def_values, parse_mode);
}
bool colvarparse::get_keyval(std::string const &conf,
char const *key,
std::vector<colvarvalue> &values,
std::vector<colvarvalue> const &def_values,
Parse_Mode const parse_mode)
{
return _get_keyval_vector_<colvarvalue>(conf, key, values, def_values, parse_mode);
}
void colvarparse::add_keyword(char const *key)
{
for (std::list<std::string>::iterator ki = allowed_keywords.begin();

156
lib/colvars/colvarparse.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARPARSE_H
#define COLVARPARSE_H
@ -64,7 +64,7 @@ public:
inline const std::string& get_config()
{
return config_string;
return config_string;
}
/// How a keyword is parsed in a string
@ -104,40 +104,113 @@ public:
/// functions, or insert this type in the \link colvarvalue \endlink
/// wrapper class (colvarvalue.h).
#define _get_keyval_scalar_proto_(_type_,_def_value_) \
bool get_keyval(std::string const &conf, \
char const *key, \
_type_ &value, \
_type_ const &def_value = _def_value_, \
Parse_Mode const parse_mode = parse_normal)
bool get_keyval(std::string const &conf,
char const *key,
int &value,
int const &def_value = (int)0,
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
size_t &value,
size_t const &def_value = (size_t)0,
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
long &value,
long const &def_value = 0,
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
std::string &value,
std::string const &def_value = std::string(""),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
cvm::real &value,
cvm::real const &def_value = (cvm::real)0.0,
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
cvm::rvector &value,
cvm::rvector const &def_value = cvm::rvector(),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
cvm::quaternion &value,
cvm::quaternion const &def_value = cvm::quaternion(),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
colvarvalue &value,
colvarvalue const &def_value = colvarvalue(colvarvalue::type_notset),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
bool &value,
bool const &def_value = false,
Parse_Mode const parse_mode = parse_normal);
_get_keyval_scalar_proto_(int, (int)0);
_get_keyval_scalar_proto_(size_t, (size_t)0);
_get_keyval_scalar_proto_(long, 0);
_get_keyval_scalar_proto_(std::string, std::string(""));
_get_keyval_scalar_proto_(cvm::real, (cvm::real)0.0);
_get_keyval_scalar_proto_(cvm::rvector, cvm::rvector());
_get_keyval_scalar_proto_(cvm::quaternion, cvm::quaternion());
_get_keyval_scalar_proto_(colvarvalue, colvarvalue(colvarvalue::type_notset));
_get_keyval_scalar_proto_(bool, false);
bool get_keyval(std::string const &conf,
char const *key,
std::vector<int> &values,
std::vector<int> const &def_values = std::vector<int>(0, (int)0),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
std::vector<size_t> &values,
std::vector<size_t> const &def_values = std::vector<size_t>(0, (size_t)0),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
std::vector<long> &values,
std::vector<long> const &def_values = std::vector<long>(0, (long)0),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
std::vector<std::string> &values,
std::vector<std::string> const &def_values = std::vector<std::string>(0, std::string("")),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
std::vector<cvm::real> &values,
std::vector<cvm::real> const &def_values = std::vector<cvm::real>(0, (cvm::real)0.0),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
std::vector<cvm::rvector> &values,
std::vector<cvm::rvector> const &def_values = std::vector<cvm::rvector>(0, cvm::rvector()),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
std::vector<cvm::quaternion> &values,
std::vector<cvm::quaternion> const &def_values = std::vector<cvm::quaternion>(0, cvm::quaternion()),
Parse_Mode const parse_mode = parse_normal);
bool get_keyval(std::string const &conf,
char const *key,
std::vector<colvarvalue> &values,
std::vector<colvarvalue> const &def_values = std::vector<colvarvalue>(0, colvarvalue(colvarvalue::type_notset)),
Parse_Mode const parse_mode = parse_normal);
#define _get_keyval_vector_proto_(_type_,_def_value_) \
bool get_keyval(std::string const &conf, \
char const *key, \
std::vector<_type_> &values, \
std::vector<_type_> const &def_values = \
std::vector<_type_> (0, static_cast<_type_>(_def_value_)), \
Parse_Mode const parse_mode = parse_normal)
protected:
_get_keyval_vector_proto_(int, 0);
_get_keyval_vector_proto_(size_t, 0);
_get_keyval_vector_proto_(long, 0);
_get_keyval_vector_proto_(std::string, std::string(""));
_get_keyval_vector_proto_(cvm::real, 0.0);
_get_keyval_vector_proto_(cvm::rvector, cvm::rvector());
_get_keyval_vector_proto_(cvm::quaternion, cvm::quaternion());
_get_keyval_vector_proto_(colvarvalue, colvarvalue(colvarvalue::type_notset));
// Templates
template<typename TYPE> bool _get_keyval_scalar_(std::string const &conf,
char const *key,
TYPE &value,
TYPE const &def_value,
Parse_Mode const parse_mode);
bool _get_keyval_scalar_string_(std::string const &conf,
char const *key,
std::string &value,
std::string const &def_value,
Parse_Mode const parse_mode);
template<typename TYPE> bool _get_keyval_vector_(std::string const &conf,
char const *key,
std::vector<TYPE> &values,
std::vector<TYPE> const &def_values,
Parse_Mode const parse_mode);
public:
/// \brief Check that all the keywords within "conf" are in the list
/// of allowed keywords; this will invoke strip_values() first and
@ -184,17 +257,16 @@ public:
static std::string const white_space;
/// \brief Low-level function for parsing configuration strings;
/// automatically adds the requested keywords to the list of valid
/// automatically adds the requested keyword to the list of valid
/// ones. \param conf the content of the configuration file or one
/// of its blocks \param key the keyword to search in "conf" \param
/// of its blocks \param key the keyword to search within "conf" \param
/// data (optional) holds the string provided after "key", if any
/// \param save_pos (optional) stores the position of the keyword
/// within "conf", useful when doing multiple calls \param
/// save_delimiters (optional)
/// within "conf", useful when doing multiple calls
bool key_lookup(std::string const &conf,
char const *key,
std::string &data = dummy_string,
size_t &save_pos = dummy_pos);
char const *key,
std::string &data = dummy_string,
size_t &save_pos = dummy_pos);
/// Used as a default argument by key_lookup
static std::string dummy_string;
@ -204,12 +276,12 @@ public:
/// \brief Works as std::getline() but also removes everything
/// between a comment character and the following newline
static std::istream & getline_nocomments(std::istream &is,
std::string &s,
char const delim = '\n');
std::string &s,
char const delim = '\n');
/// Check if the content of the file has matching braces
bool brace_check(std::string const &conf,
size_t const start_pos = 0);
size_t const start_pos = 0);
};

2
lib/colvars/colvarproxy.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARPROXY_H
#define COLVARPROXY_H

5
lib/colvars/colvarscript.cpp
View File

@ -295,6 +295,11 @@ int colvarscript::proc_colvar(int argc, char const *argv[]) {
return COLVARS_OK;
}
if (subcmd == "state") {
cv->print_state();
return COLVARS_OK;
}
result = "Syntax error\n" + help_string();
return COLVARSCRIPT_ERROR;
}

2
lib/colvars/colvarscript.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARSCRIPT_H
#define COLVARSCRIPT_H

2
lib/colvars/colvartypes.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARTYPES_H
#define COLVARTYPES_H

2
lib/colvars/colvarvalue.cpp
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#include <vector>
#include <sstream>

2
lib/colvars/colvarvalue.h
View File

@ -1,4 +1,4 @@
/// -*- c++ -*-
// -*- c++ -*-
#ifndef COLVARVALUE_H
#define COLVARVALUE_H