hillclimber 0.1.6__cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

plumed/_lib/include/plumed/ves/CoeffsMatrix.h

@@ -0,0 +1,220 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_CoeffsMatrix_h
+#define __PLUMED_ves_CoeffsMatrix_h
+
+#include "CoeffsBase.h"
+
+#include <vector>
+#include <string>
+#include <cmath>
+
+
+namespace PLMD {
+
+class Action;
+class Value;
+class IFile;
+class OFile;
+class Communicator;
+
+namespace ves {
+
+class BasisFunctions;
+class CoeffsVector;
+
+
+class CoeffsMatrix:
+  public CoeffsBase {
+public:
+private:
+  std::vector<double> data;
+  //
+  size_t size_;
+  size_t nrows_;
+  size_t ncolumns_;
+  //
+  bool diagonal_;
+  //
+  unsigned int averaging_counter;
+  unsigned int averaging_exp_decay_;
+  //
+  Communicator& mycomm;
+  //
+  void setupMatrix();
+  //
+  CoeffsMatrix& operator=(const CoeffsMatrix&);
+public:
+  explicit CoeffsMatrix(
+    const std::string&,
+    const std::vector<std::string>&,
+    const std::vector<unsigned int>&,
+    Communicator& cc,
+    const bool diagonal=true,
+    const bool use_iteration_counter=false);
+  //
+  explicit CoeffsMatrix(
+    const std::string&,
+    std::vector<Value*>&,
+    std::vector<BasisFunctions*>&,
+    Communicator& cc,
+    const bool diagonal=true,
+    const bool use_iteration_counter=false);
+  //
+  explicit CoeffsMatrix(
+    const std::string&,
+    std::vector<std::vector<Value*> >& argsv,
+    std::vector<std::vector<BasisFunctions*> >& basisfv,
+    Communicator& cc,
+    const bool diagonal=true,
+    const bool use_iteration_counter=false,
+    const std::string& multicoeffs_label="bias");
+  //
+  explicit CoeffsMatrix(
+    const std::string&,
+    CoeffsVector*,
+    Communicator& cc,
+    const bool diagonal=true);
+  //
+  ~CoeffsMatrix();
+  //
+  size_t getSize() const;
+  //
+  bool isSymmetric() const;
+  bool isDiagonal() const;
+  //
+  bool sameShape(CoeffsVector&) const;
+  bool sameShape(CoeffsMatrix&) const;
+  static bool sameShape(CoeffsMatrix&, CoeffsMatrix&);
+  static bool sameShape(CoeffsVector&, CoeffsMatrix&);
+  static bool sameShape(CoeffsMatrix&, CoeffsVector&);
+  //
+  void sumCommMPI();
+  void sumCommMPI(Communicator&);
+  //
+  void sumMultiSimCommMPI(Communicator&);
+  //
+  size_t getMatrixIndex(const size_t, const size_t) const;
+  //
+  // clear coeffs
+  void clear();
+  void setAllValuesToZero();
+  //
+  std::vector<double> getDataAsVector() const {
+    return data;
+  }
+  // get value
+  double getValue(const size_t, const size_t) const;
+  double getValue(const std::vector<unsigned int>&, const std::vector<unsigned int>&) const;
+  // set value
+  void setValue(const size_t, const size_t, const double);
+  void setValue(const std::vector<unsigned int>&, const std::vector<unsigned int>&, const double);
+  double& operator()(const size_t, const size_t);
+  const double& operator()(const size_t, const size_t) const;
+  double& operator()(const std::vector<unsigned int>&, const std::vector<unsigned int>&);
+  const double& operator()(const std::vector<unsigned int>&, const std::vector<unsigned int>&) const;
+  //
+  friend CoeffsVector operator*(const CoeffsMatrix&, const CoeffsVector&);
+  // add to value
+  void addToValue(const size_t, const size_t, const double);
+  void addToValue(const std::vector<unsigned int>&, const std::vector<unsigned int>&, const double);
+  // scale all values
+  void scaleAllValues(const double);
+  CoeffsMatrix& operator*=(const double);
+  friend CoeffsMatrix operator*(const double, const CoeffsMatrix&);
+  friend CoeffsMatrix operator*(const CoeffsMatrix&, const double);
+  CoeffsMatrix& operator*=(const CoeffsMatrix&);
+  CoeffsMatrix operator*(const CoeffsMatrix&) const;
+  // set all values
+  void setValues(const double);
+  void setValues(const std::vector<double>&);
+  void setValues(const CoeffsMatrix&);
+  CoeffsMatrix& operator=(const double);
+  CoeffsMatrix& operator=(const std::vector<double>&);
+  // CoeffsMatrix& operator=(const CoeffsMatrix&);
+  // add to all values
+  CoeffsMatrix operator+() const;
+  CoeffsMatrix operator-() const;
+  void addToValues(const double);
+  void addToValues(const std::vector<double>&);
+  void addToValues(const CoeffsMatrix&);
+  void subtractFromValues(const double);
+  void subtractFromValues(const std::vector<double>&);
+  void subtractFromValues(const CoeffsMatrix&);
+  CoeffsMatrix& operator+=(const double);
+  friend CoeffsMatrix operator+(const double, const CoeffsMatrix&);
+  friend CoeffsMatrix operator+(const CoeffsMatrix&, const double);
+  CoeffsMatrix& operator+=(const std::vector<double>&);
+  friend CoeffsMatrix operator+(const std::vector<double>&, const CoeffsMatrix&);
+  friend CoeffsMatrix operator+(const CoeffsMatrix&, const std::vector<double>&);
+  CoeffsMatrix& operator-=(const double);
+  friend CoeffsMatrix operator-(const double, const CoeffsMatrix&);
+  friend CoeffsMatrix operator-(const CoeffsMatrix&, const double);
+  CoeffsMatrix& operator-=(const std::vector<double>&);
+  friend CoeffsMatrix operator-(const std::vector<double>&, const CoeffsMatrix&);
+  friend CoeffsMatrix operator-(const CoeffsMatrix&, const std::vector<double>&);
+  CoeffsMatrix& operator+=(const CoeffsMatrix&);
+  CoeffsMatrix operator+(const CoeffsMatrix&) const;
+  CoeffsMatrix& operator-=(const CoeffsMatrix&);
+  CoeffsMatrix operator-(const CoeffsMatrix&) const;
+  //
+  static void averageMatrices(CoeffsMatrix&, CoeffsMatrix&);
+  static void averageMatrices(const std::vector<CoeffsMatrix*>&);
+  //
+  double getMinValue() const;
+  double getMaxValue() const;
+  //
+  void randomizeValuesGaussian(int);
+  //
+  void resetAveragingCounter() {
+    averaging_counter=0;
+  }
+  void setupExponentiallyDecayingAveraging(const unsigned int averaging_exp_decay_in) {
+    averaging_exp_decay_=averaging_exp_decay_in;
+  }
+  void turnOffExponentiallyDecayingAveraging() {
+    averaging_exp_decay_=0;
+  }
+  void resetAveraging();
+  void addToAverage(const CoeffsMatrix&);
+  void addToAverage(const CoeffsMatrix&, const unsigned int);
+  //
+  // file input/output stuff
+  void writeToFile(OFile&);
+  void writeToFile(const std::string&, const bool append_file=false, Action* action_pntr=NULL);
+private:
+  void writeDataToFile(OFile&);
+  void writeMatrixInfoToFile(OFile&);
+  void writeHeaderToFile(OFile&);
+  void writeDataDiagonalToFile(OFile&);
+  void writeDataFullToFile(OFile&);
+public:
+  Communicator& getCommunicator() const {
+    return mycomm;
+  }
+
+};
+}
+}
+
+
+#endif

