hillclimber 0.1.6__cp313-cp313-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/function/FunctionWithSingleArgument.h

@@ -0,0 +1,165 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_FunctionWithSingleArgument_h
+#define __PLUMED_function_FunctionWithSingleArgument_h
+
+#include "../core/ActionWithArguments.h"
+#include "../core/ActionWithValue.h"
+#include "../core/ActionRegister.h"
+#include "FunctionSetup.h"
+
+namespace PLMD {
+namespace function {
+
+template <class T>
+class FunctionWithSingleArgument :
+  public ActionWithValue,
+  public ActionWithArguments {
+private:
+  T f;
+  bool ismatrix;
+public:
+  static void registerKeywords(Keywords& keys);
+  explicit FunctionWithSingleArgument(const ActionOptions&);
+  /// Get the label to write in the graph
+  std::string writeInGraph() const override {
+    std::size_t und = getName().find_last_of("_");
+    return getName().substr(0,und);
+  }
+  unsigned getNumberOfDerivatives() override ;
+  void calculate() override ;
+  void apply() override ;
+};
+
+template <class T>
+void FunctionWithSingleArgument<T>::registerKeywords(Keywords& keys) {
+  Action::registerKeywords(keys);
+  ActionWithValue::registerKeywords(keys);
+  ActionWithArguments::registerKeywords(keys);
+  std::string name = keys.getDisplayName();
+  std::size_t und=name.find("_ONEARG");
+  keys.setDisplayName( name.substr(0,und) );
+  keys.addInputKeyword("compulsory","ARG","vector/matrix","the vector/matrix that is being used in input");
+  T::registerKeywords( keys );
+}
+
+template <class T>
+FunctionWithSingleArgument<T>::FunctionWithSingleArgument(const ActionOptions&ao):
+  Action(ao),
+  ActionWithValue(ao),
+  ActionWithArguments(ao),
+  ismatrix(false) {
+
+  if( getNumberOfArguments()!=1 ) {
+    error("should only be one argument in input for this action");
+  }
+  ismatrix = getPntrToArgument(0)->getRank()==2 && !getPntrToArgument(0)->hasDerivatives();
+
+  std::vector<std::size_t> shape;
+  FunctionData<T>::setup( f, keywords.getOutputComponents(), shape, true, this );
+}
+
+template <class T>
+unsigned FunctionWithSingleArgument<T>::getNumberOfDerivatives() {
+  return getPntrToArgument(0)->getNumberOfStoredValues();
+}
+
+template <class T>
+void FunctionWithSingleArgument<T>::calculate() {
+  const Value* myarg = getPntrToArgument(0);
+  std::vector<double> args( myarg->getNumberOfStoredValues() );
+  if( ismatrix ) {
+    unsigned nvals = 0;
+    for(unsigned i=0; i<myarg->getShape()[0]; ++i) {
+      nvals += myarg->getRowLength(i);
+    }
+    args.resize( nvals );
+    unsigned k=0;
+    unsigned ncols = myarg->getNumberOfColumns();
+    for(unsigned i=0; i<myarg->getShape()[0]; ++i) {
+      for(unsigned j=0; j<myarg->getRowLength(i); ++j) {
+        args[k] = myarg->get(i*ncols + j, false);
+        ++k;
+      }
+    }
+  } else {
+    for(unsigned i=0; i<args.size(); ++i) {
+      args[i] = myarg->get( i );
+    }
+  }
+  std::vector<double> vals( getNumberOfComponents() ), deriv( getNumberOfComponents()*args.size() );
+  auto funcout = FunctionOutput::create( getNumberOfComponents(),
+                                         vals.data(),
+                                         args.size(),
+                                         deriv.data() );
+  T::calc( f,
+           doNotCalculateDerivatives(),
+           View<const double>(args.data(), args.size()),
+           funcout );
+  for(unsigned i=0; i<getNumberOfComponents(); ++i) {
+    Value* myval=getPntrToComponent(i);
+    myval->set( vals[i] );
+
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
+
+    for(unsigned j=0; j<args.size(); ++j) {
+      myval->setDerivative( j, funcout.derivs[i][j] );
+    }
+  }
+}
+
+template <class T>
+void FunctionWithSingleArgument<T>::apply() {
+  if( !getPntrToComponent(0)->forcesWereAdded() ) {
+    return ;
+  }
+
+  Value* myarg = getPntrToArgument(0);
+  if( ismatrix ) {
+    for(unsigned i=0; i<getNumberOfComponents(); ++i) {
+      unsigned k=0;
+      const Value* myval = getPntrToComponent(i);
+      double force = myval->getForce();
+      unsigned ncols = myarg->getNumberOfColumns();
+      for(unsigned n=0; n<myarg->getShape()[0]; ++n) {
+        for(unsigned j=0; j<myarg->getRowLength(i); ++j) {
+          myarg->addForce( n*ncols+j, force*myval->getDerivative(k), false );
+          ++k;
+        }
+      }
+    }
+  } else {
+    for(unsigned i=0; i<getNumberOfComponents(); ++i) {
+      const Value* myval = getPntrToComponent(i);
+      double force = myval->getForce();
+      for(unsigned j=0; j<myarg->getNumberOfStoredValues(); ++j) {
+        myarg->addForce( j, force*myval->getDerivative(j) );
+      }
+    }
+  }
+}
+
+}
+}
+#endif

