hillclimber 0.1.5__cp313-cp313-musllinux_1_2_aarch64.whl

plumed/_lib/include/plumed/function/FunctionOfVector.h

@@ -0,0 +1,296 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2011-2020 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_function_FunctionOfVector_h
+#define __PLUMED_function_FunctionOfVector_h
+
+#include "../core/ActionWithVector.h"
+#include "../core/ParallelTaskManager.h"
+#include "../core/ActionSetup.h"
+#include "FunctionSetup.h"
+#include "Custom.h"
+
+namespace PLMD {
+namespace function {
+
+template <class T>
+class FunctionOfVector : public ActionWithVector {
+public:
+  using input_type = FunctionData<T>;
+  using PTM = ParallelTaskManager<FunctionOfVector<T>>;
+private:
+/// The parallel task manager
+  PTM taskmanager;
+/// Set equal to one if we are doing EvaluateGridFunction
+  unsigned argstart;
+public:
+  static void registerKeywords(Keywords&);
+  explicit FunctionOfVector(const ActionOptions&);
+  ~FunctionOfVector() {}
+  std::string getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const override ;
+/// Get the number of derivatives for this action
+  unsigned getNumberOfDerivatives() override ;
+/// Resize vectors that are the wrong size
+  void prepare() override ;
+/// Get the label to write in the graph
+  std::string writeInGraph() const override ;
+/// This builds the task list for the action
+  void calculate() override;
+/// Add some forces
+  void applyNonZeroRankForces( std::vector<double>& outforces ) override ;
+/// Get the input data
+  void getInputData( std::vector<double>& inputdata ) const override ;
+/// Calculate the function
+  static void performTask( std::size_t task_index,
+                           const FunctionData<T>& actiondata,
+                           ParallelActionsInput& input,
+                           ParallelActionsOutput& output );
+/// Get the indices of the forces
+  static int getNumberOfValuesPerTask( std::size_t task_index, const FunctionData<T>& actiondata );
+  static void getForceIndices( std::size_t task_index,
+                               std::size_t colno,
+                               std::size_t ntotal_force,
+                               const FunctionData<T>& actiondata,
+                               const ParallelActionsInput& input,
+                               ForceIndexHolder force_indices );
+};
+
+template <class T>
+void FunctionOfVector<T>::registerKeywords(Keywords& keys ) {
+  Action::registerKeywords(keys);
+  ActionWithValue::registerKeywords(keys);
+  ActionWithArguments::registerKeywords(keys);
+  std::string name = keys.getDisplayName();
+  std::size_t und=name.find("_VECTOR");
+  keys.setDisplayName( name.substr(0,und) );
+  keys.addInputKeyword("compulsory","ARG","scalar/vector","the labels of the scalar and vector that on which the function is being calculated elementwise");
+  keys.reserve("compulsory","PERIODIC","if the output of your function is periodic then you should specify the periodicity of the function.  If the output is not periodic you must state this using PERIODIC=NO");
+  keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
+  T::registerKeywords( keys );
+  if( keys.getDisplayName()=="SUM" ) {
+    keys.setValueDescription("scalar","the sum of all the elements in the input vector");
+  } else if( keys.getDisplayName()=="MEAN" ) {
+    keys.setValueDescription("scalar","the mean of all the elements in the input vector");
+  } else if( keys.getDisplayName()=="HIGHEST" ) {
+    keys.setValueDescription("scalar/vector","the largest element of the input vector if one vector specified.  If multiple vectors of the same size specified the largest elements of these vector computed elementwise.");
+    keys.addInputKeyword("optional","MASK","vector","the label for a sparse vector that should be used to determine which elements of the vector should be computed");
+  } else if( keys.getDisplayName()=="LOWEST" ) {
+    keys.setValueDescription("scalar/vector","the smallest element in the input vector if one vector specified.  If multiple vectors of the same size specified the largest elements of these vector computed elementwise.");
+    keys.addInputKeyword("optional","MASK","vector","the label for a sparse vector that should be used to determine which elements of the vector should be computed");
+  } else if( keys.getDisplayName()=="SORT" ) {
+    keys.setValueDescription("vector","a vector that has been sorted into ascending order");
+    keys.addInputKeyword("optional","MASK","vector","the label for a sparse vector that should be used to determine which elements of the vector should be computed");
+  } else if( keys.outputComponentExists(".#!value") ) {
+    keys.addInputKeyword("optional","MASK","vector","the label for a sparse vector that should be used to determine which elements of the vector should be computed");
+    keys.setValueDescription("vector","the vector obtained by doing an element-wise application of " + keys.getOutputComponentDescription(".#!value") + " to the input vectors");
+  }
+  PTM::registerKeywords( keys );
+}
+
+template <class T>
+FunctionOfVector<T>::FunctionOfVector(const ActionOptions&ao):
+  Action(ao),
+  ActionWithVector(ao),
+  taskmanager(this),
+  argstart(0) {
+  // Check if first argument is grid
+  if( getPntrToArgument(0)->getRank()>0 && getPntrToArgument(0)->hasDerivatives() ) {
+    argstart=1;
+  }
+  if( getNumberOfArguments()==argstart ) {
+    error("no arguments specified");
+  }
+
+  if( getPntrToArgument(argstart)->getRank()!=1 ) {
+    error("first argument to this action must be a vector");
+  }
+
+  // Get the number of arguments
+  unsigned nargs = getNumberOfArguments();
+  int nmasks = getNumberOfMasks();
+  if( nargs>=static_cast<unsigned>(nmasks) && nmasks>0 ) {
+    nargs = nargs - nmasks;
+  }
+
+  // Get the shape of the output
+  std::size_t nscalars = 0;
+  std::vector<std::size_t> shape(1);
+  shape[0]=getPntrToArgument(argstart)->getShape()[0];
+  for(unsigned i=argstart+1; i<nargs; ++i) {
+    if( getPntrToArgument(i)->getRank()==0 ) {
+      nscalars++;
+    } else if( getPntrToArgument(i)->getRank()==1 ) {
+      if( getPntrToArgument(i)->getShape()[0]!=shape[0] ) {
+        error("mismatch between sizes of input arguments");
+      } else if( nscalars>0 ) {
+        error("scalars should be specified in argument list after all vectors");
+      }
+    } else {
+      error("input arguments should be vectors or scalars");
+    }
+  }
+  if( nmasks>0 && getPntrToArgument(getNumberOfArguments()-nmasks)->getShape()[0]!=shape[0] ) {
+    error("input mask has wrong size");
+  }
+
+  // Setup the function and the values
+  // Get the function data from the parallel task manager, to avoid copies
+  auto & myfunc = taskmanager.getActionInput();
+  myfunc.argstart = argstart;
+  myfunc.nscalars = nscalars;
+  FunctionData<T>::setup( myfunc.f, keywords.getOutputComponents(), shape, false, this );
+  // Setup the parallel task manager
+  taskmanager.setupParallelTaskManager( nargs-argstart, nscalars );
+}
+
+template <class T>
+std::string FunctionOfVector<T>::getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const {
+  if( getName().find("SORT")==std::string::npos ) {
+    return ActionWithValue::getOutputComponentDescription( cname, keys );
+  }
+  return "the " + cname + "th largest element in the input vectors";
+}
+
+template <class T>
+std::string FunctionOfVector<T>::writeInGraph() const {
+  std::size_t und = getName().find_last_of("_");
+  return getName().substr(0,und);
+}
+
+template <class T>
+unsigned FunctionOfVector<T>::getNumberOfDerivatives() {
+  unsigned nder = 0;
+  for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
+    nder += getPntrToArgument(i)->getNumberOfStoredValues();
+  }
+  return nder;
+}
+
+template <class T>
+void FunctionOfVector<T>::prepare() {
+  std::vector<std::size_t> shape(1);
+  for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
+    if( getPntrToArgument(i)->getRank()==1 ) {
+      shape[0] = getPntrToArgument(i)->getShape()[0];
+      break;
+    }
+  }
+  for(unsigned i=0; i<getNumberOfComponents(); ++i) {
+    Value* myval = getPntrToComponent(i);
+    if( myval->getRank()==1 && myval->getShape()[0]!=shape[0] ) {
+      myval->setShape(shape);
+    }
+  }
+  ActionWithVector::prepare();
+}
+
+template <class T>
+void FunctionOfVector<T>::getInputData( std::vector<double>& inputdata ) const {
+  unsigned nargs = getNumberOfArguments();
+  int nmasks = getNumberOfMasks();
+  if( nargs>=static_cast<unsigned>(nmasks) && nmasks>0 ) {
+    nargs = nargs - nmasks;
+  }
+
+  std::size_t ntasks = 0;
+  for(unsigned i=argstart; i<nargs; ++i) {
+    if( getPntrToArgument(i)->getRank()==1 ) {
+      ntasks = getPntrToArgument(i)->getShape()[0];
+      break;
+    }
+  }
+
+  std::size_t ndata = static_cast<std::size_t>(nargs-argstart)*ntasks;
+  if( inputdata.size()!=ndata ) {
+    inputdata.resize( ndata );
+  }
+
+  for(unsigned j=argstart; j<nargs; ++j) {
+    const Value* myarg =  getPntrToArgument(j);
+    if( myarg->getRank()==0 ) {
+      double val = myarg->get();
+      for(unsigned i=0; i<ntasks; ++i) {
+        inputdata[(nargs-argstart)*i + j-argstart] = val;
+      }
+    } else {
+      for(unsigned i=0; i<ntasks; ++i) {
+        inputdata[(nargs-argstart)*i + j-argstart] = myarg->get(i);
+      }
+    }
+  }
+}
+
+template <class T>
+void FunctionOfVector<T>::calculate() {
+  // This is done if we are calculating a function of multiple cvs
+  taskmanager.runAllTasks();
+}
+
+template <class T>
+void FunctionOfVector<T>::performTask( std::size_t task_index,
+                                       const FunctionData<T>& actiondata,
+                                       ParallelActionsInput& input,
+                                       ParallelActionsOutput& output ) {
+  auto funcout = FunctionOutput::create( input.ncomponents,
+                                         output.values.data(),
+                                         input.nderivatives_per_scalar,
+                                         output.derivatives.data() );
+  T::calc( actiondata.f,
+           input.noderiv,
+           View<const double>( input.inputdata + task_index*input.nderivatives_per_scalar,
+                               input.nderivatives_per_scalar ),
+           funcout );
+}
+
+template <class T>
+void FunctionOfVector<T>::applyNonZeroRankForces( std::vector<double>& outforces ) {
+  taskmanager.applyForces( outforces );
+}
+
+template <class T>
+int FunctionOfVector<T>::getNumberOfValuesPerTask( std::size_t task_index, const FunctionData<T>& actiondata ) {
+  return 1;
+}
+
+template <class T>
+void FunctionOfVector<T>::getForceIndices( std::size_t task_index,
+    std::size_t colno,
+    std::size_t ntotal_force,
+    const FunctionData<T>& actiondata,
+    const ParallelActionsInput& input,
+    ForceIndexHolder force_indices ) {
+
+  unsigned vector_end = actiondata.argstart + input.nderivatives_per_scalar - actiondata.nscalars;
+  for(unsigned j=0; j<input.ncomponents; ++j) {
+    for(unsigned k=actiondata.argstart; k<vector_end; ++k) {
+      force_indices.indices[j][k-actiondata.argstart] = input.argstarts[k] + task_index;
+    }
+    for(unsigned k=vector_end; k<vector_end+actiondata.nscalars; ++k) {
+      force_indices.indices[j][k-actiondata.argstart] = input.argstarts[k];
+    }
+    force_indices.threadsafe_derivatives_end[j] = input.nderivatives_per_scalar-actiondata.nscalars;
+    force_indices.tot_indices[j] = input.nderivatives_per_scalar;
+  }
+}
+
+}
+}
+#endif

