hillclimber 0.1.6__cp313-cp313-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/tools/NeighborList.h

@@ -0,0 +1,112 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_tools_NeighborList_h //{
+#define __PLUMED_tools_NeighborList_h
+
+#include "Vector.h"
+#include "AtomNumber.h"
+
+#include <vector>
+
+namespace PLMD {
+
+class Pbc;
+class Communicator;
+
+/// \ingroup TOOLBOX
+/// A class that implements neighbor lists from two lists or a single list of atoms
+class NeighborList {
+public:
+  using pairIDs=std::pair<unsigned,unsigned>;
+  using pairAtomNumbers=std::pair<PLMD::AtomNumber,PLMD::AtomNumber>;
+private:
+  enum class NNStyle {Pair,TwoList,SingleList};
+  bool reduced=false;
+  bool serial_;
+  bool do_pbc_;
+  NNStyle style_;
+  const PLMD::Pbc* pbc_;
+  Communicator& comm;
+  std::vector<PLMD::AtomNumber> fullatomlist_{};
+  std::vector<PLMD::AtomNumber> requestlist_{};
+  std::vector<pairIDs > neighbors_{};
+  double distance_;
+  size_t nlist0_=0;
+  size_t nlist1_=0;
+  size_t nallpairs_;
+  unsigned stride_=0;
+  unsigned lastupdate_=0;
+/// Initialize the neighbor list with all possible pairs
+  void initialize();
+/// Return the pair of indexes in the positions array
+/// of the two atoms forming the i-th pair among all possible pairs
+  pairIDs getIndexPair(unsigned i);
+/// Extract the list of atoms from the current list of close pairs
+  void setRequestList();
+public:
+  NeighborList(const std::vector<PLMD::AtomNumber>& list0,
+               const std::vector<PLMD::AtomNumber>& list1,
+               bool serial,
+               bool do_pair,
+               bool do_pbc,
+               const PLMD::Pbc& pbc,
+               Communicator &cm,
+               double distance=1.0e+30,
+               unsigned stride=0);
+  NeighborList(const std::vector<PLMD::AtomNumber>& list0,
+               bool serial,
+               bool do_pbc,
+               const PLMD::Pbc& pbc,
+               Communicator &cm,
+               double distance=1.0e+30,
+               unsigned stride=0);
+  ~NeighborList();
+/// Return the list of all atoms. These are needed to rebuild the neighbor list.
+  std::vector<PLMD::AtomNumber>& getFullAtomList();
+/// Update the indexes in the neighbor list to match the
+/// ordering in the new positions array
+/// and return the new list of atoms that must be requested to the main code
+  std::vector<PLMD::AtomNumber>& getReducedAtomList();
+/// Update the neighbor list and prepare the new
+/// list of atoms that will be requested to the main code
+  void update(const std::vector<PLMD::Vector>& positions);
+/// Get the update stride of the neighbor list
+  unsigned getStride() const;
+/// Get the last step in which the neighbor list was updated
+  unsigned getLastUpdate() const;
+/// Set the step of the last update
+  void setLastUpdate(unsigned step);
+/// Get the size of the neighbor list
+  unsigned size() const;
+/// Get the distance used to create the neighbor list
+  double distance() const;
+/// Get the i-th pair of the neighbor list
+  pairIDs getClosePair(unsigned i) const;
+/// Get the list of neighbors of the i-th atom
+  std::vector<unsigned> getNeighbors(unsigned i);
+/// Get the i-th pair of AtomNumbers from the neighbor list
+  pairAtomNumbers getClosePairAtomNumber(unsigned i) const;
+};
+
+} // namespace PLMD
+
+#endif //__PLUMED_tools_NeighborList_h }

plumed/_lib/include/plumed/tools/OFile.h