plumed/_lib/include/plumed/gridtools/ActionWithGrid.h

@@ -0,0 +1,43 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2012-2017 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_gridtools_ActionWithGrid_h
+#define __PLUMED_gridtools_ActionWithGrid_h
+
+#include "../core/ActionWithVector.h"
+#include "GridCoordinatesObject.h"
+
+namespace PLMD {
+namespace gridtools {
+
+class ActionWithGrid : public ActionWithVector {
+public:
+  static void registerKeywords( Keywords& keys );
+  static ActionWithGrid* getInputActionWithGrid( Action* action );
+  explicit ActionWithGrid(const ActionOptions&ao);
+  void transferStashToValues( const std::vector<unsigned>& partialTaskList, const std::vector<double>& stash ) override ;
+  virtual std::vector<std::string> getGridCoordinateNames() const = 0;
+  virtual const GridCoordinatesObject& getGridCoordinatesObject() const = 0;
+};
+
+}
+}
+#endif

plumed/_lib/include/plumed/gridtools/EvaluateGridFunction.h

@@ -0,0 +1,99 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2015-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_gridtools_EvaluateGridFunction_h
+#define __PLUMED_gridtools_EvaluateGridFunction_h
+
+#include "../function/FunctionSetup.h"
+#include "ActionWithGrid.h"
+#include "Interpolator.h"
+
+namespace PLMD {
+namespace gridtools {
+
+class EvaluateGridFunction {
+public:
+/// Hold the function on the grid
+  Value* function=NULL;
+/// This is the grid that is used here
+  ActionWithGrid* gridact=NULL;
+/// How should we set the value of this function outside the range
+  bool set_zero_outside_range;
+/// How are we doing interpolation
+  enum {spline,linear,floor,ceiling} interpolation_type;
+/// This does the interpolating
+  std::unique_ptr<Interpolator> spline_interpolator;
+/// This is used to setup the input gridobject's bounds with the grid data from values
+  static void registerKeywords( Keywords& keys );
+  static void read( EvaluateGridFunction& func, ActionWithArguments* action, function::FunctionOptions& options );
+  static void calc( const EvaluateGridFunction& func, bool noderiv, View<const double> args, function::FunctionOutput& funcout );
+/// Get the vector containing the minimum value of the grid in each dimension
+  std::vector<std::string> getMin() const ;
+/// Get the vector containing the maximum value of the grid in each dimension
+  std::vector<std::string> getMax() const ;
+/// Get the periodicity of the grid
+  std::vector<bool> getPbc() const ;
+/// Get the number of grid points in each direction
+  std::vector<std::size_t> getNbin() const ;
+/// Get the grid spacing
+  const std::vector<double>& getGridSpacing() const ;
+/// This gets the grid object
+  const GridCoordinatesObject & getGridObject() const ;
+  EvaluateGridFunction& operator=( const EvaluateGridFunction& m ) {
+    function = m.function;
+    gridact = m.gridact;
+    set_zero_outside_range = m.set_zero_outside_range;
+    interpolation_type = m.interpolation_type;
+    if( interpolation_type==spline ) {
+      spline_interpolator = Tools::make_unique<Interpolator>( function, gridact->getGridCoordinatesObject() );
+    }
+    return *this;
+  }
+};
+
+inline
+std::vector<std::string> EvaluateGridFunction::getMin() const {
+  return (gridact->getGridCoordinatesObject()).getMin();
+}
+
+inline
+std::vector<std::string> EvaluateGridFunction::getMax() const {
+  return (gridact->getGridCoordinatesObject()).getMax();
+}
+
+inline
+std::vector<std::size_t> EvaluateGridFunction::getNbin() const {
+  return (gridact->getGridCoordinatesObject()).getNbin(false);
+}
+
+inline
+const std::vector<double>& EvaluateGridFunction::getGridSpacing() const {
+  return (gridact->getGridCoordinatesObject()).getGridSpacing();
+}
+
+inline
+const GridCoordinatesObject & EvaluateGridFunction::getGridObject() const {
+  return (gridact->getGridCoordinatesObject());
+}
+
+}
+}
+#endif

