IMP logo
IMP Reference Guide  2.20.0
The Integrative Modeling Platform
DistancePairScoreWithCache.h
Go to the documentation of this file.
1 /**
2  * \file IMP/score_functor/DistancePairScoreWithCache.h
3  * \brief A Score on the distance between a pair of particles, using cache.
4  *
5  * Copyright 2007-2022 IMP Inventors. All rights reserved.
6  */
7 
8 #ifndef IMPSCORE_FUNCTOR_DISTANCE_PAIR_SCORE_WITH_CACHE_H
9 #define IMPSCORE_FUNCTOR_DISTANCE_PAIR_SCORE_WITH_CACHE_H
10 
11 #include <IMP/score_functor/score_functor_config.h>
12 #include <IMP/PairScore.h>
13 #include <IMP/pair_macros.h>
14 
15 IMPSCOREFUNCTOR_BEGIN_NAMESPACE
16 
17 //! Create efficient distance-based pair scores, with cache.
18 /** This class allows one to create efficient distance-based
19  pair scores in C++ by simply writing a functor (ScoreWithCache) that
20  does the scoring. This is like DistancePairScore but it allows the
21  functor to do once-per-model-evaluation cache updates.
22 
23  \see ScoreWithCache, DistancePairScore
24 */
25 template <class DistanceScoreT>
27  DistanceScoreT ds_;
28 
29  double evaluate_index_with_cache(Model *m,
30  const ParticleIndexPair &pip,
31  DerivativeAccumulator *da) const;
32 
33  public:
34  typedef DistanceScoreT DistanceScore;
35 
36  // for backwards compat
37  DistancePairScoreWithCache(const DistanceScore &t0,
38  std::string name = "FunctorDistancePairScoreWithCache %1%")
39  : PairScore(name), ds_(t0) {}
40 
41  virtual double evaluate_index(Model *m,
42  const ParticleIndexPair &pip,
43  DerivativeAccumulator *da) const override;
44 
45  virtual ModelObjectsTemp do_get_inputs(
46  Model *m, const ParticleIndexes &pis) const override;
47 
48  /**
49  return a reference to the functor that is applied on a pair of particles
50  in order to compute their distances
51  */
52  DistanceScoreT& get_score_functor()
53  {return ds_; }
54 
55  virtual double evaluate_indexes(
56  Model *m, const ParticleIndexPairs &p,
57  DerivativeAccumulator *da, unsigned int lower_bound,
58  unsigned int upper_bound) const override;
59 
60  virtual double evaluate_indexes_scores(
62  unsigned int lower_bound, unsigned int upper_bound,
63  std::vector<double> &score) const override;
64 
65  virtual double evaluate_indexes_delta(
67  const std::vector<unsigned> &indexes,
68  std::vector<double> &score) const override;
69 
71 };
72 
73 #ifndef IMP_DOXYGEN
74 template <class DistanceScore>
76  Model *m, const ParticleIndexPairs &p,
77  DerivativeAccumulator *da, unsigned int lower_bound,
78  unsigned int upper_bound) const {
79  double ret = 0;
80  ds_.check_cache_valid(m);
81  for (unsigned int i = lower_bound; i < upper_bound; ++i) {
82  ret += evaluate_index_with_cache(m, p[i], da);
83  }
84  return ret;
85 }
86 
87 template <class DistanceScore>
88 inline double
89 DistancePairScoreWithCache<DistanceScore>::evaluate_indexes_scores(
90  Model *m, const ParticleIndexPairs &p, DerivativeAccumulator *da,
91  unsigned int lower_bound, unsigned int upper_bound,
92  std::vector<double> &score) const {
93  double ret = 0;
94  ds_.check_cache_valid(m);
95  for (unsigned int i = lower_bound; i < upper_bound; ++i) {
96  double s = evaluate_index_with_cache(m, p[i], da);
97  score[i] = s;
98  ret += s;
99  }
100  return ret;
101 }
102 
103 template <class DistanceScore>
104 inline double
105 DistancePairScoreWithCache<DistanceScore>::evaluate_indexes_delta(
106  Model *m, const ParticleIndexPairs &p, DerivativeAccumulator *da,
107  const std::vector<unsigned> &indexes, std::vector<double> &score) const {
108  double ret = 0;
109  ds_.check_cache_valid(m);
110  for (unsigned it : indexes) {
111  double s = evaluate_index_with_cache(m, p[it], da);
112  ret = ret - score[it] + s;
113  score[it] = s;
114  }
115  return ret;
116 }
117 
118 template <class DistanceScore>
119 inline double DistancePairScoreWithCache<DistanceScore>::evaluate_index(
120  Model *m, const ParticleIndexPair &p,
121  DerivativeAccumulator *da) const {
122  ds_.check_cache_valid(m);
123  return evaluate_index_with_cache(m, p, da);
124 }
125 
126 template <class DistanceScore>
127 inline double
128 DistancePairScoreWithCache<DistanceScore>::evaluate_index_with_cache(
129  Model *m, const ParticleIndexPair &p,
130  DerivativeAccumulator *da) const {
131  algebra::Vector3D delta =
132  m->get_sphere(p[0]).get_center() - m->get_sphere(p[1]).get_center();
133  double sq = delta.get_squared_magnitude();
134  if (ds_.get_is_trivially_zero_with_cache(m, p, sq)) {
135  return 0;
136  }
137  double dist = std::sqrt(sq);
138  if (da) {
139  std::pair<double, double> sp = ds_.get_score_and_derivative_with_cache(
140  m, p, dist);
141  static const double MIN_DISTANCE = .00001;
143  if (dist > MIN_DISTANCE) {
144  uv = delta / dist;
145  } else {
146  uv = algebra::get_zero_vector_d<3>();
147  }
148  m->add_to_coordinate_derivatives(p[0], uv * sp.second, *da);
149  m->add_to_coordinate_derivatives(p[1], -uv * sp.second, *da);
150  return sp.first;
151  } else {
152  return ds_.get_score_with_cache(m, p, dist);
153  }
154 }
155 
156 template <class DistanceScore>
157 inline ModelObjectsTemp
158 DistancePairScoreWithCache<DistanceScore>::do_get_inputs(
159  Model *m, const ParticleIndexes &pis) const {
160  ModelObjectsTemp ret;
161  ret += ds_.get_inputs(m, pis);
162  return ret;
163 }
164 #endif
165 
166 IMPSCOREFUNCTOR_END_NAMESPACE
167 
168 #endif /* IMPSCORE_FUNCTOR_DISTANCE_PAIR_SCORE_WITH_CACHE_H */
Abstract class for scoring object(s) of type ParticleIndexPair.
Definition: PairScore.h:44
Macros for various classes.
IMP::Vector< ParticleIndexPair > ParticleIndexPairs
Definition: base_types.h:185
#define IMP_OBJECT_METHODS(Name)
Define the basic things needed by any Object.
Definition: object_macros.h:25
Create efficient distance-based pair scores, with cache.
A more IMP-like version of the std::vector.
Definition: Vector.h:42
IMP::Vector< IMP::WeakPointer< ModelObject > > ModelObjectsTemp
Definition: base_types.h:106
Class for storing model, its restraints, constraints, and particles.
Definition: Model.h:86
Define PairScore.
VectorD< 3 > Vector3D
Definition: VectorD.h:425
Class for adding derivatives from restraints to the model.