IMP logo
IMP Reference Guide  develop.5651aa123e,2024/07/20
The Integrative Modeling Platform
predicates.h
Go to the documentation of this file.
1 /**
2  * \file IMP/core/predicates.h
3  * \brief Score particles based on a bounding box
4  *
5  * Copyright 2007-2022 IMP Inventors. All rights reserved.
6  */
7 
8 #ifndef IMPCORE_PREDICATES_H
9 #define IMPCORE_PREDICATES_H
10 
11 #include <IMP/core/core_config.h>
12 #include <IMP/SingletonPredicate.h>
13 #include <IMP/singleton_macros.h>
14 #include "XYZ.h"
15 
16 IMPCORE_BEGIN_NAMESPACE
17 //! Return 1 if the XYZ is in the bounding box, 0 otherwise.
20 
21  public:
23  std::string name =
24  "InBoundingBox3DSingletonPredicate%1%")
25  : SingletonPredicate(name), bb_(bb) {}
26  virtual int get_value_index(Model *m, ParticleIndex pi) const
27  override {
28  return bb_.get_contains(XYZ(m, pi).get_coordinates()) ? 1 : 0;
29  }
31  Model *m, const ParticleIndexes &pi) const override {
32  ModelObjectsTemp ret;
33  ret += IMP::get_particles(m, pi);
34  return ret;
35  }
38 };
39 
40 //! Return the value of an int attribute as the predicate value.
42  IntKey bb_;
43 
44  public:
45  AttributeSingletonPredicate(IntKey bb, std::string name =
46  "AttributeSingletonPredicate%1%")
47  : SingletonPredicate(name), bb_(bb) {}
48  virtual int get_value_index(Model *m, ParticleIndex pi) const
49  override {
50  return m->get_attribute(bb_, pi);
51  }
53  Model *m, const ParticleIndexes &pi) const override {
54  ModelObjectsTemp ret;
55  ret += IMP::get_particles(m, pi);
56  return ret;
57  }
60 };
61 
62 //! Return 1 if two XYZRs collide.
64  public:
65  IsCollisionPairPredicate(std::string name = "CollisionPairPredicate%1%")
66  : PairPredicate(name) {}
67  virtual int get_value_index(Model *m,
68  const ParticleIndexPair &pi) const
69  override {
70  Float sr =
71  m->get_sphere(std::get<0>(pi)).get_radius()
72  + m->get_sphere(std::get<1>(pi)).get_radius();
73 #if IMP_HAS_CHECKS > 1
74  bool check_collisions = (get_distance(XYZR(m, std::get<0>(pi)),
75  XYZR(m, std::get<1>(pi))) <= 0);
76 #endif
77  for (unsigned int i = 0; i < 3; ++i) {
78  double delta = std::abs(m->get_sphere(std::get<0>(pi)).get_center()[i] -
79  m->get_sphere(std::get<1>(pi)).get_center()[i]);
80  if (delta >= sr) {
81  IMP_INTERNAL_CHECK(!check_collisions, "Should be a collision");
82  return 0;
83  }
84  }
85  bool col =
87  m->get_sphere(std::get<0>(pi)).get_center(),
88  m->get_sphere(std::get<1>(pi)).get_center()) <
89  algebra::get_squared(sr);
90  IMP_INTERNAL_CHECK(col == check_collisions, "Don't match");
91  return col ? 1 : 0;
92  }
93 
95  Model *m, const ParticleIndexes &pi) const override {
96  ModelObjectsTemp ret;
97  ret += IMP::get_particles(m, pi);
98  return ret;
99  }
102 };
103 
104 /** Use a predicate to determine which score to apply. One can use this to,
105  for example, truncate a score using a bounding box.*/
106 template <class Predicate, class Score = SingletonScore>
109  Vector<PointerMember<Score> > scores_;
110  int offset_;
111  Score *get_score(int val) const {
112  if (val < offset_ || val > scores_.size() + offset_) {
113  return nullptr;
114  } else {
115  return scores_[val + offset_];
116  }
117  }
118 
119  public:
120  PredicateSingletonScore(Predicate *pred,
121  std::string name = "PredicateScore%1%")
122  : SingletonScore(name), pred_(pred), offset_(0) {}
123  void set_singleton_score(int val, Score *score) {
124  IMP_USAGE_CHECK(val >= offset_,
125  "Negative predicate values not supported yet");
126  scores_.resize(std::max<int>(val + 1, scores_.size()));
127  scores_[val] = score;
128  }
129  virtual double evaluate_index(Model *m, ParticleIndex p,
130  DerivativeAccumulator *da) const override;
131  virtual ModelObjectsTemp do_get_inputs(
132  Model *m, const ParticleIndexes &pis) const override;
135 };
136 
137 #if !defined(SWIG) && !defined(IMP_DOXYGEN)
138 template <class Predicate, class Score>
140  Model *m, ParticleIndex p,
141  DerivativeAccumulator *da) const {
142  int val = pred_->get_value(m, p);
143  Score *s = get_score(val);
144  if (s) {
145  return s->Score::evaluate_index(m, p, da);
146  } else {
147  return 0;
148  }
149 }
150 #endif
151 
152 /** Other overloads can be created as needed.*/
153 template <class Predicate, class Score>
154 inline PredicateSingletonScore<Predicate, Score> *
155 create_predicates_singleton_score(Predicate *pred, int val, Score *score) {
158  ret->set_score(val, score);
159  return ret;
160 }
161 
162 IMPCORE_END_NAMESPACE
163 
164 #endif /* IMPCORE_PREDICATES_H */
Return 1 if the XYZ is in the bounding box, 0 otherwise.
Definition: predicates.h:18
#define IMP_OBJECT_METHODS(Name)
Define the basic things needed by any Object.
Definition: object_macros.h:25
virtual ModelObjectsTemp do_get_inputs(Model *m, const ParticleIndexes &pi) const override
Overload this method to specify the inputs.
Definition: predicates.h:52
double get_squared_distance(const VectorD< D > &v1, const VectorD< D > &v2)
Compute the squared distance between two vectors.
Definition: VectorD.h:188
Macros for various classes.
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
Get the particles from a list of indexes.
virtual int get_value_index(Model *m, ParticleIndex pi) const override
Compute the predicate and the derivative if needed.
Definition: predicates.h:48
virtual ModelObjectsTemp do_get_inputs(Model *m, const ParticleIndexes &pi) const override
Overload this method to specify the inputs.
Definition: predicates.h:94
A more IMP-like version of the std::vector.
Definition: Vector.h:50
Simple XYZ decorator.
A smart pointer to a reference counted object.
Definition: Pointer.h:87
#define IMP_INTERNAL_CHECK(expr, message)
An assertion to check for internal errors in IMP. An IMP::ErrorException will be thrown.
Definition: check_macros.h:139
Define SingletonPredicate.
Class for storing model, its restraints, constraints, and particles.
Definition: Model.h:86
Return the value of an int attribute as the predicate value.
Definition: predicates.h:41
Abstract class for scoring object(s) of type ParticleIndex.
#define IMP_SINGLETON_SCORE_METHODS(Name)
virtual int get_value_index(Model *m, const ParticleIndexPair &pi) const override
Compute the predicate and the derivative if needed.
Definition: predicates.h:67
A decorator for a particle with x,y,z coordinates.
Definition: XYZ.h:30
virtual int get_value_index(Model *m, ParticleIndex pi) const override
Compute the predicate and the derivative if needed.
Definition: predicates.h:26
virtual ModelObjectsTemp do_get_inputs(Model *m, const ParticleIndexes &pi) const override
Overload this method to specify the inputs.
Definition: predicates.h:30
Return 1 if two XYZRs collide.
Definition: predicates.h:63
#define IMP_SINGLETON_PREDICATE_METHODS(Name)
Define extra the functions needed for a SingletonPredicate.
Abstract predicate function.
Definition: PairPredicate.h:31
Abstract predicate function.
double Float
Basic floating-point value (could be float, double...)
Definition: types.h:19
#define IMP_USAGE_CHECK(expr, message)
A runtime test for incorrect usage of a class or method.
Definition: check_macros.h:168
PredicateSingletonScore< Predicate, Score > * create_predicates_singleton_score(Predicate *pred, int val, Score *score)
Definition: predicates.h:155
Type get_attribute(TypeKey attribute_key, ParticleIndex particle)
get the value of the particle attribute with the specified key
double get_distance(const Line3D &s, const Vector3D &p)
Get closest distance between a line and a point.
Class for adding derivatives from restraints to the model.
#define IMP_PAIR_PREDICATE_METHODS(Name)
Define extra the functions needed for a PairPredicate.
Definition: pair_macros.h:78
A decorator for a particle with x,y,z coordinates and a radius.
Definition: XYZR.h:27