hillclimber 0.1.5__cp313-cp313-musllinux_1_2_aarch64.whl

plumed/_lib/include/plumed/core/CLToolMain.h

@@ -0,0 +1,102 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2012-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   plumed is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_core_CLToolMain_h
+#define __PLUMED_core_CLToolMain_h
+#include <cstdio>
+#include <vector>
+#include <string>
+#include <string_view>
+#include "WithCmd.h"
+#include "../tools/ForwardDecl.h"
+
+
+namespace PLMD {
+
+class Communicator;
+
+/**
+Class providing cmd() access to command line tools.
+
+This class provides an interface using the "cmd()" syntax to all the
+command-line tools.
+It is only accessed via the cmd() function, which can
+be used to set the arguments, communicators and IO descriptors and
+to run the tool.
+It can run all the tools registered via the PLUMED_REGISTER_CLTOOL macro,
+or the scripts which are located in PLUMED_ROOT/scripts.
+
+A typical usage is:
+\verbatim
+#include "CLToolMain.h"
+int main(int argc,char**argv){
+  PLMD::CLToolMain cltoolMain;
+  cltoolMain.cmd("setArgc",&argc);
+  cltoolMain.cmd("setArgv",argv);
+  int ret;
+  cltoolMain.cmd("run",&ret);
+  return ret;
+}
+\endverbatim
+This will run the tool registered with name argv[1] with options argv[2]...argv[argc-1].
+
+This class is also used in the \ref PlumedMain class to provide
+the same functionalities through the external plumed interface, which
+is available also for C and FORTRAN. Thus, the preferred approach is to do something like
+\verbatim
+#include "Plumed.h"
+int main(int argc,char**argv){
+  PLMD::Plumed p;
+  p.cmd("CLTool setArgc",&argc);
+  p.cmd("CLTool setArgv",argv);
+  int ret;
+  p.cmd("CLTool run",&ret);
+  return ret;
+}
+\endverbatim
+
+See the file \ref main.cpp for a similar example.
+
+*/
+class CLToolMain:
+  public WithCmd {
+/// arguments for command-line mode:
+  int argc;
+/// arguments for command-line mode:
+  std::vector<std::string> argv;
+  FILE*in;
+  FILE*out;
+  ForwardDecl<Communicator> comm_fwd;
+  Communicator&comm=*comm_fwd;
+  static int run(int argc, char **argv,FILE*in,FILE*out,Communicator&pc);
+public:
+  CLToolMain();
+  ~CLToolMain();
+  /**
+  Send messages to the CLToolMain.
+  */
+  void cmd(std::string_view key,const TypesafePtr & val=nullptr) override;
+};
+
+}
+
+
+#endif

plumed/_lib/include/plumed/core/CLToolRegister.h

@@ -0,0 +1,108 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2012-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   plumed is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_core_CLToolRegister_h
+#define __PLUMED_core_CLToolRegister_h
+
+#include "RegisterBase.h"
+#include "../tools/Keywords.h"
+
+namespace PLMD {
+
+class CLTool;
+class CLToolOptions;
+
+struct CLToolRegisterPointers {
+/// Pointer to a function which, given the options, create an CLTool
+  typedef std::unique_ptr<CLTool>(*creator_pointer)(const CLToolOptions&);
+/// Pointer to a function which, returns the keywords allowed
+  typedef void(*keywords_pointer)(Keywords&);
+  creator_pointer create;
+  Keywords keys;
+};
+
+
+/// Same as ActionRegister, but for CLTools
+class CLToolRegister :
+  public RegisterBase<CLToolRegisterPointers> {
+  typedef CLToolRegisterPointers::creator_pointer creator_pointer;
+  typedef CLToolRegisterPointers::keywords_pointer keywords_pointer;
+  typedef CLToolRegisterPointers Pointers;
+
+  // this is necessary to avoid warnings on getKeys overload.
+  // notice that RegisterBase<CLToolRegisterPointers>::getKeys returns
+  // the list of keys (here: CLTools). conversely
+  // CLToolRegister::getKeys(std::string name) returns the options
+  // associated to CLTool name.
+  // We hide the former here, which is actually implemented by list()
+  // not to break existing code.
+  using RegisterBase<CLToolRegisterPointers>::getKeys;
+
+public:
+/// Register a new class.
+/// \param key The name of the directive to be used in the input file
+/// \param cp  A pointer to a function which creates an object of that class
+/// \param kp  A pointer to a function which returns the allowed keywords
+  ID add(std::string key,creator_pointer cp,keywords_pointer kp);
+/// Create an CLTool of the type indicated in the options
+/// \param ao object containing information for initialization, such as the full input line, a pointer to PlumedMain, etc
+  std::unique_ptr<CLTool> create(const CLToolOptions&ao);
+  std::unique_ptr<CLTool> create(const std::vector<void*> & images,const CLToolOptions&ao);
+/// Returns a list of the allowed CLTools
+  std::vector<std::string> list()const;
+/// Print out the instructions for using the tool in html ready for input into the manual
+  bool printManual(const std::string& cltool,const bool& spelling);
+/// Return all the keys of this cltool
+  std::vector<std::string> getKeys(const std::string& cltool)const;
+};
+
+/// Function returning a reference to the CLToolRegister.
+/// \relates CLToolRegister
+/// To avoid problems with order of initialization, this function contains
+/// a static CLToolRegister which is built the first time the function is called.
+/// In this manner, it is always initialized before it's used
+CLToolRegister& cltoolRegister();
+
+}
+
+
+/// Shortcut for CLTool registration
+/// \relates PLMD::CLToolRegister
+/// For easier registration, this file also provides a macro PLUMED_REGISTER_CLTOOL.
+/// \param classname the name of the class to be registered
+/// \param directive a string containing the corresponding directive
+/// This macro should be used in the .cpp file of the corresponding class
+#define PLUMED_REGISTER_CLTOOL(classname,directive) \
+  namespace { class classname##RegisterMe{ \
+    CLToolRegister::ID id; \
+    static std::unique_ptr<CLTool> create(const CLToolOptions&ao) { \
+      return std::make_unique<classname>(ao); \
+    } \
+  public: \
+    classname##RegisterMe() : \
+      id(PLMD::cltoolRegister().add(directive,create,classname::registerKeywords)) \
+    {} \
+    ~classname##RegisterMe(){PLMD::cltoolRegister().remove(id);} \
+  } classname##RegisterMeObject; }
+
+
+#endif
+