plumed/_lib/include/plumed/function/FunctionSetup.h

@@ -0,0 +1,180 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_function_FunctionSetup_h
+#define __PLUMED_function_FunctionSetup_h
+
+#include "../core/ActionWithValue.h"
+#include "../core/ActionWithArguments.h"
+#include "../core/ActionWithVector.h"
+
+namespace PLMD {
+namespace function {
+
+struct FunctionOptions {
+  /// Is the derivative zero if the value is zero
+  bool derivativeZeroIfValueIsZero = false;
+/// Are multiple components registered with a single name as in SphericalHarmonic and Moments
+  std::vector<std::string> multipleValuesForEachRegisteredComponent;
+};
+
+template <class T>
+struct FunctionData {
+  /// Set equal to one if we are doing EvaluateGridFunction
+  unsigned argstart = 0;
+  // Number of scalars that appear in input
+  unsigned nscalars = 0;
+  T f;
+  // This is for setting up the functions
+  static void setup( T& myfunc,
+                     const std::vector<std::string>& components,
+                     const std::vector<std::size_t>& shape,
+                     bool hasderiv,
+                     ActionWithValue* action );
+#ifdef __PLUMED_USE_OPENACC
+  void toACCDevice() const {
+#pragma acc enter data copyin(this[0:1], argstart, nscalars)
+    f.toACCDevice();
+  }
+  void removeFromACCDevice() const {
+    f.removeFromACCDevice();
+#pragma acc exit data delete(nscalars, argstart, this[0:1])
+  }
+#endif //__PLUMED_USE_OPENACC
+};
+
+template <class T>
+void FunctionData<T>::setup( T& myfunc,
+                             const std::vector<std::string>& components,
+                             const std::vector<std::size_t>& shape,
+                             bool hasderiv,
+                             ActionWithValue* action ) {
+  ActionWithArguments* aarg = action->castToActionWithArguments();
+  plumed_assert( aarg );
+  FunctionOptions options;
+  T::read( myfunc, aarg, options );
+
+  if( action->keywords.getDisplayName()=="SORT" ) {
+    for(unsigned j=0; j<aarg->getNumberOfArguments(); ++j) {
+      std::string num;
+      Tools::convert( j+1, num );
+      if( hasderiv ) {
+        action->addComponentWithDerivatives( num, shape );
+      } else {
+        action->addComponent( num, shape );
+      }
+    }
+  } else {
+    for(unsigned i=0; i<components.size(); ++i) {
+      if( options.multipleValuesForEachRegisteredComponent.size()>0 ) {
+        for(unsigned j=0; j<options.multipleValuesForEachRegisteredComponent.size(); ++j) {
+          if( hasderiv ) {
+            action->addComponentWithDerivatives( components[i] + options.multipleValuesForEachRegisteredComponent[j], shape );
+          } else {
+            action->addComponent( components[i] + options.multipleValuesForEachRegisteredComponent[j], shape );
+          }
+        }
+      } else if( components[i]==".#!value" ) {
+        if( hasderiv ) {
+          action->addValueWithDerivatives( shape );
+        } else {
+          action->addValue( shape );
+        }
+      } else if( components[i].find_first_of("_")!=std::string::npos ) {
+        if( aarg->getNumberOfArguments()==1 && hasderiv ) {
+          action->addValueWithDerivatives( shape );
+        } else if( aarg->getNumberOfArguments()==1 ) {
+          action->addValue( shape );
+        } else {
+          for(unsigned j=0; j<aarg->getNumberOfArguments(); ++j) {
+            if( hasderiv ) {
+              action->addComponentWithDerivatives( (aarg->getPntrToArgument(j))->getName() + components[i], shape );
+            } else {
+              action->addComponent( (aarg->getPntrToArgument(j))->getName() + components[i], shape );
+            }
+          }
+        }
+      } else {
+        if( hasderiv ) {
+          action->addComponentWithDerivatives( components[i], shape );
+        } else {
+          action->addComponent( components[i], shape );
+        }
+      }
+    }
+  }
+  if( options.derivativeZeroIfValueIsZero ) {
+    for(unsigned i=0; i<action->getNumberOfComponents(); ++i) {
+      (action->copyOutput(i))->setDerivativeIsZeroWhenValueIsZero();
+    }
+  }
+  if( action->keywords.exists("PERIODIC") ) {
+    plumed_assert( action->keywords.getDisplayName()!="DIFFERENCE" );
+    std::vector<std::string> period;
+    action->parseVector("PERIODIC",period);
+    if( period.size()==1 ) {
+      if( period[0]!="NO") {
+        action->error("input to PERIODIC keyword does not make sense");
+      }
+      action->setNotPeriodic();
+      return;
+    } else if( period.size()!=2 ) {
+      action->error("input to PERIODIC keyword does not make sense");
+    }
+    for(unsigned i=0; i<action->getNumberOfComponents(); ++i) {
+      (action->copyOutput(i))->setDomain( period[0], period[1] );
+    }
+  } else if( action->keywords.getDisplayName()=="DIFFERENCE" ) {
+    if( aarg->getPntrToArgument(0)->isPeriodic() ) {
+      std::string min, max;
+      aarg->getPntrToArgument(0)->getDomain( min, max );
+      action->setPeriodic(min,max);
+    } else if( aarg->getPntrToArgument(1)->isPeriodic() ) {
+      std::string min, max;
+      aarg->getPntrToArgument(0)->getDomain( min, max );
+      action->setPeriodic( min, max );
+    } else {
+      action->setNotPeriodic();
+    }
+  } else {
+    for(unsigned i=0; i<action->getNumberOfComponents(); ++i) {
+      (action->copyOutput(i))->setNotPeriodic();
+    }
+  }
+}
+
+struct FunctionOutput {
+  View<double> values;
+  View2D<double> derivs;
+  static FunctionOutput create( unsigned nvals,
+                                double* vals,
+                                unsigned ndev,
+                                double* devs ) {
+    return FunctionOutput{
+      View<double>(vals,nvals),
+      View2D<double>(devs,nvals,ndev)
+    };
+  }
+};
+
+} // namespace function
+} // namespace PLMD
+#endif

