hillclimber 0.1.6__cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

plumed/_lib/include/plumed/tools/MatrixSquareBracketsAccess.h

@@ -0,0 +1,138 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_MatrixSquareBracketsAccess_h
+#define __PLUMED_tools_MatrixSquareBracketsAccess_h
+
+namespace PLMD {
+
+/**
+Utility class to add [][] access
+
+\tparam T The type of the matrix class.
+\tparam C The type of the returned value.
+\tparam I The type of the first index (default unsigned).
+\tparam J The type of the second index (default unsigned).
+
+It implements the trick described in C++ FAQ 13.12 to allow [][] access
+to matrix-like classes, based on the (,) syntax, thus translating
+[i][j] into (i,j).  In practice, one only needs to implement the (,) syntax and to inherit from
+MatrixSquareBracketsAccess.
+The first template parameter (T) should be the
+class itself, the second (C) is the type of the returned value,
+and the third (I) and fourth (J) are the types of the two indexes (unsigned by default).
+As everything is inlined, no overhead is expected.
+
+\verbatim
+
+class MyMatrixClass:
+  public MatrixSquareBracketsAccess<MyMatrixClass,double>
+{
+  double data[16];
+public:
+  double & operator ()(unsigned i,unsigned j){
+    return data[4*i+j];
+  }
+  const double & operator ()(unsigned i,unsigned j)const{
+    return data[4*i+j];
+  }
+};
+
+int main(){
+  MyMatrixClass m;
+  m[0][1]=3.0;
+  return 0;
+}
+\endverbatim
+
+*/
+
+template<class T,class C,class I=unsigned,class J=unsigned>
+class MatrixSquareBracketsAccess {
+/// Small utility class which just contains a pointer to the T and the row number
+  class Const_row {
+    friend class MatrixSquareBracketsAccess; // this so as to allow only T to instantiate Const_row
+    // the user should not manipulate it directly
+    const MatrixSquareBracketsAccess& accessor;
+    const I row;
+    constexpr Const_row(const MatrixSquareBracketsAccess&t,I i); // constructor is private and cannot be manipulated by the user
+  public:
+    /// access element
+    constexpr const C & operator[] (J j)const;
+  };
+/// Small utility class which just contains a pointer to the T and the row number
+  class Row {
+    friend class MatrixSquareBracketsAccess; // this so as to allow only T to instantiate Const_row
+    // the user should not manipulate it directly
+    MatrixSquareBracketsAccess& accessor;
+    const I row;
+    constexpr Row(MatrixSquareBracketsAccess&t,I i); // constructor is private and cannot be manipulated by the user
+  public:
+    /// access element
+    constexpr C & operator[] (J j);
+  };
+public:
+/// access element (with [][] syntax)
+  constexpr Row operator[] (I i);
+/// access element (with [][] syntax)
+  constexpr Const_row operator[] (I i)const;
+};
+
+template<class T,class C,class I,class J>
+constexpr MatrixSquareBracketsAccess<T,C,I,J>::Const_row::Const_row(const MatrixSquareBracketsAccess&t,I i):
+  accessor(t),row(i) {}
+
+template<class T,class C,class I,class J>
+constexpr MatrixSquareBracketsAccess<T,C,I,J>::Row::Row(MatrixSquareBracketsAccess&t,I i):
+  accessor(t),row(i) {}
+
+template<class T,class C,class I,class J>
+constexpr const C & MatrixSquareBracketsAccess<T,C,I,J>::Const_row::operator[] (J j)const {
+// This appears as a reference to a temporary object
+// however, in reality we know it is a reference to an object that is stored in the
+// t object. We thus suppress the warning raised by cppcheck
+  return (*static_cast<const T*>(&accessor))(row,j);
+}
+
+template<class T,class C,class I,class J>
+constexpr C & MatrixSquareBracketsAccess<T,C,I,J>::Row::operator[] (J j) {
+// This appears as a reference to a temporary object
+// however, in reality we know it is a reference to an object that is stored in the
+// t object. We thus suppress the warning raised by cppcheck
+  return (*static_cast<T*>(&accessor))(row,j);
+}
+
+template<class T,class C,class I,class J>
+constexpr typename MatrixSquareBracketsAccess<T,C,I,J>::Row MatrixSquareBracketsAccess<T,C,I,J>::operator[] (I i) {
+  return Row(*this,i);
+}
+
+template<class T,class C,class I,class J>
+constexpr typename MatrixSquareBracketsAccess<T,C,I,J>::Const_row MatrixSquareBracketsAccess<T,C,I,J>::operator[] (I i)const {
+  return Const_row(*this,i);
+}
+
+}
+
+
+#endif
+
+

