hillclimber 0.1.5__cp313-cp313-musllinux_1_2_aarch64.whl

plumed/_lib/include/plumed/core/ActionWithValue.h

@@ -0,0 +1,258 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2011-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   plumed is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_core_ActionWithValue_h
+#define __PLUMED_core_ActionWithValue_h
+
+#include "Action.h"
+#include "Value.h"
+#include "../tools/Exception.h"
+#include <vector>
+#include <memory>
+#include <cstring>
+
+namespace PLMD {
+
+/**
+\ingroup MULTIINHERIT
+Used to create a PLMD::Action that has some scalar or vectorial output that may or may not have some derivatives.
+This is used for PLMD::Bias, PLMD::Colvar and PLMD::Function
+
+The vast majority of the PLMD::Action objects that are implemented in
+plumed calculate some quantity or a set of quantities.  This could be
+the value of a CV, the value of a function or the potential due to a bias.
+PLMD::ActionWithValue provides the functionality for storing these quantities
+and (in tandem with PLMD::ActionWithArguments) the functionality for passing
+quantities between PLMD::Actions.  When you are deciding what quantities
+your new PLMD::Action will need to store using PLMD::ActionWithValue you must
+ask yourself the following two questions:
+
+- Do I need to differentiate my output quantities
+- Is my PLMD::Action calculating a single thing or does the output have multiple components
+
+If the answer to the first of these questions is yes then you must setup your values
+you using either PLMD::ActionWithValue::addValueWithDerivatives() or
+PLMD::ActionWithValue::addComponentWithDerivatives.  If the answer is no you
+can set up values using PLMD::ActionWithValue::addValue() or PLMD::ActionWithValue::addComponent().
+The precise routine you use to setup your values will depend on your answer to the
+second question.  As you are probably aware if the output of your PLMD::Action is a
+single quantity you can reference that quantity in the input file using the label of the
+PLMD::Action it was calculated in.  If your action <b> outputs only one quantity </b>
+we call that quantity the <b> value </b> of the Action.  To set the <b> value </b> and get pointers to it
+you should <b> use the set of routines that have the word value in the name </b>.  If, by contrast,
+your PLMD::Action calculates multiple quantities then these quantities are referenced in input using the
+label.component syntax.  We refer to these <b> multiple quantities </b> the <b> components </b>
+of the PLMD::Action.  Perhaps unsurprisingly, when you manipulate the <b> components </b> of an
+PLMD::Action you should use <b> the routines with the word component in the name. </b>
+*/
+
+class ActionWithValue :
+  public virtual Action {
+  friend class ActionWithVector;
+  friend class ActionWithArguments;
+private:
+/// This finishes setup on first step to check if actions are calculated during update
+  bool firststep;
+/// An array containing the values for this action
+  std::vector<std::unique_ptr<Value>> values;
+/// A vector that is used to hold the forces that we will apply on the input quantities
+  std::vector<double> forcesForApply;
+  std::vector<unsigned> valsToForce;
+/// Are we skipping the calculation of the derivatives
+  bool noderiv;
+/// Are we using numerical derivatives to differentiate
+  bool numericalDerivatives;
+/// Return the index for the component named name
+  int getComponent( const std::string& valname ) const;
+public:
+
+// -------- The action has one value only  ---------------- //
+
+/// Add a value with the name label
+  void addValue( const std::vector<std::size_t>& shape=std::vector<std::size_t>() );
+/// Add a value with the name label that has derivatives
+  virtual void addValueWithDerivatives( const std::vector<std::size_t>& shape=std::vector<std::size_t>() );
+/// Set your default value to have no periodicity
+  void setNotPeriodic();
+/// Set the value to be periodic with a particular domain
+  void setPeriodic( const std::string& min, const std::string& max );
+protected:
+/// Get a pointer to the default value
+  Value* getPntrToValue();
+/// Set the default value (the one without name)
+  void setValue(const double& d);
+
+// -------- The action has multiple components ---------- //
+
+public:
+/// Add a value with a name like label.name
+  void addComponent( const std::string& valname, const std::vector<std::size_t>& shape=std::vector<std::size_t>() );
+/// Add a value with a name like label.name that has derivatives
+  virtual void addComponentWithDerivatives( const std::string& valname, const std::vector<std::size_t>& shape=std::vector<std::size_t>() );
+/// Set your value component to have no periodicity
+  void componentIsNotPeriodic( const std::string& valname );
+/// Set the value to be periodic with a particular domain
+  void componentIsPeriodic( const std::string& valname, const std::string& min, const std::string& max );
+/// Get the description of this component
+  virtual std::string getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const ;
+/// Get a const pointer to the ith component
+  const Value* getConstPntrToComponent(unsigned i) const;
+protected:
+/// Return a pointer to the component by index
+  Value* getPntrToComponent(unsigned i);
+/// Return a pointer to the value by name
+  Value* getPntrToComponent(const std::string& valname);
+/// Accumulate the forces from the Values
+  bool checkForForces();
+/// Get the forces to apply
+  const std::vector<double>& getForcesToApply() const;
+public:
+  explicit ActionWithValue(const ActionOptions&ao);
+  ~ActionWithValue();
+
+/// Register all the relevant keywords for the action
+  static void registerKeywords( Keywords& keys );
+/// Insist that numerical derivatives should always be used for an action and make this fact appear in the manual
+  static void noAnalyticalDerivatives(Keywords& keys);
+/// The components in the action will depend on the user
+  static void useCustomisableComponents(Keywords& keys);
+/// Are we not calculating derivatives
+  virtual bool doNotCalculateDerivatives() const ;
+/// Get the value of one of the components of the PLMD::Action
+  double getOutputQuantity( const unsigned j ) const ;
+/// Get the value with a specific name (N.B. if there is no such value this returns zero)
+  double getOutputQuantity( const std::string& valname ) const ;
+
+//  --- Routines for passing stuff to ActionWithArguments -- //
+
+/// Check if a value with a particular name is present.  This is only used in PLMD::ActionWithArguments.
+/// You should not use it when manipulating components.
+  bool exists( const std::string& valname ) const;
+/// Return a pointer to the value with name (this is used to retrieve values in other PLMD::Actions)
+/// You should NEVER use this routine to refer to the components of your PLMD::Action.  Use
+/// getPntrToComponent instead.
+  Value* copyOutput( const std::string& valname ) const;
+/// Return a pointer to the value with this number (this is used to retrieve values in other PLMD::Actions)
+/// You should NEVER use this routine to refer to the components of your PLMD::Action.  Use
+/// getPntrToComponent instead.
+  Value* copyOutput( const unsigned& n ) const;
+/// get a string that contains all the available components
+  std::string getComponentsList( ) const ;
+/// get a vector that contains the label for all the components
+  std::vector<std::string> getComponentsVector( ) const ;
+
+
+// -- Routines for everything else -- //
+
+/// Returns the number of values defined
+  std::size_t getNumberOfComponents() const ;
+/// Clear the forces on the values
+  virtual void clearInputForces( const bool& force=false );
+/// Clear the derivatives of values wrt parameters
+  virtual void clearDerivatives( const bool& force=false );
+/// Calculate the gradients and store them for all the values (need for projections)
+  virtual void setGradientsIfNeeded();
+/// Set the value
+  void setValue(Value*,double);
+/// Check if numerical derivatives should be used
+  bool checkNumericalDerivatives() const override;
+/// This forces the class to use numerical derivatives
+  void useNumericalDerivatives();
+// These are things for using vectors of values as fields
+  virtual void checkFieldsAllowed() {
+    error("cannot use this action as a field");
+  }
+  virtual unsigned getNumberOfDerivatives()=0;
+/// Activate the calculation of derivatives
+  virtual void turnOnDerivatives();
+/// Get the titles to use for the columns of the matrix
+  virtual void getMatrixColumnTitles( std::vector<std::string>& argnames ) const ;
+/// This is used to check if we run calculate during the update step
+  virtual bool calculateOnUpdate();
+  ActionWithValue* castToActionWithValue() noexcept final {
+    return this;
+  }
+};
+
+inline
+double ActionWithValue::getOutputQuantity(const unsigned j) const {
+  plumed_massert(j<values.size(),"index requested is out of bounds");
+  return values[j]->get();
+}
+
+inline
+double ActionWithValue::getOutputQuantity( const std::string& quantityName ) const {
+  auto offset=getLabel().size();
+  for(unsigned i=0; i<values.size(); ++i) {
+    const std::string & valname=values[i]->name;
+    if(valname.size()>offset+1 && valname[offset]=='.' ) {
+      plumed_dbg_assert(Tools::startWith(valname,getLabel()));
+      if(!std::strcmp(valname.c_str()+offset+1,quantityName.c_str())) {
+        return values[i]->get();
+      }
+    }
+  }
+  return 0.0;
+}
+
+inline
+void ActionWithValue::setValue(const double& d) {
+  plumed_massert(values.size()==1, "cannot use setValue in multi-component actions");
+  plumed_massert(values[0]->name==getLabel(), "The value you are trying to set is not the default");
+  values[0]->set(d);
+}
+
+inline
+std::size_t ActionWithValue::getNumberOfComponents() const {
+  return values.size();
+}
+
+inline
+void ActionWithValue::useNumericalDerivatives() {
+  plumed_massert( keywords.exists("NUMERICAL_DERIVATIVES"), "numerical derivatives are not permitted for this action" );
+  numericalDerivatives=true;
+}
+
+inline
+bool ActionWithValue::checkNumericalDerivatives() const {
+  return numericalDerivatives;
+}
+
+inline
+bool ActionWithValue::doNotCalculateDerivatives() const {
+  return noderiv;
+}
+
+inline
+const std::vector<double>& ActionWithValue::getForcesToApply() const {
+  return forcesForApply;
+}
+
+inline
+Value* ActionWithValue::getPntrToValue() {
+  plumed_dbg_massert(values.size()==1,"The number of components is not equal to one");
+  plumed_dbg_massert(values[0]->name==getLabel(), "The value you are trying to retrieve is not the default");
+  return values[0].get();
+}
+
+}
+
+#endif

