hillclimber 0.1.5__cp313-cp313-musllinux_1_2_aarch64.whl

plumed/_lib/include/plumed/symfunc/CoordinationNumbers.h

@@ -0,0 +1,41 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2013-2017 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_symfunc_CoordinationNumbers_h
+#define __PLUMED_symfunc_CoordinationNumbers_h
+
+#include "../core/ActionShortcut.h"
+
+namespace PLMD {
+namespace symfunc {
+
+class CoordinationNumbers : public ActionShortcut {
+public:
+  static void shortcutKeywords( Keywords& keys );
+  static void registerKeywords( Keywords& keys );
+  static void expandMatrix( const bool& components, const std::string& lab, const std::string& sp_str,
+                            const std::string& spa_str, const std::string& spb_str, ActionShortcut* action );
+  explicit CoordinationNumbers(const ActionOptions&);
+};
+
+}
+}
+#endif

plumed/_lib/include/plumed/tools/Angle.h

@@ -0,0 +1,52 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_Angle_h
+#define __PLUMED_tools_Angle_h
+
+#include "Vector.h"
+
+namespace PLMD {
+
+/// \ingroup TOOLBOX
+/// Class to compute angles.
+/// I define it as a class even if it does not contain anything. The reason
+/// is that in the future I would like to extend it to contain options about
+/// how the calculation should be done. So, for now use it as
+/// Angle a;
+/// double angle=a.compute(v1,v2);
+/// I know it is a bit misleading. If we really do not need to store "options"
+/// inside the Angle class, we can remove it later and write compute as
+/// a static function.
+class Angle {
+// still empty, but may accommodate some options in the future
+public:
+/// Compute the angle between vectors v1 and v2
+#pragma acc routine seq
+  double compute(const Vector& v1,const Vector& v2)const;
+/// Compute the angle between vectors v1 and v2 and its derivatives wrt v1 and v2
+#pragma acc routine seq
+  double compute(const Vector& v1,const Vector& v2,Vector& d1,Vector& d2)const;
+};
+
+}
+
+#endif

plumed/_lib/include/plumed/tools/AtomDistribution.h