plumed/_lib/include/plumed/ves/CoeffsVector.h

@@ -0,0 +1,251 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_CoeffsVector_h
+#define __PLUMED_ves_CoeffsVector_h
+
+#include "CoeffsBase.h"
+
+#include <vector>
+#include <string>
+#include <cmath>
+#include <memory>
+
+
+namespace PLMD {
+
+class Action;
+class Value;
+class IFile;
+class OFile;
+class Communicator;
+
+namespace ves {
+
+class BasisFunctions;
+class CoeffsMatrix;
+
+
+class CoeffsVector:
+  public CoeffsBase {
+public:
+private:
+  std::vector<double> data;
+  //
+  unsigned int averaging_counter;
+  unsigned int averaging_exp_decay_;
+  //
+  Communicator& mycomm;
+  //
+  CoeffsVector& operator=(const CoeffsVector&);
+public:
+  explicit CoeffsVector(
+    const std::string&,
+    const std::vector<std::string>&,
+    const std::vector<unsigned int>&,
+    Communicator&,
+    const bool use_counter=false);
+  //
+  explicit CoeffsVector(
+    const std::string&,
+    const std::vector<Value*>&,
+    std::vector<BasisFunctions*>&,
+    Communicator&,
+    const bool use_counter=false);
+  //
+  explicit CoeffsVector(
+    const std::string&,
+    std::vector<std::vector<Value*> >&,
+    std::vector<std::vector<BasisFunctions*> >&,
+    Communicator&,
+    const bool use_counter=false,
+    const std::string& multicoeffs_label="bias");
+  //
+  explicit CoeffsVector(
+    const std::string&,
+    CoeffsMatrix*,
+    Communicator&);
+  //
+  ~CoeffsVector();
+  //
+  size_t getSize() const {
+    return numberOfCoeffs();
+  }
+  // clear coeffs
+  void clear();
+  void setAllValuesToZero();
+  //
+  std::vector<double> getDataAsVector() const {
+    return data;
+  }
+  //
+  bool sameShape(CoeffsVector&) const;
+  bool sameShape(CoeffsMatrix&) const;
+  static bool sameShape(CoeffsVector&, CoeffsVector&);
+  //
+  void resizeCoeffs(const std::vector<unsigned int>&);
+  void resizeCoeffs(std::vector<BasisFunctions*>&);
+  //
+  void sumCommMPI();
+  void sumCommMPI(Communicator& cc);
+  //
+  void sumMultiSimCommMPI(Communicator&);
+  // get value
+  double getValue(const size_t) const;
+  double getValue(const std::vector<unsigned int>&) const;
+  double& operator[](const size_t index);
+  const double& operator[](const size_t index) const;
+  double& operator[](const std::vector<unsigned int>&);
+  const double& operator[](const std::vector<unsigned int>&) const;
+  double& operator()(const size_t index);
+  const double& operator()(const size_t index) const;
+  double& operator()(const std::vector<unsigned int>&);
+  const double& operator()(const std::vector<unsigned int>&) const;
+  // set value
+  void setValue(const size_t, const double);
+  void setValue(const std::vector<unsigned int>&, const double);
+  // add to value
+  void addToValue(const size_t, const double);
+  void addToValue(const std::vector<unsigned int>&, const double);
+  // scale all values
+  void scaleAllValues(const double);
+  void multiplyWithValues(const std::vector<double>&);
+  CoeffsVector& operator*=(const double);
+  friend CoeffsVector operator*(const double, const CoeffsVector&);
+  friend CoeffsVector operator*(const CoeffsVector&, const double);
+  CoeffsVector& operator*=(const std::vector<double>&);
+  friend CoeffsVector operator*(const std::vector<double>&, const CoeffsVector&);
+  friend CoeffsVector operator*(const CoeffsVector&, const std::vector<double>&);
+  CoeffsVector& operator*=(const CoeffsVector&);
+  CoeffsVector operator*(const CoeffsVector&) const;
+  // set all values
+  void setValues(const double);
+  void setValues(const std::vector<double>&);
+  void setValues(const CoeffsVector&);
+  CoeffsVector& operator=(const double);
+  CoeffsVector& operator=(const std::vector<double>&);
+  // CoeffsVector& operator=(const CoeffsVector&);
+  // add to all values
+  CoeffsVector operator+() const;
+  CoeffsVector operator-() const;
+  void addToValues(const double);
+  void addToValues(const std::vector<double>&);
+  void addToValues(const CoeffsVector&);
+  void subtractFromValues(const double);
+  void subtractFromValues(const std::vector<double>&);
+  void subtractFromValues(const CoeffsVector&);
+  CoeffsVector& operator+=(const double);
+  friend CoeffsVector operator+(const double, const CoeffsVector&);
+  friend CoeffsVector operator+(const CoeffsVector&, const double);
+  CoeffsVector& operator+=(const std::vector<double>&);
+  friend CoeffsVector operator+(const std::vector<double>&, const CoeffsVector&);
+  friend CoeffsVector operator+(const CoeffsVector&, const std::vector<double>&);
+  CoeffsVector& operator-=(const double);
+  friend CoeffsVector operator-(const double, const CoeffsVector&);
+  friend CoeffsVector operator-(const CoeffsVector&, const double);
+  CoeffsVector& operator-=(const std::vector<double>&);
+  friend CoeffsVector operator-(const std::vector<double>&, const CoeffsVector&);
+  friend CoeffsVector operator-(const CoeffsVector&, const std::vector<double>&);
+  CoeffsVector& operator+=(const CoeffsVector&);
+  CoeffsVector operator+(const CoeffsVector&) const;
+  CoeffsVector& operator-=(const CoeffsVector&);
+  CoeffsVector operator-(const CoeffsVector&) const;
+  //
+  void setValuesFromDifferentShape(const CoeffsVector&);
+  //
+  static void averageVectors(CoeffsVector&, CoeffsVector&);
+  static void averageVectors(const std::vector<CoeffsVector*>&);
+  //
+  double getMinValue() const;
+  double getMinValue(size_t&) const;
+  double getMinAbsValue() const;
+  double getMinAbsValue(size_t&) const;
+  //
+  double getMaxValue() const;
+  double getMaxValue(size_t&) const;
+  double getMaxAbsValue() const;
+  double getMaxAbsValue(size_t&) const;
+  //
+  double getNorm() const;
+  double getL1Norm() const;
+  double getL2Norm() const;
+  double getLpNorm(const double) const;
+  double getRMS() const;
+  //
+  void normalizeCoeffs();
+  // Random values
+  void randomizeValuesGaussian(int);
+  //
+  void resetAveragingCounter() {
+    averaging_counter=0;
+  }
+  void setupExponentiallyDecayingAveraging(const unsigned int averaging_exp_decay_in) {
+    averaging_exp_decay_=averaging_exp_decay_in;
+  }
+  void turnOffExponentiallyDecayingAveraging() {
+    averaging_exp_decay_=0;
+  }
+  void resetAveraging();
+  void addToAverage(const CoeffsVector&);
+  //
+  size_t countValues(const double) const;
+
+  // file input/output stuff
+  void writeToFile(const std::string&, const bool print_description=false, const bool append_file=false, Action* action_pntr=NULL);
+  void writeToFile(OFile&, const bool print_description=false);
+  void writeToFile(OFile& ofile, CoeffsVector*, const bool print_coeffs_descriptions=false);
+  static void writeToFile(const std::string&, const std::vector<CoeffsVector*>&, const bool print_description=false, const bool append_file=false, Action* action_pntr=NULL);
+  static void writeToFile(OFile&, const std::vector<CoeffsVector*>&, const bool print_description=false);
+private:
+  void writeHeaderToFile(OFile&) const;
+  static void writeDataToFile(OFile&, const std::vector<CoeffsVector*>&, const bool print_description=false);
+public:
+  size_t readFromFile(IFile&, const bool ignore_missing_coeffs=false, const bool ignore_header=false);
+  size_t readFromFile(const std::string&, const bool ignore_missing_coeffs=false, const bool ignore_header=false);
+  size_t readOneSetFromFile(IFile& ifile, const bool ignore_header=false);
+private:
+  void readHeaderFromFile(IFile&, const bool ignore_coeffs_info=false);
+  size_t readDataFromFile(IFile&, const bool ignore_missing_coeffs=false);
+public:
+  Communicator& getCommunicator() const {
+    return mycomm;
+  }
+};
+
+
+inline
+double CoeffsVector::getValue(const size_t index) const {
+  return data[index];
+}
+
+
+inline
+double CoeffsVector::getValue(const std::vector<unsigned int>& indices) const {
+  return data[getIndex(indices)];
+}
+
+
+}
+
+}
+
+
+#endif

