IMP logo
IMP Reference Guide  develop.d247202c1c,2019/10/23
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-2019 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  IMP_OVERRIDE {
28  return bb_.get_contains(XYZ(m, pi).get_coordinates()) ? 1 : 0;
29  }
31  Model *m, const ParticleIndexes &pi) const IMP_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  IMP_OVERRIDE {
50  return m->get_attribute(bb_, pi);
51  }
53  Model *m, const ParticleIndexes &pi) const IMP_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  IMP_OVERRIDE {
70  Float sr =
71  m->get_sphere(pi[0]).get_radius() + m->get_sphere(pi[1]).get_radius();
72 #if IMP_HAS_CHECKS > 1
73  bool check_collisions = (get_distance(XYZR(m, pi[0]), XYZR(m, pi[1])) <= 0);
74 #endif
75  for (unsigned int i = 0; i < 3; ++i) {
76  double delta = std::abs(m->get_sphere(pi[0]).get_center()[i] -
77  m->get_sphere(pi[1]).get_center()[i]);
78  if (delta >= sr) {
79  IMP_INTERNAL_CHECK(!check_collisions, "Should be a collision");
80  return 0;
81  }
82  }
83  bool col =
84  algebra::get_squared_distance(m->get_sphere(pi[0]).get_center(),
85  m->get_sphere(pi[1]).get_center()) <
86  algebra::get_squared(sr);
87  IMP_INTERNAL_CHECK(col == check_collisions, "Don't match");
88  return col ? 1 : 0;
89  }
90 
92  Model *m, const ParticleIndexes &pi) const IMP_OVERRIDE {
93  ModelObjectsTemp ret;
94  ret += IMP::get_particles(m, pi);
95  return ret;
96  }
99 };
100 
101 /** Use a predicate to determine which score to apply. One can use this to,
102  for example, truncate a score using a bounding box.*/
103 template <class Predicate, class Score = SingletonScore>
106  Vector<PointerMember<Score> > scores_;
107  int offset_;
108  Score *get_score(int val) const {
109  if (val < offset_ || val > scores_.size() + offset_) {
110  return nullptr;
111  } else {
112  return scores_[val + offset_];
113  }
114  }
115 
116  public:
117  PredicateSingletonScore(Predicate *pred,
118  std::string name = "PredicateScore%1%")
119  : SingletonScore(name), pred_(pred), offset_(0) {}
120  void set_singleton_score(int val, Score *score) {
121  IMP_USAGE_CHECK(val >= offset_,
122  "Negative predicate values not supported yet");
123  scores_.resize(std::max<int>(val + 1, scores_.size()));
124  scores_[val] = score;
125  }
126  virtual double evaluate_index(Model *m, ParticleIndex p,
128  virtual ModelObjectsTemp do_get_inputs(
129  Model *m, const ParticleIndexes &pis) const IMP_OVERRIDE;
132 };
133 
134 #if !defined(SWIG) && !defined(IMP_DOXYGEN)
135 template <class Predicate, class Score>
137  Model *m, ParticleIndex p,
138  DerivativeAccumulator *da) const {
139  int val = pred_->get_value(m, p);
140  Score *s = get_score(val);
141  if (s) {
142  return s->Score::evaluate_index(m, p, da);
143  } else {
144  return 0;
145  }
146 }
147 #endif
148 
149 /** Other overloads can be created as needed.*/
150 template <class Predicate, class Score>
151 inline PredicateSingletonScore<Predicate, Score> *
152 create_predicates_singleton_score(Predicate *pred, int val, Score *score) {
155  ret->set_score(val, score);
156  return ret;
157 }
158 
159 IMPCORE_END_NAMESPACE
160 
161 #endif /* IMPCORE_PREDICATES_H */
Return 1 if the XYZ is in the bounding box, 0 otherwise.
Definition: predicates.h:18
virtual ModelObjectsTemp do_get_inputs(Model *m, const ParticleIndexes &pi) const
Overload this method to specify the inputs.
Definition: predicates.h:91
#define IMP_OBJECT_METHODS(Name)
Define the basic things needed by any Object.
Definition: object_macros.h:25
virtual int get_value_index(Model *m, ParticleIndex pi) const
Compute the predicate and the derivative if needed.
Definition: predicates.h:26
double get_squared_distance(const VectorD< D > &v1, const VectorD< D > &v2)
Compute the squared distance between two vectors.
Definition: VectorD.h:201
Macros for various classes.
ParticlesTemp get_particles(Model *m, const ParticleIndexes &ps)
virtual int get_value_index(Model *m, const ParticleIndexPair &pi) const
Compute the predicate and the derivative if needed.
Definition: predicates.h:67
A more IMP-like version of the std::vector.
Definition: Vector.h:39
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:72
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)
A decorator for a particle with x,y,z coordinates.
Definition: XYZ.h:30
virtual ModelObjectsTemp do_get_inputs(Model *m, const ParticleIndexes &pi) const
Overload this method to specify the inputs.
Definition: predicates.h:30
virtual ModelObjectsTemp do_get_inputs(Model *m, const ParticleIndexes &pi) const
Overload this method to specify the inputs.
Definition: predicates.h:52
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:20
#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:152
double get_distance(const Line3D &s, const Vector3D &p)
Get closest distance between a line and a point.
#define IMP_OVERRIDE
Cause a compile error if this method does not override a parent method.
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:47
virtual int get_value_index(Model *m, ParticleIndex pi) const
Compute the predicate and the derivative if needed.
Definition: predicates.h:48
A decorator for a particle with x,y,z coordinates and a radius.
Definition: XYZR.h:27