plumed/_lib/include/plumed/function/FunctionShortcut.h

@@ -0,0 +1,130 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_function_FunctionShortcut_h
+#define __PLUMED_function_FunctionShortcut_h
+
+#include "../core/ActionShortcut.h"
+#include "../core/PlumedMain.h"
+#include "../core/ActionSet.h"
+#include "../core/ActionRegister.h"
+#include "../core/ActionWithArguments.h"
+#include "../core/Value.h"
+
+namespace PLMD {
+namespace function {
+
+template <class T>
+class FunctionShortcut : public ActionShortcut {
+private:
+/// The function that is being computed
+  T myfunc;
+public:
+  static void registerKeywords(Keywords&);
+  explicit FunctionShortcut(const ActionOptions&);
+  static void createAction( ActionShortcut* action, const std::vector<Value*>& vals, const std::string& allargs );
+};
+
+template <class T>
+void FunctionShortcut<T>::registerKeywords(Keywords& keys ) {
+  ActionShortcut::registerKeywords( keys );
+  keys.reserve("compulsory","PERIODIC","if the output of your function is periodic then you should specify the periodicity of the function.  If the output is not periodic you must state this using PERIODIC=NO");
+  keys.addActionNameSuffix("_SCALAR");
+  keys.addActionNameSuffix("_ONEARG");
+  keys.addActionNameSuffix("_VECTOR");
+  keys.addActionNameSuffix("_MATRIX");
+  keys.addActionNameSuffix("_GRID");
+  T tfunc;
+  tfunc.registerKeywords( keys );
+  if( keys.getDisplayName()=="SUM" || keys.getDisplayName()=="CUSTOM" || keys.getDisplayName()=="MATHEVAL" ) {
+    keys.addInputKeyword("compulsory","ARG","scalar/vector/matrix/grid","the values input to this function");
+  } else {
+    keys.addInputKeyword("compulsory","ARG","scalar/vector/matrix","the values input to this function");
+  }
+  if( keys.outputComponentExists(".#!value") && keys.getDisplayName()!="DIFFERENCE" ) {
+    keys.addInputKeyword("optional","MASK","vector/matrix","the label for a sparse vector/matrix that should be used to determine which elements of the vector/matrix should be computed");
+  }
+}
+
+template <class T>
+FunctionShortcut<T>::FunctionShortcut(const ActionOptions&ao):
+  Action(ao),
+  ActionShortcut(ao) {
+  std::vector<std::string> args;
+  parseVector("ARG",args);
+  std::string allargs=args[0];
+  for(unsigned i=1; i<args.size(); ++i) {
+    allargs += "," + args[i];
+  }
+  std::vector<Value*> vals;
+  ActionWithArguments::interpretArgumentList( args, plumed.getActionSet(), this, vals );
+  if( vals.size()==0 ) {
+    error("found no input arguments to function");
+  }
+  createAction( this, vals, allargs );
+}
+
+template <class T>
+void FunctionShortcut<T>::createAction( ActionShortcut* action, const std::vector<Value*>& vals, const std::string& allargs ) {
+  unsigned maxrank=vals[0]->getRank();
+  bool isgrid=false;
+  for(unsigned i=0; i<vals.size(); ++i) {
+    if( vals[i]->getRank()>0 && vals[i]->hasDerivatives() ) {
+      isgrid=true;
+    }
+    if( vals[i]->getRank()>maxrank ) {
+      maxrank=vals[i]->getRank();
+    }
+  }
+  if( isgrid ) {
+    if( actionRegister().check( action->getName() + "_GRID") ) {
+      action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_GRID ARG=" + allargs + " " + action->convertInputLineToString() );
+    } else {
+      plumed_merror("there is no action registered that allows you to do " + action->getName() + " with functions on a grid");
+    }
+  } else if( maxrank==0 ) {
+    if( actionRegister().check( action->getName() + "_SCALAR") ) {
+      action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_SCALAR ARG=" + allargs + " " + action->convertInputLineToString() );
+    } else {
+      plumed_merror("there is no action registered that allows you to do " + action->getName() + " with scalars");
+    }
+  } else if( vals.size()==1 && actionRegister().check( action->getName() + "_ONEARG") ) {
+    action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_ONEARG ARG=" + allargs + " " + action->convertInputLineToString() );
+  } else if( maxrank==1 ) {
+    if( actionRegister().check( action->getName() + "_VECTOR") ) {
+      action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_VECTOR ARG=" + allargs + " " + action->convertInputLineToString() );
+    } else {
+      plumed_merror("there is no action registered that allows you to do " + action->getName() + " with vectors");
+    }
+  } else if( maxrank==2  ) {
+    if( actionRegister().check( action->getName() + "_MATRIX") ) {
+      action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_MATRIX ARG=" + allargs + " " + action->convertInputLineToString() );
+    } else {
+      plumed_merror("there is no action registered that allows you to do " + action->getName() + " with matrices");
+    }
+  } else {
+    plumed_error();
+  }
+}
+
+}
+}
+#endif