plumed/_lib/include/plumed/tools/MergeVectorTools.h

@@ -0,0 +1,153 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_MergeVectorTools_h
+#define __PLUMED_tools_MergeVectorTools_h
+
+#include "../small_vector/small_vector.h"
+#include <vector>
+#include <algorithm>
+#include <type_traits>
+
+namespace PLMD {
+
+namespace mergeVectorTools {
+
+/// Merge sorted vectors.
+/// Takes a vector of pointers to containers and merge them.
+/// Containers should be already sorted.
+/// The content is appended to the result vector.
+/// Optionally, uses a priority_queue implementation.
+template<class C>
+static void mergeSortedVectors(const C* const* vecs, std::size_t size, std::vector<typename C::value_type> & result) {
+
+  /// local class storing the range of remaining objects to be pushed
+  class Entry {
+    typename C::const_iterator fwdIt,endIt;
+
+  public:
+    explicit Entry(C const& v) : fwdIt(v.begin()), endIt(v.end()) {}
+    /// check if this vector still contains something to be pushed
+    bool empty() const {
+      return fwdIt == endIt;
+    }
+    // TODO: revert "typename C::value_type" to "auto": nvc++ and icpc seems to do not deduce automatically the return type
+    const typename C::value_type & top() const {
+      return *fwdIt;
+    }
+    /// to allow using a priority_queu, which selects the highest element.
+    /// we here (counterintuitively) define < as >
+    bool operator< (Entry const& rhs) const {
+      return top() > rhs.top();
+    }
+    void next() {
+      ++fwdIt;
+    };
+  };
+
+  // preprocessing
+  {
+    std::size_t maxsize=0;
+    for(unsigned i=0; i<size; i++) {
+      // find the largest
+      maxsize=std::max(maxsize,vecs[i]->size());
+    }
+    // this is just to decrease the number of reallocations on push_back
+    result.reserve(maxsize);
+    // if vectors are empty we are done
+    if(maxsize==0) {
+      return;
+    }
+  }
+
+  // start
+  // heap containing the ranges to be pushed
+  // avoid allocations when it's small
+  gch::small_vector<Entry,32> heap;
+
+  {
+    for(unsigned i=0; i<size; i++) {
+      if(!vecs[i]->empty()) {
+        // add entry at the end of the array
+        heap.emplace_back(Entry(*vecs[i]));
+      }
+    }
+    // make a sorted heap
+    std::make_heap(std::begin(heap),std::end(heap));
+  }
+
+  // first iteration, to avoid an extra "if" in main iteration
+  // explanations are below
+  {
+    std::pop_heap(std::begin(heap), std::end(heap));
+    auto & tmp=heap.back();
+    const auto val=tmp.top();
+    // here, we append inconditionally
+    result.push_back(val);
+    tmp.next();
+    if(tmp.empty()) {
+      heap.pop_back();
+    } else {
+      std::push_heap(std::begin(heap), std::end(heap));
+    }
+  }
+
+  while(!heap.empty()) {
+    // move entry with the smallest element to the back of the array
+    std::pop_heap(std::begin(heap), std::end(heap));
+    // entry
+    auto & tmp=heap.back();
+    // element
+    const auto val=tmp.top();
+    // if the element is larger than the current largest element,
+    // push it to result
+    if(val > result.back()) {
+      result.push_back(val);
+    }
+    // move forward the used entry
+    tmp.next();
+    // if this entry is exhausted, remove it from the array
+    if(tmp.empty()) {
+      heap.pop_back();
+    }
+    // otherwise, sort again the array
+    else {
+      std::push_heap(std::begin(heap), std::end(heap));
+    }
+  }
+}
+
+template<typename T, typename = void>
+struct has_size_and_data : std::false_type {};
+
+template<typename T>
+struct has_size_and_data<T, std::void_t<decltype(std::declval<T>().size()), decltype(std::declval<T>().data())>> : std::true_type {};
+
+template<class C, class D>
+auto mergeSortedVectors(C& vecs, std::vector<D> & result) -> typename std::enable_if<has_size_and_data<C>::value, void>::type {
+  mergeSortedVectors(vecs.data(),vecs.size(),result);
+}
+
+}
+}
+
+#endif
+

