Update Colvars to version 2018-12-18 73/4873/2
authorGiacomo Fiorin <giacomo.fiorin@gmail.com>
Thu, 20 Dec 2018 16:53:34 +0000 (11:53 -0500)
committerDavid Hardy <dhardy@ks.uiuc.edu>
Fri, 21 Dec 2018 00:14:41 +0000 (18:14 -0600)
Add dipoleMagnitude variable (contributed by Alejandro Bernardin):
https://github.com/Colvars/colvars/pull/198

Minor bugfix for #ifdef NAMD_TCL, triggered by a build without Tcl:
https://github.com/Colvars/colvars/commit/3f9fec9

Minor fixes to silence compiler warnings and cosmetic changes.

Change-Id: I7d5963e6d8d9b52a8f1c90994420c8057ee197af

12 files changed:
colvars/src/colvar.cpp
colvars/src/colvar.h
colvars/src/colvarcomp.h
colvars/src/colvarcomp_distances.cpp
colvars/src/colvarcomp_rotations.cpp
colvars/src/colvarproxy.cpp
colvars/src/colvarproxy.h
colvars/src/colvars_version.h
src/colvarproxy_namd.C
src/colvarproxy_namd.h
src/colvarproxy_namd_version.h
ug/ug_colvars.tex

index 8b28eaa..e3b0f85 100644 (file)
@@ -761,6 +761,8 @@ int colvar::init_components(std::string const &conf)
     "weighted by inverse power", "distanceInv");
   error_code |= init_components_type<distance_pairs>(conf, "N1xN2-long vector "
     "of pairwise distances", "distancePairs");
+  error_code |= init_components_type<dipole_magnitude>(conf, "dipole magnitude",
+    "dipoleMagnitude");
   error_code |= init_components_type<coordnum>(conf, "coordination "
     "number", "coordNum");
   error_code |= init_components_type<selfcoordnum>(conf, "self-coordination "
@@ -2190,6 +2192,7 @@ int colvar::calc_acf()
       acf_x_history_p = acf_x_history.begin();
       break;
 
+    case acf_notset:
     default:
       break;
     }
@@ -2222,6 +2225,7 @@ int colvar::calc_acf()
       history_incr(acf_x_history, acf_x_history_p);
       break;
 
+    case acf_notset:
     default:
       break;
     }
@@ -2316,6 +2320,9 @@ int colvar::write_acf(std::ostream &os)
   case acf_p2coor:
     os << "Coordinate (2nd Legendre poly)";
     break;
