hillclimber 0.1.6__cp313-cp313-macosx_15_0_x86_64.whl

plumed/_lib/include/plumed/maze/Optimizer.h

@@ -0,0 +1,357 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+Copyright (c) 2019 Jakub Rydzewski (jr@fizyka.umk.pl). All rights reserved.
+
+See http://www.maze-code.github.io for more information.
+
+This file is part of maze.
+
+maze 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.
+
+maze 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 maze. If not, see <https://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_maze_Optimizer_h
+#define __PLUMED_maze_Optimizer_h
+
+/**
+ * @file Optimizer.h
+ *
+ * @author J. Rydzewski (jr@fizyka.umk.pl)
+ */
+
+#include "../colvar/Colvar.h"
+#include "../tools/Communicator.h"
+#include "../tools/OpenMP.h"
+#include "../tools/NeighborList.h"
+#include "../tools/Vector.h"
+
+#include "Core.h"
+#include "Loss.h"
+
+#include <memory>
+
+#define PLUMED_OPT_INIT(ao) Action(ao), Optimizer(ao)
+
+namespace PLMD {
+namespace maze {
+
+/**
+ * @ingroup INHERIT
+ *
+ * @class Optimizer Optimizer.h "maze/Optimizer.h"
+ *
+ * @brief Base class for implementing optimizers for ligand unbinding.
+ *
+ * An optimizer is defined as a colvar that can be passed to Optimizer_Bias.
+ */
+class Optimizer: public colvar::Colvar {
+public:
+  /**
+   * PLMD constructor.
+   *
+   * @param[in] ao PLMD::ActionOptions&
+   */
+  explicit Optimizer(const ActionOptions&);
+
+  /**
+   * Destructor.
+   */
+  ~Optimizer() { /* Nothing to do. */ }
+
+  /**
+   * Registers PLMD keywords.
+   *
+   * @param[in] keys PLMD keywords
+   */
+  static void registerKeywords(Keywords& keys);
+
+  /**
+   * The pairing function needs to be overridden by a specific optimizer.
+   *
+   * @param[in] distance distance between a pair of atoms
+   */
+  virtual double pairing(double distance) const;
+
+  /**
+   * Optimal values needed for biasing are computed by methods overridding the
+   * optimize function.
+   */
+  virtual void optimize() = 0;
+
+  /**
+   * Calculate the optimal direction of pulling.
+   */
+  void calculate();
+
+  /**
+   * Prepare the neighbor list.
+   */
+  void prepare();
+
+  /**
+   * Score a ligand-protein configuration.
+   *
+   * @return score
+   */
+  double score();
+
+  /**
+   * Calculate sampling radius as the minimal distance between two groups in
+   * neighbors list.
+   *
+   * @return minimal distance of ligand-protein atom pairs
+   */
+  double sampling_radius();
+
+  /**
+   * Load new positions of atoms in the neighbor list.
+   */
+  void update_nl();
+
+  /**
+   * Calculate the center of mass.
+   *
+   * @return center of mass
+   */
+  Vector center_of_mass() const;
+
+public:
+  /**
+   * Getters and setters.
+   */
+
+  std::string get_label() const;
+  void set_label(const std::string&);
+
+  // Start optimizer at time = 0.
+  void start_step_0();
+
+  // Start optimizer at time = optimizer stride.
+  void start_step_stride();
+
+  Vector get_opt() const;
+  void set_opt(Vector);
+
+  double get_opt_value() const;
+  void set_opt_value(double);
+
+  unsigned int get_optimizer_stride() const;
+  void set_optimizer_stride(unsigned int);
+
+  bool is_pbc_on() const;
+  void pbc_on();
+  void pbc_off();
+
+  unsigned int get_n_iterations() const;
+  void set_n_iterations(unsigned int);
+
+  double get_sampling_radius() const;
+  void set_sampling_radius(double);
+
+  unsigned int get_rank_openmp() const;
+  void set_rank_openmp(unsigned int);
+
+  unsigned int get_stride_openmp() const;
+  void set_stride_openmp(unsigned int);
+
+  unsigned int get_n_threads_openmp() const;
+  void set_n_threads_openmp(unsigned int);
+
+  unsigned int get_nl_stride() const;
+  void set_nl_stride(unsigned int);
+
+  double get_nl_cutofff() const;
+  void set_nl_cutoff(double);
+
+protected:
+  //! Optimizer label.
+  std::string label_;
+
+  //! Start either at time =  0 or time = optimizer stride.
+  bool first_step_;
+
+  //! Biasing direction.
+  Vector opt_;
+
+  //! Current loss function value.
+  double opt_value_;
+
+  //! Optimizer stride.
+  unsigned int optimizer_stride_;
+
+  //! Periodic boundary conditions.
+  bool pbc_;
+
+  //! Number of global iterations.
+  unsigned int n_iter_;
+
+  //! Sampling radius.
+  double sampling_r_;
+
+  /**
+   * OpenMP
+   */
+  unsigned int rank_;
+  unsigned int stride_;
+  unsigned int n_threads_;
+
+  //! Neighbor list of ligand-protein atom pairs.
+  std::unique_ptr<NeighborList> neighbor_list_;
+
+  //! Neighbor list cut-off.
+  double nl_cutoff_;
+
+  //! Neighbor list stride.
+  int nl_stride_;
+
+private:
+  bool serial_;
+  bool validate_list_;
+  bool first_time_;
+
+  //! Pointer to the loss function.
+  Loss* loss_;
+  std::vector<Loss*> vec_loss_;
+
+public:
+  /*
+   * Pointers to PLMD components.
+   */
+
+  //! Biased cv.
+  Value* value_x_;
+  Value* value_y_;
+  Value* value_z_;
+
+  //! Loss value.
+  Value* value_action_;
+  //! Sampling radiues value.
+  Value* value_sampling_radius_;
+};
+
+/*
+ * Getters and setters.
+ */
+
+inline void Optimizer::set_nl_cutoff(double nl_cutoff) {
+  nl_cutoff_=nl_cutoff;
+}
+
+inline double Optimizer::get_nl_cutofff() const {
+  return nl_cutoff_;
+}
+
+inline void Optimizer::set_nl_stride(unsigned int nl_stride) {
+  nl_stride_=nl_stride;
+}
+
+inline unsigned int Optimizer::get_nl_stride() const {
+  return nl_stride_;
+}
+
+inline void Optimizer::set_n_threads_openmp(unsigned int n_threads) {
+  n_threads_=n_threads;
+}
+
+inline unsigned int Optimizer::get_n_threads_openmp() const {
+  return n_threads_;
+}
+
+inline void Optimizer::set_stride_openmp(unsigned int stride) {
+  stride_=stride;
+}
+
+inline unsigned int Optimizer::get_stride_openmp() const {
+  return stride_;
+}
+
+inline void Optimizer::set_rank_openmp(unsigned int rank) {
+  rank_=rank;
+}
+
+inline unsigned int Optimizer::get_rank_openmp() const {
+  return rank_;
+}
+
+inline void Optimizer::set_sampling_radius(double sampling_r) {
+  sampling_r_=sampling_r;
+}
+
+inline double Optimizer::get_sampling_radius() const {
+  return sampling_r_;
+}
+
+inline void Optimizer::set_n_iterations(unsigned int n_iter) {
+  n_iter_=n_iter;
+}
+
+inline unsigned int Optimizer::get_n_iterations() const {
+  return n_iter_;
+}
+
+inline void Optimizer::pbc_off() {
+  pbc_=false;
+}
+
+inline void Optimizer::pbc_on() {
+  pbc_=true;
+}
+
+inline bool Optimizer::is_pbc_on() const {
+  return pbc_==true;
+}
+
+inline void Optimizer::set_optimizer_stride(unsigned int optimizer_stride) {
+  optimizer_stride_=optimizer_stride;
+}
+
+inline unsigned int Optimizer::get_optimizer_stride() const {
+  return optimizer_stride_;
+}
+
+inline void Optimizer::set_opt_value(double opt_value) {
+  opt_value_=opt_value;
+}
+
+inline double Optimizer::get_opt_value() const {
+  return opt_value_;
+}
+
+// cppcheck-suppress passedByValue
+inline void Optimizer::set_opt(Vector opt) {
+  opt_=opt;
+}
+
+inline Vector Optimizer::get_opt() const {
+  return opt_;
+}
+
+inline void Optimizer::set_label(const std::string& label) {
+  label_=label;
+}
+
+inline std::string Optimizer::get_label() const {
+  return label_;
+}
+
+inline void Optimizer::start_step_0() {
+  first_step_=false;
+}
+
+inline void Optimizer::start_step_stride() {
+  first_step_=true;
+}
+
+} // namespace maze
+} // namespace PLMD
+
+#endif // __PLUMED_maze_Optimizer_h