plumed/_lib/include/plumed/ves/FermiSwitchingFunction.h

@@ -0,0 +1,74 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_FermiSwitchingFunction_h
+#define __PLUMED_ves_FermiSwitchingFunction_h
+
+#include <string>
+
+
+namespace PLMD {
+
+class Keywords;
+
+namespace ves {
+
+
+/// \ingroup TOOLBOX
+/// Small class to compute fermi switching function.
+/// kept similar to the original SwitchingFunction class.
+class FermiSwitchingFunction {
+/// This is to check that switching function has been initialized
+  bool init;
+/// Type of function
+  enum {fermi} type;
+/// Parameters for fermi function
+  double r0_;
+  double invr0_;
+  double fermi_lambda_;
+  double fermi_exp_max_;
+  FermiSwitchingFunction& operator=(const FermiSwitchingFunction&);
+public:
+  static void registerKeywords( Keywords& keys );
+/// Constructor
+  FermiSwitchingFunction();
+/// Destructor
+  ~FermiSwitchingFunction();
+/// Copy constructor
+  FermiSwitchingFunction(const FermiSwitchingFunction&);
+  //
+  void set(const double, const double, const double fermi_rdist_max=-1.0);
+  //
+  void set(const std::string& definition, std::string& errormsg);
+  //
+  std::string description() const ;
+  // Compute the switching function.
+  // Returns s(x). df will be set to the value of the derivative
+  // of the switching function _divided_by_x
+  double calculate(double x,double&df)const;
+  //
+  double get_r0() const;
+};
+
+}
+}
+
+#endif