+  case acf_notset:
+  default:
+    break;
   }
 
   if (acf_colvar_name == name) {
index a67749d..fbf142b 100644 (file)
@@ -546,6 +546,7 @@ public:
   class polar_phi;
   class distance_inv;
   class distance_pairs;
+  class dipole_magnitude;
   class angle;
   class dipole_angle;
   class dihedral;
index 1a6df37..79e4719 100644 (file)
@@ -559,6 +559,35 @@ public:
 
 
 
+/// \brief Colvar component:  dipole magnitude of a molecule
+class colvar::dipole_magnitude
+  : public colvar::cvc
+{
+protected:
+  /// Dipole atom group
+  cvm::atom_group  *atoms;
+  cvm::atom_pos dipoleV;
+public:
+  /// Initialize by parsing the configuration
+  dipole_magnitude (std::string const &conf);
+  dipole_magnitude (cvm::atom const &a1);
+  dipole_magnitude();
+  virtual inline ~dipole_magnitude() {}
+  virtual void calc_value();
+  virtual void calc_gradients();
+  //virtual void calc_force_invgrads();
+  //virtual void calc_Jacobian_derivative();
+  virtual void apply_force (colvarvalue const &force);
+  virtual cvm::real dist2 (colvarvalue const &x1,
+                           colvarvalue const &x2) const;
+  virtual colvarvalue dist2_lgrad (colvarvalue const &x1,
+                                   colvarvalue const &x2) const;
+  virtual colvarvalue dist2_rgrad (colvarvalue const &x1,
+                                   colvarvalue const &x2) const;
+};
+
+
+
 /// \brief Colvar component: Radius of gyration of an atom group
 /// (colvarvalue::type_scalar type, range [0:*))
 class colvar::gyration
@@ -1159,6 +1188,7 @@ public:
 
   orientation(std::string const &conf);
   orientation();
+  virtual int init(std::string const &conf);
   virtual ~orientation() {}
   virtual void calc_value();
   virtual void calc_gradients();
@@ -1183,6 +1213,7 @@ public:
 
   orientation_angle(std::string const &conf);
   orientation_angle();
+  virtual int init(std::string const &conf);
   virtual ~orientation_angle() {}
   virtual void calc_value();
   virtual void calc_gradients();
@@ -1207,6 +1238,7 @@ public:
 
   orientation_proj(std::string const &conf);
   orientation_proj();
+  virtual int init(std::string const &conf);
   virtual ~orientation_proj() {}
   virtual void calc_value();
   virtual void calc_gradients();
@@ -1234,6 +1266,7 @@ public:
 
   tilt(std::string const &conf);
   tilt();
+  virtual int init(std::string const &conf);
   virtual ~tilt() {}
   virtual void calc_value();
   virtual void calc_gradients();
@@ -1261,6 +1294,7 @@ public:
 
   spin_angle(std::string const &conf);
   spin_angle();
+  virtual int init(std::string const &conf);
   virtual ~spin_angle() {}
   virtual void calc_value();
   virtual void calc_gradients();
index a2b1a5c..7c27519 100644 (file)
@@ -747,6 +747,63 @@ void colvar::distance_pairs::apply_force(colvarvalue const &force)
 
 
 
+colvar::dipole_magnitude::dipole_magnitude(std::string const &conf)
+  : cvc(conf)
+{
+  function_type = "dipole_magnitude";
+  atoms = parse_group(conf, "atoms");
+  init_total_force_params(conf);
+  x.type(colvarvalue::type_scalar);
+}
+
+colvar::dipole_magnitude::dipole_magnitude(cvm::atom const &a1)
+{
+  atoms = new cvm::atom_group(std::vector<cvm::atom>(1, a1));
+  register_atom_group(atoms);
+  x.type(colvarvalue::type_scalar);
+}
+
+
+colvar::dipole_magnitude::dipole_magnitude()
+{
+  function_type = "dipole_magnitude";
+  x.type(colvarvalue::type_scalar);
+}
+
+
+void colvar::dipole_magnitude::calc_value()
+{
+  cvm::atom_pos const atomsCom = atoms->center_of_mass();
+  atoms->calc_dipole(atomsCom);
+  dipoleV = atoms->dipole();
+  x.real_value = dipoleV.norm();
+}
+
+void colvar::dipole_magnitude::calc_gradients()
+{
+  cvm::real const      aux1 = atoms->total_charge/atoms->total_mass;
+  cvm::atom_pos const  dipVunit= dipoleV.unit();
+
+  for (cvm::atom_iter ai = atoms->begin(); ai != atoms->end(); ai++) {
+    ai->grad = (ai->charge - aux1*ai->mass) * dipVunit;
+  }
+}
+
+void colvar::dipole_magnitude::apply_force (colvarvalue const &force)
+{
+  if (!atoms->noforce) {
+    atoms->apply_colvar_force (force.real_value);
+    for (cvm::atom_iter ai = atoms->begin(); ai != atoms->end(); ai++) {
+      cvm::atom_pos forceV=force.real_value*ai->grad;
+    }
+  }
+}
+
+
+simple_scalar_dist_functions(dipole_magnitude)
+
+
+
 colvar::gyration::gyration(std::string const &conf)
   : cvc(conf)
 {
index 498ef7c..257f4c1 100644 (file)
@@ -21,18 +21,22 @@ colvar::orientation::orientation(std::string const &conf)
   : cvc(conf)
 {
   function_type = "orientation";
-  atoms = parse_group(conf, "atoms");
   enable(f_cvc_implicit_gradient);
   x.type(colvarvalue::type_quaternion);
+  init(conf);
+}
+
 
+int colvar::orientation::init(std::string const &conf)
+{
+  atoms = parse_group(conf, "atoms");
   ref_pos.reserve(atoms->size());
 
   if (get_keyval(conf, "refPositions", ref_pos, ref_pos)) {
     cvm::log("Using reference positions from input file.\n");
     if (ref_pos.size() != atoms->size()) {
-      cvm::error("Error: reference positions do not "
-                        "match the number of requested atoms.\n");
-      return;
+      return cvm::error("Error: reference positions do not "
+                        "match the number of requested atoms.\n", INPUT_ERROR);
     }
   }
 
@@ -46,9 +50,8 @@ colvar::orientation::orientation(std::string const &conf)
         // use PDB flags if column is provided
         bool found = get_keyval(conf, "refPositionsColValue", file_col_value, 0.0);
         if (found && file_col_value==0.0) {
-          cvm::error("Error: refPositionsColValue, "
-                            "if provided, must be non-zero.\n");
-          return;
+          return cvm::error("Error: refPositionsColValue, "
+                            "if provided, must be non-zero.\n", INPUT_ERROR);
         }
       }
 
@@ -59,9 +62,8 @@ colvar::orientation::orientation(std::string const &conf)
   }
 
   if (!ref_pos.size()) {
-    cvm::error("Error: must define a set of "
-                      "reference coordinates.\n");
-    return;
+    return cvm::error("Error: must define a set of "
+                      "reference coordinates.\n", INPUT_ERROR);
   }
 
 
@@ -158,10 +160,18 @@ colvarvalue colvar::orientation::dist2_rgrad(colvarvalue const &x1,
 
 
 colvar::orientation_angle::orientation_angle(std::string const &conf)
-  : orientation(conf)
+  : orientation()
 {
   function_type = "orientation_angle";
+  disable(f_cvc_implicit_gradient);
   x.type(colvarvalue::type_scalar);
+  init(conf);
+}
+
+
+int colvar::orientation_angle::init(std::string const &conf)
+{
+  return orientation::init(conf);
 }
 
 
@@ -169,6 +179,7 @@ colvar::orientation_angle::orientation_angle()
   : orientation()
 {
   function_type = "orientation_angle";
+  disable(f_cvc_implicit_gradient);
   x.type(colvarvalue::type_scalar);
 }
 
@@ -214,10 +225,18 @@ simple_scalar_dist_functions(orientation_angle)
 
 
 colvar::orientation_proj::orientation_proj(std::string const &conf)
-  : orientation(conf)
+  : orientation()
 {
   function_type = "orientation_proj";
+  disable(f_cvc_implicit_gradient);
   x.type(colvarvalue::type_scalar);
+  init(conf);
+}
+
+
+int colvar::orientation_proj::init(std::string const &conf)
+{
+  return orientation::init(conf);
 }
 
 
@@ -225,6 +244,7 @@ colvar::orientation_proj::orientation_proj()
   : orientation()
 {
   function_type = "orientation_proj";
+  disable(f_cvc_implicit_gradient);
   x.type(colvarvalue::type_scalar);
 }
 
@@ -261,18 +281,28 @@ simple_scalar_dist_functions(orientation_proj)
 
 
 colvar::tilt::tilt(std::string const &conf)
-  : orientation(conf)
+  : orientation()
 {
   function_type = "tilt";
+  disable(f_cvc_implicit_gradient);
+  x.type(colvarvalue::type_scalar);
+  init(conf);
+}
 
-  get_keyval(conf, "axis", axis, cvm::rvector(0.0, 0.0, 1.0));
 
+int colvar::tilt::init(std::string const &conf)
+{
+  int error_code = COLVARS_OK;
+
+  error_code |= orientation::init(conf);
+
+  get_keyval(conf, "axis", axis, cvm::rvector(0.0, 0.0, 1.0));
   if (axis.norm2() != 1.0) {
     axis /= axis.norm();
     cvm::log("Normalizing rotation axis to "+cvm::to_str(axis)+".\n");
   }
 
-  x.type(colvarvalue::type_scalar);
+  return error_code;
 }
 
 
@@ -280,6 +310,7 @@ colvar::tilt::tilt()
   : orientation()
 {
   function_type = "tilt";
+  disable(f_cvc_implicit_gradient);
   x.type(colvarvalue::type_scalar);
 }
 
@@ -322,20 +353,30 @@ simple_scalar_dist_functions(tilt)
 
 
 colvar::spin_angle::spin_angle(std::string const &conf)
-  : orientation(conf)
+  : orientation()
 {
   function_type = "spin_angle";
+  period = 360.0;
+  b_periodic = true;
+  disable(f_cvc_implicit_gradient);
+  x.type(colvarvalue::type_scalar);
+  init(conf);
+}
 
-  get_keyval(conf, "axis", axis, cvm::rvector(0.0, 0.0, 1.0));
 
+int colvar::spin_angle::init(std::string const &conf)
+{
+  int error_code = COLVARS_OK;
+
+  error_code |= orientation::init(conf);
+
+  get_keyval(conf, "axis", axis, cvm::rvector(0.0, 0.0, 1.0));
   if (axis.norm2() != 1.0) {
     axis /= axis.norm();
     cvm::log("Normalizing rotation axis to "+cvm::to_str(axis)+".\n");
   }
 
-  period = 360.0;
-  b_periodic = true;
-  x.type(colvarvalue::type_scalar);
+  return error_code;
 }
 
 
@@ -345,6 +386,7 @@ colvar::spin_angle::spin_angle()
   function_type = "spin_angle";
   period = 360.0;
   b_periodic = true;
+  disable(f_cvc_implicit_gradient);
   x.type(colvarvalue::type_scalar);
 }
 
index da9257e..1c083a9 100644 (file)
@@ -544,7 +544,7 @@ int colvarproxy_script::run_colvar_gradient_callback(
 
 colvarproxy_tcl::colvarproxy_tcl()
 {
-  _tcl_interp = NULL;
+  tcl_interp_ = NULL;
 }
 
 
@@ -573,7 +573,7 @@ char const *colvarproxy_tcl::tcl_obj_to_str(unsigned char *obj)
 int colvarproxy_tcl::tcl_run_force_callback()
 {
 #if defined(COLVARS_TCL)
-  Tcl_Interp *const tcl_interp = reinterpret_cast<Tcl_Interp *>(_tcl_interp);
+  Tcl_Interp *const tcl_interp = reinterpret_cast<Tcl_Interp *>(tcl_interp_);
   std::string cmd = std::string("calc_colvar_forces ")
     + cvm::to_str(cvm::step_absolute());
   int err = Tcl_Eval(tcl_interp, cmd.c_str());
@@ -596,7 +596,7 @@ int colvarproxy_tcl::tcl_run_colvar_callback(
 {
 #if defined(COLVARS_TCL)
 
-  Tcl_Interp *const tcl_interp = reinterpret_cast<Tcl_Interp *>(_tcl_interp);
+  Tcl_Interp *const tcl_interp = reinterpret_cast<Tcl_Interp *>(tcl_interp_);
   size_t i;
   std::string cmd = std::string("calc_") + name;
   for (i = 0; i < cvc_values.size(); i++) {
@@ -633,7 +633,7 @@ int colvarproxy_tcl::tcl_run_colvar_gradient_callback(
 {
 #if defined(COLVARS_TCL)
 
-  Tcl_Interp *const tcl_interp = reinterpret_cast<Tcl_Interp *>(_tcl_interp);
+  Tcl_Interp *const tcl_interp = reinterpret_cast<Tcl_Interp *>(tcl_interp_);
   size_t i;
   std::string cmd = std::string("calc_") + name + "_gradient";
   for (i = 0; i < cvc_values.size(); i++) {
index 3ff5f3c..100f13f 100644 (file)
@@ -522,7 +522,7 @@ public:
 protected:
 
   /// Pointer to Tcl interpreter object
-  void *_tcl_interp;
+  void *tcl_interp_;
 
   /// Set Tcl pointers
   virtual void init_tcl_pointers();
index bd84d07..cdf5f71 100644 (file)
@@ -1,5 +1,5 @@
 #ifndef COLVARS_VERSION
-#define COLVARS_VERSION "2018-11-16"
+#define COLVARS_VERSION "2018-12-18"
 // This file is part of the Collective Variables module (Colvars).
 // The original version of Colvars and its updates are located at:
 // https://github.com/colvars/colvars
index 0f2b296..ffd4206 100644 (file)
@@ -91,7 +91,7 @@ colvarproxy_namd::colvarproxy_namd()
   init_tcl_pointers();
 
   // See is user-scripted forces are defined
-  if (Tcl_FindCommand(reinterpret_cast<Tcl_Interp *>(_tcl_interp),
+  if (Tcl_FindCommand(reinterpret_cast<Tcl_Interp *>(tcl_interp_),
                       "calc_colvar_forces", NULL, 0) == NULL) {
     force_script_defined = false;
   } else {
@@ -483,7 +483,7 @@ void colvarproxy_namd::init_tcl_pointers()
 {
 #ifdef NAMD_TCL
   // Store pointer to NAMD's Tcl interpreter
-  _tcl_interp = reinterpret_cast<void *>(Node::Object()->getScript()->interp);
+  tcl_interp_ = reinterpret_cast<void *>(Node::Object()->getScript()->interp);
 #endif
 }
 
@@ -1016,7 +1016,7 @@ std::vector<std::string> colvarproxy_namd::script_obj_to_str_vector(unsigned cha
   }
   std::vector<std::string> result;
 #ifdef NAMD_TCL
-  Tcl_Interp *interp = reinterpret_cast<Tcl_Interp *>(_tcl_interp);
+  Tcl_Interp *interp = reinterpret_cast<Tcl_Interp *>(tcl_interp_);
   Tcl_Obj *tcl_obj = reinterpret_cast<Tcl_Obj *>(obj);
   Tcl_Obj **tcl_list_elems = NULL;
   int count = 0;
index 1ca6a59..bc19679 100644 (file)
@@ -58,12 +58,8 @@ protected:
   /// Used to submit restraint energy as MISC
   SubmitReduction *reduction;
 
-#ifdef NAMD_TCL
-
   void init_tcl_pointers();
 
-#endif
-
 public:
 
   friend class cvm::atom;
index edd6778..3a3abfa 100644 (file)
@@ -1,5 +1,5 @@
 #ifndef COLVARPROXY_VERSION
-#define COLVARPROXY_VERSION "2018-08-29"
+#define COLVARPROXY_VERSION "2018-12-20"
 // This file is part of the Collective Variables module (Colvars).
 // The original version of Colvars and its updates are located at:
 // https://github.com/colvars/colvars
index ffff828..f808367 100644 (file)
@@ -598,6 +598,7 @@ The following components implement functions with a scalar value (i.e.{} a real
 \item \refkey{angle}{colvar|angle}: angle between three groups;
 \item \refkey{dihedral}{colvar|dihedral}: torsional (dihedral) angle between four groups;
 \item \refkey{dipoleAngle}{colvar|dipoleAngle}: angle between two groups and dipole of a third group;
+\item \refkey{dipoleMagnitude}: magnitude of the dipole of a group of atoms;
 \item \refkey{polarTheta}{colvar|polarTheta}: polar angle of a group in spherical coordinates;
 \item \refkey{polarPhi}{colvar|polarPhi}: azimuthal angle of a group in spherical coordinates;
 \item \refkey{coordNum}{colvar|coordNum}: coordination number between two groups;
@@ -1541,6 +1542,22 @@ define the atom group, and returns a positive number, expressed in
 \end{cvcoptions}
 
 
+\cvsubsubsec{\texttt{dipoleMagnitude}: dipole magnitude of a group of atoms.}{sec:cvc_dipoleMagnitude}
+The \texttt{dipoleMagnitude~\{...\}} block defines the dipole magnitude of a group of atoms (norm of the dipole moment's vector), being \texttt{atoms} the group where dipole magnitude is calculated.
+It returns the magnitude in elementary charge $e$ times \cvnamdonly{\AA}\cvvmdonly{\AA}\cvlammpsonly{(length unit)}.
+
+\begin{cvcoptions}
+\item %
+  \dupkey{atoms}{\texttt{dipoleMagnitude}}{colvar|rmsd|atoms}{\texttt{rmsd} component}
+\end{cvcoptions}
+
+
+\cvsubsubsec{\texttt{cartesian}: vector of atomic Cartesian coordinates.}{sec:cvc_cartesian}
+The \texttt{cartesian~\{...\}} block defines a component returning a flat vector containing
+the Cartesian coordinates of all participating atoms, in the order
+$(x_1, y_1, z_1, \cdots, x_n, y_n, z_n)$.
+
+
 \cvsubsubsec{\texttt{inertiaZ}: total moment of inertia of a group of atoms around a chosen axis.}{sec:cvc_inertiaZ}
 \labelkey{colvar|inertiaZ}
 
@@ -1559,6 +1576,7 @@ This component must contain one \texttt{atoms~\{...\}} block to
 define the atom group, and returns a positive number, expressed in
 \AA{}$^{2}$.
 
+
 \begin{cvcoptions}
 \item %
   \dupkey{atoms}{\texttt{inertiaZ}}{colvar|rmsd|atoms}{\texttt{rmsd} component}