plumed/_lib/include/plumed/core/Colvar.h

@@ -0,0 +1,115 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_Colvar_h
+#define __PLUMED_core_Colvar_h
+
+#include "ActionAtomistic.h"
+#include "ActionWithValue.h"
+#include "../tools/Matrix.h"
+#include <vector>
+
+#define PLUMED_COLVAR_INIT(ao) Action(ao),Colvar(ao)
+
+namespace PLMD {
+
+/**
+\ingroup INHERIT
+This is the abstract base class to use for implementing new collective variables, within it there is
+\ref AddingAColvar "information" as to how to go about implementing a new CV.
+*/
+
+class Colvar :
+  public ActionAtomistic,
+  public ActionWithValue {
+private:
+protected:
+  void requestAtoms(const std::vector<AtomNumber> & a);
+// Set the derivatives for a particular atom equal to the input Vector
+// This routine is called setAtomsDerivatives because not because you
+// are setting the derivative of many atoms but because you are setting
+// the derivatives of a particular atom.  The s is an apostrophe s
+// but you can't put apostrophes in function names
+  void           setAtomsDerivatives(int,const Vector&);
+  void           setAtomsDerivatives(Value*,int,const Vector&);
+  void           setBoxDerivatives(const Tensor&);
+  void           setBoxDerivatives(Value*,const Tensor&);
+  const Tensor & getBoxDerivatives()const;
+  const double & getForce()const;
+  void apply() override;
+/// Set box derivatives automatically.
+/// It should be called after the setAtomsDerivatives has been used for all
+/// single atoms.
+/// \warning It only works for collective variable NOT using PBCs!
+  void           setBoxDerivativesNoPbc();
+  void           setBoxDerivativesNoPbc(Value*);
+public:
+  explicit Colvar(const ActionOptions&);
+  ~Colvar() {}
+  static void registerKeywords( Keywords& keys );
+  unsigned getNumberOfDerivatives() override;
+};
+
+inline
+void Colvar::setAtomsDerivatives(Value*v,int i,const Vector&d) {
+  v->addDerivative(3*i+0,d[0]);
+  v->addDerivative(3*i+1,d[1]);
+  v->addDerivative(3*i+2,d[2]);
+}
+
+
+inline
+void Colvar::setBoxDerivatives(Value* v,const Tensor&d) {
+  unsigned nat=getNumberOfAtoms();
+  v->addDerivative(3*nat+0,d(0,0));
+  v->addDerivative(3*nat+1,d(0,1));
+  v->addDerivative(3*nat+2,d(0,2));
+  v->addDerivative(3*nat+3,d(1,0));
+  v->addDerivative(3*nat+4,d(1,1));
+  v->addDerivative(3*nat+5,d(1,2));
+  v->addDerivative(3*nat+6,d(2,0));
+  v->addDerivative(3*nat+7,d(2,1));
+  v->addDerivative(3*nat+8,d(2,2));
+}
+
+inline
+void Colvar::setAtomsDerivatives(int i,const Vector&d) {
+  setAtomsDerivatives(getPntrToValue(),i,d);
+}
+
+inline
+void Colvar::setBoxDerivatives(const Tensor&d) {
+  setBoxDerivatives(getPntrToValue(),d);
+}
+
+inline
+void Colvar::setBoxDerivativesNoPbc() {
+  setBoxDerivativesNoPbc(getPntrToValue());
+}
+
+inline
+unsigned Colvar::getNumberOfDerivatives() {
+  return 3*getNumberOfAtoms() + 9;
+}
+
+}
+
+#endif