plumed/_lib/include/plumed/gridtools/FunctionOfGrid.h

@@ -0,0 +1,295 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_gridtools_FunctionOfGrid_h
+#define __PLUMED_gridtools_FunctionOfGrid_h
+
+#include "ActionWithGrid.h"
+#include "../core/ParallelTaskManager.h"
+#include "../function/FunctionSetup.h"
+#include "../function/FunctionOfVector.h"
+#include "../function/Custom.h"
+#include "EvaluateGridFunction.h"
+
+namespace PLMD {
+namespace gridtools {
+
+template <class T>
+class FunctionOfGrid : public ActionWithGrid {
+public:
+  using input_type = function::FunctionData<T>;
+  using PTM = ParallelTaskManager<FunctionOfGrid<T>>;
+private:
+/// The parallel task manager
+  PTM taskmanager;
+//// Ensures we setup on first step
+  bool firststep;
+/// The number of scalars that appear in the input for this calculation
+  unsigned nscalars;
+/// Set equal to one if we are doing EvaluateGridFunction
+  unsigned argstart;
+public:
+  static void registerKeywords(Keywords&);
+  explicit FunctionOfGrid(const ActionOptions&);
+/// Get the number of derivatives for this action
+  unsigned getNumberOfDerivatives() override ;
+/// Get the label to write in the graph
+  std::string writeInGraph() const override ;
+/// Get the underlying names
+  std::vector<std::string> getGridCoordinateNames() const override ;
+/// Get the underlying grid coordinates object
+  const GridCoordinatesObject& getGridCoordinatesObject() const override ;
+/// Get the input data for doing the parallel calculation
+  void getInputData( std::vector<double>& inputdata ) const override ;
+/// Do the calculation
+  void calculate() override ;
+// Calculate the value of the function at a grid point
+  static void performTask( std::size_t task_index,
+                           const function::FunctionData<T>& actiondata,
+                           ParallelActionsInput& input,
+                           ParallelActionsOutput& output );
+/// Add the forces
+//  void apply() override;
+  void applyNonZeroRankForces( std::vector<double>& outforces ) override ;
+/// This just returns one
+  static int getNumberOfValuesPerTask( std::size_t task_index,
+                                       const function::FunctionData<T>& actiondata );
+/// Get the indexes where the forces are added
+  static void getForceIndices( std::size_t task_index,
+                               std::size_t colno,
+                               std::size_t ntotal_force,
+                               const function::FunctionData<T>& actiondata,
+                               const ParallelActionsInput& input,
+                               ForceIndexHolder force_indices );
+};
+
+template <class T>
+void FunctionOfGrid<T>::registerKeywords(Keywords& keys ) {
+  ActionWithGrid::registerKeywords(keys);
+  std::string name = keys.getDisplayName();
+  std::size_t und=name.find("_GRID");
+  keys.setDisplayName( name.substr(0,und) );
+  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");
+  T tfunc;
+  T::registerKeywords( keys );
+  if( typeid(tfunc)==typeid(function::Custom()) ) {
+    keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
+  }
+  if( keys.outputComponentExists(".#!value") ) {
+    keys.setValueDescription("grid","the grid obtained by doing an element-wise application of " + keys.getOutputComponentDescription(".#!value") + " to the input grid");
+    keys.addInputKeyword("compulsory","ARG","scalar/grid","the labels of the scalars and functions on a grid that we are using to compute the required function");
+  }
+  PTM::registerKeywords( keys );
+}
+
+template <class T>
+FunctionOfGrid<T>::FunctionOfGrid(const ActionOptions&ao):
+  Action(ao),
+  ActionWithGrid(ao),
+  taskmanager(this),
+  firststep(true),
+  nscalars(0),
+  argstart(0) {
+  if( getNumberOfArguments()==0 ) {
+    error("found no arguments");
+  }
+  if( typeid(taskmanager.getActionInput().f)==typeid(EvaluateGridFunction) ) {
+    argstart=1;
+  }
+  // This will require a fix
+  if( getPntrToArgument(argstart)->getRank()==0 || !getPntrToArgument(argstart)->hasDerivatives() ) {
+    error("first input to this action must be a grid");
+  }
+  // Get the shape of the input grid
+  std::vector<std::size_t> shape( getPntrToArgument(argstart)->getShape() );
+  for(unsigned i=argstart+1; i<getNumberOfArguments(); ++i ) {
+    if( getPntrToArgument(i)->getRank()==0 ) {
+      nscalars++;
+      continue;
+    } else if( getPntrToArgument(i)->hasDerivatives() ) {
+      std::vector<std::size_t> s( getPntrToArgument(i)->getShape() );
+      if( s.size()!=shape.size() ) {
+        error("mismatch between dimensionalities of input grids");
+      } else if( nscalars>0 ) {
+        error("scalars should be specified in argument list after all functions on grid");
+      }
+    } else {
+      error("input arguments should be functions on grid or scalars");
+    }
+  }
+  auto & myfunc = taskmanager.getActionInput();
+  myfunc.argstart = argstart;
+  myfunc.nscalars = nscalars;
+  // Create the values for this grid
+  function::FunctionData<T>::setup( myfunc.f, keywords.getOutputComponents(), shape, true, this  );
+  // Setup the task manager
+  taskmanager.setupParallelTaskManager( getNumberOfArguments()-argstart, nscalars );
+}
+
+template <class T>
+std::string FunctionOfGrid<T>::writeInGraph() const {
+  std::size_t und = getName().find_last_of("_");
+  return getName().substr(0,und);
+}
+
+template <class T>
+const GridCoordinatesObject& FunctionOfGrid<T>::getGridCoordinatesObject() const {
+  ActionWithGrid* ag=ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
+  plumed_assert( ag );
+  return ag->getGridCoordinatesObject();
+}
+
+template <class T>
+std::vector<std::string> FunctionOfGrid<T>::getGridCoordinateNames() const {
+  ActionWithGrid* ag=ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
+  plumed_assert( ag );
+  return ag->getGridCoordinateNames();
+}
+
+template <class T>
+unsigned FunctionOfGrid<T>::getNumberOfDerivatives() {
+  return getGridCoordinatesObject().getDimension();
+}
+
+template <class T>
+void FunctionOfGrid<T>::calculate() {
+  if( firststep ) {
+    const GridCoordinatesObject& mygrid = getGridCoordinatesObject();
+    unsigned npoints = getPntrToArgument(0)->getNumberOfValues();
+    if( mygrid.getGridType()=="flat" ) {
+      std::vector<std::size_t> shape( mygrid.getNbin(true) );
+      for(unsigned i=1; i<getNumberOfArguments(); ++i ) {
+        if( getPntrToArgument(i)->getRank()==0 ) {
+          continue;
+        }
+        std::vector<std::size_t> s( getPntrToArgument(i)->getShape() );
+        for(unsigned j=0; j<shape.size(); ++j) {
+          if( shape[j]!=s[j] ) {
+            error("mismatch between sizes of input grids");
+          }
+        }
+      }
+      for(unsigned i=0; i<getNumberOfComponents(); ++i) {
+        if( getPntrToComponent(i)->getRank()>0 ) {
+          getPntrToComponent(i)->setShape(shape);
+        }
+      }
+    }
+    // This resizes the scalars
+    for(unsigned i=0; i<getNumberOfComponents(); ++i) {
+      if( getPntrToComponent(i)->getRank()==0 ) {
+        getPntrToComponent(i)->resizeDerivatives( npoints );
+      }
+    }
+    taskmanager.setupParallelTaskManager( getNumberOfArguments()-argstart, nscalars );
+    firststep=false;
+  }
+  taskmanager.runAllTasks();
+}
+
+template <class T>
+void FunctionOfGrid<T>::getInputData( std::vector<double>& inputdata ) const {
+  unsigned nargs = getNumberOfArguments();
+
+  std::size_t ntasks = 0, ngder = 0;
+  for(unsigned i=argstart; i<nargs; ++i) {
+    if( getPntrToArgument(i)->getRank()>0 ) {
+      ntasks = getPntrToArgument(i)->getNumberOfStoredValues();
+      ngder = getPntrToArgument(i)->getNumberOfDerivatives();
+      break;
+    }
+  }
+
+  std::size_t ndata = static_cast<std::size_t>(nargs-argstart)*ntasks*(1+ngder);
+  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)*(1+ngder)*i + j-argstart] = val;
+      }
+    } else {
+      for(unsigned i=0; i<ntasks; ++i) {
+        inputdata[(nargs-argstart)*(1+ngder)*i + j-argstart] = myarg->get(i);
+        for(unsigned k=0; k<ngder; ++k) {
+          inputdata[(nargs-argstart)*(1+ngder)*i + (nargs-argstart) + (j-argstart)*ngder + k] = myarg->getGridDerivative( i, k );
+        }
+      }
+    }
+  }
+}
+
+template <class T>
+void FunctionOfGrid<T>::performTask( std::size_t task_index,
+                                     const function::FunctionData<T>& actiondata,
+                                     ParallelActionsInput& input,
+                                     ParallelActionsOutput& output ) {
+
+  std::size_t rank=input.ranks[actiondata.argstart];
+  std::size_t spacing = (input.nargs-actiondata.argstart)*(1+rank);
+  auto funcout = function::FunctionOutput::create( input.ncomponents,
+                 output.values.data(),
+                 input.nargs-actiondata.argstart,
+                 output.derivatives.data() );
+  T::calc( actiondata.f,
+           input.noderiv,
+           View<const double>( input.inputdata + task_index*spacing,
+                               input.nargs-actiondata.argstart ),
+           funcout );
+
+  for(unsigned j=actiondata.argstart; j<input.nargs; ++j) {
+    double df = output.derivatives[j-actiondata.argstart];
+    View<const double> inders( input.inputdata + task_index*spacing + (input.nargs-actiondata.argstart) + (j-actiondata.argstart)*rank, rank );
+    for(unsigned k=0; k<input.ranks[actiondata.argstart]; ++k) {
+      output.values[1+k] += df*inders[k];
+    }
+  }
+}
+
+template <class T>
+void FunctionOfGrid<T>::applyNonZeroRankForces( std::vector<double>& outforces ) {
+  taskmanager.applyForces( outforces );
+}
+
+template <class T>
+int FunctionOfGrid<T>::getNumberOfValuesPerTask( std::size_t task_index,
+    const function::FunctionData<T>& actiondata ) {
+  return 1;
+}
+
+template <class T>
+void FunctionOfGrid<T>::getForceIndices( std::size_t task_index,
+    std::size_t colno,
+    std::size_t ntotal_force,
+    const function::FunctionData<T>& actiondata,
+    const ParallelActionsInput& input,
+    ForceIndexHolder force_indices ) {
+  // The force indices are found in the same way as in FunctionOfVector so we reuse that function here
+  function::FunctionOfVector<T>::getForceIndices( task_index, colno, ntotal_force, actiondata, input, force_indices );
+}
+
+}
+}
+#endif