hillclimber 0.1.5a8__cp314-cp314-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/core/ActionSet.h

@@ -0,0 +1,163 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_ActionSet_h
+#define __PLUMED_core_ActionSet_h
+
+#include "Action.h"
+#include "ActionShortcut.h"
+#include <memory>
+
+namespace PLMD {
+
+class PlumedMain;
+
+/// std::vector containing the sequence of Action to be done.
+/// It is a vector of Action*, and as such it has the entire
+/// std::vector interface. Moreover, it implements methods to extract
+/// Acion* of a given type (select<T>()), NOT of a given type (selectNot<T>())
+/// or to find an Action with a given label (selectWithLabel())
+/// Finally, since it holds pointers, there is a clearDelete() function
+/// which deletes the pointers before deleting the vector
+class ActionSet:
+  public std::vector<std::unique_ptr<Action>> {
+  PlumedMain& plumed;
+public:
+  explicit ActionSet(PlumedMain&p);
+  ~ActionSet();
+/// Clear and deletes all the included pointers.
+  void clearDelete();
+
+/// Extract pointers to all Action's of type T
+/// To extract all Colvar , use select<Colvar*>();
+  template <class T>
+  std::vector<T> select()const;
+/// Extract pointers to all Action's which are not of type T
+/// E.g., to extract all noncolvars, use
+///    selectNot<Colvar*>();
+  template <class T>
+  std::vector<Action*> selectNot()const;
+/// Extract pointer to an action labeled s, only if it is of
+/// type T. E.g., to extract an action labeled "pippo", use selectWithLabel<Action*>("pippo")
+/// If you want it to be a Colvar, use selectWithLabel<Colvar*>(pippo). If it is
+/// not found, it returns NULL
+  template <class T>
+  T selectWithLabel(const std::string&s)const;
+/// get the labels in the list of actions in form of a string (useful to debug)
+/// Only classes that can be dynamic casted to T are reported
+  template <class T>
+  std::string getLabelList() const;
+/// get the labels in the form of a vector of strings
+/// Only classes that can be dynamic casted to T are reported
+  template <class T>
+  std::vector<std::string> getLabelVector() const;
+/// Extract pointer to last action of type T located before
+/// action. If action is not in ActionSet or if there is no action of type T
+/// returns NULL.
+/// Typically to be used as selectLatest<Type>(this);
+  template <class T>
+  T selectLatest(const Action*action)const;
+/// Get any shortcuts with this shortcut label
+  ActionShortcut* getShortcutActionWithLabel( const std::string& s ) const ;
+};
+
+/////
+// INLINE IMPLEMENTATIONS:
+
+template <class T>
+std::vector<T> ActionSet::select()const {
+  std::vector<T> ret;
+  for(const auto & p : (*this)) {
+    T t=dynamic_cast<T>(p.get());
+    if(t) {
+      ret.push_back(t);
+    }
+  };
+  return ret;
+}
+
+template <class T>
+T ActionSet::selectWithLabel(const std::string&s)const {
+  for(const auto & p : (*this)) {
+    T t=dynamic_cast<T>(p.get());
+    if(t && t->getLabel()==s) {
+      return t;
+    }
+  };
+  return NULL;
+}
+
+template <class T>
+std::vector<Action*> ActionSet::selectNot()const {
+  std::vector<Action*> ret;
+  for(const auto & p : (*this)) {
+    T t=dynamic_cast<T>(p);
+    if(!t) {
+      ret.push_back(p.get());
+    }
+  };
+  return ret;
+}
+
+template <class T>
+std::string ActionSet::getLabelList() const {
+  std::string outlist;
+  for(const auto & p : (*this)) {
+    if(dynamic_cast<T>(p.get())) {
+      outlist+=p->getLabel()+" ";
+    }
+  };
+  return  outlist;
+}
+
+
+template <class T>
+std::vector<std::string> ActionSet::getLabelVector() const {
+  std::vector<std::string> outlist;
+  for(const auto & p : (*this)) {
+    if(dynamic_cast<T>(p.get())) {
+      outlist.push_back(p->getLabel());
+    }
+  };
+  return  outlist;
+}
+
+template <class T>
+T ActionSet::selectLatest(const Action*action) const {
+  T t=nullptr;
+  for(const auto & p : (*this)) {
+    if(p.get()==action) {
+      return t;
+    }
+    T r=dynamic_cast<T>(p.get());
+    if(r) {
+      t=r;
+    }
+  }
+  return t;
+}
+
+
+
+}
+
+#endif
+

plumed/_lib/include/plumed/core/ActionSetup.h

