hillclimber 0.1.5__cp313-cp313-musllinux_1_2_aarch64.whl

plumed/_lib/include/plumed/tools/Brent1DRootSearch.h

@@ -0,0 +1,159 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2016-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_Brent1DRootSearch_h
+#define __PLUMED_tools_Brent1DRootSearch_h
+
+#include "Tools.h"
+
+#include <vector>
+#include <string>
+
+namespace PLMD {
+
+/// A class for doing parabolic interpolation and minimisation of
+/// 1D functions using Brent's method.
+template <class FCLASS>
+class Brent1DRootSearch {
+private:
+/// Has the minimum been bracketed
+  bool bracketed=false;
+/// The tolerance for the line minimiser
+  double tol;
+/// Maximum number of interactions in line minimiser
+  static constexpr unsigned ITMAX=100;
+/// A small number that protects against trying to achieve fractional
+/// accuracy for a minimum that happens to be exactly zero
+  static constexpr double EPS=3.0e-8;
+/// The factor by which to expand the range when bracketing
+  static constexpr double EXPAND=1.6;
+/// This is the type specifier for the function to minimise
+  typedef double(FCLASS::*eng_pointer)( const double& val );
+/// Three points bracketting the minimum and the corresponding function values
+  double ax=0.0, bx=0.0, fa=0.0, fb=0.0;
+/// The class containing the function we are trying to minimise
+  FCLASS myclass_func;
+public:
+  explicit Brent1DRootSearch( const FCLASS& pf,  double t=3.0E-8 );
+/// Bracket the minium
+  void bracket( double ax, double xx, eng_pointer eng );
+/// Find the minimum between two brackets
+  double search( eng_pointer eng );
+};
+
+template <class FCLASS>
+Brent1DRootSearch<FCLASS>::Brent1DRootSearch( const FCLASS& pf, const double t ):
+  tol(t),
+  myclass_func(pf) {
+}
+
+template <class FCLASS>
+void Brent1DRootSearch<FCLASS>::bracket( const double a, const double b,  eng_pointer eng ) {
+  plumed_assert( a!=b );
+  ax=a;
+  bx=b;
+  fa=(myclass_func.*eng)(a);
+  fb=(myclass_func.*eng)(b);
+  if ((fa > 0.0 && fb > 0.0) || (fa < 0.0 && fb < 0.0)) {
+    plumed_merror("input points do not bracket root");
+  }
+  bracketed=true;
+}
+
+template <class FCLASS>
+double Brent1DRootSearch<FCLASS>::search( eng_pointer eng ) {
+  plumed_dbg_assert( bracketed );
+  // starting with these parameters:
+  // double cx=bx;
+  // double fc=fb;
+  //by definition this is true :
+  // if ( (fb>0.0 && fc>0.0) || (fb<0.0 && fc<0.0) ) {
+  // so we initialize the variable/registers
+  // with the body of the first if statement
+  double cx=ax;
+  double fc=fa;
+  double d = bx -ax;
+  double e=d;
+  double min1, min2, p, q, r, s, tol1, xm;
+  for(unsigned iter=0; iter<ITMAX; iter++) {
+    if ( (fb>0.0 && fc>0.0) || (fb<0.0 && fc<0.0) ) {
+      cx=ax;
+      fc=fa;
+      e=d=bx-ax;
+    }
+    if( std::fabs(fc) < std::fabs(fb) ) {
+      ax=bx;
+      bx=cx;
+      cx=ax;
+      fa=fb;
+      fb=fc;
+      fc=fa;
+    }
+    tol1=2*EPS*std::fabs(bx)+0.5*tol;
+    xm=0.5*(cx-bx);
+    if( std::fabs(xm) <= tol1 || fb == 0.0 ) {
+      return bx;
+    }
+    if( std::fabs(e) >= tol1 && std::fabs(fa) > std::fabs(fb) ) {
+      s=fb/fa;
+      if( ax==cx ) {
+        p=2.0*xm*s;
+        q=1.0-s;
+      } else {
+        q=fa/fc;
+        r=fb/fc;
+        p=s*(2.0*xm*q*(q-r)-(bx-ax)*(r-1.0));
+        q=(q-1.0)*(r-1.0)*(s-1.0);
+      }
+      if (p > 0.0) {
+        q = -q;
+      }
+      p=std::fabs(p);
+      min1=3.0*xm*q-std::fabs(tol1*q);
+      min2=std::fabs(e*q);
+      if (2.0*p < (min1 < min2 ? min1 : min2)) {
+        e=d;
+        d=p/q;
+      } else {
+        d=xm;
+        e=d;
+      }
+    } else {
+      d=xm;
+      e=d;
+    }
+    ax=bx;
+    fa=fb;
+    if( std::fabs(d) > tol1 ) {
+      bx+=d;
+    } else if(xm<0 ) {
+      bx -= std::fabs(tol1);  // SIGN(tol1,xm);
+    } else {
+      bx += tol1;
+    }
+    fb = (myclass_func.*eng)(bx);
+  }
+
+  plumed_merror("Too many interactions in zbrent");
+}
+
+}
+#endif

plumed/_lib/include/plumed/tools/CheckInRange.h

@@ -0,0 +1,44 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_CheckInRange_h
+#define __PLUMED_tools_CheckInRange_h
+
+#include <vector>
+#include <string>
+
+namespace PLMD {
+
+/// \ingroup TOOLBOX
+class CheckInRange {
+private:
+  std::vector<double> lower;
+  std::vector<double> upper;
+public:
+  bool setBounds( const unsigned& n, const std::vector<std::string>& str_lower, const std::vector<std::string>& str_upper, std::string& errors );
+  bool wereSet() const ;
+  std::string report( const std::vector<std::string>& a ) const ;
+  bool check( const std::vector<double>& vals ) const ;
+};
+
+}
+
+#endif