@@ -0,0 +1,138 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_AtomDistribution_h
+#define __PLUMED_tools_AtomDistribution_h
+
+#include "Vector.h"
+#include "Tools.h"
+#include "Random.h"
+#include "TrajectoryParser.h"
+
+#include <vector>
+namespace PLMD {
+///tested in regtest/tools/rt-make-AtomicDistribution
+///Acts as a template for any distribution
+struct AtomDistribution {
+  ///Update the input vectors with the position and the box of the frame
+  virtual void frame(std::vector<Vector>& posToUpdate,
+                     std::vector<double>& box,
+                     unsigned /*step*/,
+                     Random& /*rng*/)=0;
+  virtual ~AtomDistribution() noexcept {}
+  ///If necessary changes the number of atoms, returns true if that number has been changed
+  virtual bool overrideNat(unsigned& ) {
+    return false;
+  }
+};
+
+///A wiggly line of atoms
+struct theLine:public AtomDistribution {
+  void frame(std::vector<Vector>& posToUpdate,
+             std::vector<double>& box,
+             unsigned step,
+             Random& rng) override;
+};
+
+///Atom randomly distribuited in a sphere
+struct uniformSphere:public AtomDistribution {
+  void frame(std::vector<Vector>& posToUpdate,
+             std::vector<double>& box,
+             unsigned /*step*/,
+             Random& rng) override;
+};
+
+///Atom randomly distribuited between two not overlapping a spheres
+struct twoGlobs: public AtomDistribution {
+  void frame(std::vector<Vector>& posToUpdate,
+             std::vector<double>& box,
+             unsigned /*step*/,
+             Random&rng) override;
+};
+
+struct uniformCube:public AtomDistribution {
+  void frame(std::vector<Vector>& posToUpdate,
+             std::vector<double>& box,
+             unsigned /*step*/,
+             Random& rng) override;
+};
+
+struct tiledSimpleCubic:public AtomDistribution {
+  void frame(std::vector<Vector>& posToUpdate,
+             std::vector<double>& box,
+             unsigned /*step*/,
+             Random& rng) override;
+};
+
+/// atomic distribution from a trajectory file
+class fileTraj:public AtomDistribution {
+  TrajectoryParser parser;
+  std::vector<double> masses{};
+  std::vector<double> charges{};
+  std::vector<Vector> coordinates{};
+  std::vector<double> cell{0.0,0.0,0.0,
+        0.0,0.0,0.0,
+        0.0,0.0,0.0};
+  bool read=false;
+  bool dont_read_pbc=false;
+  void rewind();
+  //read the next step
+  void step(bool doRewind=true);
+public:
+  void frame(std::vector<Vector>& posToUpdate,
+             std::vector<double>& box,
+             unsigned /*step*/,
+             Random& /*rng*/) override;
+
+  fileTraj(std::string_view fmt,
+           std::string_view fname,
+           bool useMolfile,
+           int command_line_natoms);
+  bool overrideNat(unsigned& natoms) override;
+};
+
+std::unique_ptr<AtomDistribution> getAtomDistribution(std::string_view atomicDistr);
+
+
+///a decorator for replicate the atomic distribution
+class repliedTrajectory: public AtomDistribution {
+  std::unique_ptr<AtomDistribution> distribution;
+  unsigned rX=1;
+  unsigned rY=1;
+  unsigned rZ=1;
+  std::vector<Vector> coordinates;
+public:
+  repliedTrajectory(std::unique_ptr<AtomDistribution>&& d,
+                    const unsigned repeatX,
+                    const unsigned repeatY,
+                    const unsigned repeatZ,
+                    // I think 4294967295 maximum atoms before the multiplication is more than enough
+                    const unsigned nat);
+
+  void frame(std::vector<Vector>& posToUpdate,
+             std::vector<double>& box,
+             unsigned step,
+             Random& rng) override;
+
+  bool overrideNat(unsigned& natoms) override;
+};
+} //namespace PLMD
+#endif // __PLUMED_tools_AtomDistribution_h

plumed/_lib/include/plumed/tools/AtomNumber.h