@@ -0,0 +1,286 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_tools_OFile_h
+#define __PLUMED_tools_OFile_h
+
+#include "FileBase.h"
+#include <vector>
+#include <sstream>
+#include <memory>
+#include <cstddef>
+
+namespace PLMD {
+
+class Value;
+
+/**
+\ingroup TOOLBOX
+Class for output files
+
+This class provides features similar to those in the standard C "FILE*" type,
+but only for sequential output. See IFile for sequential input.
+
+See the example here for a possible use:
+\verbatim
+#include "File.h"
+
+int main(){
+  PLMD::OFile pof;
+  pof.open("ciao");
+  pof.printf("%s\n","test1");
+  pof.setLinePrefix("plumed: ");
+  pof.printf("%s\n","test2");
+  pof.setLinePrefix("");
+  pof.addConstantField("x2").printField("x2",67.0);
+  pof.printField("x1",10.0).printField("x3",20.12345678901234567890).printField();
+  pof.printField("x1",10.0).printField("x3",-1e70*20.12345678901234567890).printField();
+  pof.printField("x3",10.0).printField("x2",777.0).printField("x1",-1e70*20.12345678901234567890).printField();
+  pof.printField("x3",67.0).printField("x1",18.0).printField();
+  return 0;
+}
+\endverbatim
+
+This program is expected to produce a file "ciao" which reads
+\verbatim
+test1
+plumed: test2
+#! FIELDS x1 x3
+#! SET x2                      67
+                     10      20.12345678901234
+                     10 -2.012345678901235e+71
+#! FIELDS x1 x3
+#! SET x2                     777
+ -2.012345678901235e+71                     10
+                     18                     67
+\endverbatim
+
+Notes
+- "x2" is declared as "constant", which means that it is written using the "SET"
+keyword. Thus, everytime it is modified, all the headers are repeated in the output file.
+- printField() without arguments is used as a "newline".
+- most methods return a reference to the OFile itself, to allow chaining many calls on the same line
+(this is similar to << operator in std::ostream)
+
+\section using-correctly-ofile Using correctly OFile in PLUMED
+
+When a OFile object is used in PLUMED it can be convenient to link() it
+to the Action object where it is defined, or to the PlumedMain object.
+This will save in the OFile a pointer to the linked object and will
+allow to have some extra information. E.g., if PLUMED is restarting,
+files will be appended. Notice that one can enforce this behavior using
+the enforceRestart() method before opening a file.
+
+To have all files managed consistently, it is important to use OFile in the proper way.
+This should allow multi-replica plumed, restart and backups to work in
+the expected way. For this reason all the operations in OFile and IFile
+are synchronizing all the processors of the group, so call to OFile functions
+should always be performed by all processes; for this reason is also not useful
+to use Log for debugging because only master threads will actually write.
+For debugging is better to use the standard stderr.
+
+\verbatim
+int main(){
+// this is a growing file, containing a full history
+// (frames are appended, as in traditional HILLS and COLVAR)
+  OFile grw;
+// this is a single-snapshopt file used e.g. for checkpointing
+// (rewritten every time)
+  OFile snp;
+
+// open both files at the beginning
+// (will go in \ref Action constructor)
+  grw.open("growing");
+  snp.open("snapshot");
+
+// trajectory loop
+  for(int i=0;i<nsteps;i++){
+
+// files should be written in the update() method of an \ref Action
+
+// write on growing file
+    grw<<"data at step "<<i<<\n";
+
+// flushing
+// it takes time, so do it only if data is critical
+// better to leave this choice to the user with the FLUSH keyword
+//    grw.flush();
+
+// write on snapshot file
+    snp.rewind();
+    snp<<"snapshot at step "<<i<<"\n";
+    snp.flush();
+// the only difference is that snp is rewound
+// notice that it should be rewound just before writing
+// because rewind is going to move the file out of the way
+// to have a safe copy of the file ("bck.last.filename")
+// Also notice that snapshots should be flushed
+// for this reason, it is better to write them only
+// rarely to avoid excessive slow down
+
+  }
+}
+
+\notice
+Notice that it is not necessary to explicitely close files, since they are closed implicitly
+when the object goes out of scope. In case you need to explicitly close the file before it is
+destroyed, please check it the procedure is exception safe and, if necessary, add some `try/catch`
+statement.
+
+\endverbatim
+*/
+
+class OFile:
+  public virtual FileBase {
+/// Pointer to a linked OFile.
+/// see link(OFile&)
+  OFile* linked;
+/// Internal buffer for printf
+  std::vector<char> buffer_string;
+/// Internal buffer (generic use)
+  std::vector<char> buffer;
+/// Internal buffer length
+  int buflen;
+/// This variables stores the actual buffer length
+  int actual_buffer_length;
+/// Class identifying a single field for fielded output
+  class Field:
+    public FieldBase {
+  };
+/// Low-level write
+  std::size_t llwrite(const char*,std::size_t);
+/// True if fields has changed.
+/// This could be due to a change in the list of fields or a reset
+/// of a nominally constant field
+  bool fieldChanged;
+/// Format for fields writing
+  std::string fieldFmt;
+/// All the previously defined variable fields
+  std::vector<Field> previous_fields;
+/// All the defined variable fields
+  std::vector<Field> fields;
+/// All the defined constant fields
+  std::vector<Field> const_fields;
+/// Prefix for line (e.g. "PLUMED: ")
+  std::string linePrefix;
+/// Temporary ostringstream for << output
+  std::ostringstream oss;
+/// The string used for backing up files
+  std::string backstring;
+/// Find field index given name
+  unsigned findField(const std::string&name)const;
+/// check if we are restarting
+  bool checkRestart()const;
+/// True if restart behavior should be forced
+  bool enforceRestart_;
+/// True if backup behavior (i.e. non restart) should be forced
+  bool enforceBackup_;
+public:
+/// Constructor
+  OFile();
+/// Allows overloading of link
+  using FileBase::link;
+/// Allows overloading of open
+  using FileBase::open;
+/// Allows linking this OFile to another one.
+/// In this way, everything written to this OFile will be immediately
+/// written on the linked OFile. Notice that a OFile should
+/// be either opened explicitly, linked to a FILE or linked to a OFile
+  OFile& link(OFile&);
+/// Set the string name to be used for automatic backup
+  void setBackupString( const std::string& );
+/// Backup a file by giving it a different name
+  void backupFile( const std::string& bstring, const std::string& fname );
+/// This backs up all the files that would have been created with the
+/// name str.  It is used in analysis when you are not restarting.  Analysis
+/// output files at different times, which are names analysis.0.<filename>,
+/// analysis.1.<filename> and <filename>, are backed up to bck.0.analysis.0.<filename>,
+/// bck.0.analysis.1.<filename> and bck.0.<filename>
+  void backupAllFiles( const std::string& str );
+/// Opens the file using automatic append/backup
+  OFile& open(const std::string&name) override;
+/// Set the prefix for output.
+/// Typically "PLUMED: ". Notice that lines with a prefix cannot
+/// be parsed using fields in a IFile.
+  OFile& setLinePrefix(const std::string&);
+/// Set the format for writing double precision fields
+  OFile& fmtField(const std::string&);
+/// Reset the format for writing double precision fields to its default
+  OFile& fmtField();
+/// Set the value of a double precision field
+  OFile& printField(const std::string&,double);
+/// Set the value of a int type field
+  OFile& printField(const std::string&,int);
+  OFile& printField(const std::string&,long int);
+  OFile& printField(const std::string&,long long int);
+  OFile& printField(const std::string&,unsigned);
+  OFile& printField(const std::string&,long unsigned);
+  OFile& printField(const std::string&,long long unsigned);
+/// Set the value of a string field
+  OFile& printField(const std::string&,const std::string&);
+///
+  OFile& addConstantField(const std::string&);
+/// Used to setup printing of values
+  OFile& setupPrintValue( Value *val );
+/// Print a value
+  OFile& printField( Value* val, const double& v );
+  /** Close a line.
+  Typically used as
+  \verbatim
+    of.printField("a",a).printField("b",b).printField();
+  \endverbatim
+  */
+  OFile& printField();
+  /**
+  Resets the list of fields.
+  As it is only possible to add new constant fields (addConstantField()),
+  this method can be used to clean the field list.
+  */
+  OFile& clearFields();
+/// Formatted output with explicit format - a la printf
+  int printf(const char*fmt,...);
+/// Formatted output with << operator
+  template <class T>
+  friend OFile& operator<<(OFile&,const T &);
+/// Rewind a file
+  OFile&rewind();
+/// Flush a file
+  FileBase&flush() override;
+/// Enforce restart, also if the attached plumed object is not restarting.
+/// Useful for tests
+  OFile&enforceRestart();
+/// Enforce backup, even if the attached plumed object is restarting.
+  OFile&enforceBackup();
+};
+
+/// Write using << syntax
+template <class T>
+OFile& operator<<(OFile&of,const T &t) {
+  of.oss<<t;
+  of.printf("%s",of.oss.str().c_str());
+  of.oss.str("");
+  return of;
+}
+
+
+}
+
+#endif