plumed/_lib/include/plumed/tools/Citations.h

@@ -0,0 +1,74 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_Citations_h
+#define __PLUMED_tools_Citations_h
+
+#include <vector>
+#include <string>
+#include <iosfwd>
+
+namespace PLMD {
+
+/**
+\ingroup TOOLBOX
+Class taking care of bibliography.
+
+This class contains a vector of citations. To add a new citations, use cite(). To print
+the entire bibliography, just dump on a ostream. Everytime cite is used, a string
+containing the number of the citation is returned. If the same citation is added twice,
+the same string is returned, so that this example will produce only two bibliographic items:
+\verbatim
+#include "Citations.h"
+#include <iostream>
+int main(int argc,char**argv){
+  PLMD::Citations citations;
+  std::cout << citations.cite("Pinco e Pallino, Il Piccolo 33, 444 (2012)") << "\n";
+  std::cout << citations.cite("Other cite") << "\n";
+  std::cout << citations.cite("Pinco e Pallino, Il Piccolo 33, 444 (2012)") << "\n";
+
+  std::cout << "Bibliography\n"<< citations;
+  return 0;
+}
+\endverbatim
+*/
+
+class Citations {
+  std::vector<std::string> items;
+public:
+/// Add a citation.
+/// It returns a string containing the reference number, something like "[10]"
+  std::string cite(const std::string &);
+/// Dumps the bibliography.
+/// It writes on the ostream the list of all the bibliographic items
+/// prefixed with their reference number
+  friend std::ostream &operator<<(std::ostream &,const Citations&);
+/// Delete all references
+  void clear();
+/// Check if bibliography is empty
+  bool empty()const;
+};
+
+std::ostream & operator<<(std::ostream &,const Citations&);
+
+}
+
+#endif

plumed/_lib/include/plumed/tools/ColvarOutput.h

@@ -0,0 +1,118 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_ColvarOutput_h
+#define __PLUMED_tools_ColvarOutput_h
+
+#include <vector>
+
+#include "Pbc.h"
+#include "View.h"
+#include "View2D.h"
+#include "Vector.h"
+#include "Tensor.h"
+
+namespace PLMD {
+
+class Colvar;
+
+class ColvarOutput {
+private:
+  class DerivHelper {
+  private:
+    std::size_t nderivPerComponent;
+    double* derivatives;
+  public:
+    DerivHelper(double* d, std::size_t n ) : nderivPerComponent(n), derivatives(d) {}
+    View2D<double, helpers::dynamic_extent, 3> operator[](std::size_t i) {
+      //the -9 is to "exclude" the virial (even if tecnically is still accessible)
+      return { derivatives + i*nderivPerComponent, nderivPerComponent-9 };
+    }
+
+    Vector getAtomDerivatives( std::size_t valueID, std::size_t atomID ) {
+      std::size_t base = valueID*nderivPerComponent + 3*atomID;
+      return Vector( derivatives[base], derivatives[base+1], derivatives[base+2] );
+    }
+
+    View<double,3> getView( std::size_t valueID, std::size_t atomID) {
+      std::size_t base = valueID*nderivPerComponent + 3*atomID;
+      return View<double,3> { derivatives +base};
+    }
+  };
+public:
+  class VirialHelper {
+  private:
+    std::size_t nderivPerComponent;
+    double* derivatives;
+  public:
+    VirialHelper(double* d, std::size_t n ) : nderivPerComponent(n), derivatives(d) {}
+    Tensor operator[](std::size_t i) const {
+      std::size_t n=(i+1)*nderivPerComponent;
+      return Tensor( derivatives[n-9],
+                     derivatives[n-8],
+                     derivatives[n-7],
+                     derivatives[n-6],
+                     derivatives[n-5],
+                     derivatives[n-4],
+                     derivatives[n-3],
+                     derivatives[n-2],
+                     derivatives[n-1] );
+    }
+    View<double,9> getView(std::size_t i) const {
+      std::size_t n=(i+1)*nderivPerComponent-9;
+      return View<double,9> {derivatives+n};
+    }
+    void set( std::size_t i, const Tensor& v ) {
+      std::size_t n=(i+1)*nderivPerComponent;
+      derivatives[n-9]=v[0][0];
+      derivatives[n-8]=v[0][1];
+      derivatives[n-7]=v[0][2];
+      derivatives[n-6]=v[1][0];
+      derivatives[n-5]=v[1][1];
+      derivatives[n-4]=v[1][2];
+      derivatives[n-3]=v[2][0];
+      derivatives[n-2]=v[2][1];
+      derivatives[n-1]=v[2][2];
+    }
+  };
+  std::size_t ncomponents;
+  View<double> values;
+  DerivHelper derivs;
+  VirialHelper virial;
+  ColvarOutput( View<double> v, std::size_t nderivPerComponent, double *derivatives ):
+    ncomponents(v.size()),
+    values(v),
+    derivs(derivatives,nderivPerComponent),
+    virial(derivatives,nderivPerComponent)
+  {}
+
+  static ColvarOutput createColvarOutput( std::vector<double>& v,
+                                          std::vector<double>& d,
+                                          Colvar* action );
+
+  Vector getAtomDerivatives( std::size_t i, std::size_t a ) {
+    return derivs.getAtomDerivatives(i,a);
+  }
+};
+
+} //namespace PLMD
+
+#endif // __PLUMED_tools_ColvarOutput_h