plumed/_lib/include/plumed/core/ActionWithVector.h

@@ -0,0 +1,94 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2011-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   plumed is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_core_ActionWithVector_h
+#define __PLUMED_core_ActionWithVector_h
+
+#include "ActionWithValue.h"
+#include "ActionAtomistic.h"
+#include "ActionWithArguments.h"
+#include <limits>
+#include <vector>
+
+namespace PLMD {
+
+class ActionWithVector:
+  public ActionAtomistic,
+  public ActionWithValue,
+  public ActionWithArguments {
+  friend class Value;
+private:
+  static constexpr int NoMasksUsed =-1;
+/// Check if there is a mask value
+  int nmask=NoMasksUsed;
+/// The list of active tasks
+  std::vector<unsigned> active_tasks;
+protected:
+/// Turn off the flag that says this action has a masked input
+  void ignoreMaskArguments();
+/// Accumulate the forces from the Values
+  bool checkForForces();
+public:
+  static void registerKeywords( Keywords& keys );
+  explicit ActionWithVector(const ActionOptions&);
+  virtual ~ActionWithVector() {}
+  void lockRequests() override;
+  void unlockRequests() override;
+  virtual void prepare() override;
+/// Check if a mask has been set
+  int getNumberOfMasks() const ;
+  void calculateNumericalDerivatives(ActionWithValue* av) override;
+/// Get the list of tasks that are active
+  virtual std::vector<unsigned>& getListOfActiveTasks( ActionWithVector* action );
+/// Find out how many tasks we need to perform in this loop
+  virtual void getNumberOfTasks( unsigned& ntasks );
+/// Determine if a particular task is active based on the values of the input argument
+  virtual int checkTaskIsActive( const unsigned& itask ) const ;
+/// This is so we can parallelize with GPU
+  virtual void getInputData( std::vector<double>& inputdata ) const ;
+/// This is so we an transfer data gathered in the parallel task manager to the underlying values
+  virtual void transferStashToValues( const std::vector<unsigned>& partialTaskList, const std::vector<double>& stash );
+/// This is so we can transfer forces from the values to the parallel task manager
+  virtual void transferForcesToStash( const std::vector<unsigned>& partialTaskList, std::vector<double>& stash ) const ;
+/// Get the number of forces to use
+  unsigned getNumberOfForceDerivatives() const ;
+/// Apply the forces on this data
+  void apply() override;
+/// Apply the forces on non-zero rank objects
+  virtual void applyNonZeroRankForces( std::vector<double>& outforces ) {
+    plumed_error();
+  }
+};
+
+inline
+int ActionWithVector::getNumberOfMasks() const {
+  return nmask;
+}
+
+inline
+void ActionWithVector::ignoreMaskArguments() {
+  plumed_assert( nmask<=0 );
+  nmask=NoMasksUsed;
+}
+
+}
+
+#endif