@@ -0,0 +1,152 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_AtomNumber_h
+#define __PLUMED_tools_AtomNumber_h
+
+#include "Exception.h"
+#include <limits>
+
+namespace PLMD {
+
+/**
+\ingroup TOOLBOX
+ Simple class to store the index of an atom.
+ It is just an unsigned, with all the methods inlined for better efficiency.
+ Its special thing is that it is only accessed through serial(), index(),
+ setSerial() and setIndex() methods, so that there
+ no ambiguity about using the "from 0" (index) or
+ "from 1" (serial) numbering (names as in VMD convention).
+*/
+class AtomNumber {
+  unsigned index_;
+/// Construct with a given index.
+/// This constructor is kept private to avoid implicit cast.
+  explicit AtomNumber(unsigned);
+public:
+/// Initialize to index=0 (serial=1)
+  AtomNumber();
+/// Returns the serial number
+  unsigned serial()const;
+/// Returns the index number
+  unsigned index()const;
+/// Sets the atom number by serial, returning a reference to the AtomNumber itself.
+  AtomNumber & setSerial(unsigned);
+/// Sets the atom number by index, returning a reference to the AtomNumber itself.
+  AtomNumber & setIndex(unsigned);
+/// Returns an AtomNumber with a specified serial.
+  static AtomNumber serial(unsigned);
+/// Returns an AtomNumber with a specified index.
+  static AtomNumber index(unsigned);
+/// Comparison operators
+  friend bool operator<(const AtomNumber&,const AtomNumber&);
+/// Comparison operators
+  friend bool operator>(const AtomNumber&,const AtomNumber&);
+/// Comparison operators
+  friend bool operator<=(const AtomNumber&,const AtomNumber&);
+/// Comparison operators
+  friend bool operator>=(const AtomNumber&,const AtomNumber&);
+/// Comparison operators
+  friend bool operator==(const AtomNumber&,const AtomNumber&);
+/// Comparison operators
+  friend bool operator!=(const AtomNumber&,const AtomNumber&);
+};
+
+inline
+AtomNumber::AtomNumber() {
+  index_=0;
+}
+
+inline
+AtomNumber::AtomNumber(unsigned i) {
+  index_=i;
+}
+
+inline
+unsigned AtomNumber::serial()const {
+  return index_+1;
+}
+
+inline
+unsigned AtomNumber::index()const {
+  return index_;
+}
+
+inline
+AtomNumber & AtomNumber::setSerial(unsigned i) {
+  plumed_massert(i>0,"serial of an atom cannot be zero");
+  plumed_massert(i<std::numeric_limits<unsigned>::max()/2,"serial cannot be negative");
+  index_=i-1;
+  return *this;
+}
+
+inline
+AtomNumber & AtomNumber::setIndex(unsigned i) {
+  index_=i;
+  return *this;
+}
+
+inline
+AtomNumber AtomNumber::serial(unsigned i) {
+  plumed_massert(i>0,"serial of an atom cannot be zero");
+  plumed_massert(i<std::numeric_limits<unsigned>::max()/2,"serial cannot be negative");
+  return AtomNumber(i-1);
+}
+
+inline
+AtomNumber AtomNumber::index(unsigned i) {
+  return AtomNumber(i);
+}
+
+inline
+bool operator<(const AtomNumber&a,const AtomNumber&b) {
+  return a.index_<b.index_;
+}
+
+inline
+bool operator>(const AtomNumber&a,const AtomNumber&b) {
+  return a.index_>b.index_;
+}
+
+inline
+bool operator<=(const AtomNumber&a,const AtomNumber&b) {
+  return a.index_<=b.index_;
+}
+
+inline
+bool operator>=(const AtomNumber&a,const AtomNumber&b) {
+  return a.index_>=b.index_;
+}
+
+inline
+bool operator==(const AtomNumber&a,const AtomNumber&b) {
+  return a.index_==b.index_;
+}
+
+inline
+bool operator!=(const AtomNumber&a,const AtomNumber&b) {
+  return a.index_!=b.index_;
+}
+
+}
+
+#endif
+

plumed/_lib/include/plumed/tools/BiasRepresentation.h

