hillclimber 0.1.5a8__cp314-cp314-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/ves/WaveletGrid.h

@@ -0,0 +1,75 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2016-2021 The VES code team
+   (see the PEOPLE-VES file at the root of this folder for a list of names)
+
+   See http://www.ves-code.org for more information.
+
+   This file is part of VES code module.
+
+   The VES code module 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.
+
+   The VES code module 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 the VES code module.  If not, see <http://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_ves_WaveletGrid_h
+#define __PLUMED_ves_WaveletGrid_h
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+namespace PLMD {
+
+template <typename T>
+class Matrix;
+
+class Grid;
+
+namespace ves {
+
+// factory class to set up a Grid with Wavelets
+class WaveletGrid {
+public:
+  // unordered map with binary representation as string and corresponding values
+  using BinaryMap = std::unordered_map<std::string, std::vector<double>>;
+  // short names of implemented wavelet types
+  enum class Type {
+    db, // standard Daubechies
+    sym // most symmetric Daubechies
+  };
+  static std::string typeToString(Type type, bool abbrev=false);
+  static Type stringToType(std::string& type_str);
+
+private:
+  // lookup function for the filter coefficients
+  static std::vector<double> getFilterCoefficients(unsigned order, bool lowpass, Type type);
+  // Fills the coefficient matrices needed for the cascade algorithm
+  static std::vector<Matrix<double>> setupMatrices(const std::vector<double>& h);
+  // calculates the values of the Wavelet or its derivatives at the Integer points
+  static std::vector<double> calcIntegerValues(const Matrix<double>& M, int deriv);
+  // get eigenvector of square matrix A corresponding to some eigenvalue via SVD decomposition
+  static std::vector<double> getEigenvector(const Matrix<double>& A, double eigenvalue);
+  // calculate the values of the Wavelet or its derivative via the vector cascade algorithm
+  static BinaryMap cascade(std::vector<Matrix<double>>& h_Matvec, std::vector<Matrix<double>>& g_Matvec,
+                           const std::vector<double>& values_at_integers, unsigned recursion_number,
+                           unsigned bins_per_int, unsigned derivnum, bool use_mother_wavelet);
+  static void fillGridFromMaps(std::unique_ptr<Grid>& grid, const BinaryMap& valuesmap,
+                               const BinaryMap& derivsmap);
+public:
+  // construct either a grid with the scaling function or the wavelet function, and its first derivative
+  static std::unique_ptr<Grid> setupGrid(unsigned order, unsigned gridsize, bool use_mother_wavelet, Type type);
+};
+
+
+}
+}
+
+#endif

plumed/_lib/include/plumed/volumes/ActionVolume.h

