hillclimber 0.1.5__cp313-cp313-musllinux_1_2_aarch64.whl

plumed/_lib/include/plumed/ves/BasisFunctions.h

@@ -0,0 +1,380 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_BasisFunctions_h
+#define __PLUMED_ves_BasisFunctions_h
+
+#include "../core/Action.h"
+
+#include <vector>
+#include <string>
+#include <cmath>
+
+
+#define PLUMED_VES_BASISFUNCTIONS_INIT(ao) BasisFunctions(ao)
+
+namespace PLMD {
+
+/**
+\ingroup INHERIT
+Abstract base class for implenting new 1D basis sets.
+*/
+
+class Action;
+class Grid;
+
+namespace ves {
+
+class VesBias;
+class TargetDistribution;
+
+class BasisFunctions :
+  public Action {
+private:
+  // print extra info about the basis set
+  bool print_debug_info_;
+  // to check if the basis set has been defined
+  bool has_been_set;
+  // description of the basis set
+  std::string description_;
+  // the type of the basis set
+  std::string type_;
+  // the maximum order of the basis functions
+  unsigned int norder_;
+  // the total number of basis functions
+  unsigned int nbasis_;
+  // the keywords used to invoke the basis set
+  std::vector<std::string> bf_keywords_;
+  // prefix for the basis function labels
+  std::string bf_label_prefix_;
+  // label of each basis function
+  std::vector<std::string> bf_labels_;
+  // if the basis functions are periodic or not
+  bool periodic_;
+  // if the basis functions are defined on a bounded interval or not
+  bool interval_bounded_;
+  // the intrinsic interval of the basis functions
+  std::string interval_intrinsic_min_str_;
+  std::string interval_intrinsic_max_str_;
+  double interval_intrinsic_min_;
+  double interval_intrinsic_max_;
+  double interval_intrinsic_range_;
+  double interval_intrinsic_mean_;
+  // the defined (translated) interval of the basis functions
+  std::string interval_min_str_;
+  std::string interval_max_str_;
+  double interval_min_;
+  double interval_max_;
+  double interval_range_;
+  double interval_mean_;
+  // the derivative term in the chain rule coming from the translation of the interval
+  double argT_derivf_;
+  // calculate numerically the integrals of the basis functions over the intervals
+  bool numerical_uniform_integrals_;
+  unsigned int nbins_;
+  // the integrals of the basis functions over the interval on which they are defined
+  std::vector <double> uniform_integrals_;
+  //
+  VesBias* vesbias_pntr_;
+  Action* action_pntr_;
+  //
+  void getAllValuesNumericalDerivs(const double, double&, bool&, std::vector<double>&, std::vector<double>&) const;
+
+protected:
+  // setup various stuff
+  void setupBF();
+  void setupInterval();
+  void setNumericalIntegrationBins(const unsigned int nbins) {
+    nbins_=nbins;
+  }
+  void numericalUniformIntegrals();
+  std::vector<double> numericalTargetDistributionIntegralsFromGrid(const Grid*) const ;
+  virtual void setupLabels();
+  virtual void setupUniformIntegrals();
+  template<typename T>
+  void addKeywordToList(const std::string&, const T);
+  template<typename T>
+  void addKeywordToList(const std::string&, const std::vector<T>&);
+  void addKeywordToList(const std::string&, const bool);
+  //
+  void setPeriodic() {
+    periodic_=true;
+  }
+  void setNonPeriodic() {
+    periodic_=false;
+  }
+  void setIntervalBounded() {
+    interval_bounded_=true;
+  }
+  void setIntervalNonBounded() {
+    interval_bounded_=false;
+  }
+  void setType(const std::string& type_in) {
+    type_=type_in;
+  }
+  void setDescription(const std::string& description_in) {
+    description_=description_in;
+  }
+  //
+  void setNumberOfBasisFunctions(const unsigned int);
+  void setOrder(const unsigned int norder_in) {
+    norder_=norder_in;
+  }
+  void setIntrinsicInterval(const double, const double);
+  void setIntrinsicInterval(const std::string&, const std::string&);
+  void setInterval(const double, const double);
+  void setInterval(const std::string&, const std::string&);
+  //
+  double intrinsicIntervalMin() const {
+    return interval_intrinsic_min_;
+  }
+  double intrinsicIntervalMax() const {
+    return interval_intrinsic_max_;
+  }
+  std::string intrinsicIntervalMinStr() const {
+    return interval_intrinsic_min_str_;
+  }
+  std::string intrinsicIntervalMaxStr() const {
+    return interval_intrinsic_max_str_;
+  }
+  //
+  void setUniformIntegral(const unsigned int, const double);
+  void setUniformIntegrals(const std::vector<double>&);
+  void setAllUniformIntegralsToZero();
+  //
+  void setLabelPrefix(const std::string&);
+  void setLabel(const unsigned int, const std::string&);
+  void setLabels(const std::vector<std::string>&);
+
+public:
+  static void registerKeywords(Keywords&);
+  explicit BasisFunctions(const ActionOptions&ao);
+  bool hasBeenSet() const {
+    return has_been_set;
+  }
+  std::string getType() const {
+    return type_;
+  }
+  std::string getDescription() const {
+    return description_;
+  }
+  unsigned int getOrder() const {
+    return norder_;
+  }
+  unsigned int getNumberOfBasisFunctions() const {
+    return nbasis_;
+  }
+  unsigned int numberOfBasisFunctions() const {
+    return nbasis_;
+  }
+  unsigned int getSize() const {
+    return nbasis_;
+  }
+  bool arePeriodic() const {
+    return periodic_;
+  }
+  bool intervalBounded() const {
+    return interval_bounded_;
+  }
+  double intervalMin() const {
+    return interval_min_;
+  }
+  double intervalMax() const {
+    return interval_max_;
+  }
+  double intervalRange() const {
+    return interval_range_;
+  }
+  double intervalMean() const {
+    return interval_mean_;
+  }
+  double intervalDerivf() const {
+    return argT_derivf_;
+  }
+  std::string intervalMinStr() const {
+    return interval_min_str_;
+  }
+  std::string intervalMaxStr() const {
+    return interval_max_str_;
+  }
+  std::vector<double> getUniformIntegrals() const {
+    return uniform_integrals_;
+  }
+  std::vector<double> getTargetDistributionIntegrals(const TargetDistribution*) const;
+  //
+  std::vector<std::string> getKeywordList() const {
+    return bf_keywords_;
+  }
+  std::string getKeywordString() const;
+  //
+  std::string getBasisFunctionLabel(const unsigned int index) const {
+    return bf_labels_[index];
+  }
+  std::vector<std::string> getBasisFunctionLabels() const {
+    return bf_labels_;
+  }
+  //
+  void linkVesBias(VesBias*);
+  void linkAction(Action*);
+  VesBias* getPntrToVesBias() const;
+  Action* getPntrToAction() const;
+  //
+  double translateArgument(const double, bool&) const;
+  double checkIfArgumentInsideInterval(const double, bool&) const;
+  //
+  void apply() override {};
+  void calculate() override {};
+  // calculate the value for the n-th basis function
+  double getValue(const double, const unsigned int, double&, bool&) const;
+  // calculate the values for all basis functions
+  virtual void getAllValues(const double, double&, bool&, std::vector<double>&, std::vector<double>&) const = 0;
+  //virtual void get2ndDerivatives(const double, std::vector<double>&)=0;
+  void printInfo() const;
+  //
+  void getMultipleValue(const std::vector<double>&, std::vector<double>&, std::vector<std::vector<double> >&, std::vector<std::vector<double> >&, const bool numerical_deriv=false) const;
+  void writeBasisFunctionsToFile(OFile&, OFile&, const std::string& min_in, const std::string& max_in, unsigned int nbins=1000, const bool ignore_periodicity=false, const std::string& output_fmt_values="%15.8f", const std::string& output_fmt_derivs="%15.8f", const bool numerical_deriv=false) const;
+};
+
+
+inline
+void BasisFunctions::setNumberOfBasisFunctions(const unsigned int nbasis_in) {
+  nbasis_=nbasis_in;
+  bf_labels_.assign(nbasis_,"");
+  uniform_integrals_.assign(nbasis_,0.0);
+}
+
+
+inline
+VesBias* BasisFunctions::getPntrToVesBias() const {
+  plumed_massert(vesbias_pntr_!=NULL,"the VES bias has not been linked");
+  return vesbias_pntr_;
+}
+
+
+inline
+Action* BasisFunctions::getPntrToAction() const {
+  plumed_massert(action_pntr_!=NULL,"the action has not been linked");
+  return action_pntr_;
+}
+
+
+inline
+void BasisFunctions::setUniformIntegral(const unsigned index, const double value) {
+  uniform_integrals_[index] = value;
+}
+
+
+inline
+void BasisFunctions::setUniformIntegrals(const std::vector<double>& uniform_integrals_in) {
+  plumed_assert(uniform_integrals_in.size()==nbasis_);
+  uniform_integrals_ = uniform_integrals_in;
+}
+
+
+inline
+void BasisFunctions::setAllUniformIntegralsToZero() {
+  uniform_integrals_.assign(nbasis_,0.0);
+}
+
+inline
+void BasisFunctions::setLabelPrefix(const std::string& bf_label_prefix_in) {
+  bf_label_prefix_ = bf_label_prefix_in;
+}
+
+
+inline
+void BasisFunctions::setLabel(const unsigned int index, const std::string& label) {
+  bf_labels_[index] = label;
+}
+
+
+inline
+void BasisFunctions::setLabels(const std::vector<std::string>& bf_labels_in) {
+  bf_labels_ = bf_labels_in;
+}
+
+
+inline
+double BasisFunctions::translateArgument(const double arg, bool& inside_interval) const {
+  // NOTE: only works for symmetric intrinsic intervals
+  inside_interval=true;
+  double argT = (arg-interval_mean_)*argT_derivf_;
+  if(argT < interval_intrinsic_min_) {
+    inside_interval=false;
+    argT=interval_intrinsic_min_;
+  } else if(argT > interval_intrinsic_max_) {
+    inside_interval=false;
+    argT=interval_intrinsic_max_;
+  }
+  return argT;
+}
+
+
+inline
+double BasisFunctions::checkIfArgumentInsideInterval(const double arg, bool& inside_interval) const {
+  inside_interval=true;
+  double argT = arg;
+  if(arg < interval_min_) {
+    inside_interval=false;
+    argT=interval_min_;
+  } else if(arg > interval_max_) {
+    inside_interval=false;
+    argT=interval_max_;
+  }
+  return argT;
+}
+
+
+
+template<typename T>
+void BasisFunctions::addKeywordToList(const std::string& keyword, const T value) {
+  std::string str_value;
+  Tools::convert(value,str_value);
+  bf_keywords_.push_back(keyword+"="+str_value);
+}
+
+
+template<typename T>
+void BasisFunctions::addKeywordToList(const std::string& keyword, const std::vector<T>& values) {
+  std::string str_value;
+  std::string str_keywordvalues;
+  Tools::convert(values[0],str_value);
+  str_keywordvalues = keyword + "=" + str_value;
+  for(unsigned int i=1; i<values.size(); i++) {
+    Tools::convert(values[i],str_value);
+    str_keywordvalues += "," + str_value;
+  }
+  bf_keywords_.push_back(str_keywordvalues);
+}
+
+
+inline
+void BasisFunctions::addKeywordToList(const std::string& keyword, const bool value) {
+  if(value) {
+    bf_keywords_.push_back(keyword);
+  }
+}
+
+
+}
+}
+
+#endif