plumed/_lib/include/plumed/tools/Minimise1DBrent.h

@@ -0,0 +1,244 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2015-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_Minimise1DBrent_h
+#define __PLUMED_tools_Minimise1DBrent_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 Minimise1DBrent {
+private:
+/// Has the minimum been bracketed
+  bool bracketed;
+/// Has the function been minimised
+  bool minimised;
+/// The tolerance for the line minimiser
+  double tol;
+/// The default ration by which successive intervals are magnified
+  const double GOLD;
+/// The maximum magnification allowed for a parabolic fit step
+  const double GLIMIT;
+/// Use to prevent any possible division by zero
+  const double TINY;
+/// Maximum number of interactions in line minimiser
+  const unsigned ITMAX;
+/// The value of the golden ratio
+  const double CGOLD;
+/// A small number that protects against trying to achieve fractional
+/// accuracy for a minimum that happens to be exactly zero
+  const double ZEPS;
+/// 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,bx,cx,fa,fb,fc,fmin;
+/// The class containing the function we are trying to minimise
+  FCLASS myclass_func;
+public:
+  explicit Minimise1DBrent( const FCLASS& pf,  const double& t=3.0E-8 );
+/// Bracket the minium
+  void bracket( const double& ax, const double& xx, eng_pointer eng );
+/// Find the minimum between two brackets
+  double minimise( eng_pointer eng );
+/// Return the value of the function at the minimum
+  double getMinimumValue() const ;
+};
+
+template <class FCLASS>
+Minimise1DBrent<FCLASS>::Minimise1DBrent( const FCLASS& pf, const double& t ):
+  bracketed(false),
+  minimised(false),
+  tol(t),
+  GOLD(1.618034),
+  GLIMIT(100.0),
+  TINY(1.0E-20),
+  ITMAX(100),
+  CGOLD(0.3819660),
+  ZEPS(epsilon*1.0E-3),
+  ax(0),bx(0),cx(0),
+  fa(0),fb(0),fc(0),
+  fmin(0),
+  myclass_func(pf) {
+}
+
+template <class FCLASS>
+void Minimise1DBrent<FCLASS>::bracket( const double& a, const double& b, eng_pointer eng ) {
+  ax=a;
+  bx=b;
+  double fu;
+  fa=(myclass_func.*eng)(ax);
+  fb=(myclass_func.*eng)(bx);
+  if( fb>fa ) {
+    double tmp;
+    tmp=ax;
+    ax=bx;
+    bx=tmp;
+    tmp=fa;
+    fa=fb;
+    fb=tmp;
+  }
+  cx=bx+GOLD*(bx-ax);
+  fc=(myclass_func.*eng)(cx);
+  while ( fb > fc ) {
+    double r=(bx-ax)*(fb-fc);
+    double q=(bx-cx)*(fb-fa);
+    double u=bx-((bx-cx)*q-(bx-ax)*r)/(2.0*(std::fabs(q-r)>TINY?std::fabs(q-r):TINY)*(q-r>=0?1:-1));
+    double ulim=bx+GLIMIT*(cx-bx);
+    if((bx-u)*(u-cx) > 0.0 ) {
+      fu=(myclass_func.*eng)(u);
+      if( fu < fc ) {
+        ax=bx;
+        bx=u;
+        fa=fb;
+        fb=fu;
+        bracketed=true;
+        return;
+      } else if( fu > fb ) {
+        cx=u;
+        fc=fu;
+        bracketed=true;
+        return;
+      }
+      u=cx+GOLD*(cx-bx);
+      fu=(myclass_func.*eng)(u);
+    } else if((cx-u)*(u-ulim) > 0.0 ) {
+      fu=(myclass_func.*eng)(u);
+      if( fu<fc ) {
+        bx=cx;
+        cx=u;
+        u+=GOLD*(u-bx);
+        fb=fc;
+        fc=fu;
+        fu=(myclass_func.*eng)(u);
+      }
+    } else if( (u-ulim)*(ulim-cx) >= 0.0 ) {
+      u=ulim;
+      fu=(myclass_func.*eng)(u);
+    } else {
+      u=cx+GOLD*(cx-bx);
+      fu=(myclass_func.*eng)(u);
+    }
+    ax=bx;
+    bx=cx;
+    cx=u;
+    fa=fb;
+    fb=fc;
+    fc=fu;
+  }
+  bracketed=true;
+}
+
+template <class FCLASS>
+double Minimise1DBrent<FCLASS>::minimise( eng_pointer eng ) {
+  plumed_dbg_assert( bracketed );
+
+  double a,b,d=0.0,etemp,fu,fv,fw,fx;
+  double p,q,r,tol1,tol2,u,v,w,x,xm;
+  double e=0.0;
+
+  a=(ax < cx ? ax : cx );
+  b=(ax >= cx ? ax : cx );
+  x=w=v=bx;
+  fw=fv=fx=(myclass_func.*eng)(x);
+  for(unsigned iter=0; iter<ITMAX; ++iter) {
+    xm=0.5*(a+b);
+    tol2=2.0*(tol1=tol*std::fabs(x)+ZEPS);
+    if( std::fabs(x-xm) <= (tol2-0.5*(b-a))) {
+      fmin=fx;
+      minimised=true;
+      return x;
+    }
+    if( std::fabs(e) > tol1 ) {
+      r=(x-w)*(fx-fv);
+      q=(x-v)*(fx-fw);
+      p=(x-v)*q-(x-w)*r;
+      q=2.0*(q-r);
+      if( q > 0.0 ) {
+        p = -p;
+      }
+      q=std::fabs(q);
+      etemp=e;
+      e=d;
+      if( std::fabs(p) >= std::fabs(0.5*q*etemp) || p <= q*(a-x) || p >= q*(b-x) ) {
+        d = CGOLD*(e=(x >= xm ? a-x : b-x ));
+      } else {
+        d=p/q;
+        u=x+d;
+        if(u-a < tol2 || b-u < tol2 ) {
+          d=(xm-x>=0?std::fabs(tol1):-std::fabs(tol1));
+        }
+      }
+    } else {
+      d=CGOLD*(e=( x >= xm ? a-x : b-x ));
+    }
+    if( std::fabs(d)>=tol1) {
+      u=x+d;
+    } else {
+      u=x+(d>=0?std::fabs(tol1):-std::fabs(tol1));
+    }
+    fu=(myclass_func.*eng)(u);
+    if( fu <= fx ) {
+      if( u >= x ) {
+        a=x;
+      } else {
+        b=x;
+      }
+      v=w;
+      fv=fw;
+      w=x;
+      fw=fx;
+      x=u;
+      fx=fu;
+    } else {
+      if( u < x ) {
+        a=u;
+      } else {
+        b=u;
+      }
+      if( fu <=fw || w==x ) {
+        v=w;
+        w=u;
+        fv=fw;
+        fw=fu;
+      } else if( fu <= fv || v==x || v==w ) {
+        v=u;
+        fv=fu;
+      }
+    }
+  }
+  plumed_merror("Too many interactions in brent");
+}
+
+template <class FCLASS>
+double Minimise1DBrent<FCLASS>::getMinimumValue() const {
+  plumed_dbg_assert( minimised );
+  return fmin;
+}
+
+}
+#endif

