hillclimber 0.1.5a8__cp314-cp314-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/tools/HistogramBead.h

@@ -0,0 +1,136 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_HistogramBead_h
+#define __PLUMED_tools_HistogramBead_h
+
+#include <string>
+#include <vector>
+#include "Exception.h"
+#include "Tools.h"
+
+namespace PLMD {
+
+class Keywords;
+class Log;
+
+/**
+\ingroup TOOLBOX
+A class for calculating whether or not values are within a given range using : \f$ \sum_i \int_a^b G( s_i, \sigma*(b-a) ) \f$
+*/
+
+class HistogramBead {
+public:
+  enum class KernelType {gaussian,triangular};
+private:
+  double lowb{0.0};
+  double highb{0.0};
+  double width{0.0};
+  double cutoff{std::numeric_limits<double>::max()};
+
+  KernelType type{KernelType::gaussian};
+  enum class Periodicity {periodic,notperiodic};
+  Periodicity periodicity{Periodicity::notperiodic};
+  double min{0.0};
+  double max{0.0};
+  double max_minus_min{0.0};
+  double inv_max_minus_min{0.0};
+
+  double difference(double d1, double d2 ) const ;
+public:
+  static void registerKeywords( Keywords& keys );
+  static void generateBins( const std::string& params, std::vector<std::string>& bins );
+  std::string description() const ;
+  //Non periodic constructor
+#pragma acc routine seq
+  explicit HistogramBead(KernelType, double l, double h, double w);
+  //with period constructor
+  HistogramBead(KernelType, double mlow, double mhigh, double l, double h, double w);
+  HistogramBead(const HistogramBead&);
+  HistogramBead(HistogramBead&&);
+  HistogramBead& operator=(const HistogramBead&);
+  HistogramBead& operator=(HistogramBead&&);
+
+#pragma acc routine seq
+  void isNotPeriodic();
+  void isPeriodic( double mlow, double mhigh );
+  static KernelType getKernelType( const std::string& ktype );
+  void setKernelType( const std::string& ktype );
+#pragma acc routine seq
+  void setKernelType( KernelType ktype );
+  void set(const std::string& params, std::string& errormsg);
+#pragma acc routine seq
+  void set(double l, double h, double w);
+#pragma acc routine seq
+  double calculate(double x, double&df) const;
+  double calculateWithCutoff( double x, double l, double u, double s, double& df ) const ;
+  double calculateWithCutoff( double x, double& df ) const;
+  double lboundDerivative( double x ) const;
+  double uboundDerivative( double x ) const;
+  double getlowb() const ;
+  double getbigb() const ;
+  double getCutoff() const ;
+  //openacc support functions
+  void toACCDevice() const {
+#pragma acc enter data copyin(this[0:1], lowb, highb, width, cutoff, type, \
+                              periodicity, min, max, max_minus_min, \
+                              inv_max_minus_min)
+  }
+  void removeFromACCDevice() const {
+#pragma acc exit data delete(inv_max_minus_min, max_minus_min, max, min,\
+                             periodicity, type, cutoff, width, highb, lowb,\
+                             this[0:1])
+  }
+};
+
+inline
+void HistogramBead::isNotPeriodic() {
+  periodicity=Periodicity::notperiodic;
+}
+
+inline
+void HistogramBead::isPeriodic( const double mlow, const double mhigh ) {
+  periodicity=Periodicity::periodic;
+  min=mlow;
+  max=mhigh;
+  max_minus_min=max-min;
+  plumed_massert(max_minus_min>0, "your function has a very strange domain?");
+  inv_max_minus_min=1.0/max_minus_min;
+}
+
+inline
+double HistogramBead::getlowb() const {
+  return lowb;
+}
+
+inline
+double HistogramBead::getbigb() const {
+  return highb;
+}
+
+inline
+double HistogramBead::getCutoff() const {
+  return cutoff*width;
+}
+
+}
+
+#endif

plumed/_lib/include/plumed/tools/IFile.h

