f3cf407a21
This commit includes several fixes to moving restraints; also added is support for runtime integration of 2D and 3D PMFs from ABF. Mostly changes to existing member functions, with few additions in classes not directly accessible by LAMMPS. Also removed are calls to std::pow(), replaced by a copy of MathSpecial::powint(). Relevant commits in Colvars repository: 7307b5c 2017-12-14 Doc improvements [Giacomo Fiorin] 7f86f37 2017-12-14 Allow K-changing restraints computing accumulated work; fix staged-k TI estimator [Giacomo Fiorin] 7c1c175 2017-12-14 Fix 1D ABF trying to do pABF [Jérôme Hénin] b94aa7e 2017-11-16 Unify PMF output for 1D, 2D and 3D in ABF [Jérôme Hénin] 771a88f 2017-11-15 Poisson integration for all BC in 2d and 3d [Jérôme Hénin] 6af4d60 2017-12-01 Print message when issuing cv delete in VMD [Giacomo Fiorin] 4413972 2017-11-30 Check for homogeneous colvar to set it periodic [Jérôme Hénin] 95fe4b2 2017-11-06 Allow abf_integrate to start in bin with 1 sample [Jérôme Hénin] 06eea27 2017-10-23 Shorten a few constructs by using the power function [Giacomo Fiorin] 3165dfb 2017-10-20 Move includes of colvarproxy.h from headers to files [Giacomo Fiorin] 32a867b 2017-10-20 Add optimized powint function from LAMMPS headers [Giacomo Fiorin] 3ad070a 2017-10-20 Remove some unused includes, isolate calls to std::pow() [Giacomo Fiorin] 0aaf540 2017-10-20 Replace all calls to std::pow() where the exponent is not an integer [Giacomo Fiorin]
665 lines
16 KiB
C++
665 lines
16 KiB
C++
// -*- c++ -*-
|
|
|
|
// This file is part of the Collective Variables module (Colvars).
|
|
// The original version of Colvars and its updates are located at:
|
|
// https://github.com/colvars/colvars
|
|
// Please update all Colvars source files before making any changes.
|
|
// If you wish to distribute your changes, please submit them to the
|
|
// Colvars repository at GitHub.
|
|
|
|
#include "colvarmodule.h"
|
|
#include "colvarproxy.h"
|
|
#include "colvarvalue.h"
|
|
#include "colvarbias.h"
|
|
#include "colvargrid.h"
|
|
|
|
|
|
colvarbias::colvarbias(char const *key)
|
|
: bias_type(to_lower_cppstr(key))
|
|
{
|
|
init_cvb_requires();
|
|
|
|
rank = 1;
|
|
|
|
has_data = false;
|
|
b_output_energy = false;
|
|
reset();
|
|
state_file_step = 0;
|
|
description = "uninitialized " + cvm::to_str(key) + " bias";
|
|
}
|
|
|
|
|
|
int colvarbias::init(std::string const &conf)
|
|
{
|
|
colvarparse::init(conf);
|
|
|
|
size_t i = 0;
|
|
|
|
if (name.size() == 0) {
|
|
|
|
// first initialization
|
|
|
|
cvm::log("Initializing a new \""+bias_type+"\" instance.\n");
|
|
rank = cvm::main()->num_biases_type(bias_type);
|
|
get_keyval(conf, "name", name, bias_type+cvm::to_str(rank));
|
|
|
|
{
|
|
colvarbias *bias_with_name = cvm::bias_by_name(this->name);
|
|
if (bias_with_name != NULL) {
|
|
if ((bias_with_name->rank != this->rank) ||
|
|
(bias_with_name->bias_type != this->bias_type)) {
|
|
cvm::error("Error: this bias cannot have the same name, \""+this->name+
|
|
"\", as another bias.\n", INPUT_ERROR);
|
|
return INPUT_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
description = "bias " + name;
|
|
|
|
{
|
|
// lookup the associated colvars
|
|
std::vector<std::string> colvar_names;
|
|
if (get_keyval(conf, "colvars", colvar_names)) {
|
|
if (num_variables()) {
|
|
cvm::error("Error: cannot redefine the colvars that a bias was already defined on.\n",
|
|
INPUT_ERROR);
|
|
return INPUT_ERROR;
|
|
}
|
|
for (i = 0; i < colvar_names.size(); i++) {
|
|
add_colvar(colvar_names[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!num_variables()) {
|
|
cvm::error("Error: no collective variables specified.\n", INPUT_ERROR);
|
|
return INPUT_ERROR;
|
|
}
|
|
} else {
|
|
cvm::log("Reinitializing bias \""+name+"\".\n");
|
|
}
|
|
|
|
output_prefix = cvm::output_prefix();
|
|
|
|
get_keyval(conf, "outputEnergy", b_output_energy, b_output_energy);
|
|
|
|
get_keyval(conf, "timeStepFactor", time_step_factor, 1);
|
|
if (time_step_factor < 1) {
|
|
cvm::error("Error: timeStepFactor must be 1 or greater.\n");
|
|
return COLVARS_ERROR;
|
|
}
|
|
|
|
// Now that children are defined, we can solve dependencies
|
|
enable(f_cvb_active);
|
|
if (cvm::debug()) print_state();
|
|
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
int colvarbias::reset()
|
|
{
|
|
bias_energy = 0.0;
|
|
for (size_t i = 0; i < num_variables(); i++) {
|
|
colvar_forces[i].reset();
|
|
}
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
colvarbias::colvarbias()
|
|
: colvarparse(), has_data(false)
|
|
{}
|
|
|
|
|
|
colvarbias::~colvarbias()
|
|
{
|
|
colvarbias::clear();
|
|
}
|
|
|
|
|
|
int colvarbias::clear()
|
|
{
|
|
free_children_deps();
|
|
|
|
// Remove references to this bias from colvars
|
|
for (std::vector<colvar *>::iterator cvi = colvars.begin();
|
|
cvi != colvars.end();
|
|
++cvi) {
|
|
for (std::vector<colvarbias *>::iterator bi = (*cvi)->biases.begin();
|
|
bi != (*cvi)->biases.end();
|
|
++bi) {
|
|
if ( *bi == this) {
|
|
(*cvi)->biases.erase(bi);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
colvarmodule *cv = cvm::main();
|
|
// ...and from the colvars module
|
|
for (std::vector<colvarbias *>::iterator bi = cv->biases.begin();
|
|
bi != cv->biases.end();
|
|
++bi) {
|
|
if ( *bi == this) {
|
|
cv->biases.erase(bi);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
int colvarbias::clear_state_data()
|
|
{
|
|
// no mutable content to delete for base class
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
int colvarbias::add_colvar(std::string const &cv_name)
|
|
{
|
|
if (colvar *cv = cvm::colvar_by_name(cv_name)) {
|
|
|
|
if (cvm::debug()) {
|
|
cvm::log("Applying this bias to collective variable \""+
|
|
cv->name+"\".\n");
|
|
}
|
|
|
|
colvars.push_back(cv);
|
|
|
|
colvar_forces.push_back(colvarvalue());
|
|
colvar_forces.back().type(cv->value()); // make sure each force is initialized to zero
|
|
colvar_forces.back().is_derivative(); // colvar constraints are not applied to the force
|
|
colvar_forces.back().reset();
|
|
|
|
previous_colvar_forces.push_back(colvar_forces.back());
|
|
|
|
cv->biases.push_back(this); // add back-reference to this bias to colvar
|
|
|
|
if (is_enabled(f_cvb_apply_force)) {
|
|
cv->enable(f_cv_gradient);
|
|
}
|
|
|
|
// Add dependency link.
|
|
// All biases need at least the value of each colvar
|
|
// although possibly not at all timesteps
|
|
add_child(cv);
|
|
|
|
} else {
|
|
cvm::error("Error: cannot find a colvar named \""+
|
|
cv_name+"\".\n", INPUT_ERROR);
|
|
return INPUT_ERROR;
|
|
}
|
|
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
int colvarbias::update()
|
|
{
|
|
if (cvm::debug()) {
|
|
cvm::log("Updating the "+bias_type+" bias \""+this->name+"\".\n");
|
|
}
|
|
|
|
has_data = true;
|
|
|
|
bias_energy = 0.0;
|
|
for (size_t ir = 0; ir < num_variables(); ir++) {
|
|
colvar_forces[ir].reset();
|
|
}
|
|
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
void colvarbias::communicate_forces()
|
|
{
|
|
size_t i = 0;
|
|
for (i = 0; i < num_variables(); i++) {
|
|
if (cvm::debug()) {
|
|
cvm::log("Communicating a force to colvar \""+
|
|
variables(i)->name+"\".\n");
|
|
}
|
|
// Impulse-style multiple timestep
|
|
// Note that biases with different values of time_step_factor
|
|
// may send forces to the same colvar
|
|
// which is why rescaling has to happen now: the colvar is not
|
|
// aware of this bias' time_step_factor
|
|
variables(i)->add_bias_force(cvm::real(time_step_factor) * colvar_forces[i]);
|
|
}
|
|
for (i = 0; i < num_variables(); i++) {
|
|
previous_colvar_forces[i] = colvar_forces[i];
|
|
}
|
|
}
|
|
|
|
|
|
int colvarbias::change_configuration(std::string const &conf)
|
|
{
|
|
cvm::error("Error: change_configuration() not implemented.\n",
|
|
COLVARS_NOT_IMPLEMENTED);
|
|
return COLVARS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
|
|
cvm::real colvarbias::energy_difference(std::string const &conf)
|
|
{
|
|
cvm::error("Error: energy_difference() not implemented.\n",
|
|
COLVARS_NOT_IMPLEMENTED);
|
|
return 0.0;
|
|
}
|
|
|
|
|
|
// So far, these are only implemented in colvarbias_abf
|
|
int colvarbias::bin_num()
|
|
{
|
|
cvm::error("Error: bin_num() not implemented.\n");
|
|
return COLVARS_NOT_IMPLEMENTED;
|
|
}
|
|
int colvarbias::current_bin()
|
|
{
|
|
cvm::error("Error: current_bin() not implemented.\n");
|
|
return COLVARS_NOT_IMPLEMENTED;
|
|
}
|
|
int colvarbias::bin_count(int bin_index)
|
|
{
|
|
cvm::error("Error: bin_count() not implemented.\n");
|
|
return COLVARS_NOT_IMPLEMENTED;
|
|
}
|
|
int colvarbias::replica_share()
|
|
{
|
|
cvm::error("Error: replica_share() not implemented.\n");
|
|
return COLVARS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
|
|
std::string const colvarbias::get_state_params() const
|
|
{
|
|
std::ostringstream os;
|
|
os << "step " << cvm::step_absolute() << "\n"
|
|
<< "name " << this->name << "\n";
|
|
return os.str();
|
|
}
|
|
|
|
|
|
int colvarbias::set_state_params(std::string const &conf)
|
|
{
|
|
std::string new_name = "";
|
|
if (colvarparse::get_keyval(conf, "name", new_name,
|
|
std::string(""), colvarparse::parse_silent) &&
|
|
(new_name != this->name)) {
|
|
cvm::error("Error: in the state file, the "
|
|
"\""+bias_type+"\" block has a different name, \""+new_name+
|
|
"\": different system?\n", INPUT_ERROR);
|
|
}
|
|
|
|
if (name.size() == 0) {
|
|
cvm::error("Error: \""+bias_type+"\" block within the restart file "
|
|
"has no identifiers.\n", INPUT_ERROR);
|
|
}
|
|
|
|
colvarparse::get_keyval(conf, "step", state_file_step,
|
|
cvm::step_absolute(), colvarparse::parse_silent);
|
|
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
std::ostream & colvarbias::write_state(std::ostream &os)
|
|
{
|
|
if (cvm::debug()) {
|
|
cvm::log("Writing state file for bias \""+name+"\"\n");
|
|
}
|
|
os.setf(std::ios::scientific, std::ios::floatfield);
|
|
os.precision(cvm::cv_prec);
|
|
os << bias_type << " {\n"
|
|
<< " configuration {\n";
|
|
std::istringstream is(get_state_params());
|
|
std::string line;
|
|
while (std::getline(is, line)) {
|
|
os << " " << line << "\n";
|
|
}
|
|
os << " }\n";
|
|
write_state_data(os);
|
|
os << "}\n\n";
|
|
return os;
|
|
}
|
|
|
|
|
|
std::istream & colvarbias::read_state(std::istream &is)
|
|
{
|
|
size_t const start_pos = is.tellg();
|
|
|
|
std::string key, brace, conf;
|
|
if ( !(is >> key) || !(key == bias_type) ||
|
|
!(is >> brace) || !(brace == "{") ||
|
|
!(is >> colvarparse::read_block("configuration", conf)) ||
|
|
(set_state_params(conf) != COLVARS_OK) ) {
|
|
cvm::error("Error: in reading state configuration for \""+bias_type+"\" bias \""+
|
|
this->name+"\" at position "+
|
|
cvm::to_str(is.tellg())+" in stream.\n", INPUT_ERROR);
|
|
is.clear();
|
|
is.seekg(start_pos, std::ios::beg);
|
|
is.setstate(std::ios::failbit);
|
|
return is;
|
|
}
|
|
|
|
if (!read_state_data(is)) {
|
|
cvm::error("Error: in reading state data for \""+bias_type+"\" bias \""+
|
|
this->name+"\" at position "+
|
|
cvm::to_str(is.tellg())+" in stream.\n", INPUT_ERROR);
|
|
is.clear();
|
|
is.seekg(start_pos, std::ios::beg);
|
|
is.setstate(std::ios::failbit);
|
|
}
|
|
|
|
is >> brace;
|
|
if (brace != "}") {
|
|
cvm::error("Error: corrupt restart information for \""+bias_type+"\" bias \""+
|
|
this->name+"\": no matching brace at position "+
|
|
cvm::to_str(is.tellg())+" in stream.\n");
|
|
is.setstate(std::ios::failbit);
|
|
}
|
|
|
|
return is;
|
|
}
|
|
|
|
|
|
std::istream & colvarbias::read_state_data_key(std::istream &is, char const *key)
|
|
{
|
|
size_t const start_pos = is.tellg();
|
|
std::string key_in;
|
|
if ( !(is >> key_in) ||
|
|
!(key_in == to_lower_cppstr(std::string(key))) ) {
|
|
cvm::error("Error: in reading restart configuration for "+
|
|
bias_type+" bias \""+this->name+"\" at position "+
|
|
cvm::to_str(is.tellg())+" in stream.\n", INPUT_ERROR);
|
|
is.clear();
|
|
is.seekg(start_pos, std::ios::beg);
|
|
is.setstate(std::ios::failbit);
|
|
return is;
|
|
}
|
|
return is;
|
|
}
|
|
|
|
|
|
|
|
std::ostream & colvarbias::write_traj_label(std::ostream &os)
|
|
{
|
|
os << " ";
|
|
if (b_output_energy)
|
|
os << " E_"
|
|
<< cvm::wrap_string(this->name, cvm::en_width-2);
|
|
return os;
|
|
}
|
|
|
|
|
|
std::ostream & colvarbias::write_traj(std::ostream &os)
|
|
{
|
|
os << " ";
|
|
if (b_output_energy)
|
|
os << " "
|
|
<< std::setprecision(cvm::en_prec) << std::setw(cvm::en_width)
|
|
<< bias_energy;
|
|
return os;
|
|
}
|
|
|
|
|
|
|
|
colvarbias_ti::colvarbias_ti(char const *key)
|
|
: colvarbias(key)
|
|
{
|
|
provide(f_cvb_calc_ti_samples);
|
|
ti_avg_forces = NULL;
|
|
ti_count = NULL;
|
|
}
|
|
|
|
|
|
colvarbias_ti::~colvarbias_ti()
|
|
{
|
|
colvarbias_ti::clear_state_data();
|
|
}
|
|
|
|
|
|
int colvarbias_ti::clear_state_data()
|
|
{
|
|
if (ti_avg_forces != NULL) {
|
|
delete ti_avg_forces;
|
|
ti_avg_forces = NULL;
|
|
}
|
|
if (ti_count != NULL) {
|
|
delete ti_count;
|
|
ti_count = NULL;
|
|
}
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
int colvarbias_ti::init(std::string const &conf)
|
|
{
|
|
int error_code = COLVARS_OK;
|
|
|
|
get_keyval_feature(this, conf, "writeTISamples",
|
|
f_cvb_write_ti_samples,
|
|
is_enabled(f_cvb_write_ti_samples));
|
|
|
|
get_keyval_feature(this, conf, "writeTIPMF",
|
|
f_cvb_write_ti_pmf,
|
|
is_enabled(f_cvb_write_ti_pmf));
|
|
|
|
if ((num_variables() > 1) && is_enabled(f_cvb_write_ti_pmf)) {
|
|
return cvm::error("Error: only 1-dimensional PMFs can be written "
|
|
"on the fly.\n"
|
|
"Consider using writeTISamples instead and "
|
|
"post-processing the sampled free-energy gradients.\n",
|
|
COLVARS_NOT_IMPLEMENTED);
|
|
} else {
|
|
error_code |= init_grids();
|
|
}
|
|
|
|
if (is_enabled(f_cvb_write_ti_pmf)) {
|
|
enable(f_cvb_write_ti_samples);
|
|
}
|
|
|
|
if (is_enabled(f_cvb_calc_ti_samples)) {
|
|
std::vector<std::string> const time_biases =
|
|
cvm::main()->time_dependent_biases();
|
|
if (time_biases.size() > 0) {
|
|
if ((time_biases.size() > 1) || (time_biases[0] != this->name)) {
|
|
for (size_t i = 0; i < num_variables(); i++) {
|
|
if (! variables(i)->is_enabled(f_cv_subtract_applied_force)) {
|
|
return cvm::error("Error: cannot collect TI samples while other "
|
|
"time-dependent biases are active and not all "
|
|
"variables have subtractAppliedForces on.\n",
|
|
INPUT_ERROR);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return error_code;
|
|
}
|
|
|
|
|
|
int colvarbias_ti::init_grids()
|
|
{
|
|
if (is_enabled(f_cvb_calc_ti_samples)) {
|
|
if (ti_avg_forces == NULL) {
|
|
ti_bin.resize(num_variables());
|
|
ti_system_forces.resize(num_variables());
|
|
for (size_t icv = 0; icv < num_variables(); icv++) {
|
|
ti_system_forces[icv].type(variables(icv)->value());
|
|
ti_system_forces[icv].is_derivative();
|
|
ti_system_forces[icv].reset();
|
|
}
|
|
ti_avg_forces = new colvar_grid_gradient(colvars);
|
|
ti_count = new colvar_grid_count(colvars);
|
|
ti_avg_forces->samples = ti_count;
|
|
ti_count->has_parent_data = true;
|
|
}
|
|
}
|
|
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
int colvarbias_ti::update()
|
|
{
|
|
return update_system_forces(NULL);
|
|
}
|
|
|
|
|
|
int colvarbias_ti::update_system_forces(std::vector<colvarvalue> const
|
|
*subtract_forces)
|
|
{
|
|
if (! is_enabled(f_cvb_calc_ti_samples)) {
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
has_data = true;
|
|
|
|
if (cvm::debug()) {
|
|
cvm::log("Updating system forces for bias "+this->name+"\n");
|
|
}
|
|
|
|
colvarproxy *proxy = cvm::main()->proxy;
|
|
|
|
size_t i;
|
|
|
|
if (proxy->total_forces_same_step()) {
|
|
for (i = 0; i < num_variables(); i++) {
|
|
ti_bin[i] = ti_avg_forces->current_bin_scalar(i);
|
|
}
|
|
}
|
|
|
|
// Collect total colvar forces
|
|
if ((cvm::step_relative() > 0) || proxy->total_forces_same_step()) {
|
|
if (ti_avg_forces->index_ok(ti_bin)) {
|
|
for (i = 0; i < num_variables(); i++) {
|
|
if (variables(i)->is_enabled(f_cv_subtract_applied_force)) {
|
|
// this colvar is already subtracting all applied forces
|
|
ti_system_forces[i] = variables(i)->total_force();
|
|
} else {
|
|
ti_system_forces[i] = variables(i)->total_force() -
|
|
((subtract_forces != NULL) ?
|
|
(*subtract_forces)[i] : previous_colvar_forces[i]);
|
|
}
|
|
}
|
|
ti_avg_forces->acc_value(ti_bin, ti_system_forces);
|
|
}
|
|
}
|
|
|
|
if (!proxy->total_forces_same_step()) {
|
|
// Set the index for use in the next iteration, when total forces come in
|
|
for (i = 0; i < num_variables(); i++) {
|
|
ti_bin[i] = ti_avg_forces->current_bin_scalar(i);
|
|
}
|
|
}
|
|
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
std::string const colvarbias_ti::get_state_params() const
|
|
{
|
|
return std::string("");
|
|
}
|
|
|
|
|
|
int colvarbias_ti::set_state_params(std::string const &state_conf)
|
|
{
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
std::ostream & colvarbias_ti::write_state_data(std::ostream &os)
|
|
{
|
|
if (! is_enabled(f_cvb_calc_ti_samples)) {
|
|
return os;
|
|
}
|
|
os << "\nhistogram\n";
|
|
ti_count->write_raw(os);
|
|
os << "\nsystem_forces\n";
|
|
ti_avg_forces->write_raw(os);
|
|
return os;
|
|
}
|
|
|
|
|
|
std::istream & colvarbias_ti::read_state_data(std::istream &is)
|
|
{
|
|
if (! is_enabled(f_cvb_calc_ti_samples)) {
|
|
return is;
|
|
}
|
|
if (cvm::debug()) {
|
|
cvm::log("Reading state data for the TI estimator.\n");
|
|
}
|
|
if (! read_state_data_key(is, "histogram")) {
|
|
return is;
|
|
}
|
|
if (! ti_count->read_raw(is)) {
|
|
return is;
|
|
}
|
|
if (! read_state_data_key(is, "system_forces")) {
|
|
return is;
|
|
}
|
|
if (! ti_avg_forces->read_raw(is)) {
|
|
return is;
|
|
}
|
|
if (cvm::debug()) {
|
|
cvm::log("Done reading state data for the TI estimator.\n");
|
|
}
|
|
return is;
|
|
}
|
|
|
|
|
|
int colvarbias_ti::write_output_files()
|
|
{
|
|
if (!has_data) {
|
|
// nothing to write
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
std::string const ti_output_prefix = cvm::output_prefix()+"."+this->name;
|
|
|
|
std::ostream *os = NULL;
|
|
|
|
if (is_enabled(f_cvb_write_ti_samples)) {
|
|
std::string const ti_count_file_name(ti_output_prefix+".ti.count");
|
|
os = cvm::proxy->output_stream(ti_count_file_name);
|
|
if (os) {
|
|
ti_count->write_multicol(*os);
|
|
cvm::proxy->close_output_stream(ti_count_file_name);
|
|
}
|
|
|
|
std::string const ti_grad_file_name(ti_output_prefix+".ti.grad");
|
|
os = cvm::proxy->output_stream(ti_grad_file_name);
|
|
if (os) {
|
|
ti_avg_forces->write_multicol(*os);
|
|
cvm::proxy->close_output_stream(ti_grad_file_name);
|
|
}
|
|
}
|
|
|
|
if (is_enabled(f_cvb_write_ti_pmf)) {
|
|
std::string const pmf_file_name(ti_output_prefix+".ti.pmf");
|
|
cvm::log("Writing TI PMF to file \""+pmf_file_name+"\".\n");
|
|
os = cvm::proxy->output_stream(pmf_file_name);
|
|
if (os) {
|
|
// get the FE gradient
|
|
ti_avg_forces->multiply_constant(-1.0);
|
|
ti_avg_forces->write_1D_integral(*os);
|
|
ti_avg_forces->multiply_constant(-1.0);
|
|
cvm::proxy->close_output_stream(pmf_file_name);
|
|
}
|
|
}
|
|
|
|
return COLVARS_OK;
|
|
}
|
|
|
|
|
|
// Static members
|
|
|
|
std::vector<colvardeps::feature *> colvarbias::cvb_features;
|