hillclimber 0.1.5a8__cp314-cp314-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/matrixtools/MatrixTimesMatrix.h

@@ -0,0 +1,309 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_matrixtools_MatrixTimesMatrix_h
+#define __PLUMED_matrixtools_MatrixTimesMatrix_h
+
+#include "../core/ActionWithMatrix.h"
+#include "../core/ParallelTaskManager.h"
+
+namespace PLMD {
+namespace matrixtools {
+
+template <class T>
+struct MatrixTimesMatrixInput {
+  T funcinput;
+  RequiredMatrixElements outmat;
+#ifdef __PLUMED_USE_OPENACC
+  void toACCDevice() const {
+#pragma acc enter data copyin(this[0:1])
+    funcinput.toACCDevice();
+    outmat.toACCDevice();
+  }
+  void removeFromACCDevice() const {
+    funcinput.removeFromACCDevice();
+    outmat.removeFromACCDevice();
+#pragma acc exit data delete(this[0:1])
+  }
+#endif //__PLUMED_USE_OPENACC
+};
+
+class InputVectors {
+public:
+  std::size_t nelem;
+  View<double> arg1;
+  View<double> arg2;
+  InputVectors( std::size_t n,  double* b ) : nelem(n), arg1(b,n), arg2(b+n,n) {}
+};
+
+template <class T>
+class MatrixTimesMatrix : public ActionWithMatrix {
+public:
+  using input_type = MatrixTimesMatrixInput<T>;
+  using PTM = ParallelTaskManager<MatrixTimesMatrix<T>>;
+private:
+  PTM taskmanager;
+public:
+  static void registerKeywords( Keywords& keys );
+  explicit MatrixTimesMatrix(const ActionOptions&);
+  void prepare() override ;
+  unsigned getNumberOfDerivatives() override;
+  void calculate() override ;
+  void applyNonZeroRankForces( std::vector<double>& outforces ) override ;
+  static void performTask( std::size_t task_index, const MatrixTimesMatrixInput<T>& actiondata, ParallelActionsInput& input, ParallelActionsOutput& output );
+  static int getNumberOfValuesPerTask( std::size_t task_index, const MatrixTimesMatrixInput<T>& actiondata );
+  static void getForceIndices( std::size_t task_index, std::size_t colno, std::size_t ntotal_force, const MatrixTimesMatrixInput<T>& actiondata, const ParallelActionsInput& input, ForceIndexHolder force_indices );
+};
+
+template <class T>
+void MatrixTimesMatrix<T>::registerKeywords( Keywords& keys ) {
+  ActionWithMatrix::registerKeywords(keys);
+  keys.addInputKeyword("optional","MASK","matrix","a matrix that is used to used to determine which elements of the output matrix to compute");
+  keys.addInputKeyword("compulsory","ARG","matrix","the label of the two matrices from which the product is calculated");
+  if( keys.getDisplayName()=="MATRIX_PRODUCT" ) {
+    keys.addFlag("ELEMENTS_ON_DIAGONAL_ARE_ZERO",false,"set all diagonal elements to zero");
+  }
+  T::registerKeywords( keys );
+  PTM::registerKeywords( keys );
+}
+
+template <class T>
+MatrixTimesMatrix<T>::MatrixTimesMatrix(const ActionOptions&ao):
+  Action(ao),
+  ActionWithMatrix(ao),
+  taskmanager(this) {
+  int nm=getNumberOfMasks();
+  if( nm<0 ) {
+    nm = 0;
+  }
+  if( getNumberOfArguments()-nm!=2 ) {
+    error("should be two arguments to this action, a matrix and a vector");
+  }
+  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) {
+    error("first argument to this action should be a matrix");
+  }
+  if( getPntrToArgument(1)->getRank()!=2 || getPntrToArgument(1)->hasDerivatives() ) {
+    error("second argument to this action should be a matrix");
+  }
+  if( getPntrToArgument(0)->getShape()[1]!=getPntrToArgument(1)->getShape()[0] ) {
+    error("number of columns in first matrix does not equal number of rows in second matrix");
+  }
+  std::vector<std::size_t> shape(2);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
+  shape[1]=getPntrToArgument(1)->getShape()[1];
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  if( getName()!="DISSIMILARITIES" && getPntrToArgument(0)->isDerivativeZeroWhenValueIsZero() && getPntrToArgument(1)->isDerivativeZeroWhenValueIsZero() ) {
+    getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
+  }
+
+  if( nm>0 ) {
+    unsigned iarg = getNumberOfArguments()-1;
+    if( getPntrToArgument(iarg)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) {
+      error("argument passed to MASK keyword should be a matrix");
+    }
+    if( getPntrToArgument(iarg)->getShape()[0]!=shape[0] || getPntrToArgument(iarg)->getShape()[1]!=shape[1] ) {
+      error("argument passed to MASK keyword has the wrong shape");
+    }
+  }
+  MatrixTimesMatrixInput<T> actdata;
+  actdata.funcinput.setup( this, getPntrToArgument(0) );
+  taskmanager.setActionInput( actdata );
+}
+
+template <class T>
+unsigned MatrixTimesMatrix<T>::getNumberOfDerivatives() {
+  return getPntrToArgument(0)->getNumberOfStoredValues() + getPntrToArgument(1)->getNumberOfStoredValues();
+}
+
+template <class T>
+void MatrixTimesMatrix<T>::prepare() {
+  ActionWithVector::prepare();
+  Value* myval = getPntrToComponent(0);
+  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] && myval->getShape()[1]==getPntrToArgument(1)->getShape()[1] ) {
+    return;
+  }
+  std::vector<std::size_t> shape(2);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
+  shape[1]=getPntrToArgument(1)->getShape()[1];
+  myval->setShape(shape);
+  myval->reshapeMatrixStore( shape[1] );
+}
+
+template <class T>
+void MatrixTimesMatrix<T>::calculate() {
+  if( !getPntrToComponent(0)->isDerivativeZeroWhenValueIsZero() ) {
+    if( getPntrToArgument(0)->getNumberOfColumns()<getPntrToArgument(0)->getShape()[1] ) {
+      if( !doNotCalculateDerivatives() ) {
+        error("cannot calculate derivatives for this action with sparse matrices");
+      } else if( getName()=="DISSIMILARITIES" ) {
+        error("cannot calculate dissimilarities for sparse matrices");
+      }
+    }
+    if( getPntrToArgument(1)->getNumberOfColumns()<getPntrToArgument(1)->getShape()[1] ) {
+      if( !doNotCalculateDerivatives() ) {
+        error("cannot calculate derivatives for this action with sparse matrices");
+      } else if( getName()=="DISSIMILARITIES" ) {
+        error("cannot calculate dissimilarities for sparse matrices");
+      }
+    }
+  }
+  updateBookeepingArrays( taskmanager.getActionInput().outmat );
+  taskmanager.setupParallelTaskManager( 2*getPntrToArgument(0)->getNumberOfColumns(), getPntrToArgument(1)->getNumberOfStoredValues() );
+  taskmanager.setWorkspaceSize( 2*getPntrToArgument(0)->getNumberOfColumns() );
+  taskmanager.runAllTasks();
+}
+
+template <class T>
+void MatrixTimesMatrix<T>::performTask( std::size_t task_index,
+                                        const MatrixTimesMatrixInput<T>& actiondata,
+                                        ParallelActionsInput& input,
+                                        ParallelActionsOutput& output ) {
+  auto arg0=ArgumentBookeepingHolder::create( 0, input );
+  auto arg1=ArgumentBookeepingHolder::create( 1, input );
+  std::size_t fpos = task_index*(1+arg0.ncols);
+  std::size_t nmult = arg0.bookeeping[fpos];
+  std::size_t vstart = task_index*arg0.ncols;
+  InputVectors vectors( nmult, output.buffer.data() );
+  if( arg1.ncols<arg1.shape[1] ) {
+    std::size_t fstart = task_index*(1+actiondata.outmat.ncols);
+    std::size_t nelements = actiondata.outmat[fstart];
+    for(unsigned i=0; i<nelements; ++i) {
+      std::size_t nm = 0;
+      for(unsigned j=0; j<nmult; ++j) {
+        std::size_t kind = arg0.bookeeping[fpos+1+j];
+        std::size_t bstart = kind*(arg1.ncols + 1);
+        std::size_t nr = arg1.bookeeping[bstart];
+        for(unsigned k=0; k<nr; ++k) {
+          if( arg1.bookeeping[bstart+1+k]==actiondata.outmat[fstart+1+i] ) {
+            nm++;
+            break;
+          }
+        }
+      }
+      vectors.nelem = nm;
+      nm = 0;
+      for(unsigned j=0; j<nmult; ++j) {
+        std::size_t kind = arg0.bookeeping[fpos+1+j];
+        std::size_t bstart = kind*(arg1.ncols + 1);
+        std::size_t nr = arg1.bookeeping[bstart];
+        for(unsigned k=0; k<nr; ++k) {
+          if( arg1.bookeeping[bstart+1+k]==actiondata.outmat[fstart+1+i] ) {
+            vectors.arg1[nm] = input.inputdata[ vstart + j ];
+            vectors.arg2[nm] = input.inputdata[ arg1.start + kind*arg1.ncols + k ];
+            nm++;
+            break;
+          }
+        }
+      }
+      MatrixElementOutput elem( 1, 2*nmult, output.values.data() + i, output.derivatives.data() + 2*nmult*i );
+      T::calculate( input.noderiv, actiondata.funcinput, vectors, elem );
+      for(unsigned ii=vectors.nelem; ii<nmult; ++ii) {
+        elem.derivs[0][ii] = 0;
+      }
+    }
+  } else {
+    // Retrieve the row of the first matrix
+    for(unsigned i=0; i<nmult; ++i) {
+      vectors.arg1[i] = input.inputdata[ vstart + i ];
+    }
+
+    // Now do our multiplications
+    std::size_t fstart = task_index*(1+actiondata.outmat.ncols);
+    std::size_t nelements = actiondata.outmat[fstart];
+    for(unsigned i=0; i<nelements; ++i) {
+      std::size_t base = arg1.start + actiondata.outmat[fstart+1+i];
+      for(unsigned j=0; j<nmult; ++j) {
+        vectors.arg2[j] = input.inputdata[ base + arg1.ncols*arg0.bookeeping[fpos+1+j] ];
+      }
+      MatrixElementOutput elem( 1, 2*nmult, output.values.data() + i, output.derivatives.data() + 2*nmult*i );
+      T::calculate( input.noderiv, actiondata.funcinput, vectors, elem );
+    }
+  }
+}
+
+template <class T>
+void MatrixTimesMatrix<T>::applyNonZeroRankForces( std::vector<double>& outforces ) {
+  taskmanager.applyForces( outforces );
+}
+
+template <class T>
+int MatrixTimesMatrix<T>::getNumberOfValuesPerTask( std::size_t task_index,
+    const MatrixTimesMatrixInput<T>& actiondata ) {
+  std::size_t fstart = task_index*(1+actiondata.outmat.ncols);
+  return actiondata.outmat[fstart];
+}
+
+template <class T>
+void MatrixTimesMatrix<T>::getForceIndices( std::size_t task_index,
+    std::size_t colno,
+    std::size_t ntotal_force,
+    const MatrixTimesMatrixInput<T>& actiondata,
+    const ParallelActionsInput& input,
+    ForceIndexHolder force_indices ) {
+  auto arg0=ArgumentBookeepingHolder::create( 0, input );
+  auto arg1=ArgumentBookeepingHolder::create( 1, input );
+  std::size_t fpos = task_index*(1+arg0.ncols);
+  std::size_t nmult = arg0.bookeeping[fpos];
+  std::size_t fstart = task_index*(1+actiondata.outmat.ncols);
+  if( arg1.ncols<arg1.shape[1] ) {
+    std::size_t nmult_r = 0;
+    for(unsigned j=0; j<nmult; ++j) {
+      std::size_t kind = arg0.bookeeping[fpos+1+j];
+      std::size_t bstart = kind*(arg1.ncols + 1);
+      std::size_t nr = arg1.bookeeping[bstart];
+      for(unsigned k=0; k<nr; ++k) {
+        if( arg1.bookeeping[bstart+1+k]==actiondata.outmat[fstart+1+colno] ) {
+          nmult_r++;
+          break;
+        }
+      }
+    }
+    std::size_t n = 0;
+    for(unsigned j=0; j<nmult; ++j) {
+      std::size_t kind = arg0.bookeeping[fpos+1+j];
+      std::size_t bstart = kind*(arg1.ncols + 1);
+      std::size_t nr = arg1.bookeeping[bstart];
+      for(unsigned k=0; k<nr; ++k) {
+        if( arg1.bookeeping[bstart+1+k]==actiondata.outmat[fstart+1+colno] ) {
+          force_indices.indices[0][n] = task_index*arg0.ncols + j;
+          force_indices.indices[0][nmult+n] = arg1.start + arg0.bookeeping[fpos+1+j]*arg1.ncols + k;
+          n++;
+          break;
+        }
+      }
+    }
+    force_indices.threadsafe_derivatives_end[0] = nmult_r;
+    force_indices.tot_indices[0] = nmult + nmult_r;
+  } else {
+    for(unsigned j=0; j<nmult; ++j) {
+      force_indices.indices[0][j] = task_index*arg0.ncols + j;
+      force_indices.indices[0][nmult+j] = arg1.start + arg0.bookeeping[fpos+1+j]*arg1.ncols + actiondata.outmat[fstart+1+colno];
+    }
+    force_indices.threadsafe_derivatives_end[0] = nmult;
+    force_indices.tot_indices[0] = 2*nmult;
+  }
+}
+
+}
+}
+#endif

