diff --git a/colvartools/poisson_integrator.cpp b/colvartools/poisson_integrator.cpp index 4ad4f3080..5d8066c5f 100644 --- a/colvartools/poisson_integrator.cpp +++ b/colvartools/poisson_integrator.cpp @@ -17,14 +17,14 @@ int main (int argc, char *argv[]) { proxy->cvmodule = new colvarmodule(proxy); // This could be omitted if we used the colvarproxy_stub class std::string gradfile (argv[1]); - std::shared_ptr grad_ptr = std::make_shared(gradfile); + std::shared_ptr grad_ptr = std::make_shared(proxy->cvmodule, gradfile); if (proxy->cvmodule->get_error()) { return -1; } int itmax = 10000; cvm::real err; cvm::real tol = 1e-8; - colvargrid_integrate fes(grad_ptr); + colvargrid_integrate fes(proxy->cvmodule, grad_ptr); fes.set_div(); fes.integrate(itmax, tol, err); fes.set_zero_minimum(); diff --git a/colvartools/poisson_integrator_conv.cpp b/colvartools/poisson_integrator_conv.cpp index e8a477ffc..a01610a15 100644 --- a/colvartools/poisson_integrator_conv.cpp +++ b/colvartools/poisson_integrator_conv.cpp @@ -17,17 +17,17 @@ int main (int argc, char *argv[]) { proxy->cvmodule = new colvarmodule(proxy); // This could be omitted if we used the colvarproxy_stub class std::string gradfile (argv[1]); - std::shared_ptr grad_ptr = std::make_shared(gradfile); + std::shared_ptr grad_ptr = std::make_shared(proxy->cvmodule, gradfile); if (proxy->cvmodule->get_error()) { return -1; } cvm::real err = 1.; cvm::real tol = 1e-10; - colvargrid_integrate fes(grad_ptr); + colvargrid_integrate fes(proxy->cvmodule, grad_ptr); fes.set_div(); // Load reference - colvar_grid_scalar ref(gradfile + ".ref"); + colvar_grid_scalar ref(proxy->cvmodule, gradfile + ".ref"); if (proxy->cvmodule->get_error()) { return -1; } if (ref.number_of_points() != fes.number_of_points()) { diff --git a/misc_interfaces/C_fortran/C_test.c b/misc_interfaces/C_fortran/C_test.c index 0305cd01f..47269155d 100644 --- a/misc_interfaces/C_fortran/C_test.c +++ b/misc_interfaces/C_fortran/C_test.c @@ -11,8 +11,8 @@ int main() { // Cannot yet call colvarscript without language interface unsigned char cmd[][256] = {"", "version" }; - run_colvarscript_command(1, (unsigned char **)(cmd)); - const char *res = get_colvarscript_result(); + run_colvarscript_command(proxy, 1, (unsigned char **)(cmd)); + const char *res = get_colvarscript_result(proxy); printf("Colvarscript claims it runs version %s\n", res); return 0; } diff --git a/misc_interfaces/C_fortran/Makefile b/misc_interfaces/C_fortran/Makefile index cd5361a49..eac0e8b46 100644 --- a/misc_interfaces/C_fortran/Makefile +++ b/misc_interfaces/C_fortran/Makefile @@ -7,7 +7,7 @@ COLVARS_LIB = ../../src/libcolvars.a COLVARS_SRC_DIR = ../../src IF_OBJ = colvarproxy_C.o -CXXFLAGS := -std=c++11 -pedantic -g -O2 -fPIC +CXXFLAGS := -std=c++17 -pedantic -g -O2 -fPIC .PHONY: default $(COLVARS_LIB) diff --git a/misc_interfaces/C_fortran/colvarproxy_C.cpp b/misc_interfaces/C_fortran/colvarproxy_C.cpp index 6ccd68fcd..d67ff8c2d 100644 --- a/misc_interfaces/C_fortran/colvarproxy_C.cpp +++ b/misc_interfaces/C_fortran/colvarproxy_C.cpp @@ -10,8 +10,8 @@ static colvarproxy* unique_colvarproxy_object; colvarproxy_C::colvarproxy_C() { std::cerr << "This is the colvarproxy_C constructor at address " << this << std::endl; - colvars = new colvarmodule(this); - cvmodule->log("This is the Module speaking."); + cvmodule = new colvarmodule(this); + cvmodule->log_static("This is the Module speaking."); } colvarproxy_C::~colvarproxy_C() diff --git a/misc_interfaces/C_fortran/colvarproxy_C_interface.h b/misc_interfaces/C_fortran/colvarproxy_C_interface.h index 583011d5b..6539d3ee0 100644 --- a/misc_interfaces/C_fortran/colvarproxy_C_interface.h +++ b/misc_interfaces/C_fortran/colvarproxy_C_interface.h @@ -15,8 +15,8 @@ void call_proxy_member(void *proxy); // Functions of this type should define a complete interface // This could be based on colvarscript -int run_colvarscript_command(int objc, unsigned char *const objv[]); -const char * get_colvarscript_result(); +int run_colvarscript_command(void *proxy_in, int objc, unsigned char *const objv[]); +const char * get_colvarscript_result(void *proxy_in); #ifdef __cplusplus } diff --git a/src/Makefile b/src/Makefile index cd59fff35..5c191f468 100644 --- a/src/Makefile +++ b/src/Makefile @@ -17,7 +17,7 @@ ifeq ($(CXX),) CXX := g++ endif ifeq ($(CXXFLAGS),) -CXXFLAGS := -std=c++11 -pedantic -g -O2 -fPIC +CXXFLAGS := -std=c++17 -pedantic -g -O2 -fPIC ifneq ($(CXX),"CC") CXXFLAGS += -Wall endif diff --git a/src/colvar.cpp b/src/colvar.cpp index 2c81fe419..c1c72d46a 100644 --- a/src/colvar.cpp +++ b/src/colvar.cpp @@ -22,8 +22,8 @@ #include "colvars_memstream.h" #include "colvarcomp_torchann.h" -std::map> colvar::global_cvc_map = - std::map>(); +std::map> colvar::global_cvc_map = + std::map>(); std::map colvar::global_cvc_desc_map = std::map(); @@ -821,8 +821,8 @@ template void colvar::add_component_type(char const *def_description, char const *def_config_key) { if (global_cvc_map.count(def_config_key) == 0) { - global_cvc_map[def_config_key] = []() { - return new def_class_name(); + global_cvc_map[def_config_key] = [](colvarmodule *cvmodule_in) { + return new def_class_name(cvmodule_in); }; global_cvc_desc_map[def_config_key] = std::string(def_description); } @@ -844,7 +844,7 @@ int colvar::init_components_type(const std::string& conf, const char* def_config "a new \""+std::string(def_config_key)+"\" component"+ (cvm::debug() ? ", with configuration:\n"+def_conf : ".\n")); - cvc *cvcp = global_cvc_map[def_config_key](); + cvc *cvcp = global_cvc_map[def_config_key](cvmodule); if (!cvcp) { return cvmodule->error("Error: in creating object of type \"" + std::string(def_config_key) + "\".\n", @@ -1990,7 +1990,7 @@ void colvar::update_extended_Lagrangian() // [O] leap to v_(i+1/2) (10c) if (is_enabled(f_cv_Langevin)) { colvarvalue rnd(x); - rnd.set_random(); + rnd.set_random(this->cvmodule); // ext_sigma has been computed at init time according to (10c) v_ext = cvm::exp(- 1.0 * dt * ext_gamma) * v_ext + ext_sigma * rnd / ext_mass; } diff --git a/src/colvar.h b/src/colvar.h index c8498a7ed..7283a58d1 100644 --- a/src/colvar.h +++ b/src/colvar.h @@ -652,7 +652,7 @@ class colvar : public colvardeps { class map_total; /// A global mapping of cvc names to the cvc constructors - static const std::map> &get_global_cvc_map() + static const std::map> &get_global_cvc_map() { return global_cvc_map; } @@ -705,7 +705,7 @@ class colvar : public colvardeps { #endif /// A global mapping of cvc names to the cvc constructors - static std::map> global_cvc_map; + static std::map> global_cvc_map; /// A global mapping of cvc names to the corresponding descriptions static std::map global_cvc_desc_map; diff --git a/src/colvaratoms.cpp b/src/colvaratoms.cpp index 56d750fed..0612e65d2 100644 --- a/src/colvaratoms.cpp +++ b/src/colvaratoms.cpp @@ -93,7 +93,8 @@ cvm::atom_group::simple_atom cvm::atom_group::init_atom_from_proxy( /*.grad = */{0, 0, 0}}; } -cvm::atom_group::atom_group(): +cvm::atom_group::atom_group(colvarmodule* cvmodule_in): + colvardeps(cvmodule_in), b_dummy(false), fitting_group(nullptr), noforce(false), b_user_defined_fit(false), @@ -108,7 +109,7 @@ cvm::atom_group::atom_group(): init(); } -cvm::atom_group::atom_group(char const *key_in): atom_group() { +cvm::atom_group::atom_group(char const *key_in, colvarmodule* cvmodule_in): atom_group(cvmodule_in) { key = std::string(key_in); init(); } @@ -837,7 +838,7 @@ int cvm::atom_group::parse_fitting_options(std::string const &group_conf) { return COLVARS_INPUT_ERROR; } cvmodule->log("Within atom group \""+key+"\":\n"); - fitting_group = new atom_group("fittingGroup"); + fitting_group = new atom_group("fittingGroup", cvmodule); if (fitting_group->parse(fitting_group_conf) == COLVARS_OK) { fitting_group->check_keywords(fitting_group_conf, "fittingGroup"); if (cvmodule->get_error()) { diff --git a/src/colvaratoms.h b/src/colvaratoms.h index 717d9a281..ab8d576e9 100644 --- a/src/colvaratoms.h +++ b/src/colvaratoms.h @@ -63,11 +63,11 @@ class cvm::atom_group: public colvardeps { * @attention Will call \p init_dependencies() to initialize the * dependency tree. */ - atom_group(); + atom_group(colvarmodule* cvmodule_in); /** * @brief Create a group object, assign a name to it */ - atom_group(char const *key_in); + atom_group(char const *key_in, colvarmodule* cvmodule_in); /** * @brief Destructor * diff --git a/src/colvaratoms_gpu.cpp b/src/colvaratoms_gpu.cpp index a041d7e07..59a67e329 100644 --- a/src/colvaratoms_gpu.cpp +++ b/src/colvaratoms_gpu.cpp @@ -936,7 +936,7 @@ void colvaratoms_gpu::do_feature_side_effects_gpu( break; } case colvardeps::f_ag_rotate: { - rot_gpu.init(); + rot_gpu.init(this->cvmodule); break; } } @@ -948,7 +948,7 @@ int colvaratoms_gpu::setup_rotation(const cvm::atom_group* cpu_atoms) { error_code |= p->reallocate_device(&gpu_buffers.d_ref_pos, cpu_atoms->ref_pos.size()); error_code |=p->copy_HtoD(cpu_atoms->ref_pos.data(), gpu_buffers.d_ref_pos, cpu_atoms->ref_pos.size()); error_code |=p->copy_HtoD(&cpu_atoms->ref_pos_cog, gpu_buffers.d_ref_pos_cog, 1); - rot_gpu.init(); + rot_gpu.init(this->cvmodule); return error_code; } diff --git a/src/colvarbias.cpp b/src/colvarbias.cpp index 065aec4d4..fa152a480 100644 --- a/src/colvarbias.cpp +++ b/src/colvarbias.cpp @@ -133,7 +133,7 @@ int colvarbias::init(std::string const &conf) std::string biasing_force_scaling_factors_in_filename; get_keyval(conf, "scaledBiasingForceFactorsGrid", biasing_force_scaling_factors_in_filename, std::string()); - biasing_force_scaling_factors = new colvar_grid_scalar(colvars); + biasing_force_scaling_factors = new colvar_grid_scalar(cvmodule, colvars); error_code |= biasing_force_scaling_factors->read_multicol(biasing_force_scaling_factors_in_filename, "grid file"); biasing_force_scaling_factors_bin.assign(num_variables(), 0); @@ -278,8 +278,8 @@ int colvarbias::reset() } -colvarbias::colvarbias() - : has_data(false) +colvarbias::colvarbias(colvarmodule* cvmodule_in) + : colvardeps(cvmodule_in), has_data(false) {} @@ -810,7 +810,7 @@ std::ostream & colvarbias::write_traj(std::ostream &os) } -colvarbias_ti::colvarbias_ti(char const *key) +colvarbias_ti::colvarbias_ti(colvarmodule* cvmodule_in, char const *key): colvardeps(cvmodule_in), colvarbias(cvmodule_in) { colvarproxy *proxy = cvmodule->proxy; provide(f_cvb_calc_ti_samples); @@ -891,8 +891,8 @@ int colvarbias_ti::init_grids() ti_system_forces[icv].is_derivative(); ti_system_forces[icv].reset(); } - ti_count.reset(new colvar_grid_count(colvars, grid_conf)); - ti_avg_forces.reset(new colvar_grid_gradient(colvars, ti_count)); + ti_count.reset(new colvar_grid_count(cvmodule, colvars, grid_conf)); + ti_avg_forces.reset(new colvar_grid_gradient(cvmodule, colvars, ti_count)); } } diff --git a/src/colvarbias.h b/src/colvarbias.h index bf05fc5be..adad93e49 100644 --- a/src/colvarbias.h +++ b/src/colvarbias.h @@ -124,7 +124,7 @@ class colvarbias protected: /// Default constructor - colvarbias(); + colvarbias(colvarmodule* cvmodule_in); /// Copy constructor colvarbias(colvarbias &); @@ -336,7 +336,7 @@ class colvar_grid_count; class colvarbias_ti : public virtual colvarbias { public: - colvarbias_ti(char const *key); + colvarbias_ti(colvarmodule* cvmodule_in, char const *key); virtual ~colvarbias_ti(); virtual int init(std::string const &conf); diff --git a/src/colvarbias_abf.cpp b/src/colvarbias_abf.cpp index f5278bb9f..ac5b793fd 100644 --- a/src/colvarbias_abf.cpp +++ b/src/colvarbias_abf.cpp @@ -15,7 +15,7 @@ #include "colvars_memstream.h" colvarbias_abf::colvarbias_abf(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key), + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), b_UI_estimator(false), b_CZAR_estimator(false), pabf_freq(0), @@ -181,16 +181,16 @@ int colvarbias_abf::init(std::string const &conf) std::string grid_conf; key_lookup(conf, "grid", &grid_conf); - samples.reset(new colvar_grid_count(colvars, grid_conf)); + samples.reset(new colvar_grid_count(cvmodule, colvars, grid_conf)); } - gradients.reset(new colvar_grid_gradient(colvars, samples)); // Also use samples as template for sizes + gradients.reset(new colvar_grid_gradient(cvmodule, colvars, samples)); // Also use samples as template for sizes gradients->full_samples = full_samples; gradients->min_samples = min_samples; if (shared_on) { - local_samples.reset(new colvar_grid_count(colvars, samples)); - local_gradients.reset(new colvar_grid_gradient(colvars, local_samples)); + local_samples.reset(new colvar_grid_count(cvmodule, colvars, samples)); + local_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, local_samples)); } // Data for eABF z-based estimator @@ -204,11 +204,11 @@ int colvarbias_abf::init(std::string const &conf) colvarparse::parse_silent); z_bin.assign(num_variables(), 0); - z_samples.reset(new colvar_grid_count(colvars, samples)); + z_samples.reset(new colvar_grid_count(cvmodule, colvars, samples)); z_samples->request_actual_value(); - z_gradients.reset(new colvar_grid_gradient(colvars, z_samples)); + z_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, z_samples)); z_gradients->request_actual_value(); - czar_gradients.reset(new colvar_grid_gradient(colvars, nullptr, samples)); + czar_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, nullptr, samples)); } get_keyval(conf, "integrate", b_integrate, num_variables() <= 3); // Integrate for output if d<=3 @@ -218,12 +218,12 @@ int colvarbias_abf::init(std::string const &conf) cvmodule->error("Error: cannot integrate free energy in dimension > 3.\n"); return COLVARS_ERROR; } - pmf.reset(new colvargrid_integrate(colvars, gradients)); + pmf.reset(new colvargrid_integrate(cvmodule, colvars, gradients)); if (b_CZAR_estimator) { - czar_pmf.reset(new colvargrid_integrate(colvars, czar_gradients)); + czar_pmf.reset(new colvargrid_integrate(cvmodule, colvars, czar_gradients)); } if (shared_on) { - local_pmf.reset(new colvargrid_integrate(colvars, local_gradients)); + local_pmf.reset(new colvargrid_integrate(cvmodule, colvars, local_gradients)); } // Parameters for integrating initial (and final) gradient data get_keyval(conf, "integrateMaxIterations", integrate_iterations, 10000, colvarparse::parse_silent); @@ -237,10 +237,10 @@ int colvarbias_abf::init(std::string const &conf) if (b_CZAR_estimator && shared_on && cvmodule->proxy->replica_index() == 0) { // The pointers below are used for outputting CZAR data // Allocate grids for collected global data, on replica 0 only - global_z_samples.reset(new colvar_grid_count(colvars, samples)); - global_z_gradients.reset(new colvar_grid_gradient(colvars, global_z_samples)); - global_czar_gradients.reset(new colvar_grid_gradient(colvars, nullptr, samples)); - global_czar_pmf.reset(new colvargrid_integrate(colvars, global_czar_gradients)); + global_z_samples.reset(new colvar_grid_count(cvmodule, colvars, samples)); + global_z_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, global_z_samples)); + global_czar_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, nullptr, samples)); + global_czar_pmf.reset(new colvargrid_integrate(cvmodule, colvars, global_czar_gradients)); } else { // otherwise they are just aliases for the local CZAR grids global_z_samples = z_samples; @@ -253,11 +253,11 @@ int colvarbias_abf::init(std::string const &conf) // This used to be only if "shared" was defined, // but now we allow calling share externally (e.g. from Tcl). if (b_CZAR_estimator) { - z_samples_in.reset(new colvar_grid_count(colvars, samples)); - z_gradients_in.reset(new colvar_grid_gradient(colvars, z_samples_in)); + z_samples_in.reset(new colvar_grid_count(cvmodule, colvars, samples)); + z_gradients_in.reset(new colvar_grid_gradient(cvmodule, colvars, z_samples_in)); } - last_samples.reset(new colvar_grid_count(colvars, samples)); - last_gradients.reset(new colvar_grid_gradient(colvars, last_samples)); + last_samples.reset(new colvar_grid_count(cvmodule, colvars, samples)); + last_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, last_samples)); // Any data collected after now is new for shared ABF purposes shared_last_step = cvmodule->step_absolute(); @@ -555,9 +555,9 @@ int colvarbias_abf::replica_share() { if (!local_samples) { // We arrive here if sharing has just been enabled by a script // in which case local arrays have not been initialized yet - local_samples.reset(new colvar_grid_count(colvars, samples)); - local_gradients.reset(new colvar_grid_gradient(colvars, local_samples)); - local_pmf.reset(new colvargrid_integrate(colvars, local_gradients)); + local_samples.reset(new colvar_grid_count(cvmodule, colvars, samples)); + local_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, local_samples)); + local_pmf.reset(new colvargrid_integrate(cvmodule, colvars, local_gradients)); } // Calculate the delta gradient and count for the local replica last_gradients->delta_grid(*gradients); @@ -675,10 +675,10 @@ int colvarbias_abf::replica_share_CZAR() { // We arrive here if sharing has just been enabled by a script // Allocate grids for collective data, on replica 0 only // overriding CZAR grids that are equal to local ones by default - global_z_samples.reset(new colvar_grid_count(colvars, samples)); - global_z_gradients.reset(new colvar_grid_gradient(colvars, global_z_samples)); - global_czar_gradients.reset(new colvar_grid_gradient(colvars, nullptr, samples)); - global_czar_pmf.reset(new colvargrid_integrate(colvars, global_czar_gradients)); + global_z_samples.reset(new colvar_grid_count(cvmodule, colvars, samples)); + global_z_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, global_z_samples)); + global_czar_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, nullptr, samples)); + global_czar_pmf.reset(new colvargrid_integrate(cvmodule, colvars, global_czar_gradients)); } // Start with data from replica 0 @@ -886,7 +886,7 @@ int colvarbias_abf::read_gradients_samples() // Therefore the czar_gradients grid is not linked to a sampling grid // Here we define a temporary czar_gradients grid linked to z_samples, // to correctly average input gradients if overlapping - czar_gradients_in.reset(new colvar_grid_gradient(colvars, z_samples)); + czar_gradients_in.reset(new colvar_grid_gradient(cvmodule, colvars, z_samples)); } for ( size_t i = 0; i < input_prefix.size(); i++ ) { diff --git a/src/colvarbias_abmd.cpp b/src/colvarbias_abmd.cpp index 65031e401..6930dfd0a 100644 --- a/src/colvarbias_abmd.cpp +++ b/src/colvarbias_abmd.cpp @@ -14,8 +14,8 @@ colvarbias_abmd::colvarbias_abmd(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key), - colvarbias_ti(key) + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), + colvarbias_ti(cvmodule_in, key) { } diff --git a/src/colvarbias_alb.cpp b/src/colvarbias_alb.cpp index 1314b4876..f18cb662c 100644 --- a/src/colvarbias_alb.cpp +++ b/src/colvarbias_alb.cpp @@ -31,7 +31,7 @@ double fmin(double A, double B) { return ( A < B ? A : B ); } */ colvarbias_alb::colvarbias_alb(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key), update_calls(0), b_equilibration(true) + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), update_calls(0), b_equilibration(true) { } diff --git a/src/colvarbias_histogram.cpp b/src/colvarbias_histogram.cpp index cd82afb5e..65a27092b 100644 --- a/src/colvarbias_histogram.cpp +++ b/src/colvarbias_histogram.cpp @@ -17,7 +17,7 @@ colvarbias_histogram::colvarbias_histogram(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key), + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), grid(NULL), out_name("") { provide(f_cvb_bypass_ext_lagrangian); // Allow histograms of actual cv for extended-Lagrangian @@ -90,7 +90,7 @@ int colvarbias_histogram::init(std::string const &conf) colvars[i]->enable(f_cv_grid); // Could be a child dependency of a f_cvb_use_grids feature } - grid = new colvar_grid_scalar(); + grid = new colvar_grid_scalar(cvmodule); grid->init_from_colvars(colvars); if (is_enabled(f_cvb_bypass_ext_lagrangian)) { diff --git a/src/colvarbias_histogram_reweight_amd.cpp b/src/colvarbias_histogram_reweight_amd.cpp index 2a1878310..29e06a0ca 100644 --- a/src/colvarbias_histogram_reweight_amd.cpp +++ b/src/colvarbias_histogram_reweight_amd.cpp @@ -12,7 +12,7 @@ #include "colvars_memstream.h" colvarbias_reweightaMD::colvarbias_reweightaMD(colvarmodule *cvmodule_in, char const *key) - : colvarbias_histogram(cvmodule_in, key) {} + : colvardeps(cvmodule_in), colvarbias_histogram(cvmodule_in, key) {} colvarbias_reweightaMD::~colvarbias_reweightaMD() {} @@ -31,21 +31,21 @@ int colvarbias_reweightaMD::init(std::string const &conf) { cvmodule->error("Error: historyFreq must be a multiple of outputFreq.\n", COLVARS_INPUT_ERROR); } b_history_files = (history_freq > 0); - grid_count.reset(new colvar_grid_scalar(colvars, nullptr, false, grid_conf)); + grid_count.reset(new colvar_grid_scalar(cvmodule, colvars, nullptr, false, grid_conf)); grid_count->request_actual_value(); grid->request_actual_value(); - pmf_grid_exp_avg.reset(new colvar_grid_scalar(colvars, grid_count)); + pmf_grid_exp_avg.reset(new colvar_grid_scalar(cvmodule, colvars, grid_count)); if (b_write_gradients) { - grad_grid_exp_avg.reset(new colvar_grid_gradient(colvars, nullptr, grid_count)); + grad_grid_exp_avg.reset(new colvar_grid_gradient(cvmodule, colvars, nullptr, grid_count)); } if (b_use_cumulant_expansion) { - grid_dV.reset(new colvar_grid_scalar(colvars, grid_count)); - grid_dV_square.reset(new colvar_grid_scalar(colvars, grid_count)); - pmf_grid_cumulant.reset(new colvar_grid_scalar(colvars, grid_count)); + grid_dV.reset(new colvar_grid_scalar(cvmodule, colvars, grid_count)); + grid_dV_square.reset(new colvar_grid_scalar(cvmodule, colvars, grid_count)); + pmf_grid_cumulant.reset(new colvar_grid_scalar(cvmodule, colvars, grid_count)); grid_dV->request_actual_value(); grid_dV_square->request_actual_value(); if (b_write_gradients) { - grad_grid_cumulant.reset(new colvar_grid_gradient(colvars, nullptr, grid_count)); + grad_grid_cumulant.reset(new colvar_grid_gradient(cvmodule, colvars, nullptr, grid_count)); } } previous_bin.assign(num_variables(), -1); diff --git a/src/colvarbias_meta.cpp b/src/colvarbias_meta.cpp index e06751788..f9cf9a410 100644 --- a/src/colvarbias_meta.cpp +++ b/src/colvarbias_meta.cpp @@ -20,7 +20,7 @@ colvarbias_meta::colvarbias_meta(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key), colvarbias_ti(key) + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), colvarbias_ti(cvmodule_in, key) { new_hills_begin = hills.end(); @@ -157,8 +157,8 @@ int colvarbias_meta::init(std::string const &conf) get_keyval(conf, "keepFreeEnergyFiles", dump_fes_save, dump_fes_save); if (!hills_energy) { - hills_energy.reset(new colvar_grid_scalar(colvars, nullptr, false, grid_conf)); - hills_energy_gradients.reset(new colvar_grid_gradient(colvars, nullptr, hills_energy)); + hills_energy.reset(new colvar_grid_scalar(cvmodule, colvars, nullptr, false, grid_conf)); + hills_energy_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, nullptr, hills_energy)); } } else { @@ -285,7 +285,7 @@ int colvarbias_meta::init_ebmeta_params(std::string const &conf) "targetDistFile accordingly.\n", COLVARS_INPUT_ERROR); } - target_dist.reset(new colvar_grid_scalar()); + target_dist.reset(new colvar_grid_scalar(cvmodule)); error_code |= target_dist->init_from_colvars(colvars); std::string target_dist_file; get_keyval(conf, "targetDistFile", target_dist_file); @@ -1098,10 +1098,10 @@ int colvarbias_meta::update_replicas_registry() if (use_grids) { (replicas.back()) - ->hills_energy.reset(new colvar_grid_scalar(colvars, hills_energy)); + ->hills_energy.reset(new colvar_grid_scalar(cvmodule, colvars, hills_energy)); (replicas.back()) ->hills_energy_gradients.reset( - new colvar_grid_gradient(colvars, nullptr, hills_energy)); + new colvar_grid_gradient(cvmodule, colvars, nullptr, hills_energy)); } if (is_enabled(f_cvb_calc_ti_samples)) { @@ -1377,8 +1377,8 @@ template IST &colvarbias_meta::read_state_data_template_(IST &is) hills_energy_backup = std::move(hills_energy); hills_energy_gradients_backup = std::move(hills_energy_gradients); - hills_energy.reset(new colvar_grid_scalar(colvars, hills_energy)); - hills_energy_gradients.reset(new colvar_grid_gradient(colvars, nullptr, hills_energy)); + hills_energy.reset(new colvar_grid_scalar(cvmodule, colvars, hills_energy)); + hills_energy_gradients.reset(new colvar_grid_gradient(cvmodule, colvars, nullptr, hills_energy)); } read_grid_data_template_(is, "hills_energy", hills_energy.get(), @@ -1489,9 +1489,9 @@ void colvarbias_meta::rebin_grids_after_restart() // Create new grids based on the configuration parameters, because reading from the state // file automatically sets the old parameters std::shared_ptr new_hills_energy( - new colvar_grid_scalar(colvars, nullptr, false, grid_conf)); + new colvar_grid_scalar(cvmodule, colvars, nullptr, false, grid_conf)); std::shared_ptr new_hills_energy_gradients( - new colvar_grid_gradient(colvars, nullptr, new_hills_energy)); + new colvar_grid_gradient(cvmodule, colvars, nullptr, new_hills_energy)); if (cvm::debug()) { std::ostringstream tmp_os; diff --git a/src/colvarbias_opes.cpp b/src/colvarbias_opes.cpp index 7c44bba10..1f54585d4 100644 --- a/src/colvarbias_opes.cpp +++ b/src/colvarbias_opes.cpp @@ -44,7 +44,7 @@ colvarbias_opes::colvarbias_opes(colvarmodule *cvmodule_in, char const *key): - colvarbias(cvmodule_in, key), m_kbt(0), m_barrier(0), m_biasfactor(0), + colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), m_kbt(0), m_barrier(0), m_biasfactor(0), m_bias_prefactor(0), m_temperature(0), m_pace(0), m_adaptive_sigma_stride(0), m_adaptive_counter(0), m_counter(1), @@ -282,8 +282,8 @@ int colvarbias_opes::init(const std::string& conf) { } } key_lookup(conf, "grid", &grid_conf); - m_reweight_grid.reset(new colvar_grid_scalar(m_pmf_cvs, nullptr, false, grid_conf)); - m_pmf_grid.reset(new colvar_grid_scalar(m_pmf_cvs, m_reweight_grid)); + m_reweight_grid.reset(new colvar_grid_scalar(cvmodule, m_pmf_cvs, nullptr, false, grid_conf)); + m_pmf_grid.reset(new colvar_grid_scalar(cvmodule, m_pmf_cvs, m_reweight_grid)); get_keyval(conf, "pmfHistoryFrequency", m_pmf_hist_freq, output_freq); if ((m_pmf_hist_freq % output_freq) != 0) { error_code |= cvmodule->error("Error: pmfHistoryFrequency must be a multiple of outputFreq.\n", @@ -292,8 +292,8 @@ int colvarbias_opes::init(const std::string& conf) { if (comm == multiple_replicas) { get_keyval(conf, "pmfShared", m_pmf_shared, true); if (m_pmf_shared) { - m_global_reweight_grid.reset(new colvar_grid_scalar(m_pmf_cvs, m_reweight_grid)); - m_global_pmf_grid.reset(new colvar_grid_scalar(m_pmf_cvs, m_reweight_grid)); + m_global_reweight_grid.reset(new colvar_grid_scalar(cvmodule, m_pmf_cvs, m_reweight_grid)); + m_global_pmf_grid.reset(new colvar_grid_scalar(cvmodule, m_pmf_cvs, m_reweight_grid)); } } } diff --git a/src/colvarbias_restraint.cpp b/src/colvarbias_restraint.cpp index ba813c778..a307a9930 100644 --- a/src/colvarbias_restraint.cpp +++ b/src/colvarbias_restraint.cpp @@ -18,8 +18,8 @@ -colvarbias_restraint::colvarbias_restraint(char const *key) - : colvarbias_ti(key) +colvarbias_restraint::colvarbias_restraint(colvarmodule* cvmodule_in, char const *key) + : colvardeps(cvmodule_in), colvarbias_ti(cvmodule_in, key) // intermediate in virtual inheritance, no need to initialize base class colvarbias {} @@ -97,8 +97,8 @@ std::ostream & colvarbias_restraint::write_traj(std::ostream &os) -colvarbias_restraint_centers::colvarbias_restraint_centers(char const *key) - : colvarbias_ti(key) +colvarbias_restraint_centers::colvarbias_restraint_centers(colvarmodule* cvmodule_in, char const *key) + : colvardeps(cvmodule_in), colvarbias_ti(cvmodule_in, key) { } @@ -156,8 +156,8 @@ int colvarbias_restraint_centers::change_configuration(std::string const &conf) -colvarbias_restraint_k::colvarbias_restraint_k(char const *key) - : colvarbias_ti(key), colvarbias_restraint(key) +colvarbias_restraint_k::colvarbias_restraint_k(colvarmodule* cvmodule_in, char const *key) + : colvardeps(cvmodule_in), colvarbias_ti(cvmodule_in, key), colvarbias_restraint(cvmodule_in, key) { force_k = -1.0; check_positive_k = true; @@ -325,11 +325,11 @@ int colvarbias_restraint_moving::set_state_params(std::string const &conf) } -colvarbias_restraint_centers_moving::colvarbias_restraint_centers_moving(char const *key) - : colvarbias_ti(key), - colvarbias_restraint(key), - colvarbias_restraint_centers(key), - colvarbias_restraint_moving(key) +colvarbias_restraint_centers_moving::colvarbias_restraint_centers_moving(colvarmodule* cvmodule_in, char const *key) + : colvardeps(cvmodule_in), colvarbias_ti(cvmodule_in, key), + colvarbias_restraint(cvmodule_in, key), + colvarbias_restraint_centers(cvmodule_in, key), + colvarbias_restraint_moving(cvmodule_in, key) { b_chg_centers = false; b_output_centers = false; @@ -526,11 +526,11 @@ std::ostream & colvarbias_restraint_centers_moving::write_traj(std::ostream &os) -colvarbias_restraint_k_moving::colvarbias_restraint_k_moving(char const *key) - : colvarbias_ti(key), - colvarbias_restraint(key), - colvarbias_restraint_k(key), - colvarbias_restraint_moving(key) +colvarbias_restraint_k_moving::colvarbias_restraint_k_moving(colvarmodule* cvmodule_in, char const *key) + : colvardeps(cvmodule_in), colvarbias_ti(cvmodule_in, key), + colvarbias_restraint(cvmodule_in, key), + colvarbias_restraint_k(cvmodule_in, key), + colvarbias_restraint_moving(cvmodule_in, key) { b_chg_force_k = false; b_decoupling = false; @@ -694,14 +694,14 @@ std::ostream & colvarbias_restraint_k_moving::write_traj(std::ostream &os) colvarbias_restraint_harmonic::colvarbias_restraint_harmonic(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key), - colvarbias_ti(key), - colvarbias_restraint(key), - colvarbias_restraint_centers(key), - colvarbias_restraint_moving(key), - colvarbias_restraint_k(key), - colvarbias_restraint_centers_moving(key), - colvarbias_restraint_k_moving(key) + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), + colvarbias_ti(cvmodule_in, key), + colvarbias_restraint(cvmodule_in, key), + colvarbias_restraint_centers(cvmodule_in, key), + colvarbias_restraint_moving(cvmodule_in, key), + colvarbias_restraint_k(cvmodule_in, key), + colvarbias_restraint_centers_moving(cvmodule_in, key), + colvarbias_restraint_k_moving(cvmodule_in, key) { } @@ -836,13 +836,13 @@ cvm::real colvarbias_restraint_harmonic::energy_difference(std::string const &co colvarbias_restraint_harmonic_walls::colvarbias_restraint_harmonic_walls(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key), - colvarbias_ti(key), - colvarbias_restraint(key), - colvarbias_restraint_k(key), - colvarbias_restraint_moving(key), + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), + colvarbias_ti(cvmodule_in, key), + colvarbias_restraint(cvmodule_in, key), + colvarbias_restraint_k(cvmodule_in, key), + colvarbias_restraint_moving(cvmodule_in, key), // colvarbias_restraint_centers_moving(key) - colvarbias_restraint_k_moving(key) + colvarbias_restraint_k_moving(cvmodule_in, key) { lower_wall_k = -1.0; upper_wall_k = -1.0; @@ -1298,14 +1298,14 @@ std::ostream & colvarbias_restraint_harmonic_walls::write_traj(std::ostream &os) colvarbias_restraint_linear::colvarbias_restraint_linear(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key), - colvarbias_ti(key), - colvarbias_restraint(key), - colvarbias_restraint_centers(key), - colvarbias_restraint_moving(key), - colvarbias_restraint_k(key), - colvarbias_restraint_centers_moving(key), - colvarbias_restraint_k_moving(key) + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key), + colvarbias_ti(cvmodule_in, key), + colvarbias_restraint(cvmodule_in, key), + colvarbias_restraint_centers(cvmodule_in, key), + colvarbias_restraint_moving(cvmodule_in, key), + colvarbias_restraint_k(cvmodule_in, key), + colvarbias_restraint_centers_moving(cvmodule_in, key), + colvarbias_restraint_k_moving(cvmodule_in, key) { check_positive_k = false; } @@ -1444,7 +1444,7 @@ std::ostream & colvarbias_restraint_linear::write_traj(std::ostream &os) colvarbias_restraint_histogram::colvarbias_restraint_histogram(colvarmodule *cvmodule_in, char const *key) - : colvarbias(cvmodule_in, key) + : colvardeps(cvmodule_in), colvarbias(cvmodule_in, key) { lower_boundary = 0.0; upper_boundary = 0.0; diff --git a/src/colvarbias_restraint.h b/src/colvarbias_restraint.h index 402f35e12..8441d0bc9 100644 --- a/src/colvarbias_restraint.h +++ b/src/colvarbias_restraint.h @@ -42,7 +42,7 @@ class colvarbias_restraint virtual std::ostream & write_traj(std::ostream &os); /// \brief Constructor - colvarbias_restraint(char const *key); + colvarbias_restraint(colvarmodule* cvmodule_in, char const *key); virtual int init(std::string const &conf); virtual ~colvarbias_restraint(); @@ -67,7 +67,7 @@ class colvarbias_restraint_centers { public: - colvarbias_restraint_centers(char const *key); + colvarbias_restraint_centers(colvarmodule* cvmodule_in, char const *key); virtual int init(std::string const &conf); virtual int change_configuration(std::string const &conf); @@ -84,7 +84,7 @@ class colvarbias_restraint_k { public: - colvarbias_restraint_k(char const *key); + colvarbias_restraint_k(colvarmodule* cvmodule_in, char const *key); virtual int init(std::string const &conf); virtual int change_configuration(std::string const &conf); @@ -104,9 +104,9 @@ class colvarbias_restraint_moving public virtual colvardeps { public: - colvarbias_restraint_moving(char const *key) - : colvarbias_ti(key), - colvarbias_restraint(key) {} + colvarbias_restraint_moving(colvarmodule* cvmodule_in, char const *key) + : colvardeps(cvmodule_in), colvarbias_ti(cvmodule_in, key), + colvarbias_restraint(cvmodule_in, key) {} // Note: despite the diamond inheritance, most of this function gets only executed once virtual int init(std::string const &conf) override; virtual int update() override; @@ -192,7 +192,7 @@ class colvarbias_restraint_centers_moving { public: - colvarbias_restraint_centers_moving(char const *key); + colvarbias_restraint_centers_moving(colvarmodule* cvmodule_in, char const *key); virtual int init(std::string const &conf) override; virtual int change_configuration(std::string const & /* conf */) override { return COLVARS_NOT_IMPLEMENTED; } @@ -234,7 +234,7 @@ class colvarbias_restraint_k_moving public: // Do not initialize colvarbias here to avoid diamond inheritance issues // because this is an intermediate class - colvarbias_restraint_k_moving(char const *key); + colvarbias_restraint_k_moving(colvarmodule* cvmodule_in, char const *key); virtual int init(std::string const &conf) override; virtual int change_configuration(std::string const & /* conf */) override { return COLVARS_NOT_IMPLEMENTED; } diff --git a/src/colvarcomp.cpp b/src/colvarcomp.cpp index 620206444..9529bc2f3 100644 --- a/src/colvarcomp.cpp +++ b/src/colvarcomp.cpp @@ -18,15 +18,6 @@ #include "colvarcomp.h" -// This constructor depends on a static cvm pointer and is deprecated -colvar::cvc::cvc() - : colvardeps(cvm::main()) -{ - description = "uninitialized colvar component"; - cvc::init_dependencies(); -} - - colvar::cvc::cvc(colvarmodule *cvmodule_in) : colvardeps(cvmodule_in) { @@ -184,7 +175,7 @@ cvm::atom_group *colvar::cvc::parse_group(std::string const &conf, std::string group_conf; if (key_lookup(conf, group_key, &group_conf)) { - group = new cvm::atom_group(group_key); + group = new cvm::atom_group(group_key, cvmodule); if (b_try_scalable) { if (is_available(f_cvc_scalable_com) diff --git a/src/colvarcomp.h b/src/colvarcomp.h index b7a5d78c1..bd995bc52 100644 --- a/src/colvarcomp.h +++ b/src/colvarcomp.h @@ -95,7 +95,7 @@ class colvar::cvc cvm::real wrap_center = 0.0; /// Constructor - cvc(); + // cvc(); cvc(colvarmodule *cvmodule_in); @@ -385,7 +385,7 @@ class colvar::distance /// Vector distance, cached to be recycled cvm::rvector dist_v; public: - distance(); + distance(colvarmodule* cvmodule_in); virtual ~distance() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -394,8 +394,6 @@ class colvar::distance virtual void calc_Jacobian_derivative(); }; - - // \brief Colvar component: distance vector between centers of mass // of two groups (\link colvarvalue::type_3vector \endlink type, // range (-*:*)x(-*:*)x(-*:*)) @@ -403,7 +401,7 @@ class colvar::distance_vec : public colvar::distance { public: - distance_vec(); + distance_vec(colvarmodule* cvmodule_in); virtual ~distance_vec() {} virtual void calc_value(); virtual void calc_gradients(); @@ -426,7 +424,7 @@ class colvar::distance_dir : public colvar::distance { public: - distance_dir(); + distance_dir(colvarmodule* cvmodule_in); virtual ~distance_dir() {} virtual void calc_value(); virtual void calc_gradients(); @@ -464,7 +462,7 @@ class colvar::distance_z /// Flag: using a fixed axis vector? bool fixed_axis = true; public: - distance_z(); + distance_z(colvarmodule* cvmodule_in); virtual ~distance_z() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -486,7 +484,7 @@ class colvar::distance_xy /// Vector distances cvm::rvector v12, v13; public: - distance_xy(); + distance_xy(colvarmodule* cvmodule_in); virtual ~distance_xy() {} virtual void calc_value(); virtual void calc_gradients(); @@ -505,7 +503,7 @@ class colvar::polar_phi cvm::real r, theta, phi; public: - polar_phi(); + polar_phi(colvarmodule* cvmodule_in); virtual ~polar_phi() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -519,7 +517,7 @@ class colvar::polar_theta : public colvar::cvc { public: - polar_theta(); + polar_theta(colvarmodule* cvmodule_in); virtual ~polar_theta() {} virtual int init(std::string const &conf); protected: @@ -544,7 +542,7 @@ class colvar::distance_inv /// Components of the distance vector orthogonal to the axis int exponent = 6; public: - distance_inv(); + distance_inv(colvarmodule* cvmodule_in); virtual ~distance_inv() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -564,7 +562,7 @@ class colvar::distance_pairs /// Second atom group cvm::atom_group *group2 = nullptr; public: - distance_pairs(); + distance_pairs(colvarmodule* cvmodule_in); virtual ~distance_pairs() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -590,7 +588,7 @@ class colvar::dipole_magnitude cvm::atom_group *atoms = nullptr; cvm::atom_pos dipoleV; public: - dipole_magnitude(); + dipole_magnitude(colvarmodule* cvmodule_in); virtual ~dipole_magnitude() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -608,7 +606,7 @@ class colvar::gyration /// Atoms involved cvm::atom_group *atoms = nullptr; public: - gyration(); + gyration(colvarmodule* cvmodule_in); virtual ~gyration() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -625,7 +623,7 @@ class colvar::inertia : public colvar::gyration { public: - inertia(); + inertia(colvarmodule* cvmodule_in); virtual ~inertia() {} virtual void calc_value(); virtual void calc_gradients(); @@ -642,7 +640,7 @@ class colvar::inertia_z /// Vector on which the inertia tensor is projected cvm::rvector axis; public: - inertia_z(); + inertia_z(colvarmodule* cvmodule_in); virtual ~inertia_z() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -672,7 +670,7 @@ class colvar::eigenvector public: - eigenvector(); + eigenvector(colvarmodule* cvmodule_in); virtual ~eigenvector() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -708,11 +706,12 @@ class colvar::angle bool b_1site_force = false; public: - angle(); + angle(colvarmodule* cvmodule_in); /// \brief Initialize the three groups after three atoms angle(cvm::atom_group::simple_atom const &a1, cvm::atom_group::simple_atom const &a2, - cvm::atom_group::simple_atom const &a3); + cvm::atom_group::simple_atom const &a3, + colvarmodule* cvmodule_in); virtual ~angle() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -749,7 +748,7 @@ class colvar::dipole_angle bool b_1site_force = false; public: - dipole_angle(); + dipole_angle(colvarmodule* cvmodule_in); virtual ~dipole_angle() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -786,8 +785,9 @@ class colvar::dihedral dihedral(cvm::atom_group::simple_atom const &a1, cvm::atom_group::simple_atom const &a2, cvm::atom_group::simple_atom const &a3, - cvm::atom_group::simple_atom const &a4); - dihedral(); + cvm::atom_group::simple_atom const &a4, + colvarmodule* cvmodule_in); + dihedral(colvarmodule* cvmodule_in); virtual ~dihedral() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -833,7 +833,7 @@ class colvar::coordnum public: - coordnum(); + coordnum(colvarmodule* cvmodule_in); virtual ~coordnum(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -907,7 +907,7 @@ class colvar::selfcoordnum public: - selfcoordnum(); + selfcoordnum(colvarmodule* cvmodule_in); ~selfcoordnum(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -937,7 +937,7 @@ class colvar::groupcoordnum /// Integer exponent of the function denominator int ed = 12; public: - groupcoordnum(); + groupcoordnum(colvarmodule* cvmodule_in); virtual ~groupcoordnum() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -963,8 +963,8 @@ class colvar::h_bond /// Constructor for atoms already allocated h_bond(cvm::atom_group::simple_atom const &acceptor, cvm::atom_group::simple_atom const &donor, - cvm::real r0, int en, int ed); - h_bond(); + cvm::real r0, int en, int ed, colvarmodule* cvmodule_in); + h_bond(colvarmodule* cvmodule_in); virtual ~h_bond() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -1007,7 +1007,7 @@ class colvar::alpha_angles public: - alpha_angles(); + alpha_angles(colvarmodule* cvmodule_in); virtual ~alpha_angles(); virtual int init(std::string const &conf); void calc_value(); @@ -1033,7 +1033,7 @@ class colvar::dihedPC public: - dihedPC(); + dihedPC(colvarmodule* cvmodule_in); virtual ~dihedPC(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1079,7 +1079,7 @@ class colvar::orientation public: - orientation(); + orientation(colvarmodule* cvmodule_in); virtual ~orientation(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1104,7 +1104,7 @@ class colvar::orientation_angle { public: - orientation_angle(); + orientation_angle(colvarmodule* cvmodule_in); virtual ~orientation_angle() {} virtual void calc_value(); virtual void calc_gradients(); @@ -1129,7 +1129,7 @@ class colvar::orientation_proj { public: - orientation_proj(); + orientation_proj(colvarmodule* cvmodule_in); virtual ~orientation_proj() {} virtual void calc_value(); virtual void calc_gradients(); @@ -1148,7 +1148,7 @@ class colvar::tilt public: - tilt(); + tilt(colvarmodule* cvmodule_in); virtual ~tilt() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -1164,7 +1164,7 @@ class colvar::spin_angle { public: - spin_angle(); + spin_angle(colvarmodule* cvmodule_in); virtual ~spin_angle() {} virtual void calc_value(); virtual void calc_gradients(); @@ -1175,7 +1175,7 @@ class colvar::euler_phi : public colvar::orientation_angle { public: - euler_phi(); + euler_phi(colvarmodule* cvmodule_in); virtual ~euler_phi() {} virtual void calc_value(); virtual void calc_gradients(); @@ -1186,7 +1186,7 @@ class colvar::euler_psi : public colvar::orientation_angle { public: - euler_psi(); + euler_psi(colvarmodule* cvmodule_in); virtual ~euler_psi() {} virtual void calc_value(); virtual void calc_gradients(); @@ -1197,7 +1197,7 @@ class colvar::euler_theta : public colvar::orientation_angle { public: - euler_theta(); + euler_theta(colvarmodule* cvmodule_in); virtual ~euler_theta() {} virtual void calc_value(); virtual void calc_gradients(); @@ -1247,7 +1247,7 @@ class colvar::rmsd int init_permutation(std::vector& ref_pos, std::string const &conf); public: - rmsd(); + rmsd(colvarmodule* cvmodule_in); bool has_gpu_implementation() const override; #if defined (COLVARS_CUDA) || defined (COLVARS_HIP) int add_calc_value_node( @@ -1287,7 +1287,7 @@ class colvar::cartesian /// Which Cartesian coordinates to include std::vector axes; public: - cartesian(); + cartesian(colvarmodule* cvmodule_in); virtual ~cartesian() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -1315,7 +1315,7 @@ class colvar::alch_lambda protected: // No atom groups needed public: - alch_lambda(); + alch_lambda(colvarmodule* cvmodule_in); int init_alchemy(int time_step_factor); virtual ~alch_lambda() {} virtual void calc_value(); @@ -1333,7 +1333,7 @@ class colvar::alch_Flambda protected: // No atom groups needed public: - alch_Flambda(); + alch_Flambda(colvarmodule* cvmodule_in); virtual ~alch_Flambda() {} virtual void calc_value(); virtual void calc_gradients(); @@ -1359,7 +1359,7 @@ class colvar::CartesianBasedPath /// Total number of reference frames size_t total_reference_frames = 0; public: - CartesianBasedPath(); + CartesianBasedPath(colvarmodule* cvmodule_in); virtual ~CartesianBasedPath(); virtual int init(std::string const &conf); virtual void calc_value() = 0; @@ -1380,7 +1380,7 @@ class colvar::gspath virtual void prepareVectors(); virtual void updateDistanceToReferenceFrames(); public: - gspath(); + gspath(colvarmodule* cvmodule_in); virtual ~gspath() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -1403,7 +1403,7 @@ class colvar::gzpath virtual void prepareVectors(); virtual void updateDistanceToReferenceFrames(); public: - gzpath(); + gzpath(colvarmodule* cvmodule_in); virtual ~gzpath() {} virtual int init(std::string const &conf); virtual void calc_value(); @@ -1423,7 +1423,7 @@ class colvar::linearCombination protected: cvm::real getPolynomialFactorOfCVGradient(size_t i_cv) const; public: - linearCombination(); + linearCombination(colvarmodule* cvmodule_in); virtual ~linearCombination(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1461,7 +1461,7 @@ class colvar::customColvar double dev_null = 0.0; #endif public: - customColvar(); + customColvar(colvarmodule* cvmodule_in); virtual ~customColvar(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1488,7 +1488,7 @@ class colvar::CVBasedPath virtual void computeDistanceBetweenReferenceFrames(std::vector& result) const; cvm::real getPolynomialFactorOfCVGradient(size_t i_cv) const; public: - CVBasedPath(); + CVBasedPath(colvarmodule* cvmodule_in); virtual ~CVBasedPath(); virtual int init(std::string const &conf); virtual void calc_value() = 0; @@ -1516,7 +1516,7 @@ class colvar::gspathCV virtual void updateDistanceToReferenceFrames(); virtual void prepareVectors(); public: - gspathCV(); + gspathCV(colvarmodule* cvmodule_in); virtual ~gspathCV(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1533,7 +1533,7 @@ class colvar::gzpathCV virtual void updateDistanceToReferenceFrames(); virtual void prepareVectors(); public: - gzpathCV(); + gzpathCV(colvarmodule* cvmodule_in); virtual ~gzpathCV(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1550,7 +1550,7 @@ class colvar::aspath std::unique_ptr impl_; friend struct ArithmeticPathImpl; public: - aspath(); + aspath(colvarmodule* cvmodule_in); virtual ~aspath(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1565,7 +1565,7 @@ class colvar::azpath std::unique_ptr impl_; friend struct ArithmeticPathImpl; public: - azpath(); + azpath(colvarmodule* cvmodule_in); virtual ~azpath(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1580,7 +1580,7 @@ class colvar::aspathCV std::unique_ptr impl_; friend struct ArithmeticPathImpl; public: - aspathCV(); + aspathCV(colvarmodule* cvmodule_in); virtual ~aspathCV(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1596,7 +1596,7 @@ class colvar::azpathCV std::unique_ptr impl_; friend struct ArithmeticPathImpl; public: - azpathCV(); + azpathCV(colvarmodule* cvmodule_in); virtual ~azpathCV(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1619,7 +1619,7 @@ class colvar::neuralNetwork /// the index of nn output components size_t m_output_index = 0; public: - neuralNetwork(); + neuralNetwork(colvarmodule* cvmodule_in); virtual ~neuralNetwork(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -1646,7 +1646,7 @@ class colvar::map_total { public: - map_total(); + map_total(colvarmodule* cvmodule_in); virtual ~map_total() {} virtual int init(std::string const &conf); virtual void calc_value(); diff --git a/src/colvarcomp_alchlambda.cpp b/src/colvarcomp_alchlambda.cpp index 7a780791b..2baa3551b 100644 --- a/src/colvarcomp_alchlambda.cpp +++ b/src/colvarcomp_alchlambda.cpp @@ -16,7 +16,7 @@ #include "colvarcomp.h" -colvar::alch_lambda::alch_lambda() +colvar::alch_lambda::alch_lambda(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("alchLambda"); @@ -85,7 +85,7 @@ void colvar::alch_lambda::apply_force(colvarvalue const & /* force */) } -colvar::alch_Flambda::alch_Flambda() +colvar::alch_Flambda::alch_Flambda(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("alch_Flambda"); diff --git a/src/colvarcomp_angles.cpp b/src/colvarcomp_angles.cpp index d6fc402c3..a8474a89e 100644 --- a/src/colvarcomp_angles.cpp +++ b/src/colvarcomp_angles.cpp @@ -12,7 +12,7 @@ #include "colvarcomp.h" -colvar::angle::angle() +colvar::angle::angle(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("angle"); init_as_angle(); @@ -38,11 +38,12 @@ int colvar::angle::init(std::string const &conf) colvar::angle::angle(cvm::atom_group::simple_atom const &a1, cvm::atom_group::simple_atom const &a2, - cvm::atom_group::simple_atom const &a3) : angle() + cvm::atom_group::simple_atom const &a3, + colvarmodule* cvmodule_in) : angle(cvmodule_in) { - group1 = new cvm::atom_group(); - group2 = new cvm::atom_group(); - group3 = new cvm::atom_group(); + group1 = new cvm::atom_group(cvmodule); + group2 = new cvm::atom_group(cvmodule); + group3 = new cvm::atom_group(cvmodule); { auto modify_group1 = group1->get_atom_modifier(); auto modify_group2 = group2->get_atom_modifier(); @@ -128,7 +129,7 @@ void colvar::angle::calc_Jacobian_derivative() -colvar::dipole_angle::dipole_angle() +colvar::dipole_angle::dipole_angle(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("dipoleAngle"); init_as_angle(); @@ -222,7 +223,7 @@ void colvar::dipole_angle::calc_gradients() -colvar::dihedral::dihedral() +colvar::dihedral::dihedral(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("dihedral"); init_as_periodic_angle(); @@ -248,15 +249,16 @@ int colvar::dihedral::init(std::string const &conf) colvar::dihedral::dihedral(cvm::atom_group::simple_atom const &a1, cvm::atom_group::simple_atom const &a2, cvm::atom_group::simple_atom const &a3, - cvm::atom_group::simple_atom const &a4) - : dihedral() + cvm::atom_group::simple_atom const &a4, + colvarmodule* cvmodule_in) + : dihedral(cvmodule_in) { b_1site_force = false; - group1 = new cvm::atom_group(); - group2 = new cvm::atom_group(); - group3 = new cvm::atom_group(); - group4 = new cvm::atom_group(); + group1 = new cvm::atom_group(cvmodule); + group2 = new cvm::atom_group(cvmodule); + group3 = new cvm::atom_group(cvmodule); + group4 = new cvm::atom_group(cvmodule); { auto modify_group1 = group1->get_atom_modifier(); auto modify_group2 = group2->get_atom_modifier(); @@ -363,7 +365,7 @@ void colvar::dihedral::calc_Jacobian_derivative() -colvar::polar_theta::polar_theta() +colvar::polar_theta::polar_theta(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { r = theta = phi = 0.0; set_function_type("polarTheta"); @@ -405,7 +407,7 @@ void colvar::polar_theta::calc_gradients() -colvar::polar_phi::polar_phi() +colvar::polar_phi::polar_phi(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { r = theta = phi = 0.0; set_function_type("polarPhi"); diff --git a/src/colvarcomp_apath.cpp b/src/colvarcomp_apath.cpp index c472708cd..a3c8e69bd 100644 --- a/src/colvarcomp_apath.cpp +++ b/src/colvarcomp_apath.cpp @@ -134,7 +134,7 @@ struct ArithmeticPathImpl: public ArithmeticPathCV::ArithmeticPathBase sub_cvc_confs; get_key_string_multi_value(conf, it_cv_map->first.c_str(), sub_cvc_confs); for (auto it_sub_cvc_conf = sub_cvc_confs.begin(); it_sub_cvc_conf != sub_cvc_confs.end(); ++it_sub_cvc_conf) { - cv.push_back((it_cv_map->second)()); + cv.push_back((it_cv_map->second)(cvmodule)); cv.back()->init(*(it_sub_cvc_conf)); if (cv.back()->has_gpu_implementation()) { // TODO: GPU support for nested CVs @@ -170,7 +170,7 @@ void colvar::linearCombination::wrap(colvarvalue & /* x_unwrapped */) const {} -colvar::customColvar::customColvar() +colvar::customColvar::customColvar(colvarmodule* cvmodule_in): colvar::linearCombination(cvmodule_in) { set_function_type("customColvar"); } diff --git a/src/colvarcomp_coordnums.cpp b/src/colvarcomp_coordnums.cpp index fdcd5aa4e..743e3735e 100644 --- a/src/colvarcomp_coordnums.cpp +++ b/src/colvarcomp_coordnums.cpp @@ -122,7 +122,7 @@ cvm::real colvar::coordnum::switching_function(cvm::real const &r0, } -colvar::coordnum::coordnum() +colvar::coordnum::coordnum(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("coordNum"); x.type(colvarvalue::type_scalar); @@ -357,7 +357,7 @@ void colvar::coordnum::calc_gradients() // h_bond member functions -colvar::h_bond::h_bond() +colvar::h_bond::h_bond(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { colvarproxy *proxy = cvmodule->proxy; r0 = proxy->angstrom_to_internal(3.3); @@ -386,7 +386,7 @@ int colvar::h_bond::init(std::string const &conf) error_code |= cvmodule->error("Error: either acceptor or donor undefined.\n", COLVARS_INPUT_ERROR); } - register_atom_group(new cvm::atom_group); + register_atom_group(new cvm::atom_group(cvmodule)); { colvarproxy* const p = cvmodule->proxy; auto modify_atom = atom_groups[0]->get_atom_modifier(); @@ -415,13 +415,13 @@ int colvar::h_bond::init(std::string const &conf) colvar::h_bond::h_bond(cvm::atom_group::simple_atom const &acceptor, cvm::atom_group::simple_atom const &donor, - cvm::real r0_i, int en_i, int ed_i) - : h_bond() + cvm::real r0_i, int en_i, int ed_i, colvarmodule* cvmodule_in) + : h_bond(cvmodule_in) { r0 = r0_i; en = en_i; ed = ed_i; - register_atom_group(new cvm::atom_group); + register_atom_group(new cvm::atom_group(cvmodule)); auto modify_atom = atom_groups[0]->get_atom_modifier(); modify_atom.add_atom(acceptor); modify_atom.add_atom(donor); @@ -496,7 +496,7 @@ void colvar::h_bond::calc_gradients() -colvar::selfcoordnum::selfcoordnum() +colvar::selfcoordnum::selfcoordnum(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("selfCoordNum"); x.type(colvarvalue::type_scalar); @@ -639,7 +639,7 @@ void colvar::selfcoordnum::calc_gradients() -colvar::groupcoordnum::groupcoordnum() +colvar::groupcoordnum::groupcoordnum(colvarmodule* cvmodule_in): colvar::distance(cvmodule_in) { set_function_type("groupCoord"); x.type(colvarvalue::type_scalar); diff --git a/src/colvarcomp_distances.cpp b/src/colvarcomp_distances.cpp index f2ddd6863..6857db6e0 100644 --- a/src/colvarcomp_distances.cpp +++ b/src/colvarcomp_distances.cpp @@ -21,7 +21,7 @@ #endif // defined (COLVARS_CUDA) || defined (COLVARS_HIP) -colvar::distance::distance() +colvar::distance::distance(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("distance"); init_as_distance(); @@ -88,7 +88,7 @@ void colvar::distance::calc_Jacobian_derivative() -colvar::distance_vec::distance_vec() +colvar::distance_vec::distance_vec(colvarmodule* cvmodule_in): colvar::distance(cvmodule_in) { set_function_type("distanceVec"); disable(f_cvc_explicit_gradient); @@ -151,7 +151,7 @@ colvarvalue colvar::distance_vec::dist2_rgrad(colvarvalue const &x1, colvarvalue void colvar::distance_vec::wrap(colvarvalue & /* x_unwrapped */) const {} -colvar::distance_z::distance_z() +colvar::distance_z::distance_z(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("distanceZ"); provide(f_cvc_inv_gradient); @@ -262,7 +262,7 @@ void colvar::distance_z::calc_Jacobian_derivative() -colvar::distance_xy::distance_xy() +colvar::distance_xy::distance_xy(colvarmodule* cvmodule_in): colvar::distance_z(cvmodule_in) { set_function_type("distanceXY"); provide(f_cvc_periodic, false); // Disable inherited distance_z flag @@ -343,7 +343,7 @@ void colvar::distance_xy::calc_Jacobian_derivative() -colvar::distance_dir::distance_dir() +colvar::distance_dir::distance_dir(colvarmodule* cvmodule_in): colvar::distance(cvmodule_in) { set_function_type("distanceDir"); enable(f_cvc_com_based); @@ -411,7 +411,7 @@ void colvar::distance_dir::wrap(colvarvalue & /* x_unwrapped */) const {} -colvar::distance_inv::distance_inv() +colvar::distance_inv::distance_inv(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("distanceInv"); init_as_distance(); @@ -514,7 +514,7 @@ void colvar::distance_inv::calc_gradients() -colvar::distance_pairs::distance_pairs() +colvar::distance_pairs::distance_pairs(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("distancePairs"); disable(f_cvc_explicit_gradient); @@ -635,7 +635,7 @@ void colvar::distance_pairs::wrap(colvarvalue & /* x_unwrapped */) const {} -colvar::dipole_magnitude::dipole_magnitude() +colvar::dipole_magnitude::dipole_magnitude(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("dipoleMagnitude"); x.type(colvarvalue::type_scalar); @@ -674,7 +674,7 @@ void colvar::dipole_magnitude::calc_gradients() -colvar::gyration::gyration() +colvar::gyration::gyration(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("gyration"); provide(f_cvc_inv_gradient); @@ -744,7 +744,7 @@ void colvar::gyration::calc_Jacobian_derivative() -colvar::inertia::inertia() +colvar::inertia::inertia(colvarmodule* cvmodule_in): colvar::gyration(cvmodule_in) { set_function_type("inertia"); } @@ -770,7 +770,7 @@ void colvar::inertia::calc_gradients() -colvar::inertia_z::inertia_z() +colvar::inertia_z::inertia_z(colvarmodule* cvmodule_in): colvar::inertia(cvmodule_in) { set_function_type("inertiaZ"); } @@ -821,7 +821,7 @@ void colvar::inertia_z::calc_gradients() -colvar::rmsd::rmsd() +colvar::rmsd::rmsd(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("rmsd"); init_as_distance(); @@ -1285,7 +1285,7 @@ int colvar::rmsd::calc_Jacobian_derivative_after_gpu() { #endif // defined (COLVARS_CUDA) || defined (COLVARS_HIP) -colvar::eigenvector::eigenvector() +colvar::eigenvector::eigenvector(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("eigenvector"); provide(f_cvc_inv_gradient); @@ -1577,7 +1577,7 @@ void colvar::eigenvector::calc_Jacobian_derivative() -colvar::cartesian::cartesian() +colvar::cartesian::cartesian(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("cartesian"); x.type(colvarvalue::type_vector); diff --git a/src/colvarcomp_gpath.cpp b/src/colvarcomp_gpath.cpp index 32bcdbbd6..efd3214a0 100644 --- a/src/colvarcomp_gpath.cpp +++ b/src/colvarcomp_gpath.cpp @@ -20,7 +20,7 @@ -colvar::CartesianBasedPath::CartesianBasedPath() +colvar::CartesianBasedPath::CartesianBasedPath(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { x.type(colvarvalue::type_scalar); // Don't use implicit gradient @@ -80,7 +80,7 @@ int colvar::CartesianBasedPath::init(std::string const &conf) } else { // parse a group of atoms for fitting std::string fitting_group_name = std::string("fittingAtoms") + cvm::to_str(i_frame); - cvm::atom_group* tmp_fitting_atoms = new cvm::atom_group(fitting_group_name.c_str()); + cvm::atom_group* tmp_fitting_atoms = new cvm::atom_group(fitting_group_name.c_str(), cvmodule); tmp_fitting_atoms->parse(fitting_conf); tmp_fitting_atoms->disable(f_ag_scalable); tmp_fitting_atoms->fit_gradients.assign(3 * tmp_fitting_atoms->size(), 0); @@ -178,7 +178,7 @@ void colvar::CartesianBasedPath::apply_force(colvarvalue const &force) -colvar::gspath::gspath() +colvar::gspath::gspath(colvarmodule* cvmodule_in): colvar::CartesianBasedPath(cvmodule_in) { set_function_type("gspath"); } @@ -342,7 +342,7 @@ void colvar::gspath::apply_force(colvarvalue const &force) { } -colvar::gzpath::gzpath() +colvar::gzpath::gzpath(colvarmodule* cvmodule_in): colvar::CartesianBasedPath(cvmodule_in) { set_function_type("gzpath"); } @@ -496,7 +496,7 @@ void colvar::gzpath::apply_force(colvarvalue const &force) { } -colvar::CVBasedPath::CVBasedPath() +colvar::CVBasedPath::CVBasedPath(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("gspathCV"); x.type(colvarvalue::type_scalar); @@ -514,7 +514,7 @@ int colvar::CVBasedPath::init(std::string const &conf) std::vector sub_cvc_confs; get_key_string_multi_value(conf, it_cv_map->first.c_str(), sub_cvc_confs); for (auto it_sub_cvc_conf = sub_cvc_confs.begin(); it_sub_cvc_conf != sub_cvc_confs.end(); ++it_sub_cvc_conf) { - cv.push_back((it_cv_map->second)()); + cv.push_back((it_cv_map->second)(cvmodule)); cv.back()->init(*(it_sub_cvc_conf)); if (cv.back()->has_gpu_implementation()) { // TODO: GPU support for nested CVs @@ -699,7 +699,7 @@ void colvar::CVBasedPath::wrap(colvarvalue & /* x_unwrapped */) const {} -colvar::gspathCV::gspathCV() +colvar::gspathCV::gspathCV(colvarmodule* cvmodule_in): colvar::CVBasedPath(cvmodule_in) { set_function_type("gspathCV"); x.type(colvarvalue::type_scalar); @@ -837,7 +837,7 @@ void colvar::gspathCV::apply_force(colvarvalue const &force) { } } -colvar::gzpathCV::gzpathCV() +colvar::gzpathCV::gzpathCV(colvarmodule* cvmodule_in): colvar::CVBasedPath(cvmodule_in) { set_function_type("gzpathCV"); } diff --git a/src/colvarcomp_neuralnetwork.cpp b/src/colvarcomp_neuralnetwork.cpp index f82719ea2..81f752ace 100644 --- a/src/colvarcomp_neuralnetwork.cpp +++ b/src/colvarcomp_neuralnetwork.cpp @@ -16,7 +16,7 @@ using namespace neuralnetworkCV; -colvar::neuralNetwork::neuralNetwork() +colvar::neuralNetwork::neuralNetwork(colvarmodule* cvmodule_in): colvar::linearCombination(cvmodule_in) { set_function_type("neuralNetwork"); } diff --git a/src/colvarcomp_protein.cpp b/src/colvarcomp_protein.cpp index e68d3951f..e13b7cdd9 100644 --- a/src/colvarcomp_protein.cpp +++ b/src/colvarcomp_protein.cpp @@ -15,7 +15,7 @@ #include "colvarcomp.h" -colvar::alpha_angles::alpha_angles() +colvar::alpha_angles::alpha_angles(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("alpha"); enable(f_cvc_explicit_gradient); @@ -34,7 +34,7 @@ int colvar::alpha_angles::init(std::string const &conf) std::vector residues; bool b_use_index_groups = false; - cvm::atom_group group_CA, group_N, group_O; + cvm::atom_group group_CA(cvmodule), group_N(cvmodule), group_O(cvmodule); std::string residues_conf = ""; std::string prefix; @@ -112,7 +112,7 @@ int colvar::alpha_angles::init(std::string const &conf) // Note: the angle constructor constructs copies of the atom objects theta.push_back(new colvar::angle(group_CA[i], group_CA[i+1], - group_CA[i+2])); + group_CA[i+2], cvmodule)); register_atom_group(theta.back()->atom_groups[0]); register_atom_group(theta.back()->atom_groups[1]); register_atom_group(theta.back()->atom_groups[2]); @@ -124,7 +124,8 @@ int colvar::alpha_angles::init(std::string const &conf) new colvar::angle( cvm::atom_group::init_atom_from_proxy(p, r[i ], "CA", sid), cvm::atom_group::init_atom_from_proxy(p, r[i+1], "CA", sid), - cvm::atom_group::init_atom_from_proxy(p, r[i+2], "CA", sid))); + cvm::atom_group::init_atom_from_proxy(p, r[i+2], "CA", sid), + cvmodule)); register_atom_group(theta.back()->atom_groups[0]); register_atom_group(theta.back()->atom_groups[1]); register_atom_group(theta.back()->atom_groups[2]); @@ -153,7 +154,7 @@ int colvar::alpha_angles::init(std::string const &conf) hb.push_back( new colvar::h_bond(cvm::atom_group::init_atom_from_proxy(p,group_O[i]), cvm::atom_group::init_atom_from_proxy(p,group_N[i+4]), - r0, en, ed)); + r0, en, ed, cvmodule)); register_atom_group(hb.back()->atom_groups[0]); } } else { @@ -161,7 +162,7 @@ int colvar::alpha_angles::init(std::string const &conf) hb.push_back( new colvar::h_bond(cvm::atom_group::init_atom_from_proxy(p,r[i ], "O", sid), cvm::atom_group::init_atom_from_proxy(p,r[i+4], "N", sid), - r0, en, ed)); + r0, en, ed, cvmodule)); register_atom_group(hb.back()->atom_groups[0]); } } @@ -338,7 +339,7 @@ void colvar::alpha_angles::apply_force(colvarvalue const &force) // dihedral principal component ////////////////////////////////////////////////////////////////////// -colvar::dihedPC::dihedPC() +colvar::dihedPC::dihedPC(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("dihedPC"); // Supported through references to atom groups of children cvcs @@ -360,7 +361,7 @@ int colvar::dihedPC::init(std::string const &conf) size_t n_residues; std::string residues_conf = ""; std::string prefix; - cvm::atom_group group_CA, group_N, group_C; + cvm::atom_group group_CA(cvmodule), group_N(cvmodule), group_C(cvmodule); // residueRange is mandatory for the topology-based case if (key_lookup(conf, "residueRange", &residues_conf)) { @@ -480,14 +481,14 @@ int colvar::dihedPC::init(std::string const &conf) theta.push_back(new colvar::dihedral( group_N[i], group_CA[i], group_C[i], - group_N[i+1])); + group_N[i+1], cvmodule)); } else { theta.push_back( new colvar::dihedral( cvm::atom_group::init_atom_from_proxy(p,r[i ], "N", sid), cvm::atom_group::init_atom_from_proxy(p,r[i ], "CA", sid), cvm::atom_group::init_atom_from_proxy(p,r[i ], "C", sid), - cvm::atom_group::init_atom_from_proxy(p,r[i+1], "N", sid))); + cvm::atom_group::init_atom_from_proxy(p,r[i+1], "N", sid), cvmodule)); } if (cvmodule->get_error()) { return cvmodule->get_error(); @@ -501,13 +502,13 @@ int colvar::dihedPC::init(std::string const &conf) theta.push_back(new colvar::dihedral(group_C[i], group_N[i+1], group_CA[i+1], - group_C[i+1])); + group_C[i+1], cvmodule)); } else { theta.push_back( new colvar::dihedral(cvm::atom_group::init_atom_from_proxy(p,r[i ], "C", sid), cvm::atom_group::init_atom_from_proxy(p,r[i+1], "N", sid), cvm::atom_group::init_atom_from_proxy(p,r[i+1], "CA", sid), - cvm::atom_group::init_atom_from_proxy(p,r[i+1], "C", sid))); + cvm::atom_group::init_atom_from_proxy(p,r[i+1], "C", sid), cvmodule)); } if (cvmodule->get_error()) { return cvmodule->get_error(); diff --git a/src/colvarcomp_rotations.cpp b/src/colvarcomp_rotations.cpp index 7c2b5b2b6..66923e796 100644 --- a/src/colvarcomp_rotations.cpp +++ b/src/colvarcomp_rotations.cpp @@ -25,7 +25,7 @@ struct colvar::orientation::rotation_derivative_impl_: public rotation_derivativ }; -colvar::orientation::orientation() +colvar::orientation::orientation(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("orientation"); disable(f_cvc_explicit_gradient); @@ -179,7 +179,7 @@ void colvar::orientation::wrap(colvarvalue & /* x_unwrapped */) const {} -colvar::orientation_angle::orientation_angle() +colvar::orientation_angle::orientation_angle(colvarmodule* cvmodule_in): colvar::orientation(cvmodule_in) { set_function_type("orientationAngle"); init_as_angle(); @@ -250,7 +250,7 @@ void colvar::orientation_angle::wrap(colvarvalue & /* x_unwrapped */) const {} -colvar::orientation_proj::orientation_proj() +colvar::orientation_proj::orientation_proj(colvarmodule* cvmodule_in): colvar::orientation_angle(cvmodule_in) { set_function_type("orientationProj"); enable(f_cvc_explicit_gradient); @@ -283,7 +283,7 @@ void colvar::orientation_proj::calc_gradients() -colvar::tilt::tilt() +colvar::tilt::tilt(colvarmodule* cvmodule_in): colvar::orientation_proj(cvmodule_in) { set_function_type("tilt"); x.type(colvarvalue::type_scalar); @@ -333,7 +333,7 @@ void colvar::tilt::calc_gradients() -colvar::spin_angle::spin_angle() +colvar::spin_angle::spin_angle(colvarmodule* cvmodule_in): colvar::tilt(cvmodule_in) { set_function_type("spinAngle"); init_as_periodic_angle(); @@ -369,7 +369,7 @@ void colvar::spin_angle::calc_gradients() -colvar::euler_phi::euler_phi() +colvar::euler_phi::euler_phi(colvarmodule* cvmodule_in): colvar::orientation_angle(cvmodule_in) { set_function_type("eulerPhi"); init_as_periodic_angle(); @@ -416,7 +416,7 @@ void colvar::euler_phi::calc_gradients() -colvar::euler_psi::euler_psi() +colvar::euler_psi::euler_psi(colvarmodule* cvmodule_in): colvar::orientation_angle(cvmodule_in) { set_function_type("eulerPsi"); init_as_periodic_angle(); @@ -463,7 +463,7 @@ void colvar::euler_psi::calc_gradients() -colvar::euler_theta::euler_theta() +colvar::euler_theta::euler_theta(colvarmodule* cvmodule_in): colvar::orientation_angle(cvmodule_in) { set_function_type("eulerTheta"); init_as_angle(); diff --git a/src/colvarcomp_torchann.cpp b/src/colvarcomp_torchann.cpp index f4f580a0e..bc4491d70 100644 --- a/src/colvarcomp_torchann.cpp +++ b/src/colvarcomp_torchann.cpp @@ -18,7 +18,7 @@ #ifdef COLVARS_TORCH -colvar::torchANN::torchANN() +colvar::torchANN::torchANN(colvarmodule* cvmodule_in): colvar::linearCombination(cvmodule_in) { set_function_type("torchANN"); provide(f_cvc_periodic); @@ -213,7 +213,7 @@ void colvar::torchANN::apply_force(colvarvalue const &force) { #else -colvar::torchANN::torchANN() +colvar::torchANN::torchANN(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("torchANN"); } diff --git a/src/colvarcomp_torchann.h b/src/colvarcomp_torchann.h index ae241edbc..839ec93cd 100644 --- a/src/colvarcomp_torchann.h +++ b/src/colvarcomp_torchann.h @@ -39,7 +39,7 @@ class colvar::torchANN // record the initial index of of sub-cvcs in input_tensor std::vector cvc_indices; public: - torchANN(); + torchANN(colvarmodule* cvmodule_in); virtual ~torchANN(); virtual int init(std::string const &conf); virtual void calc_value(); @@ -53,7 +53,7 @@ class colvar::torchANN : public colvar::cvc { public: - torchANN(); + torchANN(colvarmodule* cvmodule_in); virtual ~torchANN(); virtual int init(std::string const &conf); virtual void calc_value(); diff --git a/src/colvarcomp_volmaps.cpp b/src/colvarcomp_volmaps.cpp index 66fa7fa1b..f9094d6e9 100644 --- a/src/colvarcomp_volmaps.cpp +++ b/src/colvarcomp_volmaps.cpp @@ -14,7 +14,7 @@ -colvar::map_total::map_total() +colvar::map_total::map_total(colvarmodule* cvmodule_in): colvar::cvc(cvmodule_in) { set_function_type("mapTotal"); x.type(colvarvalue::type_scalar); diff --git a/src/colvardeps.cpp b/src/colvardeps.cpp index afdf561a9..650b67946 100644 --- a/src/colvardeps.cpp +++ b/src/colvardeps.cpp @@ -13,12 +13,6 @@ #include "colvardeps.h" -// This constructor depends on a static cvm pointer and is deprecated -colvardeps::colvardeps() - : colvarparse(cvm::main()) -{} - - colvardeps::colvardeps(colvarmodule *cvmodulein) : colvarparse(cvmodulein) {} diff --git a/src/colvardeps.h b/src/colvardeps.h index 113e97edb..45ea11c9d 100644 --- a/src/colvardeps.h +++ b/src/colvardeps.h @@ -34,7 +34,7 @@ class colvardeps : public colvarparse { public: - colvardeps (); + // colvardeps (); colvardeps(colvarmodule *cvmodule_in); virtual ~colvardeps(); diff --git a/src/colvargrid.cpp b/src/colvargrid.cpp index 00c573521..beb1bc2dd 100644 --- a/src/colvargrid.cpp +++ b/src/colvargrid.cpp @@ -18,20 +18,22 @@ -colvar_grid_count::colvar_grid_count() - : colvar_grid() +colvar_grid_count::colvar_grid_count(colvarmodule* cvmodule_in) + : colvar_grid(cvmodule_in) { mult = 1; } -colvar_grid_count::colvar_grid_count(std::vector &colvars, +colvar_grid_count::colvar_grid_count(colvarmodule* cvmodule_in, + std::vector &colvars, std::string config) - : colvar_grid(colvars, 0, 1, false, nullptr, config) + : colvar_grid(cvmodule_in, colvars, 0, 1, false, nullptr, config) {} -colvar_grid_count::colvar_grid_count(std::vector &colvars, +colvar_grid_count::colvar_grid_count(colvarmodule* cvmodule_in, + std::vector &colvars, std::shared_ptr params) - : colvar_grid(colvars, 0, 1, false, params) + : colvar_grid(cvmodule_in, colvars, 0, 1, false, params) {} std::string colvar_grid_count::get_state_params() const @@ -122,25 +124,26 @@ int colvar_grid_count::write_opendx(std::string const &filename, -colvar_grid_scalar::colvar_grid_scalar() - : colvar_grid(), samples(NULL) +colvar_grid_scalar::colvar_grid_scalar(colvarmodule* cvmodule_in) + : colvar_grid(cvmodule_in), samples(NULL) {} -colvar_grid_scalar::colvar_grid_scalar(colvar_grid_scalar const &g) +colvar_grid_scalar::colvar_grid_scalar(colvarmodule* cvmodule_in, colvar_grid_scalar const &g) : colvar_grid(g), samples(NULL) { } -colvar_grid_scalar::colvar_grid_scalar(std::vector &colvars, +colvar_grid_scalar::colvar_grid_scalar(colvarmodule* cvmodule_in, + std::vector &colvars, std::shared_ptr params, bool add_extra_bin, std::string config) - : colvar_grid(colvars, 0.0, 1, add_extra_bin, params, config), samples(NULL) + : colvar_grid(cvmodule_in, colvars, 0.0, 1, add_extra_bin, params, config), samples(NULL) { } -colvar_grid_scalar::colvar_grid_scalar(std::string const &filename) - : colvar_grid(filename, 1), +colvar_grid_scalar::colvar_grid_scalar(colvarmodule* cvmodule_in, std::string const &filename) + : colvar_grid(cvmodule_in, filename, 1), samples(nullptr) { } @@ -332,8 +335,8 @@ cvm::real colvar_grid_scalar::grid_rmsd(colvar_grid_scalar const &other_grid) co } -colvar_grid_gradient::colvar_grid_gradient() - : colvar_grid(), samples(NULL) +colvar_grid_gradient::colvar_grid_gradient(colvarmodule* cvmodule_in) + : colvar_grid(cvmodule_in), samples(NULL) {} @@ -349,19 +352,20 @@ colvar_grid_gradient::colvar_grid_gradient() // samples_in->has_parent_data = true; // } -colvar_grid_gradient::colvar_grid_gradient(std::vector &colvars, +colvar_grid_gradient::colvar_grid_gradient(colvarmodule* cvmodule_in, + std::vector &colvars, std::shared_ptr samples_in, std::shared_ptr params, std::string config) - : colvar_grid(colvars, 0.0, colvars.size(), false, params, config), samples(samples_in) + : colvar_grid(cvmodule_in, colvars, 0.0, colvars.size(), false, params, config), samples(samples_in) { if (samples_in) samples_in->has_parent_data = true; } -colvar_grid_gradient::colvar_grid_gradient(std::string const &filename) - : colvar_grid(filename, 0), +colvar_grid_gradient::colvar_grid_gradient(colvarmodule* cvmodule_in, std::string const &filename) + : colvar_grid(cvmodule_in, filename, 0), samples(nullptr) { } diff --git a/src/colvargrid.h b/src/colvargrid.h index 07e1a35db..257e198bb 100644 --- a/src/colvargrid.h +++ b/src/colvargrid.h @@ -211,7 +211,7 @@ template class colvar_grid : public colvar_grid_params, public colvarp /// Default constructor // This constructor depends on a static cvm pointer and is deprecated - colvar_grid() : colvarparse(cvm::main()), has_data(false) + colvar_grid(colvarmodule* cvmodule_in) : colvarparse(cvmodule_in), has_data(false) { nd = nt = 0; mult = 1; @@ -227,27 +227,29 @@ template class colvar_grid : public colvar_grid_params, public colvarp /// parameters from another grid, but doesn't reallocate stuff; /// setup() must be called after that; // This constructor depends on a static cvm pointer and is deprecated - colvar_grid(colvar_grid const &g) : colvar_grid_params(colvar_grid_params(g)), - colvarparse(cvm::main()), - mult(g.mult), - data(), - cv(g.cv), - use_actual_value(g.use_actual_value), - periodic(g.periodic), - hard_lower_boundaries(g.hard_lower_boundaries), - hard_upper_boundaries(g.hard_upper_boundaries), - has_parent_data(false), - has_data(false) + colvar_grid(colvarmodule* cvmodule_in, colvar_grid const &g) : + colvar_grid_params(colvar_grid_params(g)), + colvarparse(cvmodule_in), + mult(g.mult), + data(), + cv(g.cv), + use_actual_value(g.use_actual_value), + periodic(g.periodic), + hard_lower_boundaries(g.hard_lower_boundaries), + hard_upper_boundaries(g.hard_upper_boundaries), + has_parent_data(false), + has_data(false) {} /// \brief Constructor from explicit grid sizes \param nx_i Number /// of grid points along each dimension \param t Initial value for /// the function at each point (optional) \param mult_i Multiplicity /// of each value - colvar_grid(std::vector const &nx_i, + colvar_grid(colvarmodule* cvmodule_in, + std::vector const &nx_i, T const &t = T(), size_t mult_i = 1) - : colvarparse(cvm::main()), has_parent_data(false), has_data(false) + : colvarparse(cvmodule_in), has_parent_data(false), has_data(false) { this->setup(nx_i, t, mult_i); } @@ -255,13 +257,14 @@ template class colvar_grid : public colvar_grid_params, public colvarp /// \brief Constructor from a vector of colvars or an optional grid config string /// \param add_extra_bin requests that non-periodic dimensions are extended /// by 1 bin to accommodate the integral (PMF) of another gridded quantity (gradient) - colvar_grid(std::vector const &colvars, + colvar_grid(colvarmodule* cvmodule_in, + std::vector const &colvars, T const &t = T(), size_t mult_i = 1, bool add_extra_bin = false, std::shared_ptr params = nullptr, std::string config = std::string()) - : colvarparse(cvm::main()), has_parent_data(false), has_data(false) + : colvarparse(cvmodule_in), has_parent_data(false), has_data(false) { (void) t; this->init_from_colvars(colvars, mult_i, add_extra_bin, params, config); @@ -270,7 +273,7 @@ template class colvar_grid : public colvar_grid_params, public colvarp /// \brief Constructor from a multicol file /// \param filename multicol file containing data to be read /// \param multi_i multiplicity of the data - if 0, assume gradient multiplicity (mult = nd) - colvar_grid(std::string const &filename, size_t mult_i = 1); + colvar_grid(colvarmodule* cvmodule_in, std::string const &filename, size_t mult_i = 1); int init_from_colvars(std::vector const &colvars, size_t mult_i = 1, @@ -1015,17 +1018,19 @@ class colvar_grid_count : public colvar_grid public: /// Default constructor - colvar_grid_count(); + colvar_grid_count(colvarmodule* cvmodule_in); /// Destructor virtual ~colvar_grid_count() {} /// Constructor from a vector of colvars or a config string - colvar_grid_count(std::vector &colvars, + colvar_grid_count(colvarmodule* cvmodule_in, + std::vector &colvars, std::shared_ptr params = nullptr); - colvar_grid_count(std::vector &colvars, + colvar_grid_count(colvarmodule* cvmodule_in, + std::vector &colvars, std::string config); /// Increment the counter at given position @@ -1300,22 +1305,23 @@ class colvar_grid_scalar : public colvar_grid colvar_grid_count *samples; /// Default constructor - colvar_grid_scalar(); + colvar_grid_scalar(colvarmodule* cvmodule_in); /// Copy constructor (needed because of the grad pointer) - colvar_grid_scalar(colvar_grid_scalar const &g); + colvar_grid_scalar(colvarmodule* cvmodule_in, colvar_grid_scalar const &g); /// Destructor virtual ~colvar_grid_scalar(); /// Constructor from a vector of colvars - colvar_grid_scalar(std::vector &colvars, + colvar_grid_scalar(colvarmodule* cvmodule_in, + std::vector &colvars, std::shared_ptr params = nullptr, bool add_extra_bin = false, std::string config = std::string()); /// Constructor from a multicol file - colvar_grid_scalar(std::string const &filename); + colvar_grid_scalar(colvarmodule* cvmodule_in, std::string const &filename); /// Accumulate the value inline void acc_value(std::vector const &ix, @@ -1615,7 +1621,7 @@ class colvar_grid_gradient : public colvar_grid std::shared_ptr samples; /// Default constructor - colvar_grid_gradient(); + colvar_grid_gradient(colvarmodule* cvmodule_in); /// Destructor virtual ~colvar_grid_gradient() @@ -1629,10 +1635,11 @@ class colvar_grid_gradient : public colvar_grid // std::string config = std::string()); /// Constructor from a multicol file - colvar_grid_gradient(std::string const &filename); + colvar_grid_gradient(colvarmodule* cvmodule_in, std::string const &filename); /// Constructor from a vector of colvars and a pointer to the count grid - colvar_grid_gradient(std::vector &colvars, + colvar_grid_gradient(colvarmodule* cvmodule_in, + std::vector &colvars, std::shared_ptr samples_in = nullptr, std::shared_ptr params = nullptr, std::string config = std::string()); diff --git a/src/colvargrid_def.h b/src/colvargrid_def.h index 24e025d94..caca3df92 100644 --- a/src/colvargrid_def.h +++ b/src/colvargrid_def.h @@ -23,35 +23,20 @@ template -colvar_grid::colvar_grid(std::string const &filename, size_t mult_i) - : colvarparse(cvm::main()) +colvar_grid::colvar_grid(colvarmodule* cvmodule_in, std::string const &filename, size_t mult_i) + : colvarparse(cvmodule_in) { -std::istream &is = cvm::main()->proxy->input_stream(filename, "multicol grid file"); -if (!is) { - return; -} - -// Data in the header: nColvars, then for each -// xiMin, dXi, nPoints, periodic flag - -std::string hash; -size_t i; - -if ( !(is >> hash) || (hash != "#") ) { - cvmodule->error("Error reading grid at position "+ - cvm::to_str(static_cast(is.tellg()))+ - " in stream(read \"" + hash + "\")\n"); - return; -} + std::istream &is = cvmodule_in->proxy->input_stream(filename, "multicol grid file"); + if (!is) { + return; + } -is >> nd; -mult = (mult_i == 0) ? nd : mult_i; + // Data in the header: nColvars, then for each + // xiMin, dXi, nPoints, periodic flag -std::vector lower_in(nd), widths_in(nd); -std::vector nx_in(nd); -std::vector periodic_in(nd); + std::string hash; + size_t i; -for (i = 0; i < nd; i++ ) { if ( !(is >> hash) || (hash != "#") ) { cvmodule->error("Error reading grid at position "+ cvm::to_str(static_cast(is.tellg()))+ @@ -59,23 +44,38 @@ for (i = 0; i < nd; i++ ) { return; } - is >> lower_in[i] >> widths_in[i] >> nx_in[i] >> periodic_in[i]; -} + is >> nd; + mult = (mult_i == 0) ? nd : mult_i; -this->setup(nx_in, 0., mult); + std::vector lower_in(nd), widths_in(nd); + std::vector nx_in(nd); + std::vector periodic_in(nd); -widths = widths_in; + for (i = 0; i < nd; i++ ) { + if ( !(is >> hash) || (hash != "#") ) { + cvmodule->error("Error reading grid at position "+ + cvm::to_str(static_cast(is.tellg()))+ + " in stream(read \"" + hash + "\")\n"); + return; + } -for (i = 0; i < nd; i++ ) { - lower_boundaries.push_back(colvarvalue(lower_in[i])); - periodic.push_back(static_cast(periodic_in[i])); -} + is >> lower_in[i] >> widths_in[i] >> nx_in[i] >> periodic_in[i]; + } -// Reset the istream for read_multicol, which expects the whole file -is.clear(); -is.seekg(0); -read_multicol(is); -cvm::main()->proxy->close_input_stream(filename); + this->setup(nx_in, 0., mult); + + widths = widths_in; + + for (i = 0; i < nd; i++ ) { + lower_boundaries.push_back(colvarvalue(lower_in[i])); + periodic.push_back(static_cast(periodic_in[i])); + } + + // Reset the istream for read_multicol, which expects the whole file + is.clear(); + is.seekg(0); + read_multicol(is); + cvmodule->proxy->close_input_stream(filename); } @@ -414,12 +414,12 @@ int colvar_grid::read_multicol(std::string const &filename, std::string description, bool add) { - std::istream &is = cvm::main()->proxy->input_stream(filename, description); + std::istream &is = cvmodule->proxy->input_stream(filename, description); if (!is) { return COLVARS_FILE_ERROR; } if (colvar_grid::read_multicol(is, add)) { - cvm::main()->proxy->close_input_stream(filename); + cvmodule->proxy->close_input_stream(filename); return COLVARS_OK; } return COLVARS_FILE_ERROR; @@ -479,13 +479,13 @@ int colvar_grid::write_multicol(std::string const &filename, std::string description) const { int error_code = COLVARS_OK; - std::ostream &os = cvm::main()->proxy->output_stream(filename, description); + std::ostream &os = cvmodule->proxy->output_stream(filename, description); if (!os) { return COLVARS_FILE_ERROR; } error_code |= colvar_grid::write_multicol(os) ? COLVARS_OK : COLVARS_FILE_ERROR; - cvm::main()->proxy->close_output_stream(filename); + cvmodule->proxy->close_output_stream(filename); return error_code; } @@ -537,13 +537,13 @@ int colvar_grid::write_opendx(std::string const &filename, std::string description) const { int error_code = COLVARS_OK; - std::ostream &os = cvm::main()->proxy->output_stream(filename, description); + std::ostream &os = cvmodule->proxy->output_stream(filename, description); if (!os) { return COLVARS_FILE_ERROR; } error_code |= colvar_grid::write_opendx(os) ? COLVARS_OK : COLVARS_FILE_ERROR; - cvm::main()->proxy->close_output_stream(filename); + cvmodule->proxy->close_output_stream(filename); return error_code; } diff --git a/src/colvargrid_integrate.cpp b/src/colvargrid_integrate.cpp index b85c8cbf8..ee1711d35 100644 --- a/src/colvargrid_integrate.cpp +++ b/src/colvargrid_integrate.cpp @@ -3,9 +3,9 @@ #include -colvargrid_integrate::colvargrid_integrate(std::vector &colvars, +colvargrid_integrate::colvargrid_integrate(colvarmodule* cvmodule_in, std::vector &colvars, std::shared_ptr gradients) - : colvar_grid_scalar(colvars, gradients, true), + : colvar_grid_scalar(cvmodule_in, colvars, gradients, true), b_smoothed(false), gradients(gradients) { @@ -35,8 +35,9 @@ colvargrid_integrate::colvargrid_integrate(std::vector &colvars, } -colvargrid_integrate::colvargrid_integrate(std::shared_ptr gradients) - : b_smoothed(false), +colvargrid_integrate::colvargrid_integrate(colvarmodule* cvmodule_in, std::shared_ptr gradients) + : colvar_grid_scalar(cvmodule_in), + b_smoothed(false), gradients(gradients) { nd = gradients->num_variables(); diff --git a/src/colvargrid_integrate.h b/src/colvargrid_integrate.h index 52b0001b6..a9a77a703 100644 --- a/src/colvargrid_integrate.h +++ b/src/colvargrid_integrate.h @@ -9,17 +9,19 @@ class colvargrid_integrate : public colvar_grid_scalar { public: - colvargrid_integrate(); + colvargrid_integrate(colvarmodule* cvmodule_in); virtual ~colvargrid_integrate() {} /// Constructor from a vector of colvars + gradient grid - colvargrid_integrate(std::vector &colvars, - std::shared_ptr gradients); + colvargrid_integrate(colvarmodule* cvmodule_in, + std::vector &colvars, + std::shared_ptr gradients); /// Constructor from a gradient grid (for processing grid files without a Colvars config) - colvargrid_integrate(std::shared_ptr gradients); + colvargrid_integrate(colvarmodule* cvmodule_in, + std::shared_ptr gradients); /// \brief Calculate potential from divergence (in 2D); return number of steps int integrate(const int itmax, const cvm::real & tol, cvm::real & err, bool verbose = true); diff --git a/src/colvarscript.cpp b/src/colvarscript.cpp index ae5155cd8..28b319bc2 100644 --- a/src/colvarscript.cpp +++ b/src/colvarscript.cpp @@ -616,8 +616,10 @@ int colvarscript::clear_str_result() extern "C" -int run_colvarscript_command(colvarscript *script, int objc, unsigned char *const objv[]) +int run_colvarscript_command(void* proxy_in, int objc, unsigned char *const objv[]) { + colvarproxy* proxy = (colvarproxy*)proxy_in; + colvarscript* script = proxy->script; if (!script) { cvm::error_static("Called run_colvarscript_command without a script object.\n", COLVARS_BUG_ERROR); @@ -629,9 +631,10 @@ int run_colvarscript_command(colvarscript *script, int objc, unsigned char *cons extern "C" -const char * get_colvarscript_result() +const char * get_colvarscript_result(void* proxy_in) { - colvarscript *script = colvarscript_obj(); + colvarproxy* proxy = (colvarproxy*)proxy_in; + colvarscript* script = proxy->script; if (!script) { cvm::error_static("Called get_colvarscript_result without a script object.\n"); return NULL; diff --git a/src/colvarscript.h b/src/colvarscript.h index 80b24520c..456c50bc2 100644 --- a/src/colvarscript.h +++ b/src/colvarscript.h @@ -343,11 +343,6 @@ inline static colvarscript *colvarscript_obj(void *pobj) return reinterpret_cast(pobj); } -/// Get a pointer to the main colvarscript object -inline static colvarscript *colvarscript_obj() -{ - return cvm::main()->proxy->script; -} /// Get a pointer to the colvar object pointed to by pobj inline static colvar *colvar_obj(void *pobj) @@ -466,10 +461,10 @@ extern "C" { /// Generic wrapper for string-based scripting // New: requires pointer to colvarscript object - TODO - pass it in ctypes Python example - int run_colvarscript_command(colvarscript *script, int objc, unsigned char *const objv[]); + int run_colvarscript_command(void *proxy_in, int objc, unsigned char *const objv[]); /// Get the string result of a script call - const char * get_colvarscript_result(); + const char * get_colvarscript_result(void *proxy_in); } diff --git a/src/colvarscript_commands.cpp b/src/colvarscript_commands.cpp index 10900561c..2adecebea 100644 --- a/src/colvarscript_commands.cpp +++ b/src/colvarscript_commands.cpp @@ -26,58 +26,93 @@ int cvscript_n_commands() extern "C" -char const **cvscript_command_names() +char const **cvscript_command_names(void *proxy_in) { - colvarscript *script = colvarscript_obj(); - return script->get_command_names(); + colvarproxy* proxy = (colvarproxy*)proxy_in; + if (proxy) { + if (proxy->script) { + return proxy->script->get_command_names(); + } + } + return nullptr; } extern "C" -char const *cvscript_command_help(char const *c) +char const *cvscript_command_help(void *proxy_in, char const *c) { - colvarscript *script = colvarscript_obj(); - return script->get_command_help(c); + colvarproxy* proxy = (colvarproxy*)proxy_in; + if (proxy) { + if (proxy->script) { + return proxy->script->get_command_help(c); + } + } + return nullptr; } extern "C" -char const *cvscript_command_rethelp(char const *c) +char const *cvscript_command_rethelp(void *proxy_in, char const *c) { - colvarscript *script = colvarscript_obj(); - return script->get_command_rethelp(c); + colvarproxy* proxy = (colvarproxy*)proxy_in; + if (proxy) { + if (proxy->script) { + return proxy->script->get_command_rethelp(c); + } + } + return nullptr; } extern "C" -char const *cvscript_command_arghelp(char const *c, int i) +char const *cvscript_command_arghelp(void *proxy_in, char const *c, int i) { - colvarscript *script = colvarscript_obj(); - return script->get_command_arghelp(c, i); + colvarproxy* proxy = (colvarproxy*)proxy_in; + if (proxy) { + if (proxy->script) { + return proxy->script->get_command_arghelp(c, i); + } + } + return nullptr; } extern "C" -char const *cvscript_command_full_help(char const *c) +char const *cvscript_command_full_help(void *proxy_in, char const *c) { - colvarscript *script = colvarscript_obj(); - return script->get_command_full_help(c); + colvarproxy* proxy = (colvarproxy*)proxy_in; + if (proxy) { + if (proxy->script) { + return proxy->script->get_command_full_help(c); + } + } + return nullptr; } extern "C" -int cvscript_command_n_args_min(char const *c) +int cvscript_command_n_args_min(void *proxy_in, char const *c) { - colvarscript *script = colvarscript_obj(); - return script->get_command_n_args_min(c); + colvarproxy* proxy = (colvarproxy*)proxy_in; + if (proxy) { + if (proxy->script) { + return proxy->script->get_command_n_args_min(c); + } + } + return -1; } extern "C" -int cvscript_command_n_args_max(char const *c) +int cvscript_command_n_args_max(void *proxy_in, char const *c) { - colvarscript *script = colvarscript_obj(); - return script->get_command_n_args_max(c); + colvarproxy* proxy = (colvarproxy*)proxy_in; + if (proxy) { + if (proxy->script) { + return proxy->script->get_command_n_args_max(c); + } + } + return -1; } diff --git a/src/colvarscript_commands.h b/src/colvarscript_commands.h index 9db6c903b..f6f39946e 100644 --- a/src/colvarscript_commands.h +++ b/src/colvarscript_commands.h @@ -63,34 +63,34 @@ extern "C" { int cvscript_n_commands(); /// Get the names of all commands (array of strings) - char const ** cvscript_command_names(); + char const ** cvscript_command_names(void *proxy_in); /// Get the help summary of the given command /// \param cmd Name of the command's function (e.g. "cv_units") - char const *cvscript_command_help(char const *cmd); + char const *cvscript_command_help(void *proxy_in, char const *cmd); /// Get description of the return value of a command /// \param cmd Name of the command's function (e.g. "cv_units") - char const *cvscript_command_rethelp(char const *cmd); + char const *cvscript_command_rethelp(void *proxy_in, char const *cmd); /// Get description of the arguments of a command (excluding prefix) /// \param cmd Name of the command's function (e.g. "cv_units") /// \param i Index of the argument; 0 is the first argument after the /// prefix, e.g. "value" has an index of 0 in the array of arguments: /// { "cv", "colvar", "xi", "value" } - char const *cvscript_command_arghelp(char const *cmd, int i); + char const *cvscript_command_arghelp(void *proxy_in, char const *cmd, int i); /// Get the full help string of a command /// \param cmd Name of the command's function (e.g. "cv_units") - char const *cvscript_command_full_help(char const *cmd); + char const *cvscript_command_full_help(void *proxy_in, char const *cmd); /// Get number of required arguments (excluding prefix) /// \param cmd Name of the command's function (e.g. "cv_units") - int cvscript_command_n_args_min(char const *cmd); + int cvscript_command_n_args_min(void *proxy_in, char const *cmd); /// Get number of total arguments (excluding prefix) /// \param cmd Name of the command's function (e.g. "cv_units") - int cvscript_command_n_args_max(char const *cmd); + int cvscript_command_n_args_max(void *proxy_in, char const *cmd); } @@ -439,7 +439,7 @@ CVSCRIPT(cv_listcommands, 0, 0, "", int const n_commands = cvscript_n_commands(); - char const **command_names = cvscript_command_names(); + char const **command_names = cvscript_command_names(cvmodule->proxy); std::string result; for (int i = 0; i < n_commands; i++) { if (i > 0) result.append(1, ' '); diff --git a/src/colvartypes.cpp b/src/colvartypes.cpp index da7c66bcd..676d99081 100644 --- a/src/colvartypes.cpp +++ b/src/colvartypes.cpp @@ -31,7 +31,7 @@ std::string cvm::rvector::to_simple_string() const { std::ostringstream os; os.setf(std::ios::scientific, std::ios::floatfield); - os.precision(cvm::main()->cv_prec); + os.precision(cvm::cv_prec); os << x << " " << y << " " << z; return os.str(); } @@ -86,7 +86,7 @@ std::string cvm::quaternion::to_simple_string() const { std::ostringstream os; os.setf(std::ios::scientific, std::ios::floatfield); - os.precision(cvm::main()->cv_prec); + os.precision(cvm::cv_prec); os << q0 << " " << q1 << " " << q2 << " " << q3; return os.str(); } @@ -306,21 +306,21 @@ void colvarmodule::rotation::debug_gradients( cvm::quaternion const Q2(rot.S_eigvec[2]); cvm::quaternion const Q3(rot.S_eigvec[3]); - cvm::log_static("L0 = "+cvm::to_str(L0, cvm::main()->cv_width, cvm::main()->cv_prec)+ - ", Q0 = "+cvm::to_str(Q0, cvm::main()->cv_width, cvm::main()->cv_prec)+ - ", Q0*Q0 = "+cvm::to_str(Q0.inner(Q0), cvm::main()->cv_width, cvm::main()->cv_prec)+ + cvm::log_static("L0 = "+cvm::to_str(L0, cvm::cv_width, cvm::cv_prec)+ + ", Q0 = "+cvm::to_str(Q0, cvm::cv_width, cvm::cv_prec)+ + ", Q0*Q0 = "+cvm::to_str(Q0.inner(Q0), cvm::cv_width, cvm::cv_prec)+ "\n"); - cvm::log_static("L1 = "+cvm::to_str(L1, cvm::main()->cv_width, cvm::main()->cv_prec)+ - ", Q1 = "+cvm::to_str(Q1, cvm::main()->cv_width, cvm::main()->cv_prec)+ - ", Q0*Q1 = "+cvm::to_str(Q0.inner(Q1), cvm::main()->cv_width, cvm::main()->cv_prec)+ + cvm::log_static("L1 = "+cvm::to_str(L1, cvm::cv_width, cvm::cv_prec)+ + ", Q1 = "+cvm::to_str(Q1, cvm::cv_width, cvm::cv_prec)+ + ", Q0*Q1 = "+cvm::to_str(Q0.inner(Q1), cvm::cv_width, cvm::cv_prec)+ "\n"); - cvm::log_static("L2 = "+cvm::to_str(L2, cvm::main()->cv_width, cvm::main()->cv_prec)+ - ", Q2 = "+cvm::to_str(Q2, cvm::main()->cv_width, cvm::main()->cv_prec)+ - ", Q0*Q2 = "+cvm::to_str(Q0.inner(Q2), cvm::main()->cv_width, cvm::main()->cv_prec)+ + cvm::log_static("L2 = "+cvm::to_str(L2, cvm::cv_width, cvm::cv_prec)+ + ", Q2 = "+cvm::to_str(Q2, cvm::cv_width, cvm::cv_prec)+ + ", Q0*Q2 = "+cvm::to_str(Q0.inner(Q2), cvm::cv_width, cvm::cv_prec)+ "\n"); - cvm::log_static("L3 = "+cvm::to_str(L3, cvm::main()->cv_width, cvm::main()->cv_prec)+ - ", Q3 = "+cvm::to_str(Q3, cvm::main()->cv_width, cvm::main()->cv_prec)+ - ", Q0*Q3 = "+cvm::to_str(Q0.inner(Q3), cvm::main()->cv_width, cvm::main()->cv_prec)+ + cvm::log_static("L3 = "+cvm::to_str(L3, cvm::cv_width, cvm::cv_prec)+ + ", Q3 = "+cvm::to_str(Q3, cvm::cv_width, cvm::cv_prec)+ + ", Q0*Q3 = "+cvm::to_str(Q0.inner(Q3), cvm::cv_width, cvm::cv_prec)+ "\n"); rotation_derivative deriv(rot, pos1, pos2, num_atoms_pos1, num_atoms_pos2); cvm::rvector dl0_2; @@ -368,9 +368,9 @@ void colvarmodule::rotation::debug_gradients( dq0_2[3][comp] * colvarmodule::debug_gradients_step_size); cvm::log_static( "|(l_0+dl_0) - l_0^new|/l_0 = "+ - cvm::to_str(cvm::fabs(L0+DL0 - L0_new)/L0, cvm::main()->cv_width, cvm::main()->cv_prec)+ + cvm::to_str(cvm::fabs(L0+DL0 - L0_new)/L0, cvm::cv_width, cvm::cv_prec)+ ", |(q_0+dq_0) - q_0^new| = "+ - cvm::to_str((Q0+DQ0 - Q0_new).norm(), cvm::main()->cv_width, cvm::main()->cv_prec)+ + cvm::to_str((Q0+DQ0 - Q0_new).norm(), cvm::cv_width, cvm::cv_prec)+ "\n"); } } @@ -441,7 +441,7 @@ void colvarmodule::rotation::calc_optimal_rotation_impl() { S_backup_out[i][j] = S_backup[i][j]; } } - cvm::log_static("S = "+cvm::to_str(S_backup_out, cvm::main()->cv_width, cvm::main()->cv_prec)+"\n"); + cvm::log_static("S = "+cvm::to_str(S_backup_out, cvm::cv_width, cvm::cv_prec)+"\n"); } @@ -497,30 +497,36 @@ rotation_gpu::rotation_gpu(): discontinuous_rotation(nullptr), max_iteration_reached(nullptr), b_initialized(false), h_C(nullptr), h_S(nullptr), h_S_eigval(nullptr), - h_S_eigvec(nullptr) + h_S_eigvec(nullptr), cvmodule(nullptr) {} rotation_gpu::~rotation_gpu() { - colvarproxy* p = cvm::main()->proxy; - p->deallocate_device(&d_S); - p->deallocate_device(&d_S_eigval); - p->deallocate_device(&d_S_eigvec); - p->deallocate_device(&tbcount); - p->deallocate_device(&d_q); - p->deallocate_device(&d_q_old); - p->deallocate_host(&discontinuous_rotation); - p->deallocate_host(&max_iteration_reached); - p->deallocate_host(&h_C); - p->deallocate_host(&h_S); - p->deallocate_host(&h_S_eigval); - p->deallocate_host(&h_S_eigvec); - b_initialized = false; + if (cvmodule) { + colvarproxy* p = cvmodule->proxy; + p->deallocate_device(&d_S); + p->deallocate_device(&d_S_eigval); + p->deallocate_device(&d_S_eigvec); + p->deallocate_device(&tbcount); + p->deallocate_device(&d_q); + p->deallocate_device(&d_q_old); + p->deallocate_host(&discontinuous_rotation); + p->deallocate_host(&max_iteration_reached); + p->deallocate_host(&h_C); + p->deallocate_host(&h_S); + p->deallocate_host(&h_S_eigval); + p->deallocate_host(&h_S_eigvec); + b_initialized = false; + } } -int rotation_gpu::init(/*const cudaStream_t& stream_in*/) { +int rotation_gpu::init(colvarmodule* cvmodule_in/*const cudaStream_t& stream_in*/) { int error_code = COLVARS_OK; // stream = stream_in; - colvarproxy* p = cvm::main()->proxy; + cvmodule = cvmodule_in; + if (cvmodule == nullptr) { + return cvm::error_static("cvmodule is NULL.\n", COLVARS_ERROR); + } + colvarproxy* p = cvmodule->proxy; if (!b_initialized) { error_code |= p->allocate_device(&d_S, 4 * 4); error_code |= p->allocate_device(&d_S_eigval, 4); @@ -540,7 +546,7 @@ int rotation_gpu::init(/*const cudaStream_t& stream_in*/) { if (colvarmodule::rotation::monitor_crossings) { error_code |= p->clear_device_array(&d_q_old, 1); } - cvm::main()->cite_feature("Optimal rotation via flexible fitting"); + cvmodule->cite_feature("Optimal rotation via flexible fitting"); b_initialized = true; } return error_code; @@ -616,14 +622,14 @@ int rotation_gpu::add_optimal_rotation_nodes( void rotation_gpu::after_sync_check() const { if (max_iteration_reached[0]) { - cvm::error_static("Too many iterations in jacobi diagonalization.\n" + cvmodule->error("Too many iterations in jacobi diagonalization.\n" "This is usually the result of an ill-defined set of atoms for " "rotational alignment (RMSD, rotateReference, etc).\n"); max_iteration_reached[0] = 0; } if (colvarmodule::rotation::monitor_crossings) { if (discontinuous_rotation[0]) { - cvm::main()->log("Warning: one molecular orientation has changed by more than "+ + cvmodule->log("Warning: one molecular orientation has changed by more than "+ cvm::to_str(colvarmodule::rotation::crossing_threshold)+ ": discontinuous rotation ?\n"); } diff --git a/src/colvartypes.h b/src/colvartypes.h index def572d89..b7c6e0361 100644 --- a/src/colvartypes.h +++ b/src/colvartypes.h @@ -1613,6 +1613,8 @@ class rotation_gpu { cvm::real* h_S; cvm::real* h_S_eigval; cvm::real* h_S_eigvec; + /// \brief Colvar module object for debugging and logging + colvarmodule* cvmodule; public: /// Constructor rotation_gpu(); @@ -1621,7 +1623,7 @@ class rotation_gpu { /// Check if the object is initialized bool initialized() const {return b_initialized;} /// Initialize member data - int init(/*const cudaStream_t& stream_in*/); + int init(colvarmodule* cvmodule_in/*const cudaStream_t& stream_in*/); /// \brief Calculate the optimal rotation and store the /// corresponding eigenvalue and eigenvector in the arguments l0 and /// q0; if the gradients have been previously requested, calculate diff --git a/src/colvarvalue.cpp b/src/colvarvalue.cpp index 3801859da..b28ef41d5 100644 --- a/src/colvarvalue.cpp +++ b/src/colvarvalue.cpp @@ -349,30 +349,30 @@ void colvarvalue::set_elem(int const icv, colvarvalue const &x) } -void colvarvalue::set_random() +void colvarvalue::set_random(colvarmodule* cvmodule) { size_t ic; switch (this->type()) { case colvarvalue::type_scalar: - this->real_value = cvm::main()->rand_gaussian(); + this->real_value = cvmodule->rand_gaussian(); break; case colvarvalue::type_3vector: case colvarvalue::type_unit3vector: case colvarvalue::type_unit3vectorderiv: - this->rvector_value.x = cvm::main()->rand_gaussian(); - this->rvector_value.y = cvm::main()->rand_gaussian(); - this->rvector_value.z = cvm::main()->rand_gaussian(); + this->rvector_value.x = cvmodule->rand_gaussian(); + this->rvector_value.y = cvmodule->rand_gaussian(); + this->rvector_value.z = cvmodule->rand_gaussian(); break; case colvarvalue::type_quaternion: case colvarvalue::type_quaternionderiv: - this->quaternion_value.q0 = cvm::main()->rand_gaussian(); - this->quaternion_value.q1 = cvm::main()->rand_gaussian(); - this->quaternion_value.q2 = cvm::main()->rand_gaussian(); - this->quaternion_value.q3 = cvm::main()->rand_gaussian(); + this->quaternion_value.q0 = cvmodule->rand_gaussian(); + this->quaternion_value.q1 = cvmodule->rand_gaussian(); + this->quaternion_value.q2 = cvmodule->rand_gaussian(); + this->quaternion_value.q3 = cvmodule->rand_gaussian(); break; case colvarvalue::type_vector: for (ic = 0; ic < this->vector1d_value.size(); ic++) { - this->vector1d_value[ic] = cvm::main()->rand_gaussian(); + this->vector1d_value[ic] = cvmodule->rand_gaussian(); } break; case colvarvalue::type_notset: @@ -745,7 +745,7 @@ std::string colvarvalue::to_simple_string() const { switch (type()) { case colvarvalue::type_scalar: - return cvm::to_str(real_value, 0, cvm::main()->cv_prec); + return cvm::to_str(real_value, 0, cvm::cv_prec); break; case colvarvalue::type_3vector: case colvarvalue::type_unit3vector: diff --git a/src/colvarvalue.h b/src/colvarvalue.h index bea7199a8..a88874ac3 100644 --- a/src/colvarvalue.h +++ b/src/colvarvalue.h @@ -277,7 +277,7 @@ class colvarvalue { void set_elem(int const i_begin, int const i_end, colvarvalue const &x); /// Make each element a random number in N(0,1) - void set_random(); + void set_random(colvarmodule* cvmodule); /// Make each element equal to the given argument void set_ones(cvm::real assigned_value = 1.0); diff --git a/tests/functional/run_colvars_test.cpp b/tests/functional/run_colvars_test.cpp index a95220ad6..6ceae891f 100644 --- a/tests/functional/run_colvars_test.cpp +++ b/tests/functional/run_colvars_test.cpp @@ -82,8 +82,8 @@ int main(int argc, char *argv[]) { unsigned char * args[2] = { (unsigned char *) "cv", (unsigned char *) "listinputfiles" }; - err |= run_colvarscript_command(proxy->script, 2, args); - cvmodule->log(" " + std::string(get_colvarscript_result())); + err |= run_colvarscript_command(proxy, 2, args); + cvmodule->log(" " + std::string(get_colvarscript_result(proxy))); double const max_gradient_error = proxy->cvmodule->get_max_gradient_error(); if (max_gradient_error > 0.) { diff --git a/tests/functional_gpu/run_colvars_test_cuda.cpp b/tests/functional_gpu/run_colvars_test_cuda.cpp index 6e3f3defe..c177872dd 100644 --- a/tests/functional_gpu/run_colvars_test_cuda.cpp +++ b/tests/functional_gpu/run_colvars_test_cuda.cpp @@ -343,8 +343,8 @@ int main(int argc, char *argv[]) { unsigned char * args[2] = { (unsigned char *) "cv", (unsigned char *) "listinputfiles" }; - err |= run_colvarscript_command(proxy->script, 2, args); - cvmodule->log(" " + std::string(get_colvarscript_result())); + err |= run_colvarscript_command(proxy, 2, args); + cvmodule->log(" " + std::string(get_colvarscript_result(proxy))); double const max_gradient_error = proxy->cvmodule->get_max_gradient_error(); if (max_gradient_error > 0.) {