plumed/_lib/include/plumed/ves/GridIntegrationWeights.h

@@ -0,0 +1,50 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_GridIntegrationWeights_h
+#define __PLUMED_ves_GridIntegrationWeights_h
+
+#include <vector>
+#include <string>
+
+
+namespace PLMD {
+
+
+class Grid;
+
+
+namespace ves {
+
+class GridIntegrationWeights {
+private:
+  static std::vector<double> getOneDimensionalTrapezoidalWeights(const unsigned int, const double, const bool periodic=false);
+public:
+  static std::vector<double> getIntegrationWeights(const Grid*, const std::string& fname_weights_grid="", const std::string& weights_type="trapezoidal");
+  static void getOneDimensionalIntegrationPointsAndWeights(std::vector<double>&, std::vector<double>&, const unsigned int, const double, const double, const std::string& weights_type="trapezoidal");
+};
+
+
+
+}
+}
+
+#endif

plumed/_lib/include/plumed/ves/GridLinearInterpolation.h

@@ -0,0 +1,81 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+   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_GridLinearInterpolation_h
+#define __PLUMED_ves_GridLinearInterpolation_h
+
+#include <vector>
+
+
+namespace PLMD {
+
+
+class GridBase;
+
+
+namespace ves {
+
+class GridLinearInterpolation {
+private:
+  static double getGridValueWithLinearInterpolation_1D(GridBase* grid_pntr, const std::vector<double>& arg);
+  static double getGridValueWithLinearInterpolation_2D(GridBase* grid_pntr, const std::vector<double>& arg);
+  static double getGridValueWithLinearInterpolation_ND(GridBase* grid_pntr, const std::vector<double>& arg);
+  static double getGridValueAndDerivativesWithLinearInterpolation_1D(GridBase* grid_pntr, const std::vector<double>& arg, std::vector<double>& der);
+  static double getGridValueAndDerivativesWithLinearInterpolation_ND(GridBase* grid_pntr, const std::vector<double>& arg, std::vector<double>& der);
+  static double linearInterpolation(const double x, const double x0, const double x1, const double y0, const double y1);
+  static double multiLinearInterpolation(const std::vector<double>& x, const std::vector<std::vector<double>>& points, std::vector<double>& values, const double dim);
+public:
+  static double getGridValueWithLinearInterpolation(GridBase* grid_pntr, const std::vector<double>& arg);
+  static double getGridValueAndDerivativesWithLinearInterpolation(GridBase* grid_pntr, const std::vector<double>& arg, std::vector<double>& der);
+  static std::vector<std::vector<unsigned>> getAdjacentIndices(GridBase* grid_pntr, const std::vector<double>& arg);
+  static std::vector<std::vector<unsigned>> getAdjacentPoints(GridBase* grid_pntr, const std::vector<double>& arg);
+};
+
+
+inline
+double GridLinearInterpolation::linearInterpolation(const double x, const double x0, const double x1, const double y0, const double y1) {
+  // https://en.wikipedia.org/wiki/Linear_interpolation
+  if(x1!=x0) {
+    return y0 + (x-x0) * ((y1-y0)/(x1-x0));
+  } else {
+    return y0;
+  }
+}
+
+
+inline
+double GridLinearInterpolation::multiLinearInterpolation(const std::vector<double>& x, const std::vector<std::vector<double>>& points, std::vector<double>& values, const double dim) {
+  for (unsigned direction = 0; direction < dim; ++direction) {
+    unsigned shift = 1<<(direction+1); // shift by 2, then 4, then 8 etc
+    for (unsigned i = 0; i < points.size(); i += shift) {
+      // replace every second value with interpolated ones
+      values[i] = linearInterpolation(
+                    x[direction], points[i][direction], points[i+shift/2][direction], values[i], values[i+shift/2]);
+    }
+  }
+  return values[0];
+}
+
+
+}
+}
+
+#endif