plumed/_lib/include/plumed/core/ActionWithVirtualAtom.h

@@ -0,0 +1,123 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2011-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   plumed is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_core_ActionWithVirtualAtom_h
+#define __PLUMED_core_ActionWithVirtualAtom_h
+
+#include "ActionAtomistic.h"
+#include "ActionWithValue.h"
+#include "../tools/AtomNumber.h"
+#include "../tools/Vector.h"
+#include "../tools/Tensor.h"
+
+namespace PLMD {
+
+/**
+\ingroup INHERIT
+Inherit from here if you are calculating the position of a virtual atom (eg a center of mass)
+*/
+
+/// Class to add a single virtual atom to the system.
+/// (it might be extended to add multiple virtual atoms).
+class ActionWithVirtualAtom:
+  public ActionAtomistic,
+  public ActionWithValue {
+protected:
+/// Set position of the virtual atom
+  void setPosition(const Vector &);
+/// Set its mass
+  void setMass(double);
+/// Set its charge
+  void setCharge(double);
+/// Request the atoms on which the calculation demands
+  void requestAtoms(const std::vector<AtomNumber> & a);
+/// Set the derivatives of virtual atom coordinate wrt atoms on which it dependes
+  void setAtomsDerivatives(const std::vector<Tensor> &d);
+/// Set the box derivatives.
+/// This should be a vector of size 3. First index corresponds
+/// to the components of the virtual atom.
+/// Notice that this routine subtract the trivial term coming from cell deformation
+/// since this term is already implicitly included. Indeed, if the vatom
+/// position is a linear function of atomic coordinates it is not necessary
+/// to call this function (implicit term is fine) (e.g. vatom::COM and vatom::Center).
+/// On the other hand if the vatom position is a non-linear function of atomic coordinates this
+/// should be called (see vatom::Ghost).
+  void setBoxDerivatives(const std::vector<Tensor> &d);
+/// Set box derivatives automatically.
+/// It should be called after the settomsDerivatives has been used for all
+/// single atoms.
+/// \warning It only works for virtual atoms NOT using PBCs!
+///          This implies that all atoms used + the new virtual atom should be
+///          in the same periodic image.
+  void setBoxDerivativesNoPbc();
+public:
+/// Return the atom id of the corresponding virtual atom
+  AtomNumber getIndex()const;
+  explicit ActionWithVirtualAtom(const ActionOptions&ao);
+  static void registerKeywords(Keywords& keys);
+  virtual unsigned getNumberOfDerivatives();
+  virtual void apply();
+  ActionWithVirtualAtom* castToActionWithVirtualAtom() noexcept final {
+    return this;
+  }
+};
+
+inline
+unsigned ActionWithVirtualAtom::getNumberOfDerivatives() {
+  return 3*getNumberOfAtoms()+9;
+}
+
+inline
+void ActionWithVirtualAtom::setPosition(const Vector & pos) {
+  for(unsigned i=0; i<3; ++i) {
+    getPntrToComponent(i)->set(pos[i]);
+  }
+}
+
+inline
+void ActionWithVirtualAtom::setMass(double m) {
+  getPntrToComponent(3)->set(m);
+}
+
+inline
+void ActionWithVirtualAtom::setCharge(double c) {
+  getPntrToComponent(4)->set(c);
+}
+
+inline
+void ActionWithVirtualAtom::setAtomsDerivatives(const std::vector<Tensor> &d) {
+  unsigned jj=0;
+  Value* xval=getPntrToComponent(0);
+  Value* yval=getPntrToComponent(1);
+  Value* zval=getPntrToComponent(2);
+  for(unsigned j=0; j<getNumberOfAtoms(); ++j) {
+    for(unsigned k=0; k<3; ++k) {
+      xval->setDerivative( jj, d[j][k][0] );
+      yval->setDerivative( jj, d[j][k][1] );
+      zval->setDerivative( jj, d[j][k][2] );
+      jj++;
+    }
+  }
+}
+
+}
+
+#endif