plumed/_lib/include/plumed/matrixtools/MatrixTimesVectorBase.h

@@ -0,0 +1,365 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_matrixtools_MatrixTimesVectorBase_h
+#define __PLUMED_matrixtools_MatrixTimesVectorBase_h
+
+#include "../core/ActionWithVector.h"
+#include "../core/ParallelTaskManager.h"
+
+namespace PLMD {
+namespace matrixtools {
+
+class MatrixTimesVectorData {
+public:
+  std::size_t fshift;
+  Matrix<std::size_t> pairs;
+#ifdef __PLUMED_USE_OPENACC
+  void toACCDevice() const {
+#pragma acc enter data copyin(this[0:1],fshift)
+    pairs.toACCDevice();
+  }
+  void removeFromACCDevice() const {
+    pairs.removeFromACCDevice();
+#pragma acc exit data delete(fshift,this[0:1])
+  }
+#endif //__PLUMED_USE_OPENACC
+};
+
+class MatrixForceIndexInput {
+public:
+  std::size_t rowlen;
+  View<const std::size_t> indices;
+  MatrixForceIndexInput( std::size_t task_index,
+                         std::size_t ipair,
+                         const MatrixTimesVectorData& actiondata,
+                         const ParallelActionsInput& input ):
+    rowlen(input.bookeeping[input.bookstarts[actiondata.pairs[ipair][0]]
+                            + (1+input.ncols[actiondata.pairs[ipair][0]])*task_index]),
+    indices(input.bookeeping + input.bookstarts[actiondata.pairs[ipair][0]]
+            + (1+input.ncols[actiondata.pairs[ipair][0]])*task_index + 1,
+            rowlen) {}
+};
+
+class MatrixTimesVectorInput {
+public:
+  bool noderiv;
+  std::size_t rowlen;
+  View<const std::size_t> indices;
+  View<const double> matrow;
+  View<const double> vector;
+  MatrixTimesVectorInput( std::size_t task_index,
+                          std::size_t ipair,
+                          const MatrixTimesVectorData& actiondata,
+                          const ParallelActionsInput& input,
+                          double* argdata ):
+    noderiv(input.noderiv),
+    rowlen(input.bookeeping[input.bookstarts[actiondata.pairs[ipair][0]]
+                            + (1+input.ncols[actiondata.pairs[ipair][0]])*task_index]),
+    indices(input.bookeeping + input.bookstarts[actiondata.pairs[ipair][0]]
+            + (1+input.ncols[actiondata.pairs[ipair][0]])*task_index + 1,rowlen),
+    matrow(argdata + input.argstarts[actiondata.pairs[ipair][0]]
+           + task_index*input.ncols[actiondata.pairs[ipair][0]],rowlen),
+    vector(argdata + input.argstarts[actiondata.pairs[ipair][1]], input.shapedata[1]) {
+  }
+};
+
+class MatrixTimesVectorOutput {
+public:
+  std::size_t rowlen;
+  View<double,1> values;
+  View<double> matrow_deriv;
+  View<double> vector_deriv;
+  MatrixTimesVectorOutput( std::size_t task_index,
+                           std::size_t ipair,
+                           std::size_t nder,
+                           const MatrixTimesVectorData& actiondata,
+                           const ParallelActionsInput& input,
+                           ParallelActionsOutput& output ):
+    rowlen(input.bookeeping[input.bookstarts[actiondata.pairs[ipair][0]]
+                            + (1+input.ncols[actiondata.pairs[ipair][0]])*task_index]),
+    values(output.values.data()+ipair),
+    matrow_deriv(output.derivatives.data()+ipair*nder,rowlen),
+    vector_deriv(output.derivatives.data()+ipair*nder+rowlen,rowlen) {
+  }
+};
+
+template <class T>
+class MatrixTimesVectorBase : public ActionWithVector {
+public:
+  using input_type = MatrixTimesVectorData;
+  using PTM = ParallelTaskManager<MatrixTimesVectorBase<T>>;
+private:
+/// The parallel task manager
+  PTM taskmanager;
+public:
+  static void registerKeywords( Keywords& keys );
+  static void registerLocalKeywords( Keywords& keys );
+  explicit MatrixTimesVectorBase(const ActionOptions&);
+  std::string getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const override ;
+  unsigned getNumberOfDerivatives() override ;
+  void prepare() override ;
+  void calculate() override ;
+  void applyNonZeroRankForces( std::vector<double>& outforces ) override ;
+  int checkTaskIsActive( const unsigned& itask ) const override ;
+  /// Override this so we write the graph properly
+  std::string writeInGraph() const override {
+    return "MATRIX_VECTOR_PRODUCT";
+  }
+  static void performTask( std::size_t task_index,
+                           const MatrixTimesVectorData& actiondata,
+                           ParallelActionsInput& input,
+                           ParallelActionsOutput& output );
+  static int getNumberOfValuesPerTask( std::size_t task_index,
+                                       const MatrixTimesVectorData& actiondata );
+  static void getForceIndices( std::size_t task_index,
+                               std::size_t colno,
+                               std::size_t ntotal_force,
+                               const MatrixTimesVectorData& actiondata,
+                               const ParallelActionsInput& input,
+                               ForceIndexHolder force_indices );
+};
+
+template <class T>
+void MatrixTimesVectorBase<T>::registerKeywords( Keywords& keys ) {
+  ActionWithVector::registerKeywords(keys);
+  keys.setDisplayName("MATRIX_VECTOR_PRODUCT");
+  registerLocalKeywords( keys );
+  ActionWithValue::useCustomisableComponents(keys);
+  keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
+}
+
+template <class T>
+void MatrixTimesVectorBase<T>::registerLocalKeywords( Keywords& keys ) {
+  PTM::registerKeywords( keys );
+  keys.addInputKeyword("compulsory","ARG","matrix/vector/scalar","the label for the matrix and the vector/scalar that are being multiplied.  Alternatively, you can provide labels for multiple matrices and a single vector or labels for a single matrix and multiple vectors. In these cases multiple matrix vector products will be computed.");
+  keys.add("hidden","MASKED_INPUT_ALLOWED","turns on that you are allowed to use masked inputs ");
+  keys.setValueDescription("vector","the vector that is obtained by taking the product between the matrix and the vector that were input");
+  ActionWithValue::useCustomisableComponents(keys);
+}
+
+template <class T>
+std::string MatrixTimesVectorBase<T>::getOutputComponentDescription( const std::string& cname,
+    const Keywords& keys ) const {
+  if( getPntrToArgument(1)->getRank()==1 ) {
+    for(unsigned i=1; i<getNumberOfArguments(); ++i) {
+      if( getPntrToArgument(i)->getName().find(cname)!=std::string::npos ) {
+        return "the product of the matrix " + getPntrToArgument(0)->getName() + " and the vector " + getPntrToArgument(i)->getName();
+      }
+    }
+  }
+  for(unsigned i=0; i<getNumberOfArguments()-1; ++i) {
+    if( getPntrToArgument(i)->getName().find(cname)!=std::string::npos ) {
+      return "the product of the matrix " + getPntrToArgument(i)->getName() + " and the vector " + getPntrToArgument(getNumberOfArguments()-1)->getName();
+    }
+  }
+  plumed_merror( "could not understand request for component " + cname );
+  return "";
+}
+
+template <class T>
+MatrixTimesVectorBase<T>::MatrixTimesVectorBase(const ActionOptions&ao):
+  Action(ao),
+  ActionWithVector(ao),
+  taskmanager(this) {
+  if( getNumberOfArguments()<2 ) {
+    error("Not enough arguments specified");
+  }
+  bool vectormask=false, derivbool = true;
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    if( getPntrToArgument(i)->hasDerivatives() ) {
+      error("arguments should be vectors or matrices");
+    }
+    if( getPntrToArgument(i)->getRank()<=1 ) {
+      ActionWithVector* av=dynamic_cast<ActionWithVector*>( getPntrToArgument(i)->getPntrToAction() );
+      if( av && av->getNumberOfMasks()>=0 ) {
+        vectormask=true;
+      }
+    }
+    if( !getPntrToArgument(i)->isDerivativeZeroWhenValueIsZero() ) {
+      derivbool = false;
+    }
+  }
+  if( !vectormask ) {
+    ignoreMaskArguments();
+  }
+
+  std::vector<std::size_t> shape(1);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
+  if( getNumberOfArguments()==2 ) {
+    addValue( shape );
+    setNotPeriodic();
+    if( derivbool ) {
+      getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
+    }
+  } else {
+    unsigned namestart=1, nameend=getNumberOfArguments();
+    if( getPntrToArgument(1)->getRank()==2 ) {
+      namestart = 0;
+      nameend = getNumberOfArguments()-1;
+    }
+
+    for(unsigned i=namestart; i<nameend; ++i) {
+      std::string name = getPntrToArgument(i)->getName();
+      if( name.find_first_of(".")!=std::string::npos ) {
+        std::size_t dot=name.find_first_of(".");
+        name = name.substr(dot+1);
+      }
+      addComponent( name, shape );
+      componentIsNotPeriodic( name );
+      if( derivbool ) {
+        copyOutput( getLabel() + "." + name )->setDerivativeIsZeroWhenValueIsZero();
+      }
+    }
+  }
+  // This sets up an array in the parallel task manager to hold all the indices
+  // Sets up the index list in the task manager
+  std::size_t nder = getPntrToArgument(getNumberOfArguments()-1)->getNumberOfStoredValues();
+  MatrixTimesVectorData input;
+  input.pairs.resize( getNumberOfArguments()-1, 2 );
+  if( getPntrToArgument(1)->getRank()==2 ) {
+    for(unsigned i=1; i<getNumberOfArguments(); ++i) {
+      input.pairs[i-1][0] = i-1;
+      input.pairs[i-1][1] = getNumberOfArguments()-1;
+    }
+    input.fshift=0;
+  } else {
+    for(unsigned i=1; i<getNumberOfArguments(); ++i) {
+      input.pairs[i-1][0] = 0;
+      input.pairs[i-1][1] = i;
+    }
+    input.fshift=nder;
+  }
+  taskmanager.setActionInput( input );
+}
+
+template <class T>
+unsigned MatrixTimesVectorBase<T>::getNumberOfDerivatives() {
+  unsigned nderivatives=0;
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    nderivatives += getPntrToArgument(i)->getNumberOfStoredValues();
+  }
+  return nderivatives;
+}
+
+template <class T>
+void MatrixTimesVectorBase<T>::prepare() {
+  ActionWithVector::prepare();
+  Value* myval = getPntrToComponent(0);
+  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] ) {
+    return;
+  }
+  std::vector<std::size_t> shape(1);
+  shape[0] = getPntrToArgument(0)->getShape()[0];
+  myval->setShape(shape);
+}
+
+template <class T>
+void MatrixTimesVectorBase<T>::calculate() {
+  std::size_t nvectors, nder = getPntrToArgument(getNumberOfArguments()-1)->getNumberOfStoredValues();
+  if( getPntrToArgument(1)->getRank()==2 ) {
+    nvectors = 1;
+  } else {
+    nvectors = getNumberOfArguments()-1;
+  }
+  if( getName()=="MATRIX_VECTOR_PRODUCT_ROWSUMS" ) {
+    taskmanager.setupParallelTaskManager( nder, 0 );
+  } else {
+    taskmanager.setupParallelTaskManager( 2*nder, nvectors*nder );
+  }
+  taskmanager.runAllTasks();
+}
+
+template <class T>
+int MatrixTimesVectorBase<T>::checkTaskIsActive( const unsigned& itask ) const {
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    Value* myarg = getPntrToArgument(i);
+    if( myarg->getRank()==1 && !myarg->hasDerivatives() ) {
+      return 0;
+    } else if( myarg->getRank()==2 && !myarg->hasDerivatives() ) {
+      if (myarg->checkValueIsActiveForMMul(itask)) {
+        return 1;
+      }
+    } else {
+      plumed_merror("should not be in action " + getName() );
+    }
+  }
+  return 0;
+}
+
+template <class T>
+void MatrixTimesVectorBase<T>::performTask( std::size_t task_index,
+    const MatrixTimesVectorData& actiondata,
+    ParallelActionsInput& input,
+    ParallelActionsOutput& output ) {
+  for(unsigned i=0; i<actiondata.pairs.nrows(); ++i) {
+    MatrixTimesVectorOutput doutput( task_index,
+                                     i,
+                                     input.nderivatives_per_scalar,
+                                     actiondata,
+                                     input,
+                                     output );
+    T::performTask( MatrixTimesVectorInput( task_index,
+                                            i,
+                                            actiondata,
+                                            input,
+                                            input.inputdata ),
+                    doutput );
+  }
+}
+
+template <class T>
+void MatrixTimesVectorBase<T>::applyNonZeroRankForces( std::vector<double>& outforces ) {
+  taskmanager.applyForces( outforces );
+}
+
+template <class T>
+int MatrixTimesVectorBase<T>::getNumberOfValuesPerTask( std::size_t task_index,
+    const MatrixTimesVectorData& actiondata ) {
+  return 1;
+}
+
+template <class T>
+void MatrixTimesVectorBase<T>::getForceIndices( std::size_t task_index,
+    std::size_t colno,
+    std::size_t ntotal_force,
+    const MatrixTimesVectorData& actiondata,
+    const ParallelActionsInput& input,
+    ForceIndexHolder force_indices ) {
+  for(unsigned i=0; i<actiondata.pairs.nrows(); ++i) {
+    std::size_t base = input.argstarts[actiondata.pairs[i][0]]
+                       + task_index*input.ncols[actiondata.pairs[i][0]];
+    std::size_t n = input.bookeeping[input.bookstarts[actiondata.pairs[i][0]]
+                                     + (1+input.ncols[actiondata.pairs[i][0]])*task_index];
+    for(unsigned j=0; j<n; ++j) {
+      force_indices.indices[i][j] = base + j;
+    }
+    force_indices.threadsafe_derivatives_end[i] = n;
+    force_indices.tot_indices[i] = T::getAdditionalIndices( n,
+                                   input.argstarts[actiondata.pairs[i][1]],
+                                   MatrixForceIndexInput( task_index, i, actiondata, input ),
+                                   force_indices.indices[i] );
+  }
+}
+
+}
+}
+#endif