plumed/_lib/include/plumed/core/DataPassingObject.h

@@ -0,0 +1,94 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_DataPassingObject_h
+#define __PLUMED_core_DataPassingObject_h
+
+#include <vector>
+#include <memory>
+#include <set>
+#include "../tools/AtomNumber.h"
+#include "../tools/TypesafePtr.h"
+#include "Value.h"
+
+namespace PLMD {
+
+class DataPassingObject {
+protected:
+/// The start of the data in the input pointer
+  unsigned start;
+/// The spacing between values in the input arrays
+  unsigned stride;
+/// The units of the quantity
+  double unit;
+/// The units of the force on this quantity
+  double funit;
+/// The backup value of the quantity (used if the value is passed directly)
+  bool hasbackup;
+  double bvalue;
+public:
+  static std::unique_ptr<DataPassingObject> create(unsigned n);
+  explicit DataPassingObject() : start(0), stride(1), unit(1), funit(1), hasbackup(false), bvalue(0) {}
+  /// Virtual destructor, just to allow inheritance.
+  virtual ~DataPassingObject() {}
+/// Convert what comes from the MD code to a double
+  virtual double MD2double(const TypesafePtr & m) const=0;
+///
+  void setStart( const unsigned& s ) {
+    start=s;
+  }
+/// Set the stride to use when getting data from the input array
+  void setStride( const unsigned& s ) {
+    stride=s;
+  }
+/// Set the unit for the value
+  void setUnit( const double& u ) {
+    unit=u;
+  }
+/// Set the unit for the force
+  void setForceUnit( const double& u ) {
+    funit=u;
+  }
+/// This is used when you want to save the passed object to a double variable in PLUMED rather than the pointer
+/// this can be used even when you don't pass a pointer from the MD code
+  virtual void saveValueAsDouble( const TypesafePtr & val )=0;
+/// Set the pointer to the value
+  virtual void setValuePointer( const TypesafePtr & val, const std::vector<std::size_t>& shape, const bool& isconst )=0;
+/// Set the pointer to the force
+  virtual void setForcePointer( const TypesafePtr & val, const std::vector<std::size_t>& shape )=0;
+/// This gets the data in the pointer and passes it to the output value
+  virtual void share_data( std::vector<double>& values ) const = 0;
+/// Share the data and put it in the value from sequential data
+  virtual void share_data( const unsigned& j, const unsigned& k, Value* value )=0;
+/// Share the data and put it in the value from a scattered data
+  virtual void share_data( const std::vector<AtomNumber>&index, const std::vector<unsigned>& i, Value* value )=0;
+/// Pass the force from the value to the output value
+  virtual void add_force( Value* vv )=0;
+  virtual void add_force( const std::vector<int>& index, Value* value )=0;
+  virtual void add_force( const std::vector<AtomNumber>& index, const std::vector<unsigned>& i, Value* value )=0;
+/// Rescale the forces that were passed
+  virtual void rescale_force( const unsigned& n, const double& factor, Value* value )=0;
+/// This transfers everything to the output
+  virtual void setData( Value* value )=0;
+};
+
+}
+#endif

plumed/_lib/include/plumed/core/DataPassingTools.h

@@ -0,0 +1,54 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_DataPassingTools_h
+#define __PLUMED_core_DataPassingTools_h
+
+#include <string>
+#include <memory>
+#include <map>
+#include "../tools/TypesafePtr.h"
+#include "../tools/Units.h"
+
+namespace PLMD {
+
+class PlumedMain;
+
+class DataPassingTools {
+  friend class PlumedMain;
+private:
+/// The units used in the MD code and PLUMED
+  Units units;
+  Units MDUnits;
+/// Is the code using natural units
+  bool usingNaturalUnits;
+public:
+/// Virtual destructor, just to allow inheritance.
+  virtual ~DataPassingTools() {}
+  static std::unique_ptr<DataPassingTools> create(unsigned n);
+  virtual int getRealPrecision() const = 0;
+  double getUnitConversion( const std::string& unit ) const ;
+  virtual double MD2double(const TypesafePtr & m) const=0;
+  virtual void double2MD(const double&,const TypesafePtr & m) const=0;
+};
+
+}
+#endif

plumed/_lib/include/plumed/core/DomainDecomposition.h