plumed/_lib/include/plumed/core/CLTool.h

@@ -0,0 +1,177 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2012-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   plumed is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_core_CLTool_h
+#define __PLUMED_core_CLTool_h
+#include <cstdio>
+#include <vector>
+#include <string>
+#include <cstdio>
+#include "../tools/Tools.h"
+#include "../tools/Keywords.h"
+
+namespace PLMD {
+
+class Communicator;
+
+class CLToolOptions {
+  friend class CLTool;
+  friend class CLToolRegister;
+private:
+  std::vector<std::string> line;
+/// The documentation for this command line tool
+  const Keywords& keys;
+  static Keywords emptyKeys;
+public:
+  explicit CLToolOptions(const std::string &name);
+  CLToolOptions(const CLToolOptions& co, const Keywords& k);
+};
+
+/**
+\ingroup INHERIT
+This is the abstract base class to use for implementing new command line tool, within it there
+is \ref AddingACLTool "information" as to how to go about implemneting a new tool.
+*/
+
+class CLTool {
+private:
+/// The name of this command line tool
+  const std::string name;
+/// The list of keywords for this CLTool
+  const Keywords& keywords;
+/// The data read in from the command line stored in a map with the keywords
+  std::map<std::string,std::string> inputData;
+/// Read the arguments from the command line
+  bool readCommandLineArgs( int argc, char**argv, FILE*out );
+/// Read the arguments from an input file specified on the command line
+  bool readInputFile( int argc, char**argv, FILE* in, FILE*out );
+/// Set arguments from the default options provided to Keywords
+  void setRemainingToDefault(FILE* out);
+public:
+/// Set the input data:
+  void setInputData(const std::map<std::string,std::string>&newInputData) {
+    inputData=newInputData;
+  }
+  const std::map<std::string,std::string>&getInputData() {
+    return inputData;
+  }
+protected:
+/// Get the value of one of the command line arguments
+  template<class T>
+  bool parse(const std::string&key,T&t);
+/// Find out whether one of the command line flags is present or not
+  void parseFlag(const std::string&key,bool&t);
+/// Crash the command line tool with an error
+  [[noreturn]] void error(const std::string& msg);
+  template<class T>
+  bool parseVector(const std::string&key,std::vector<T>&t);
+public:
+/// How is the input specified on the command line or in an input file
+  enum class inputType {unset,commandline,ifile} inputdata;
+/// Create the help keywords
+  static void registerKeywords( Keywords& keys );
+  explicit CLTool(const CLToolOptions& co );
+/// Read the arguments from the command line
+  bool readInput( int argc, char**argv, FILE* in, FILE*out );
+/// virtual function mapping to the specific main for each tool
+  virtual int main( FILE* in, FILE*out, Communicator&pc )=0;
+/// virtual function returning a one-line descriptor for the tool
+  virtual std::string description()const {
+    return "(no description available)";
+  }
+/// virtual destructor to allow inheritance
+  virtual ~CLTool() {}
+};
+
+template<class T>
+bool CLTool::parse(const std::string&key,T&t) {
+  plumed_massert(keywords.exists(key),"keyword " + key + " has not been registered");
+  if(keywords.style(key,"compulsory") ) {
+    if(inputData.count(key)==0) {
+      error("missing data for keyword " + key);
+    }
+    bool check=Tools::convertNoexcept(inputData[key],t);
+    if(!check) {
+      error("data input for keyword " + key + " has wrong type");
+    }
+    return true;
+  }
+  if( inputData.count(key)==0 ) {
+    return false;
+  }
+  Tools::convert(inputData[key],t);
+  return true;
+}
+// very limited support and check: take more from core/Action.h parseVector
+template<class T>
+bool CLTool::parseVector(const std::string&key,std::vector<T>&t) {
+
+  // Check keyword has been registered
+  plumed_massert(keywords.exists(key), "keyword " + key + " has not been registered");
+  // initial size
+  unsigned size=t.size();
+  bool skipcheck=false;
+  if(size==0) {
+    skipcheck=true;  // if the vector in input has size zero, skip the check if size of input vector is the same of argument read
+  }
+
+  // check if there is some value
+
+  plumed_massert(inputData[key]!="false","compulsory keyword "+std::string(key)+"has no data");
+  std::vector<std::string> words=Tools::getWords(inputData[key],"\t\n ,");
+  t.resize(0);
+  if(words.size()==0) {
+    return false;
+  }
+
+  for(unsigned i=0; i<words.size(); ++i) {
+    T v;
+    Tools::convert(words[i],v);
+    t.push_back(v);
+  }
+  // check the size
+  if( !skipcheck && t.size()!=size ) {
+    plumed_merror("vector read in for keyword  "+key+" has wrong size" );
+  }
+  std::string def;
+  T val;
+  if ( keywords.style(key,"compulsory") && t.size()==0 ) {
+    if( keywords.getDefaultValue(key,def) ) {
+      if( def.length()==0 || !Tools::convertNoexcept(def,val) ) {
+        plumed_merror("ERROR in keyword "+key+ " has weird default value" );
+      } else {
+        // GB: before it was like this, but clearly if t.size()==0 this was not doing anything
+        // for(unsigned i=0; i<t.size(); ++i) t[i]=val;
+        t.resize(1);
+        t[0]=val;
+      }
+    } else {
+      plumed_merror("keyword " + key + " is compulsory for this action");
+    }
+  }
+  return true;
+}
+
+
+
+}
+
+#endif