@@ -0,0 +1,106 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_BiasRepresentation_h
+#define __PLUMED_tools_BiasRepresentation_h
+
+#include "Exception.h"
+#include <memory>
+#include <vector>
+
+namespace PLMD {
+
+class Value;
+class Grid;
+class IFile;
+class KernelFunctions;
+class Communicator;
+
+//+PLUMEDOC INTERNAL biasrepresentation
+/*
+
+*/
+//+ENDPLUMEDOC
+
+/// this class implements a general purpose class that aims to
+/// provide a Grid/list
+/// transparently add gaussians to a bias
+
+class BiasRepresentation {
+public:
+  /// create a bias representation from a list of pointer to values
+  BiasRepresentation(const std::vector<Value*> & tmpvalues, Communicator &cc  );
+  /// create a bias using explicit sigma in input (needed for histogram building)
+  BiasRepresentation(const std::vector<Value*> & tmpvalues, Communicator &cc,  const std::vector<double> & sigma);
+  /// create a bias containing a grid representation
+  BiasRepresentation(const std::vector<Value*> & tmpvalues, Communicator &cc, const std::vector<std::string> &  gmin, const std::vector<std::string> & gmax,
+                     const std::vector<unsigned> & nbin, bool doInt, double lowI_, double uppI_);
+  /// create a histogram with grid representation and sigmas in input
+  BiasRepresentation(const std::vector<Value*> & tmpvalues, Communicator &cc, const std::vector<std::string> & gmin, const std::vector<std::string> & gmax, const std::vector<unsigned> & nbin, const std::vector<double> & sigma);
+  /// retrieve the number of dimension of the representation
+  unsigned 	getNumberOfDimensions();
+  /// add the grid to the representation
+  void 		addGrid(const std::vector<std::string> & gmin, const std::vector<std::string> & gmax, const std::vector<unsigned> & nbin );
+  /// push a kernel on the representation (includes widths and height)
+  void 		pushKernel( IFile * ff);
+  /// set the flag that rescales the free energy to the bias
+  void 		setRescaledToBias(bool rescaled);
+  /// check if the representation is rescaled to the bias
+  const bool & 	isRescaledToBias();
+  /// check if the sigma values are already provided (in case of a histogram representation with input sigmas)
+  bool  	hasSigmaInInput();
+  /// get the names of the variables
+  std::vector<std::string> getNames();
+  /// get the pointer to the values
+  const std::vector<Value*> & getPtrToValues();
+  /// get the number of kernels contained in the representation
+  int 		getNumberOfKernels();
+  /// get the name of the i-th value
+  const std::string & getName(unsigned i);
+  /// get a pointer to a specific value
+  Value* 	getPtrToValue(unsigned i);
+  /// get the pointer to the grid
+  Grid* 	getGridPtr();
+  /// get a new histogram point from a file
+  std::unique_ptr<KernelFunctions> readFromPoint(IFile *ifile);
+  /// get an automatic min/max from the set so to know how to configure the grid
+  void getMinMaxBin(std::vector<double> &vmin, std::vector<double> &vmax, std::vector<unsigned> &vbin);
+  /// clear the representation (grid included)
+  void clear();
+private:
+  int ndim;
+  bool hasgrid;
+  bool rescaledToBias;
+  bool doInt_;
+  double lowI_;
+  double uppI_;
+  std::vector<Value*> values;
+  std::vector<std::string> names;
+  std::vector<std::unique_ptr<KernelFunctions>> hills;
+  std::vector<double> biasf;
+  std::vector<double> histosigma;
+  Communicator& mycomm;
+  std::unique_ptr<Grid> BiasGrid_;
+};
+
+}
+
+#endif

plumed/_lib/include/plumed/tools/BitmaskEnum.h