plumed/_lib/include/plumed/maze/Random_MT.h

@@ -0,0 +1,156 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+Copyright (c) 2019 Jakub Rydzewski (jr@fizyka.umk.pl). All rights reserved.
+
+See http://www.maze-code.github.io for more information.
+
+This file is part of maze.
+
+maze 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.
+
+maze 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 maze. If not, see <https://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_maze_Random_MT_h
+#define __PLUMED_maze_Random_MT_h
+
+/**
+ * @file Random_MT.h
+ *
+ * @author J. Rydzewski (jr@fizyka.umk.pl)
+ */
+
+#include "Core.h"
+
+namespace PLMD {
+namespace maze {
+
+/**
+ * @class rnd Random_MT.h "maze/Random_MT.h"
+ *
+ * @brief Mersenne Twister sampler for random variables.
+ *
+ * Supports generating integers, doubles, and std::vectors and PLMD::Vectors
+ * within a given range.
+ */
+class rnd {
+public:
+  /**
+   * Initialize MT sampler engine based on std::mt19937_64.
+   */
+  static std::mt19937_64& mt_eng();
+
+  /**
+   * Feed a random seed.
+   */
+  static void randomize();
+
+  /**
+   * Returns a random double from the Cauchy distribution.
+   *
+   * @param m mean
+   * @param s spread
+   */
+  static double next_cauchy(double m, double s);
+
+  /**
+   * Returns a random int from the uniform distribution from a [f, e) range.
+   *
+   * @param f begin
+   * @param e end
+   */
+  static int next_int(int f, int e);
+  static int next_int(int e);
+
+  /**
+   * Returns a random double from the uniform distribution from a [f, e) range.
+   */
+  static double next_double(double f, double e);
+  static double next_double(double e);
+  static double next_double();
+
+  /**
+   * Returns a random vector<double> from the uniform distribution from a [f, e)
+   * range of length n.
+   */
+  static std::vector<double> next_double(double f, double e, std::size_t n);
+
+  /**
+   * Returns a random PLMD::Vector of length r.
+   */
+  static Vector next_plmd_vector();
+  static Vector next_plmd_vector(double r);
+
+  /**
+   * Returns a random std::vector of length r.
+   */
+  static std::vector<double> next_std_vector();
+  static std::vector<double> next_std_vector(double r);
+};
+
+inline Vector rnd::next_plmd_vector(double r) {
+  return next_plmd_vector() * r;
+}
+
+inline std::vector<double> rnd::next_std_vector(double r) {
+  double t = next_double() * 2.0 * pi;
+  double p = next_double() * pi;
+
+  return std::vector<double> {
+    r * std::sin(p) * std::cos(t),
+    r * std::sin(t) * std::sin(p),
+    r * std::cos(p)
+  };
+}
+
+inline std::vector<double> rnd::next_double(double f, double e, size_t n) {
+  std::vector<double> t(n);
+  for (std::size_t i=0; i < n; ++i) {
+    t[i] = next_double(f, e);
+  }
+
+  return t;
+}
+
+inline Vector rnd::next_plmd_vector() {
+  double t = next_double() * 2.0 * pi;
+  double p = next_double() * pi;
+
+  return Vector(
+           std::sin(p) * std::cos(t),
+           std::sin(t) * std::sin(p),
+           std::cos(p)
+         );
+}
+
+inline std::vector<double> rnd::next_std_vector() {
+  double t = next_double() * 2.0 * pi;
+  double p = next_double() * pi;
+
+  return std::vector<double> {
+    std::sin(p) * std::cos(t),
+    std::sin(t) * std::sin(p),
+    std::cos(p)
+  };
+}
+
+inline double rnd::next_double(double e) {
+  return next_double(0, e);
+}
+
+inline void rnd::randomize() {
+  mt_eng().seed(time(0));
+}
+
+} // namespace maze
+} // namespace PLMD
+
+#endif // __PLUMED_maze_Random_MT_h