@@ -0,0 +1,120 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_DomainDecomposition_h
+#define __PLUMED_core_DomainDecomposition_h
+
+#include "ActionForInterface.h"
+#include "../tools/Communicator.h"
+
+namespace PLMD {
+
+class ActionToPutData;
+class ActionAtomistic;
+
+class DomainDecomposition : public ActionForInterface {
+private:
+  class DomainComms : public Communicator {
+  public:
+    bool on;
+    bool async;
+
+    std::vector<Communicator::Request> mpi_request_positions;
+    std::vector<Communicator::Request> mpi_request_index;
+
+    std::vector<double> positionsToBeSent;
+    std::vector<double> positionsToBeReceived;
+    std::vector<int>    indexToBeSent;
+    std::vector<int>    indexToBeReceived;
+    operator bool() const {
+      return on;
+    }
+    DomainComms(): on(false), async(false) {}
+    void enable(Communicator& c);
+  };
+  DomainComms dd;
+  long int ddStep;
+
+  std::vector<int>    gatindex;
+/// Map global indexes to local indexes
+/// E.g. g2l[i] is the position of atom i in the array passed from the MD engine.
+/// Called "global to local" since originally it was used to map global indexes to local
+/// ones used in domain decomposition. However, it is now also used for the NAMD-like
+/// interface, where only a small number of atoms is passed to plumed.
+  std::vector<int> g2l;
+
+  unsigned shuffledAtoms;
+
+  bool asyncSent;
+  bool unique_serial; // use unique in serial mode
+/// This holds the list of unique atoms
+  std::vector<AtomNumber> unique;
+  std::vector<unsigned> uniq_index;
+/// This holds the list of atoms that have a force on
+  std::vector<AtomNumber> forced_unique;
+/// This holds the list of actions that are set from this action
+  std::vector<ActionToPutData*> inputs;
+/// This holds all the actions that read atoms
+  std::vector<ActionAtomistic*> actions;
+/// The list that holds all the atom indexes we need
+  std::vector<int> fullList;
+/// This actually does the sharing of the data across the domains
+  void share(const std::vector<AtomNumber>& unique);
+/// Get all the atoms in the input that are active at this time
+  void getAllActiveAtoms( std::vector<AtomNumber>& u );
+public:
+  static void registerKeywords(Keywords& keys);
+  explicit DomainDecomposition(const ActionOptions&ao);
+  void setStart( const std::string& name, const unsigned& sss) override ;
+  void setStride( const std::string& name, const unsigned& sss) override ;
+  void resetForStepStart() override ;
+  bool setValuePointer( const std::string& name, const TypesafePtr & ) override ;
+  bool setForcePointer( const std::string& name, const TypesafePtr & ) override ;
+  unsigned getNumberOfForcesToRescale() const override ;
+  void share() override ;
+  void shareAll() override ;
+  void wait() override ;
+  void reset() override ;
+  void writeBinary(std::ostream&o) override ;
+  void readBinary(std::istream&i) override ;
+  void apply() override ;
+  void setAtomsNlocal(int n);
+  void setAtomsGatindex(const TypesafePtr & g,bool fortran);
+  void setAtomsContiguous(int start);
+  void Set_comm(Communicator& comm) override ;
+  void broadcastToDomains( Value* val );
+  void sumOverDomains( Value* val );
+  const long int& getDdStep() const ;
+  const std::vector<int>& getGatindex() const ;
+  void createFullList(const TypesafePtr & x);
+  void getFullList(const TypesafePtr & x);
+  void clearFullList();
+  bool onStep() const override {
+    return getNumberOfAtoms()>0;
+  }
+  unsigned getNumberOfAtoms() const;
+  DomainDecomposition* castToDomainDecomposition() noexcept final {
+    return this;
+  }
+};
+
+}
+#endif

plumed/_lib/include/plumed/core/ExchangePatterns.h

@@ -0,0 +1,47 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2012-2023 The plumed team
+   (see the PEOPLE file at the root of the distribution for a list of names)
+
+   See http://www.plumed.org for more information.
+
+   This file is part of plumed, version 2.
+
+   plumed is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   plumed is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with plumed.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_core_ExchangePatterns_h
+#define __PLUMED_core_ExchangePatterns_h
+
+#include "../tools/ForwardDecl.h"
+#include "../tools/TypesafePtr.h"
+
+namespace PLMD {
+class Random;
+
+class ExchangePatterns {
+  int    PatternFlag;
+  int    NumberOfReplicas;
+  ForwardDecl<Random> random_fwd;
+  Random& random=*random_fwd;
+public:
+  ExchangePatterns();
+  ~ExchangePatterns();
+  enum PatternFlags { NONE, RANDOM, NEIGHBOR, TOTAL };
+  void setNofR(const int);
+  void setSeed(const int);
+  void setFlag(const int);
+  void getList(const TypesafePtr & ind);
+  void getFlag(int&);
+};
+}
+#endif