plumed/_lib/include/plumed/tools/MinimiseBase.h

@@ -0,0 +1,120 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2015-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_MinimiseBase_h
+#define __PLUMED_tools_MinimiseBase_h
+
+#include "Minimise1DBrent.h"
+
+namespace PLMD {
+
+template <class FCLASS>
+class F1dim {
+private:
+/// This is the pointer to the member function in the energy
+/// calculating class that calculates the energy
+  typedef double(FCLASS::*engf_pointer)( const std::vector<double>& p, std::vector<double>& der ) const ;
+  typedef double(FCLASS::*engfnc_pointer)( const std::vector<double>& p, std::vector<double>& der ) ;
+/// Pointer to the vector containing an initial position on the vector
+  const std::vector<double>& p;
+/// The direction of the vector we are minimising along
+  const std::vector<double>& dir;
+/// Tempory vector that holds a point at which we want to calculate the energy
+  std::vector<double> pt;
+/// Vector that holds the derivatives at the point at which we calculate the energy (these are not used)
+  std::vector<double> fake_der;
+/// Class containging the function in the class
+  FCLASS* func;
+/// Member of class that calculates the energy we are trying to mnimise
+  engf_pointer calc;
+/// Member of class that calcualtes the energy we are trying to minimise
+  engfnc_pointer calc2;
+public:
+  explicit F1dim( const std::vector<double>& pp, const std::vector<double>& dd, FCLASS* ff, engf_pointer cc, engfnc_pointer cc2 );
+/// Calculate the energy at \f$\mathbf{p} + xt*\mathbf{dir}\f$
+  double getEng( const double& xt );
+};
+
+template <class FCLASS>
+F1dim<FCLASS>::F1dim( const std::vector<double>& pp, const std::vector<double>& dd, FCLASS* ff, engf_pointer cc, engfnc_pointer cc2 ):
+  p(pp),
+  dir(dd),
+  pt(pp.size()),
+  fake_der(pp.size()),
+  func(ff),
+  calc(cc),
+  calc2(cc2) {
+  plumed_assert( calc || calc2 );
+}
+
+template <class FCLASS>
+double F1dim<FCLASS>::getEng( const double& xt ) {
+  for(unsigned j=0; j<pt.size(); ++j) {
+    pt[j] = p[j] + xt*dir[j];
+  }
+  if( calc ) {
+    return (func->*calc)(pt,fake_der);
+  }
+  return (func->*calc2)(pt,fake_der);
+}
+
+template <class FCLASS>
+class MinimiseBase {
+private:
+/// This is the pointer to the member function in the energy
+/// calculating class that calculates the energy
+  typedef double(FCLASS::*engf_pointer)( const std::vector<double>& p, std::vector<double>& der );
+/// The class that calculates the energy given a position
+  FCLASS* myclass_func;
+protected:
+/// This calculates the derivatives at a point
+  double calcDerivatives( const std::vector<double>& p, std::vector<double>& der, engf_pointer myfunc ) const ;
+public:
+  explicit MinimiseBase( FCLASS* funcc ) : myclass_func(funcc) {}
+/// This is the line minimiser
+  double linemin( const std::vector<double>& dir, std::vector<double>& p, engf_pointer myfunc ) const ;
+};
+
+template <class FCLASS>
+double MinimiseBase<FCLASS>::linemin( const std::vector<double>& dir, std::vector<double>& p, engf_pointer myfunc ) const {
+  // Construct the object that turns points on a line into vectors
+  F1dim<FCLASS> f1dim( p, dir, myclass_func, NULL, myfunc );
+
+  // Construct an object that will do the line search for the minimum
+  Minimise1DBrent<F1dim<FCLASS> > bb(f1dim);
+
+  // This does the actual line minimisation
+  double ax=0.0, xx=1.0;
+  bb.bracket( ax, xx, &F1dim<FCLASS>::getEng );
+  double xmin=bb.minimise( &F1dim<FCLASS>::getEng );
+  for(unsigned i=0; i<p.size(); ++i) {
+    p[i] += xmin*dir[i];
+  }
+  return bb.getMinimumValue();
+}
+
+template <class FCLASS>
+double MinimiseBase<FCLASS>::calcDerivatives( const std::vector<double>& p, std::vector<double>& der, engf_pointer myfunc ) const {
+  return (myclass_func->*myfunc)( p, der );
+}
+
+}
+#endif

