Homec4science
Diffusion lammps (lammm-master-deprecated) Browse

lammps/lib/colvars/colvargrid.C
5c27661f0077lammm-master-deprecated

Last Change
Raw File

colvargrid.C
View Options

// -*- c++ -*-
#include "colvarmodule.h"
#include "colvarvalue.h"
#include "colvarparse.h"
#include "colvar.h"
#include "colvarcomp.h"
#include "colvargrid.h"
colvar_grid_count::colvar_grid_count()
: colvar_grid<size_t>()
{}
colvar_grid_count::colvar_grid_count (std::vector<int> const &nx_i,
size_t const &def_count)
: colvar_grid<size_t> (nx_i, def_count)
{}
colvar_grid_count::colvar_grid_count (std::vector<colvar *> &colvars,
size_t const &def_count)
: colvar_grid<size_t> (colvars, def_count)
{}
std::istream & colvar_grid_count::read_restart (std::istream &is)
{
size_t const start_pos = is.tellg();
std::string key, conf;
if ((is >> key) && (key == std::string ("grid_parameters"))) {
is.seekg (start_pos, std::ios::beg);
is >> colvarparse::read_block ("grid_parameters", conf);
parse_params (conf);
} else {
cvm::log ("Grid parameters are missing in the restart file, using those from the configuration.\n");
is.seekg (start_pos, std::ios::beg);
}
read_raw (is);
return is;
}
std::ostream & colvar_grid_count::write_restart (std::ostream &os)
{
write_params (os);
write_raw (os);
return os;
}
colvar_grid_scalar::colvar_grid_scalar()
: colvar_grid<cvm::real>(), samples (NULL), grad (NULL)
{}
colvar_grid_scalar::colvar_grid_scalar (colvar_grid_scalar const &g)
: colvar_grid<cvm::real> (g), samples (NULL), grad (NULL)
{
grad = new cvm::real[nd];
}
colvar_grid_scalar::colvar_grid_scalar (std::vector<int> const &nx_i)
: colvar_grid<cvm::real> (nx_i, 0.0, 1), samples (NULL)
{
grad = new cvm::real[nd];
}
colvar_grid_scalar::colvar_grid_scalar (std::vector<colvar *> &colvars, bool margin)
: colvar_grid<cvm::real> (colvars, 0.0, 1, margin), samples (NULL)
{
grad = new cvm::real[nd];
}
colvar_grid_scalar::~colvar_grid_scalar()
{
if (grad) {
delete [] grad;
grad = NULL;
}
}
std::istream & colvar_grid_scalar::read_restart (std::istream &is)
{
size_t const start_pos = is.tellg();
std::string key, conf;
if ((is >> key) && (key == std::string ("grid_parameters"))) {
is.seekg (start_pos, std::ios::beg);
is >> colvarparse::read_block ("grid_parameters", conf);
parse_params (conf);
} else {
cvm::log ("Grid parameters are missing in the restart file, using those from the configuration.\n");
is.seekg (start_pos, std::ios::beg);
}
read_raw (is);
return is;
}
std::ostream & colvar_grid_scalar::write_restart (std::ostream &os)
{
write_params (os);
write_raw (os);
return os;
}
colvar_grid_gradient::colvar_grid_gradient()
: colvar_grid<cvm::real>(), samples (NULL)
{}
colvar_grid_gradient::colvar_grid_gradient (std::vector<int> const &nx_i)
: colvar_grid<cvm::real> (nx_i, 0.0, nx_i.size()), samples (NULL)
{}
colvar_grid_gradient::colvar_grid_gradient (std::vector<colvar *> &colvars)
: colvar_grid<cvm::real> (colvars, 0.0, colvars.size()), samples (NULL)
{}
std::istream & colvar_grid_gradient::read_restart (std::istream &is)
{
size_t const start_pos = is.tellg();
std::string key, conf;
if ((is >> key) && (key == std::string ("grid_parameters"))) {
is.seekg (start_pos, std::ios::beg);
is >> colvarparse::read_block ("grid_parameters", conf);
parse_params (conf);
} else {
cvm::log ("Grid parameters are missing in the restart file, using those from the configuration.\n");
is.seekg (start_pos, std::ios::beg);
}
read_raw (is);
return is;
}
std::ostream & colvar_grid_gradient::write_restart (std::ostream &os)
{
write_params (os);
write_raw (os);
return os;
}
void colvar_grid_gradient::write_1D_integral (std::ostream &os)
{
cvm::real bin, min, integral;
std::vector<cvm::real> int_vals;
os << "# xi A(xi)\n";
if ( cv.size() != 1 ) {
cvm::fatal_error ("Cannot write integral for multi-dimensional gradient grids.");
}
integral = 0.0;
int_vals.push_back ( 0.0 );
bin = 0.0;
min = 0.0;
// correction for periodic colvars, so that the PMF is periodic
cvm::real corr;
if ( periodic[0] ) {
corr = average();
} else {
corr = 0.0;
}
for (std::vector<int> ix = new_index(); index_ok (ix); incr (ix), bin += 1.0 ) {
if (samples) {
size_t const samples_here = samples->value (ix);
if (samples_here)
integral += (value (ix) / cvm::real (samples_here) - corr) * cv[0]->width;
} else {
integral += (value (ix) - corr) * cv[0]->width;
}
if ( integral < min ) min = integral;
int_vals.push_back ( integral );
}
bin = 0.0;
for ( int i = 0; i < nx[0]; i++, bin += 1.0 ) {
os << std::setw (10) << cv[0]->lower_boundary.real_value + cv[0]->width * bin << " "
<< std::setw (cvm::cv_width)
<< std::setprecision (cvm::cv_prec)
<< int_vals[i] - min << "\n";
}
os << std::setw (10) << cv[0]->lower_boundary.real_value + cv[0]->width * bin << " "
<< std::setw (cvm::cv_width)
<< std::setprecision (cvm::cv_prec)
<< int_vals[nx[0]] - min << "\n";
return;
}
// quaternion_grid::quaternion_grid (std::vector<colvar *> const &cv_i,
// std::vector<std::string> const &grid_str)
// {
// cv = cv_i;
// std::istringstream is (grid_str[0]);
// is >> grid_size;
// min.assign (3, -1.0);
// max.assign (3, 1.0);
// np.assign (3, grid_size);
// dx.assign (3, 2.0/(cvm::real (grid_size)));
// // assumes a uniform grid in the three directions; change
// // get_value() if you want to use different sizes
// cvm::log ("Allocating quaternion grid ("+cvm::to_str (np.size())+" dimensional)...");
// data.create (np, 0.0);
// cvm::log ("done.\n");
// if (cvm::debug()) cvm::log ("Grid size = "+data.size());
// }
c4science · Help