@@ -0,0 +1,48 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_ActionSetup_h
+#define __PLUMED_core_ActionSetup_h
+
+#include "Action.h"
+
+namespace PLMD {
+
+/**
+\ingroup MULTIINHERIT
+Action used to create a PLMD::Action that do something during setup only e.g. PLMD::SetupUnits
+*/
+class ActionSetup :
+  public virtual Action {
+public:
+/// Constructor
+  explicit ActionSetup(const ActionOptions&ao);
+/// Creator of keywords
+  static void registerKeywords( Keywords& keys );
+/// Do nothing.
+  void calculate() override {}
+/// Do nothing.
+  void apply() override {}
+};
+
+}
+
+#endif

plumed/_lib/include/plumed/core/ActionShortcut.h

@@ -0,0 +1,73 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2018-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_ActionShortcut_h
+#define __PLUMED_core_ActionShortcut_h
+
+#include "Action.h"
+
+namespace PLMD {
+
+/**
+\ingroup MULTIINHERIT
+Action used to create a command that expands to multiple PLMD::Action commands when read in during input
+*/
+class ActionShortcut :
+  public virtual Action {
+  friend class ActionSet;
+private:
+  std::string shortcutlabel;
+  std::vector<std::string> savedInputLines;
+  std::vector<std::string> savedOutputs;
+  void addToSavedInputLines( const std::string& line );
+protected:
+  std::string getUpdateLimits() const ;
+public:
+  const std::string & getShortcutLabel() const ;
+  static void registerKeywords( Keywords& keys );
+/// Constructor
+  explicit ActionShortcut(const ActionOptions&ao);
+/// Read keywords
+  void readShortcutKeywords( const Keywords& keys, std::map<std::string,std::string>& keymap );
+/// Read a line of input and create appropriate actions
+  void readInputLine( const std::string& input, bool saveline=true );
+/// Add a comment to your shortcut output
+  void addCommentToShortcutOutput( const std::string& input );
+/// Do nothing.
+  void calculate() override {}
+/// Do nothing.
+  void apply() override {}
+/// Get the lines of the shortcut that were read in
+  const std::vector<std::string>& getSavedInputLines() const ;
+/// Get the labels of the actions that this creates
+  const std::vector<std::string>& getSavedOutputs() const ;
+/// Take everything that was input to this action and convert it to a string
+  std::string convertInputLineToString();
+/// This sorts out the reading of arguments from shortcuts
+  void interpretDataLabel( const std::string& mystr, Action* myuser, std::vector<Value*>& args ) const ;
+  ActionShortcut* castToActionShortcut() noexcept final {
+    return this;
+  }
+};
+
+}
+
+#endif

plumed/_lib/include/plumed/core/ActionToGetData.h

@@ -0,0 +1,59 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2017-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_ActionToGetData_h
+#define __PLUMED_core_ActionToGetData_h
+
+#include "ActionWithArguments.h"
+#include "ActionPilot.h"
+#include "DataPassingObject.h"
+
+namespace PLMD {
+
+class ActionToGetData :
+  public ActionPilot,
+  public ActionWithArguments {
+private:
+/// What do you want to collect to pass back to python
+  enum class dataType {val,deriv,force} gtype;
+/// This holds the pointer that we are setting
+  std::unique_ptr<DataPassingObject> mydata;
+/// This temporarily holds the data so it can be passed out
+  std::vector<double> data;
+public:
+  static void registerKeywords(Keywords& keys);
+  explicit ActionToGetData(const ActionOptions&ao);
+/// Get the rank of the output
+  void get_rank( const TypesafePtr & rank );
+/// Get the shape of the output
+  void get_shape( const TypesafePtr & dims );
+/// Set the memory that holds the output
+  void set_memory( const TypesafePtr & val );
+/// Actually set the values for the output
+  void calculate();
+  void apply() {}
+  ActionToGetData* castToActionToGetData() noexcept final {
+    return this;
+  }
+};
+
+}
+#endif

plumed/_lib/include/plumed/core/ActionToPutData.h