plumed/_lib/include/plumed/tools/OpenACC.h

@@ -0,0 +1,180 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2025 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_tools_OpenACC_h
+#define __PLUMED_tools_OpenACC_h
+
+#include <vector>
+#include "View.h"
+
+#ifdef __PLUMED_HAS_OPENACC
+#include <openacc.h>
+#endif //__PLUMED_HAS_OPENACC
+
+namespace PLMD {
+
+namespace OpenACC {
+
+/** @brief this  little tool is a RAII helper to put and remove data on the device
+
+ the captured data will need to have two functions: toACCDevice() and removeFromACCDevice():
+ in toACCDevice  you should declare a `#pragma acc enter data` statement with the object
+  within your structure to put on the device and eventual calls to toACCDevice of contained objects.
+
+ In the removeFromACCDevice function you should declare a `#pragma acc exit data` statement
+ to remove the object from the device but the onbject names should be delcared in the opposite order.fromToDataHelper
+
+ Remember to stat/finish with `this[0:1]`.
+ For example:
+
+ @code{c++}
+ struct dataContainer {
+  int * ptr;
+  size_t size;
+  void toACCDevice()const {
+#pragma acc enter data copyin(this[0:1],ptr[0:size], size)
+  }
+  void removeFromACCDevice() const  {
+#pragma acc exit data delete(size,ptr[0:size],this[0:1])
+  }
+};
+ @endcode
+
+ Or, for a slightly more complex example:
+ @code{c++}
+ struct ParallelActionsInput {
+  bool noderiv{false};
+  const Pbc* pbc;
+  unsigned ncomponents{0};
+  unsigned dataSize{0};
+  double *inputdata{nullptr};
+  ParallelActionsInput( const Pbc& box )
+    : pbc(&box) {}
+  void toACCDevice()const {
+#pragma acc enter data copyin(this[0:1], noderiv, pbc[0:1],ncomponents, dataSize, inputdata[0:dataSize])
+    pbc->toACCDevice();
+  }
+  void removeFromACCDevice() const  {
+    pbc->removeFromACCDevice();
+    // assuming dataSize is not changed
+#pragma acc exit data delete(inputdata[0:dataSize],dataSize,ncomponents, pbc[0:1],noderiv,this[0:1])
+  }
+};
+ @endcode
+*/
+
+template<typename accData>
+class fromToDataHelper {
+  accData &m;
+public:
+  fromToDataHelper(accData &d) : m(d) {
+    m.toACCDevice();
+  }
+  ~fromToDataHelper() {
+    m.removeFromACCDevice();
+  }
+};
+#ifdef __PLUMED_HAS_OPENACC
+///C++ wrapper around acc_malloc, allocates sizeof(T) bytes and return a typed pointer
+template <typename T> T *myAccMalloc(size_t size) {
+  return reinterpret_cast<T *>(acc_malloc(size * sizeof(T)));
+}
+
+///C++ wrapper around acc_free
+template <typename T> void myAccFree(T *ptr) {
+  acc_free(ptr);
+}
+
+///Memory manager for openacc
+template <typename T> class memoryManager {
+  /// the number of T element stored by the pointer
+  size_t size_ {0};
+  /// the size of the array stored on the GPU
+  size_t stored_ {0};
+  /// the device address, not the host address!!!
+  void *ptr_ {nullptr};
+public:
+  /// @brief Initilialize an empty placeholder
+  memoryManager()=default;
+  /// @brief allocate the memory on the device, and store the pointer
+  /// @param sz the number of T that you want to allocate
+  memoryManager(size_t sz)
+    : size_{sz},
+      stored_ {sz} {
+    if (size_ > 0) {
+      ptr_ = acc_malloc(size_ * sizeof(T));
+    }
+  }
+  /// @brief allocates and copies to the memory of the device the given vector
+  memoryManager(const std::vector<T>& data)
+    : size_{data.size()},
+      stored_{data.size()},
+      ptr_{acc_malloc(size_ * sizeof(T))} {
+    copyToDevice(data.data());
+  }
+  /// @brief allocates and copies to the memory of the device the given vector
+  template <size_t N>
+  memoryManager(const View<T,N>& data)
+    : size_{data.size()},
+      stored_{data.size()},
+      ptr_{acc_malloc(size_ * sizeof(T))} {
+    copyToDevice(data.data());
+  }
+  /// frees the stored memory
+  ~memoryManager() {
+    acc_free(ptr_);
+  }
+  /// @brief gets the device addres
+  /// @return gets the device addres, typed
+  constexpr T *devicePtr() const {
+    return reinterpret_cast<T *>(ptr_);
+  }
+  /// Resizes the data stored on the device if the new size is smaller that the curent one, the memory will not be realocated
+  void resize(size_t sz) {
+    size_=sz;
+    if (size_ > stored_) {
+      stored_=size_;
+      acc_free(ptr_);
+      ptr_=acc_malloc(size_ * sizeof(T));
+    }
+  }
+  /// return the current number of elements stored on the device
+  constexpr size_t size() const {
+    return size_;
+  }
+  /// @brief Copies the data from the address to the device
+  void copyToDevice(T *data) {
+    acc_memcpy_to_device(ptr_, data, sizeof(T) * size_);
+  }
+  /// @brief Copies the data from the address to the device
+  void copyToDevice(T const *data) {
+    acc_memcpy_to_device(ptr_, const_cast<T *>(data), sizeof(T) * size_);
+  }
+  /// @brief copies the data from the device to the host
+  void copyFromDevice(T *data) {
+    acc_memcpy_from_device(data, ptr_, sizeof(T) * size_);
+  }
+};
+#endif //__PLUMED_HAS_OPENACC
+}//namespace OpenACC
+}//namespace PLMD
+
+#endif