plumed/_lib/include/plumed/maze/Tools.h

@@ -0,0 +1,183 @@
+/* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+Copyright (c) 2019 Jakub Rydzewski (jr@fizyka.umk.pl). All rights reserved.
+
+See http://www.maze-code.github.io for more information.
+
+This file is part of maze.
+
+maze 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.
+
+maze 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 maze. If not, see <https://www.gnu.org/licenses/>.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
+#ifndef __PLUMED_maze_Tools_h
+#define __PLUMED_maze_Tools_h
+
+/**
+ * @file Tools.h
+ *
+ * @author J. Rydzewski
+ */
+
+#include "../core/ActionSet.h"
+#include "../tools/Vector.h"
+#include "Core.h"
+
+namespace PLMD {
+namespace maze {
+
+/**
+ * @class tls Tools.h "maze/Tools.h"
+ *
+ * @brief Helper functions.
+ */
+class tls {
+public:
+  template<typename T> static int sgn(T val);
+
+  template<typename T>
+  static std::vector<std::string> get_labels_actions(const ActionSet&);
+
+  template<typename T>
+  static T get_pointer_label(
+    const std::string&,
+    const ActionSet&, std::string&
+  );
+
+  template<typename T>
+  static std::vector<T> get_pointers_labels(
+    const std::vector<std::string>&,
+    const ActionSet&, std::string&
+  );
+
+  template<typename T>
+  static std::vector<T> Vector2vector(const Vector&);
+
+  template<typename T>
+  static Vector vector2Vector(const std::vector<T>&);
+
+  template<typename T>
+  static T vector_l(const std::vector<T>&);
+
+  template<typename T>
+  static std::vector<T> vector_n(const std::vector<T>&);
+
+  template<typename T>
+  static T mean(const std::vector<T>&);
+
+  template<typename T>
+  static T std(const std::vector<T>&);
+
+  struct delete_ptr {
+    template<typename T> void operator()(T t) {
+      delete t;
+    }
+  };
+};
+
+template<typename T>
+T tls::std(const std::vector<T>& v) {
+  T m=mean(v);
+  T sq_sum=std::inner_product(v.begin(), v.end(), v.begin(), 0.0);
+
+  return std::sqrt(sq_sum/v.size()-m*m);
+}
+
+template<typename T>
+T tls::mean(const std::vector<T>& v) {
+  return std::accumulate(v.begin(), v.end(), 0.0)/v.size();
+}
+
+template<typename T>
+T tls::vector_l(const std::vector<T>& v) {
+  return std::sqrt(std::inner_product(v.begin(), v.end(), v.begin(), 0.0));
+}
+
+template<typename T>
+std::vector<T> tls::vector_n(const std::vector<T>& v) {
+  double l=vector_l(v);
+  std::vector<double> n;
+  for(std::size_t i=0; i<v.size(); ++i) {
+    n.push_back(v[i]/l);
+  }
+
+  return n;
+}
+
+template<typename T>
+std::vector<T> tls::Vector2vector(const Vector& v) {
+  std::vector<T> t= {v[0], v[1], v[2]};
+
+  return t;
+}
+
+template<typename T>
+Vector tls::vector2Vector(const std::vector<T>& v) {
+  Vector t(v[0], v[1], v[2]);
+
+  return t;
+}
+
+template<typename T>
+int tls::sgn(T val) {
+  return (T(0)<val)-(val<T(0));
+}
+
+template<typename T>
+std::vector<std::string> tls::get_labels_actions(const ActionSet& actionset) {
+  std::vector<std::string> action_str(0);
+  std::vector<T> action_pntrs=actionset.select<T>();
+
+  for(unsigned int i=0; i<action_pntrs.size(); i++) {
+    action_str.push_back(action_pntrs[i]->getLabel());
+  }
+
+  return action_str;
+}
+
+template<typename T> T
+tls::get_pointer_label(
+  const std::string& action_label,
+  const ActionSet& actionset,
+  std::string& error_msg) {
+
+  std::vector<std::string> action_labels(1);
+  action_labels[0]=action_label;
+  std::vector<T> action_pntrs=get_pointers_labels<T>(action_labels, actionset, error_msg);
+
+  return action_pntrs[0];
+}
+
+template<typename T>
+std::vector<T> tls::get_pointers_labels(
+  const std::vector<std::string>& action_labels,
+  const ActionSet& actionset,
+  std::string& error_msg) {
+
+  std::vector<T> action_pntrs(action_labels.size(), NULL);
+  error_msg="";
+  std::vector<std::string> missing(0);
+
+  for(unsigned int i=0; i<action_labels.size(); i++) {
+    action_pntrs[i]=actionset.selectWithLabel<T>(action_labels[i]);
+    if(action_pntrs[i]==NULL) {
+      missing.push_back(action_labels[i]);
+    }
+  }
+
+  return action_pntrs;
+}
+
+} // namespace maze
+} // namespace PLMD
+
+#endif // __PLUMED_maze_Tools_h