plumed/_lib/include/plumed/tools/MolDataClass.h

@@ -0,0 +1,51 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2013-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_MolDataClass_h
+#define __PLUMED_tools_MolDataClass_h
+
+#include <vector>
+#include <string>
+#include "AtomNumber.h"
+
+namespace PLMD {
+
+class PDB;
+
+/// This class provides information on various kinds of molecules
+/// for instance the kinds of residues that are in a protein
+/// the atoms involved in the backbone of a particular residue etc
+class MolDataClass {
+public:
+/// Return true if the residue name is one of the allowed reisude names e.g. one of the 20 amino acids for proteins
+  static bool allowedResidue( const std::string& type, const std::string& residuename );
+/// Return the number of atoms in the backbone per residue e.g. 5 for proteins
+  static unsigned numberOfAtomsPerResidueInBackbone( const std::string& type );
+/// Return the names of the atoms in the backbone e.g. N, CA, CB, C, O for most protein residues
+  static void getBackboneForResidue( const std::string& type, const unsigned& residuenum, const PDB& mypdb, std::vector<AtomNumber>& atoms );
+/// Return true if the residue is a terminal group e.g. ACE, NME for proteins
+  static bool isTerminalGroup( const std::string& type, const std::string& residuename );
+/// Used to interpret special symbols - currently phi and psi and omega
+  static void specialSymbol( const std::string& type, const std::string& symbol, const PDB& mypdb, std::vector<AtomNumber>& numbers );
+};
+
+}
+#endif