@@ -0,0 +1,117 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_IFile_h
+#define __PLUMED_tools_IFile_h
+
+#include "FileBase.h"
+#include <vector>
+#include <cstddef>
+
+namespace PLMD {
+
+class Value;
+
+/**
+\ingroup TOOLBOX
+Class for input files
+
+This class provides features similar to those in the standard C "FILE*" type,
+but only for sequential input. See OFile for sequential output.
+
+*/
+
+//TODO: the `fields` component may be made a map or a ordered/unordered set, since Field objects can be ordered (hence findable in Log(N)/log(1)!
+class IFile:
+/// Class identifying a single field for fielded output
+  public virtual FileBase {
+  struct Field:
+    public FieldBase {
+    bool read=false;
+  };
+/// Low-level read.
+/// Note: in parallel, all processes read
+  std::size_t llread(char*,std::size_t);
+/// All the defined fields
+  std::vector<Field> fields;
+/// Flag set in the middle of a field reading
+  bool inMiddleOfField;
+/// Set to true if you want to allow fields to be ignored in the read in file
+  bool ignoreFields;
+/// Set to true to allow files without end-of-line at the end
+  bool noEOL;
+/// Advance to next field (= read one line)
+  IFile& advanceField();
+/// Find field index by name
+  unsigned findField(const std::string&name)const;
+public:
+/// Constructor
+  IFile();
+/// Destructor
+  ~IFile();
+/// Opens the file
+  IFile& open(const std::string&mypath) override;
+/// Gets the list of all fields
+  IFile& scanFieldList(std::vector<std::string>&);
+/// Read a double field
+  IFile& scanField(const std::string&,double&);
+/// Read a int field
+  IFile& scanField(const std::string&,int&);
+/// Read a long int field
+  IFile& scanField(const std::string&,long int&);
+/// Read a long long int field
+  IFile& scanField(const std::string&,long long int&);
+/// Read a unsigned field
+  IFile& scanField(const std::string&,unsigned&);
+/// Read a long unsigned field
+  IFile& scanField(const std::string&,long unsigned&);
+/// Read a long long unsigned field
+  IFile& scanField(const std::string&,long long unsigned&);
+/// Read a string field
+  IFile& scanField(const std::string&,std::string&);
+  /**
+   Ends a field-formatted line.
+
+  Typically used as
+  \verbatim
+    if.scanField("a",a).scanField("b",b).scanField();
+  \endverbatim
+  */
+  IFile& scanField();
+/// Get a full line as a string
+  IFile& getline(std::string&);
+/// Reset end of file
+  void reset(bool);
+/// Check if a field exist
+  bool FieldExist(const std::string& s);
+/// Read in a value
+  IFile& scanField(Value* val);
+/// Allow some of the fields in the input to be ignored
+  void allowIgnoredFields();
+/// Allow files without EOL at the end.
+/// This in practice should be only used when opening
+/// plumed input files
+  void allowNoEOL();
+};
+
+}
+
+#endif

plumed/_lib/include/plumed/tools/KernelFunctions.h

@@ -0,0 +1,113 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_KernelFunctions_h
+#define __PLUMED_tools_KernelFunctions_h
+
+#include "Matrix.h"
+#include "../core/Value.h"
+#include <vector>
+#include <memory>
+
+namespace PLMD {
+
+class KernelFunctions {
+private:
+/// Is the metric matrix diagonal
+  enum class matrixType {diagonal,multi,vonmises} dtype;
+/// What type of kernel are we using
+  enum class kernelType {gaussian,truncatedgaussian,stretchedgaussian,uniform,triangular} ktype;
+/// The center of the kernel function
+  std::vector<double> center;
+/// The width of the kernel
+  std::vector<double> width;
+/// The height of the kernel
+  double height;
+
+  double stretchA=1.0;
+  double stretchB=0.0;
+
+/// Used to set all the data in the kernel during construction - avoids double coding as this has two constructors
+  void setData( const std::vector<double>& at,
+                const std::vector<double>& sig,
+                const std::string& type,
+                const std::string& mtype,
+                const double& w );
+/// Convert the width into matrix form
+  Matrix<double> getMatrix() const;
+public:
+  explicit KernelFunctions( const std::string& input );
+  KernelFunctions( const std::vector<double>& at,
+                   const std::vector<double>& sig,
+                   const std::string& type,
+                   const std::string& mtype,
+                   const double& w );
+  explicit KernelFunctions( const KernelFunctions* in );
+/// Normalise the function and scale the height accordingly
+  void normalize( const std::vector<Value*>& myvals );
+/// Get the dimensionality of the kernel
+  unsigned ndim() const;
+/// Get the cutoff for a kernel
+  double getCutoff(double width) const ;
+/// Get the position of the center
+  std::vector<double> getCenter() const;
+/// Get the support
+  std::vector<unsigned> getSupport( const std::vector<double>& dx ) const;
+/// get it in continuous form
+  std::vector<double> getContinuousSupport( ) const;
+/// Evaluate the kernel function with constant intervals
+  double evaluate( const std::vector<Value*>& pos,
+                   std::vector<double>& derivatives,
+                   bool usederiv=true,
+                   bool doInt=false,
+                   double lowI_=-1,
+                   double uppI_=-1 ) const;
+/// Read a kernel function from a file
+  static std::unique_ptr<KernelFunctions> read( IFile* ifile,
+      const bool& cholesky,
+      const std::vector<std::string>& valnames );
+};
+
+inline
+Matrix<double> KernelFunctions::getMatrix() const {
+  unsigned k=0, ncv=ndim();
+  Matrix<double> mymatrix(ncv,ncv);
+  for(unsigned i=0; i<ncv; i++) {
+    for(unsigned j=i; j<ncv; j++) {
+      mymatrix(i,j)=mymatrix(j,i)=width[k]; // recompose the full inverse matrix
+      k++;
+    }
+  }
+  return mymatrix;
+}
+
+inline
+unsigned KernelFunctions::ndim() const {
+  return center.size();
+}
+
+inline
+std::vector<double> KernelFunctions::getCenter() const {
+  return center;
+}
+
+}
+#endif