@@ -0,0 +1,167 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2024 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_BitmaskEnum_h
+#define __PLUMED_tools_BitmaskEnum_h
+#include <type_traits>
+
+namespace PLMD {
+namespace enum_traits {
+/**  @brief struct for setting up bitmask operations on enum types
+
+  example usage: specialize with extra traits (see it in action in tools/Keywords.h)
+  Example:
+
+  Please note that in the example the `0` is not a named value (it is reserved
+  as a result of mask not matching masks) and the others values are implemented as single bit
+  @code{.cpp}
+  enum class argType {scalar=1,grid=1<<2,vector=1<<3,matrix=1<<4};
+  template<>
+  struct BitmaskEnum< argType > {
+    static constexpr bool has_valid = true;
+    static constexpr bool has_bit_or = true;
+    static constexpr bool has_bit_and = true;
+  };
+  @endcode
+   Currenlty we have implemented:
+  @code{.cpp}
+   static constexpr bool has_valid = true;
+  @endcode
+   that activates the ::valid(enumtype) function
+  @code{.cpp}
+   static constexpr bool has_bit_or = true;
+  @endcode
+   that activates the operator|(enumtype , enumtype )
+  @code{.cpp}
+   static constexpr bool has_bit_and = true;
+  @endcode
+   that activates the operator&(enumtype , enumtype )
+
+  @see valid(enumtype) for a complete example
+  @see operator&(enumtype, enumtype)
+  @see operator|(enumtype, enumtype)
+*/
+template< typename enum_type >
+struct BitmaskEnum {
+};
+} // namespace enum_traits
+
+/**
+ @brief Perform a bitwise AND between two enum values.
+
+ @param a The first enum value.
+ @param b The second enum value.
+ @return The result of performing a bitwise AND between the two values.
+
+ This operator is only available for enum types that have a specialization of
+enum_traits::BitmaskEnum with the `has_bit_and` trait enabled.
+
+Useful for checking composed values agains masks.
+
+Note that the value may be a 0, and if you do not have defined the 0 as a named
+value you should use valid(enumtype) to check it.
+
+@see valid(enumtype) for a complete example
+@see operator|(enumtype, enumtype)
+*/
+template< typename enumtype > // SFINAE makes function contingent on trait
+constexpr typename std::enable_if_t< enum_traits::BitmaskEnum< enumtype >::has_bit_and,enumtype>
+operator&( enumtype a, enumtype b ) {
+  return static_cast<enumtype>(static_cast<std::underlying_type_t<enumtype>>(a) &
+                               static_cast<std::underlying_type_t<enumtype>>(b));
+}
+
+/**
+ @brief Perform a bitwise OR between two enum values.
+
+ @param a The first enum value.
+ @param b The second enum value.
+ @return The result of performing a bitwise OR between the two values.
+
+This operator is only available for enum types that have a specialization of
+enum_traits::BitmaskEnum with the `has_bit_or` trait enabled.
+
+The principal use is to compose named enum values into masks or combined options.
+
+@see valid(enumtype) for a complete example
+@see operator&(enumtype, enumtype)
+*/
+template< typename enumtype > // SFINAE makes function contingent on trait
+constexpr typename std::enable_if_t< enum_traits::BitmaskEnum< enumtype >::has_bit_or,enumtype>
+operator|( enumtype a, enumtype b ) {
+  return static_cast<enumtype>(static_cast<std::underlying_type_t<enumtype>>(a) |
+                               static_cast<std::underlying_type_t<enumtype>>(b));
+}
+
+/**
+ @brief Test if an enum value is valid.
+
+ @param a The enum value to test.
+ @return true if the enum value is not equal to zero, false otherwise.
+
+
+This operator is only available for enum types that have a specialization of
+enum_traits::BitmaskEnum with the `has_valid` trait enabled.
+
+ @code
+ // Note: explicit declarations of the values, and
+ enum class myenum { A=1,B=1<<1,C=1<<2 };
+ //then activate the functions `&`, `|` and `valid`
+ template<>
+ struct BitmaskEnum< myenum > {
+  static constexpr bool has_valid   = true;
+  static constexpr bool has_bit_or  = true;
+  static constexpr bool has_bit_and = true;
+ };
+ //...code...
+ myenum val = myenum::A | myenum::C;
+ std::cout <<"val is "<< int(val) << "\n";
+ if(PLMD::valid( val & myenum::A)) {
+   std::cout << "val has A\n";
+ }
+ if(PLMD::valid(val & myenum::B)) {
+   std::cout << "val has B\n";
+ }
+ if(PLMD::valid(val & myenum::C)) {
+   std::cout << "val has C\n";
+ }
+ if(PLMD::valid(val & (myenum::A | myenum::C))) {
+   std::cout << "val has C and A\n";
+ }
+ //will produce:
+ ///>val is 5
+ ///>val has A
+ ///>val has C
+ ///>val has C and A
+ @endcode
+
+@see operator|(enumtype, enumtype)
+@see operator&(enumtype, enumtype)
+*/
+template< typename enumtype > // SFINAE makes function contingent on trait
+constexpr typename std::enable_if_t< enum_traits::BitmaskEnum< enumtype >::has_valid,bool>
+valid( enumtype a) {
+  return static_cast<std::underlying_type_t<enumtype>>(a)!=0;
+}
+} // namespace PLMD
+
+#endif //__PLUMED_tools_BitmaskEnum_h