@@ -0,0 +1,101 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2017-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_ActionToPutData_h
+#define __PLUMED_core_ActionToPutData_h
+
+#include "ActionForInterface.h"
+#include "DataPassingObject.h"
+#include "../tools/Units.h"
+#include "DataPassingTools.h"
+
+namespace PLMD {
+
+class ActionToPutData :
+  public ActionForInterface {
+  friend class PlumedMain;
+  friend class TimeStep;
+  friend class DomainDecomposition;
+private:
+/// Are we not applying forces on this values
+  bool noforce;
+/// Is this quantity fixed
+  bool fixed;
+/// Is this quantity passed from the domains
+  bool from_domains;
+/// Is PLUMED allowed to change the value of this pointer
+  bool resetable;
+/// Are we allowed to set data at this time
+  bool dataCanBeSet;
+/// The unit of the value that has been passed to plumed
+  enum {n,e,l,m,q,t} unit;
+/// The unit to to use for the force
+  enum {d,eng} funit;
+/// This holds the pointer that we getting data from
+  std::unique_ptr<DataPassingObject> mydata;
+/// Convert the enum contaning the unit into the name of the unit
+  std::string getUnitName() const ;
+protected:
+/// Setup the units of the input value
+  void setUnit( const std::string& unitstr, const std::string& funitstr );
+public:
+  static void registerKeywords(Keywords& keys);
+  explicit ActionToPutData(const ActionOptions&ao);
+/// Set the start point for the memory if needed
+  void setStart( const std::string& actname, const unsigned& sss) override;
+/// This resets the stride in the collection object
+  void setStride( const std::string& actname, const unsigned& sss ) override;
+/// Update the units on the input data
+  void updateUnits( DataPassingTools* passtools );
+/// This is called at the start of the step
+  void resetForStepStart() override {
+    dataCanBeSet = true;
+  }
+/// These are the actions that set the pointers to the approrpiate values
+  virtual bool setValuePointer( const std::string& actname, const TypesafePtr & val ) override ;
+  bool setForcePointer( const std::string& actname, const TypesafePtr & val ) override ;
+///
+  void Set_comm(Communicator& newcomm) override {}
+/// And this gets the number of forces that need to be rescaled
+  unsigned getNumberOfForcesToRescale() const override ;
+/// Share the data
+  void share() override {}
+  void shareAll() override {}
+///
+  void getLocalValues( std::vector<double>& vals ) const ;
+/// Get the data to share
+  virtual void wait() override ;
+/// Actually set the values for the output
+  virtual void apply() override ;
+  void rescaleForces( const double& alpha );
+/// For replica exchange
+  void writeBinary(std::ostream&o) override;
+  virtual void readBinary(std::istream&i) override;
+  bool onStep() const override {
+    return false;
+  }
+  ActionToPutData* castToActionToPutData() noexcept final {
+    return this;
+  }
+};
+
+}
+#endif

plumed/_lib/include/plumed/core/ActionWithArguments.h

@@ -0,0 +1,140 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_ActionWithArguments_h
+#define __PLUMED_core_ActionWithArguments_h
+
+#include "Action.h"
+#include "Value.h"
+#include <vector>
+
+namespace PLMD {
+
+/**
+\ingroup MULTIINHERIT
+This is used to create PLMD::Action objects that take the output from some other Action as input.
+This is used in PLMD::Function and PLMD::Bias
+ PLMD::Action objects that inherit from PLMD::ActionWithArguments take
+ values and components calculated in other PLMD::Action objects and
+ use this information to calculate some new function.  If you have
+ only one list of arguments you should use the reserved keyword <b> ARG </b>
+ when you use parseArgumentList.
+*/
+
+class ActionSet;
+
+class ActionWithArguments:
+  public virtual Action {
+  std::vector<Value*> arguments;
+  bool lockRequestArguments;
+protected:
+/// This changes the arg keyword in the pdb file
+  void expandArgKeywordInPDB( const PDB& pdb );
+public:
+/// Get the scalar product between the gradients of two variables
+  double getProjection(unsigned i,unsigned j)const;
+/// Registers the list of keywords
+  static void registerKeywords( Keywords& keys );
+/// Returns the value of an argument
+  double getArgument( const unsigned n ) const;
+/// Return a pointer to specific argument
+  Value* getPntrToArgument( const unsigned n ) const;
+/// Returns the number of arguments
+  virtual unsigned getNumberOfArguments() const ;
+/// Takes the difference taking into account pbc for arg i
+  double difference(int, double, double) const;
+/// Takes one value and brings it back into the pbc of argument i
+  double bringBackInPbc(int i,double d1)const;
+/// Parse a list of arguments
+  void parseArgumentList(const std::string&key,std::vector<Value*>&args);
+/// Parse a numbered list of arguments
+  bool parseArgumentList(const std::string&key,int i,std::vector<Value*>&args);
+/// Setup the dependencies
+  void requestArguments(const std::vector<Value*> &arg);
+  void requestExtraDependencies(const std::vector<Value*> &extra);
+/// Add forces to arguments (used in apply)
+  void addForcesOnArguments( const unsigned& argstart, const std::vector<double>& forces, unsigned& ind );
+public:
+  explicit ActionWithArguments(const ActionOptions&);
+  virtual ~ActionWithArguments() {}
+/// Calculate the numerical derivatives
+/// N.B. only pass an ActionWithValue to this routine if you know exactly what you
+/// are doing.  The default will be correct for the vast majority of cases
+  void calculateNumericalDerivatives( ActionWithValue* a=NULL ) override;
+  void lockRequests() override;
+  void unlockRequests() override;
+/// Returns an array of pointers to the arguments
+  virtual const std::vector<Value*>    & getArguments() const ;
+/// Convert a list of argument names into a list of pointers to the values
+  static void interpretArgumentList(const std::vector<std::string>& c, const ActionSet& as, Action* action, std::vector<Value*>&arg);
+/// Used to calculate constant values in startup
+  virtual bool calculateConstantValues( const bool& have_atoms );
+/// Get the gradient for this action
+  void setGradients( Value* myval, unsigned& start ) const ;
+  ActionWithArguments* castToActionWithArguments() noexcept final {
+    return this;
+  }
+};
+
+
+inline
+Value* ActionWithArguments::getPntrToArgument( const unsigned n ) const {
+  return arguments[n];
+}
+
+inline
+double ActionWithArguments::getArgument(const unsigned n) const {
+  return arguments[n]->get();
+}
+
+inline
+unsigned ActionWithArguments::getNumberOfArguments()const {
+  return arguments.size();
+}
+
+inline
+double ActionWithArguments::difference(int i,double d1,double d2)const {
+  return arguments[i]->difference(d1,d2);
+}
+
+inline
+double ActionWithArguments::bringBackInPbc(int i,double d1)const {
+  return arguments[i]->bringBackInPbc(d1);
+}
+
+inline
+void ActionWithArguments::lockRequests() {
+  lockRequestArguments=true;
+}
+
+inline
+void ActionWithArguments::unlockRequests() {
+  lockRequestArguments=false;
+}
+
+inline
+const std::vector<Value*> & ActionWithArguments::getArguments() const {
+  return arguments;
+}
+
+}
+
+#endif