plumed/_lib/include/plumed/ves/CoeffsBase.h

@@ -0,0 +1,310 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_CoeffsBase_h
+#define __PLUMED_ves_CoeffsBase_h
+
+#include <vector>
+#include <string>
+
+
+namespace PLMD {
+
+class Action;
+class Value;
+class IFile;
+class OFile;
+
+namespace ves {
+
+class BasisFunctions;
+class VesBias;
+
+/// \ingroup TOOLBOX
+class CoeffsBase {
+public:
+  // the type of 1D index
+  // typedef size_t index_t;
+  // typedef unsigned int index_t;
+private:
+  std::string label_;
+  std::string data_label_;
+  enum CoeffsType {
+    Generic,
+    LinearBasisSet,
+    MultiCoeffs_LinearBasisSet
+  } coeffs_type_;
+  //
+  bool iteration_and_time_active_;
+  unsigned int iteration_opt;
+  double time_md;
+  //
+  bool active;
+  //
+  Action* action_pntr_;
+  VesBias* vesbias_pntr_;
+  //
+  unsigned int ndimensions_;
+  std::vector<unsigned int> indices_shape_;
+  size_t ncoeffs_;
+  std::vector<std::string> coeffs_descriptions_;
+  std::vector<std::string> dimension_labels_;
+  //
+  std::vector<Value*> args_;
+  std::vector<BasisFunctions*> basisf_;
+  //
+  bool multicoeffs_;
+  std::vector<std::vector<Value*> > multicoeffs_args_;
+  std::vector<std::vector<BasisFunctions*> >multicoeffs_basisf_;
+  // Labels for fields in output/input files
+  const std::string field_type_;
+  const std::string field_ndimensions_;
+  const std::string field_ncoeffs_total_;
+  const std::string field_shape_prefix_;
+  const std::string field_time_;
+  const std::string field_iteration_;
+  //
+  std::string output_fmt_;
+  //
+  void initializeIndices(const std::vector<unsigned int>&, const std::vector<std::string>&);
+  void reinitializeIndices(const std::vector<unsigned int>&);
+public:
+  explicit CoeffsBase();
+  //
+  explicit CoeffsBase(
+    const std::string&,
+    const std::vector<std::string>&,
+    const std::vector<unsigned int>&,
+    const bool use_iteration_counter=false);
+  //
+  explicit CoeffsBase(
+    const std::string&,
+    const std::vector<Value*>&,
+    std::vector<BasisFunctions*>&,
+    const bool use_iteration_counter=false);
+  //
+  explicit CoeffsBase(
+    const std::string&,
+    std::vector<std::vector<Value*> >&,
+    std::vector<std::vector<BasisFunctions*> >&,
+    const bool use_iteration_counter=false,
+    const std::string& multicoeffs_label="bias"
+  );
+  //
+  ~CoeffsBase();
+  //
+  std::string getLabel() const {
+    return label_;
+  }
+  void setLabel(const std::string&);
+  std::string getDataLabel() const {
+    return data_label_;
+  };
+  void setDataLabel(const std::string&);
+  void setLabels(const std::string&);
+  void setLabels(const std::string&, const std::string&);
+  //
+  CoeffsType getType() const {
+    return coeffs_type_;
+  }
+  std::string getTypeStr() const;
+  void setType(const CoeffsType coeffs_type);
+  void linkVesBias(VesBias*);
+  void linkAction(Action*);
+  VesBias* getPntrToVesBias() const {
+    return vesbias_pntr_;
+  }
+  Action* getPntrToAction() const {
+    return action_pntr_;
+  }
+  bool isGenericCoeffs() const {
+    return coeffs_type_==Generic;
+  }
+  bool isLinearBasisSetCoeffs() const {
+    return coeffs_type_==LinearBasisSet;
+  }
+  bool isMultiLinearBasisSetCoeffs() const {
+    return coeffs_type_==MultiCoeffs_LinearBasisSet;
+  }
+  //
+  std::vector<unsigned int> shapeOfIndices() const {
+    return indices_shape_;
+  }
+  unsigned int shapeOfIndices(const unsigned int dim_index) const {
+    return indices_shape_[dim_index];
+  }
+  size_t numberOfCoeffs() const {
+    return ncoeffs_;
+  }
+  unsigned int numberOfDimensions() const {
+    return ndimensions_;
+  }
+  //
+  bool isActive() const {
+    return active;
+  }
+  void activate() {
+    active=true;
+  }
+  void deactivate() {
+    active=false;
+  }
+  //
+  size_t getIndex(const std::vector<unsigned int>&) const;
+  std::vector<unsigned int> getIndices(const size_t) const;
+  bool indicesExist(const std::vector<unsigned int>&) const;
+  //
+  std::string getCoeffDescription(const size_t index) const {
+    return coeffs_descriptions_[index];
+  }
+  std::string getCoeffDescription(const std::vector<unsigned int>&) const;
+  std::vector<std::string> getAllCoeffsDescriptions() const {
+    return coeffs_descriptions_;
+  }
+  void setCoeffDescription(const size_t, const std::string&);
+  void setCoeffDescription(const std::vector<unsigned int>&, const std::string&);
+  void setAllCoeffsDescriptions(const std::string& description_prefix="C");
+  void setAllCoeffsDescriptions(const std::vector<std::string>&);
+  //
+  std::string getDimensionLabel(const unsigned int) const;
+  std::vector<std::string> getAllDimensionLabels() const {
+    return dimension_labels_;
+  }
+  void setDimensionLabel(const unsigned int, const std::string&);
+  void setAllDimensionLabels(const std::string&);
+  void setAllDimensionLabels(const std::vector<std::string>&);
+  void writeCoeffsInfoToFile(OFile&) const;
+  void writeTimeInfoToFile(OFile&, const double) const;
+  void getCoeffsInfoFromFile(IFile&, const bool ignore_coeffs_info=false);
+  void checkCoeffsInfo(const std::string&, const std::string&, const unsigned int, const size_t, const std::vector<unsigned int>&);
+  //
+  void turnOnIterationCounter() {
+    iteration_and_time_active_=true;
+  }
+  void turnOffIterationCounter() {
+    iteration_and_time_active_=false;
+  }
+  bool isIterationCounterActive() const {
+    return iteration_and_time_active_;
+  }
+  void setIterationCounter(const unsigned int);
+  void setTime(const double);
+  void setIterationCounterAndTime(const unsigned int, const double);
+  unsigned int getIterationCounter() const {
+    return iteration_opt;
+  }
+  double getTimeValue() const {
+    return time_md;
+  }
+  //
+  void setOutputFmt(const std::string& ss) {
+    output_fmt_=ss;
+  }
+  void resetOutputFmt() {
+    output_fmt_="%30.16e";
+  }
+  std::string getOutputFmt() const {
+    return output_fmt_;
+  }
+  //
+  void replaceLabelString(const std::string&, const std::string&);
+protected:
+  void setupBasisFunctionsInfo();
+  void resizeIndices(const std::vector<unsigned int>&);
+  void resizeIndices(std::vector<BasisFunctions*>&);
+  bool sameShape(const CoeffsBase&) const;
+  //
+  void writeIterationCounterAndTimeToFile(OFile&) const;
+  bool getIterationCounterAndTimeFromFile(IFile&);
+  //
+
+};
+
+inline
+void CoeffsBase::setIterationCounter(const unsigned int iteration_opt_in) {
+  iteration_opt=iteration_opt_in;
+}
+
+inline
+void CoeffsBase::setTime(const double time_md_in) {
+  time_md=time_md_in;
+}
+
+inline
+void CoeffsBase::setIterationCounterAndTime(const unsigned int iteration_opt_in, const double time_md_in) {
+  iteration_opt=iteration_opt_in;
+  time_md=time_md_in;
+}
+
+inline
+std::string CoeffsBase::getCoeffDescription(const std::vector<unsigned int>& indices) const {
+  return getCoeffDescription(getIndex(indices));
+}
+
+inline
+std::string CoeffsBase::getDimensionLabel(const unsigned int dim_index) const {
+  // plumed_massert(dim_index<numberOfDimensions(),"Trying to get the label of a dimension outside the number of dimensions");
+  return dimension_labels_[dim_index];
+}
+
+
+// we are flattening arrays using a column-major order
+inline
+size_t CoeffsBase::getIndex(const std::vector<unsigned int>& indices) const {
+  // plumed_dbg_assert(indices.size()==ndimensions_);
+  // for(unsigned int i=0; i<ndimensions_; i++){
+  //   if(indices[i]>=indices_shape_[i]){
+  //     std::string is;
+  //     Tools::convert(i,is);
+  //     std::string msg="ERROR: the system is looking for a value outside the indices along the " + is + "dimension!";
+  //     plumed_merror(msg);
+  //   }
+  // }
+  size_t index=indices[ndimensions_-1];
+  for(unsigned int i=ndimensions_-1; i>0; --i) {
+    index=index*indices_shape_[i-1]+indices[i-1];
+  }
+  return index;
+}
+
+// we are flattening arrays using a column-major order
+inline
+std::vector<unsigned int> CoeffsBase::getIndices(const size_t index) const {
+  std::vector<unsigned int> indices(ndimensions_);
+  size_t kk=index;
+  indices[0]=(index%indices_shape_[0]);
+  for(unsigned int i=1; i<ndimensions_-1; ++i) {
+    kk=(kk-indices[i-1])/indices_shape_[i-1];
+    indices[i]=(kk%indices_shape_[i]);
+  }
+  if(ndimensions_>=2) {
+    indices[ndimensions_-1]=((kk-indices[ndimensions_-2])/indices_shape_[ndimensions_-2]);
+  }
+  return indices;
+}
+
+
+
+
+}
+}
+
+#endif