@@ -0,0 +1,268 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2012-2020 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_volumes_ActionVolume_h
+#define __PLUMED_volumes_ActionVolume_h
+
+#include "../core/ActionWithVector.h"
+#include "../core/ParallelTaskManager.h"
+#include "../tools/ColvarOutput.h"
+
+namespace PLMD {
+namespace volumes {
+
+template <class T>
+struct VolumeData {
+  bool not_in;
+  std::size_t numberOfNonReferenceAtoms;
+  T voldata;
+#ifdef __PLUMED_USE_OPENACC
+  void toACCDevice() const {
+#pragma acc enter data copyin(this[0:1],not_in,numberOfNonReferenceAtoms)
+    voldata.toACCDevice();
+  }
+  void removeFromACCDevice() const {
+    voldata.removeFromACCDevice();
+#pragma acc exit data delete(numberOfNonReferenceAtoms,not_in,this[0:1])
+  }
+#endif //__PLUMED_USE_OPENACC
+};
+
+struct VolumeInput {
+  std::size_t task_index;
+  const Pbc& pbc;
+  View<const double,3> cpos;
+  View2D<const double,helpers::dynamic_extent,3> refpos;
+  VolumeInput( std::size_t t, unsigned nref, double* p, double* rp, const Pbc& box ) :
+    task_index(t),pbc(box),cpos(p),refpos(rp,nref) {
+  }
+};
+
+class VolumeOutput {
+private:
+  class RefderHelper {
+  private:
+    double* derivatives;
+  public:
+    RefderHelper( double* d ) : derivatives(d) {}
+    View<double,3> operator[](std::size_t i) {
+      return View<double,3>( derivatives + 3*(i+1) );
+    }
+  };
+  ColvarOutput fulldata;
+public:
+  View<double>& values;
+  ColvarOutput::VirialHelper& virial;
+  View<double,3> derivatives;
+  RefderHelper refders;
+  VolumeOutput( View<double>& v, std::size_t nder, double* d ) :
+    fulldata(v, nder, d),
+    values(fulldata.values),
+    virial(fulldata.virial),
+    derivatives(d), refders(d) {
+  }
+};
+
+/**
+\ingroup INHERIT
+This is the abstract base class to use for implementing a new way of defining a particular region of the simulation
+box. You can use this to calculate the number of atoms inside that part or the average value of a quantity like the
+coordination number inside that part of the cell.
+*/
+
+template <class T>
+class ActionVolume : public ActionWithVector {
+public:
+  using input_type = VolumeData<T>;
+  using PTM = ParallelTaskManager<ActionVolume<T>>;
+private:
+/// The parallel task manager
+  PTM taskmanager;
+public:
+  static void registerKeywords( Keywords& keys );
+  explicit ActionVolume(const ActionOptions&);
+  unsigned getNumberOfDerivatives() override;
+  void getInputData( std::vector<double>& inputdata ) const override ;
+  void calculate() override ;
+  void applyNonZeroRankForces( std::vector<double>& outforces ) override ;
+  static void performTask( std::size_t task_index, const VolumeData<T>& actiondata, ParallelActionsInput& input, ParallelActionsOutput& output );
+  static void gatherForces( std::size_t task_index, const VolumeData<T>& actiondata, const ParallelActionsInput& input, const ForceInput& fdata, ForceOutput& forces );
+  static int getNumberOfValuesPerTask( std::size_t task_index, const VolumeData<T>& actiondata );
+  static void getForceIndices( std::size_t task_index, std::size_t colno, std::size_t ntotal_force, const VolumeData<T>& actiondata, const ParallelActionsInput& input, ForceIndexHolder force_indices );
+};
+
+template <class T>
+unsigned ActionVolume<T>::getNumberOfDerivatives() {
+  return 3*getNumberOfAtoms()+9;
+}
+
+template <class T>
+void ActionVolume<T>::registerKeywords( Keywords& keys ) {
+  ActionWithVector::registerKeywords( keys );
+  PTM::registerKeywords( keys );
+  keys.add("atoms","ATOMS","the group of atoms that you would like to investigate");
+  keys.addFlag("OUTSIDE",false,"calculate quantities for colvars that are on atoms outside the region of interest");
+  keys.setValueDescription("scalar/vector","vector of numbers between 0 and 1 that measure the degree to which each atom is within the volume of interest");
+  T::registerKeywords( keys );
+}
+
+template <class T>
+ActionVolume<T>::ActionVolume(const ActionOptions&ao):
+  Action(ao),
+  ActionWithVector(ao),
+  taskmanager(this) {
+  std::vector<AtomNumber> atoms;
+  parseAtomList("ATOMS",atoms);
+  if( atoms.size()==0 ) {
+    error("no atoms were specified");
+  }
+  log.printf("  examining positions of atoms ");
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf(" %d", atoms[i].serial() );
+  }
+  log.printf("\n");
+  std::vector<std::size_t> shape(1);
+  shape[0]=atoms.size();
+
+  std::vector<AtomNumber> refatoms;
+  T::parseAtoms( this, refatoms );
+  for(unsigned i=0; i<refatoms.size(); ++i) {
+    atoms.push_back( refatoms[i] );
+  }
+  requestAtoms( atoms );
+  VolumeData<T> actioninput;
+  actioninput.voldata.parseInput(this);
+
+  actioninput.numberOfNonReferenceAtoms=shape[0];
+  parseFlag("OUTSIDE",actioninput.not_in);
+
+  if( shape[0]==1 ) {
+    ActionWithValue::addValueWithDerivatives();
+  } else {
+    ActionWithValue::addValue( shape );
+    taskmanager.setupParallelTaskManager( 3*(1+refatoms.size())+9, 3*refatoms.size()+9 );
+  }
+  setNotPeriodic();
+  getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
+
+  taskmanager.setActionInput( actioninput );
+}
+
+template <class T>
+void ActionVolume<T>::getInputData( std::vector<double>& inputdata ) const {
+  if( inputdata.size()!=3*getNumberOfAtoms() ) {
+    inputdata.resize( 3*getNumberOfAtoms() );
+  }
+
+  for(unsigned i=0; i<getNumberOfAtoms(); ++i) {
+    Vector ipos = getPosition(i);
+    for(unsigned j=0; j<3; ++j) {
+      inputdata[3*i+j] = ipos[j];
+    }
+  }
+}
+
+template <class T>
+void ActionVolume<T>::calculate() {
+  unsigned k=0;
+  std::vector<Vector> positions( getNumberOfAtoms()-getPntrToComponent(0)->getNumberOfValues() );
+  for(unsigned i=getPntrToComponent(0)->getNumberOfValues(); i<getNumberOfAtoms(); ++i) {
+    positions[k] = getPosition( i );
+    k++;
+  }
+  taskmanager.getActionInput().voldata.setupRegions( this, getPbc(), positions );
+
+  if( getPntrToComponent(0)->getRank()==0 ) {
+    std::size_t nref = getNumberOfAtoms() - 1;
+    std::vector<double> posvec;
+    getInputData( posvec );
+    std::vector<double> deriv( getNumberOfDerivatives() );
+    std::vector<double> val(1);
+    View<double> valview(val.data(),1);
+    VolumeOutput output( valview, getNumberOfDerivatives(), deriv.data() );
+    T::calculateNumberInside( VolumeInput( 0, nref, posvec.data(), posvec.data()+3, getPbc() ), taskmanager.getActionInput().voldata, output );
+    if( taskmanager.getActionInput().not_in ) {
+      val[0] = 1.0 - val[0];
+      for(unsigned i=0; i<deriv.size(); ++i) {
+        deriv[i] *= -1;
+      }
+    }
+    Value* v = getPntrToComponent(0);
+    v->set( val[0] );
+    for(unsigned i=0; i<deriv.size(); ++i) {
+      v->addDerivative( i, deriv[i] );
+    }
+  } else {
+    taskmanager.runAllTasks();
+  }
+}
+
+template <class T>
+void ActionVolume<T>::applyNonZeroRankForces( std::vector<double>& outforces ) {
+  taskmanager.applyForces( outforces );
+}
+
+template <class T>
+void ActionVolume<T>::performTask( std::size_t task_index, const VolumeData<T>& actiondata, ParallelActionsInput& input, ParallelActionsOutput& output ) {
+  std::size_t nref = output.derivatives.size()/3 - 4; // This is the number of reference atoms
+  VolumeOutput volout( output.values, output.derivatives.size(), output.derivatives.data() );
+  T::calculateNumberInside( VolumeInput( task_index, nref, input.inputdata+3*task_index, input.inputdata+3*actiondata.numberOfNonReferenceAtoms, *input.pbc ), actiondata.voldata, volout );
+
+  if( actiondata.not_in ) {
+    output.values[0] = 1.0 - output.values[0];
+    if( input.noderiv ) {
+      return;
+    }
+    for(unsigned i=0; i<output.derivatives.size(); ++i) {
+      output.derivatives[i] *= -1;
+    }
+  }
+}
+
+template <class T>
+int ActionVolume<T>::getNumberOfValuesPerTask( std::size_t task_index,
+    const VolumeData<T>& actiondata ) {
+  return 1;
+}
+
+template<class T>
+void ActionVolume<T>::getForceIndices( std::size_t task_index,
+                                       std::size_t colno,
+                                       std::size_t ntotal_force,
+                                       const VolumeData<T>& actiondata,
+                                       const ParallelActionsInput& input,
+                                       ForceIndexHolder force_indices ) {
+  std::size_t base = 3*task_index;
+  force_indices.indices[0][0] = base;
+  force_indices.indices[0][1] = base + 1;
+  force_indices.indices[0][2] = base + 2;
+  force_indices.threadsafe_derivatives_end[0]=3;
+  std::size_t m=3;
+  for(unsigned n=3*actiondata.numberOfNonReferenceAtoms; n<ntotal_force; ++n) {
+    force_indices.indices[0][m] = n;
+    ++m;
+  }
+  force_indices.tot_indices[0] = m;
+}
+
+}
+}
+#endif