plumed/_lib/include/plumed/core/ActionWithMatrix.h

@@ -0,0 +1,87 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_ActionWithMatrix_h
+#define __PLUMED_core_ActionWithMatrix_h
+
+#include "ActionWithVector.h"
+#include <cstddef>
+
+namespace PLMD {
+
+//this class serves as a workaround for moving data with openacc without specifying --memory=managed
+class RequiredMatrixElements {
+  std::vector<std::size_t> bookeeping{};
+  std::size_t* bookeeping_data=nullptr;
+public:
+  std::size_t ncols=0;
+  void update() {
+    bookeeping_data = bookeeping.data();
+  }
+  void toACCDevice() const {
+    //this assumes that update() has already been called
+#pragma acc enter data copyin(this[0:1], bookeeping_data[0:bookeeping.size()])
+  }
+  void removeFromACCDevice() const {
+#pragma acc exit data delete(bookeeping_data[0:bookeeping.size()],this[0:1])
+  }
+  std::size_t& operator[]( std::size_t i ) {
+    return bookeeping_data[i];
+  }
+  std::size_t operator[]( std::size_t i ) const {
+    return bookeeping_data[i];
+  }
+  std::size_t size() const {
+    return bookeeping.size();
+  }
+  void resize(std::size_t newSize) {
+    bookeeping.resize(newSize);
+    update();
+  }
+};
+
+class MatrixElementOutput {
+public:
+  View<double> values;
+  View2D<double> derivs;
+  MatrixElementOutput( std::size_t nv, std::size_t nd, double* v, double* d ) :
+    values( v, nv ),
+    derivs( d, nv, nd ) {
+  }
+};
+
+class ActionWithMatrix : public ActionWithVector {
+protected:
+/// Some actions have a flag that sets this to true.  The elements on the diagonal of the resulting matrix are then set to zero
+  bool diagzero;
+/// Update all the arrays for doing bookeeping
+  void updateBookeepingArrays( RequiredMatrixElements& mat );
+public:
+  static void registerKeywords( Keywords& keys );
+  explicit ActionWithMatrix(const ActionOptions&);
+/// Get the elements of the matrices into the output values
+  void transferStashToValues( const std::vector<unsigned>& partialTaskList, const std::vector<double>& stash ) override ;
+/// Get the forces from the output values and transfer them to the stash
+  void transferForcesToStash( const std::vector<unsigned>& partialTaskList, std::vector<double>& stash ) const override ;
+};
+
+}
+#endif