plumed/_lib/include/plumed/tools/OpenMP.h

@@ -0,0 +1,75 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2014-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_tools_OpenMP_h
+#define __PLUMED_tools_OpenMP_h
+
+#include <vector>
+
+namespace PLMD {
+
+namespace OpenMP {
+
+/// Set number of threads that can be used by openMP
+void setNumThreads(const unsigned nt);
+
+/// Get number of threads that can be used by openMP
+unsigned getNumThreads();
+
+/// Returns a unique thread identification number within the current team
+unsigned getThreadNum();
+
+/// get cacheline size
+unsigned getCachelineSize();
+
+/// Get a reasonable number of threads so as to access to an array of size s located at x
+template<typename T>
+unsigned getGoodNumThreads(const T* /*getTheType*/,unsigned n) {
+  // this is more or less the equivalent of writing "unsigned getGoodNumThreads<T>(unsigned n)"
+
+  // a factor two is necessary since there is no guarantee that x is aligned
+  // to cache line boundary
+  unsigned m=n*sizeof(T)/(2*getCachelineSize());
+  unsigned numThreads=getNumThreads();
+  if(m>=numThreads) {
+    m=numThreads;
+  } else {
+    //it is better to use either all the active threads or only one
+    //this solves a performance problem as explained in issue #415
+    m=1;
+  }
+  return m;
+}
+
+/// Get a reasonable number of threads so as to access to vector v
+template<typename T>
+unsigned getGoodNumThreads(const std::vector<T> & v) {
+  if(v.size()==0) {
+    return 1;
+  } else {
+    return getGoodNumThreads(&v[0],v.size());
+  }
+}
+
+}//namespace OpenMP
+}//namespace PLMD
+
+#endif