plumed/_lib/include/plumed/volumes/VolumeShortcut.h

@@ -0,0 +1,147 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   Copyright (c) 2011-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_volumes_VolumeShortcut_h
+#define __PLUMED_volumes_VolumeShortcut_h
+
+#include "../core/ActionShortcut.h"
+#include "../core/ActionRegister.h"
+#include "../core/PlumedMain.h"
+#include "../core/ActionSet.h"
+#include "../core/Group.h"
+
+namespace PLMD {
+namespace volumes {
+
+template <const char* v>
+class VolumeShortcut : public ActionShortcut {
+public:
+  static void registerKeywords( Keywords& keys );
+  VolumeShortcut(const ActionOptions&ao);
+};
+
+template <const char* v>
+void VolumeShortcut<v>::registerKeywords( Keywords& keys ) {
+  actionRegister().getKeywords( std::string(v) + "_CALC", keys );
+  keys.add("hidden","IS_SHORTCUT","hidden keyword to tell if actions are shortcuts so that example generator can provide expansions of shortcuts");
+  keys.addDeprecatedKeyword("DATA","");
+  keys.addDeprecatedKeyword("LESS_THAN","");
+  keys.addOutputComponent("lessthan","LESS_THAN","scalar","the number of cvs in the region of interest that are less than a certain threshold");
+  keys.addDeprecatedKeyword("MORE_THAN","");
+  keys.addOutputComponent("morethan","MORE_THAN","scalar","the number of cvs in the region of interest that are more than a certain threshold");
+  keys.addDeprecatedKeyword("BETWEEN","");
+  keys.addOutputComponent("between","BETWEEN","scalar","the number of cvs in the region of interest that are within a certain range");
+  keys.addDeprecatedFlag("SUM","");
+  keys.addOutputComponent("sum","SUM","scalar","the sum of all the colvars weighted by the function that determines if we are in the region");
+  keys.addDeprecatedFlag("MEAN","");
+  keys.addOutputComponent("mean","MEAN","scalar","the average values of the colvar in the region of interest");
+  keys.addActionNameSuffix("_CALC");
+  keys.needsAction("LESS_THAN");
+  keys.needsAction("MORE_THAN");
+  keys.needsAction("GROUP");
+  keys.needsAction("BETWEEN");
+  keys.needsAction("SUM");
+  keys.needsAction("MEAN");
+  keys.needsAction("CUSTOM");
+  keys.setValueDescription("scalar","sum of values of input CVs in regin of interest");
+}
+
+template <const char* v>
+VolumeShortcut<v>::VolumeShortcut(const ActionOptions&ao):
+  Action(ao),
+  ActionShortcut(ao) {
+  std::string voltype(v), mc_lab;
+  parse("DATA",mc_lab);
+  bool dosum;
+  parseFlag("SUM",dosum);
+  if( mc_lab.length()>0 ) {
+    Group* mygrp = plumed.getActionSet().template selectWithLabel<Group*>(mc_lab);
+    Group* mygrp2 = plumed.getActionSet().template selectWithLabel<Group*>(mc_lab + "_grp");
+    if( mygrp || mygrp2 ) {
+      readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + mc_lab );
+    }
+    bool domean;
+    parseFlag("MEAN",domean);
+    std::string lt_input, mt_input, bt_input;
+    parse("LESS_THAN",lt_input);
+    parse("MORE_THAN",mt_input);
+    parse("BETWEEN",bt_input);
+    std::string atomsd;
+    parse("ATOMS",atomsd);
+    if( atomsd.length()==0 ) {
+      atomsd=mc_lab;
+    }
+    // Create the apprpriate volume object
+    readInputLine( getShortcutLabel() + ": " + voltype + "_CALC " + convertInputLineToString() + " ATOMS=" + atomsd );
+    // Now create input for sums
+    if( dosum || domean ) {
+      readInputLine( getShortcutLabel() + "_prod: CUSTOM ARG=" + mc_lab + "," + getShortcutLabel() + " FUNC=x*y PERIODIC=NO");
+      std::string tlab = getShortcutLabel() + "_numer";
+      if( dosum ) {
+        tlab = getShortcutLabel() + "_sum";
+      }
+      readInputLine( tlab + ": SUM ARG=" + getShortcutLabel() + "_prod PERIODIC=NO");
+    }
+    if( domean ) {
+      // Calculate denominator
+      readInputLine( getShortcutLabel() + "_norm: SUM ARG=" + getShortcutLabel() + " PERIODIC=NO");
+      // And calculate final quantity which is mean of these two actions
+      std::string arg1_lab = getShortcutLabel() + "_numer";
+      if( dosum ) {
+        arg1_lab = getShortcutLabel()  + "_sum";
+      }
+      readInputLine( getShortcutLabel() + "_mean: CUSTOM ARG=" + arg1_lab + "," + getShortcutLabel() + "_norm FUNC=x/y PERIODIC=NO");
+    }
+    if( lt_input.length()>0 ) {
+      // Calculate number less than
+      readInputLine( mc_lab + "_" + getShortcutLabel() + "_lt: LESS_THAN ARG=" + mc_lab + " SWITCH={" + lt_input +"}");
+      // And the matheval bit
+      readInputLine( getShortcutLabel() + "_lt: CUSTOM ARG=" + mc_lab + "_" + getShortcutLabel() + "_lt," + getShortcutLabel() + " FUNC=x*y PERIODIC=NO");
+      // And the final sum
+      readInputLine( getShortcutLabel() + "_lessthan: SUM ARG=" + getShortcutLabel() + "_lt PERIODIC=NO");
+    }
+    if( mt_input.length()>0 ) {
+      // Calculate number less than
+      readInputLine( mc_lab + "_" + getShortcutLabel() + "_mt: MORE_THAN ARG=" + mc_lab + " SWITCH={" + mt_input  + "}");
+      // And the matheval bit
+      readInputLine( getShortcutLabel() + "_mt: CUSTOM ARG=" + mc_lab + "_" + getShortcutLabel() + "_mt," + getShortcutLabel() + " FUNC=x*y PERIODIC=NO");
+      // And the final sum
+      readInputLine( getShortcutLabel() + "_morethan: SUM ARG=" + getShortcutLabel() + "_mt PERIODIC=NO");
+    }
+    if( bt_input.length()>0 ) {
+      // Calculate number less than
+      readInputLine( mc_lab + "_" + getShortcutLabel() + "_bt: BETWEEN ARG=" + mc_lab + " SWITCH={" + bt_input +"}");
+      // And the matheval bit
+      readInputLine( getShortcutLabel() + "_bt: CUSTOM ARG=" + mc_lab + "_" + getShortcutLabel() + "_bt," + getShortcutLabel() + " FUNC=x*y PERIODIC=NO");
+      // And the final sum
+      readInputLine( getShortcutLabel() + "_between: SUM ARG=" + getShortcutLabel() + "_bt PERIODIC=NO");
+    }
+  } else if( dosum ) {
+    readInputLine( getShortcutLabel() + "_vols: " + voltype + "_CALC " + convertInputLineToString() );
+    readInputLine( getShortcutLabel() + ": SUM ARG=" + getShortcutLabel() + "_vols PERIODIC=NO");
+  } else {
+    readInputLine( getShortcutLabel() + ": " + voltype + "_CALC " + convertInputLineToString() );
+  }
+}
+
+}
+}
+#endif