IMP logo
IMP Reference Guide  develop.031dafb4d2,2024/05/21
The Integrative Modeling Platform
Model.h
Go to the documentation of this file.
1 /**
2  * \file IMP/Model.h
3  * \brief Storage of a model, its restraints, constraints and particles.
4  *
5  * Copyright 2007-2022 IMP Inventors. All rights reserved.
6  *
7  */
8 
9 #ifndef IMPKERNEL_MODEL_H
10 #define IMPKERNEL_MODEL_H
11 
12 #include <IMP/kernel_config.h>
13 #include "ModelObject.h"
14 #include "ScoringFunction.h"
15 #include "Restraint.h"
16 #include "RestraintSet.h"
17 #include "ScoreState.h"
18 #include "container_macros.h"
19 #include "base_types.h"
20 //#include "Particle.h"
21 #include "Undecorator.h"
22 #include "internal/AttributeTable.h"
23 #include "internal/attribute_tables.h"
24 #include "internal/moved_particles_cache.h"
25 #include "internal/KeyVector.h"
26 #include <IMP/Object.h>
27 #include <IMP/Pointer.h>
28 #include <IMP/internal/IDGenerator.h>
29 #include <boost/unordered_map.hpp>
30 #include <boost/unordered_set.hpp>
31 #include <IMP/tuple_macros.h>
32 #include <boost/iterator/transform_iterator.hpp>
33 #include <boost/iterator/filter_iterator.hpp>
34 #include <cereal/access.hpp>
35 #include <cereal/types/polymorphic.hpp>
36 
37 #include <limits>
38 
39 IMPKERNEL_BEGIN_NAMESPACE
40 
41 class ModelObject;
42 class Undecorator;
43 class Particle;
44 
45 #if !defined(SWIG) && !defined(IMP_DOXYGEN)
46 namespace internal {
47 enum Stage {
48  NOT_EVALUATING,
49  BEFORE_EVALUATING,
50  EVALUATING,
51  AFTER_EVALUATING,
52  COMPUTING_DEPENDENCIES
53 };
54 }
55 #endif
56 
57 class Model;
58 
59 #if !defined(SWIG) && !defined(IMP_DOXYGEN)
60 // This is needed as NodeInfo (below) needs to be showable, and Edges are not
61 inline std::ostream &operator<<(
62  std::ostream &out, const std::set<ModelObject *> &) {
63  out << "(set of ModelObject)";
64  return out;
65 }
66 #endif
67 
68 //! Class for storing model, its restraints, constraints, and particles.
69 /** The Model maintains a standard \imp container for each of Particle,
70  ScoreState and Restraint object types.
71 
72  Each Float attribute has an associated range which reflects the
73  range of values that it is expected to take on during optimization.
74  The optimizer can use these ranges to make the optimization process
75  more efficient. By default, the range estimates are simply the
76  range of values for that attribute in the various particles, but
77  it can be set to another value. For example, an attribute storing
78  an angle could have the range set to (0,PI).
79 
80  The ranges are not enforced; they are just guidelines. In order to
81  enforce ranges, see, for example,
82  IMP::example::ExampleSingletonModifier.
83 
84  \headerfile Model.h "IMP/Model.h"
85  */
86 class IMPKERNELEXPORT Model : public Object
87 #if !defined(SWIG) && !defined(IMP_DOXYGEN)
88  ,
89  public internal::Masks,
90  // The attribute tables provide fast access to
91  // e.g. particle attributes, etc.
92  public internal::FloatAttributeTable,
93  public internal::StringAttributeTable,
94  public internal::IntAttributeTable,
95  public internal::ObjectAttributeTable,
96  public internal::WeakObjectAttributeTable,
97  public internal::IntsAttributeTable,
98  public internal::FloatsAttributeTable,
99  public internal::ObjectsAttributeTable,
100  public internal::ParticleAttributeTable,
101  public internal::ParticlesAttributeTable,
102  public internal::SparseStringAttributeTable,
103  public internal::SparseIntAttributeTable,
104  public internal::SparseFloatAttributeTable,
105  public internal::SparseParticleAttributeTable
106 #endif
107  {
108  typedef std::set<ModelObject *> Edges;
109  // must be up top
110  // we don't want any liveness checks
111  IMP_NAMED_TUPLE_5(NodeInfo, NodeInfos, Edges, inputs, Edges, input_outputs,
112  Edges, outputs, Edges, readers, Edges, writers, );
113  typedef boost::unordered_map<const ModelObject *, NodeInfo> DependencyGraph;
114  DependencyGraph dependency_graph_;
115  boost::unordered_set<const ModelObject *> no_dependencies_;
116  boost::unordered_map<const ModelObject *, ScoreStatesTemp>
117  required_score_states_;
118 
119  // basic representation
120  boost::unordered_map<FloatKey, FloatRange> ranges_;
121 
122  ParticleIndexes free_particles_;
125 
126  internal::KeyVector<ModelKey, PointerMember<Object> > model_data_;
127 
128 #if !defined(IMP_DOXYGEN)
129  // Map unique ID to Model*
130  class ModelMap {
131  std::map<uint32_t, Model*> map_;
132  internal::IDGenerator id_gen_;
133  public:
134  ModelMap() {}
135  uint32_t add_new_model(Model *m);
136  void add_model_with_id(Model *m, uint32_t id);
137  void remove_model(Model *m);
138  Model *get(uint32_t id) const;
139  };
140 
141  static ModelMap model_map_;
142  uint32_t unique_id_;
143 #endif
144 
145  void do_add_dependencies(const ModelObject *mo);
146  void do_clear_required_score_states(ModelObject *mo);
147  void do_check_required_score_states(const ModelObject *mo) const;
148  void do_check_update_order(const ScoreState *ss) const;
149  void do_check_inputs_and_outputs(const ModelObject *mo) const;
150  void do_check_readers_and_writers(const ModelObject *mo) const;
151  void do_check_not_in_readers_and_writers(const ModelObject *mo) const;
152  void do_clear_dependencies(const ModelObject *mo);
153 
154  // used to track time when triggers are activated
155  unsigned age_counter_;
156  // all triggers
157  Vector<unsigned> trigger_age_;
158  // time when dependencies were last changed, or 0
159  unsigned dependencies_age_;
160 
161  // allow skipping updating dependencies_age_ for temporary ModelObjects
162  bool dependencies_saved_;
163  unsigned saved_dependencies_age_;
164  // We don't use ModelObjectsTemp here because these objects might get freed
165  // under us, which would cause WeakPointer to raise an exception
166  std::vector<ModelObject *> mos_added_since_save_, mos_removed_since_save_;
167 
168  // cache of restraints that are affected by each moved particle,
169  // used for evaluate_moved() and related functions
170  internal::MovedParticlesRestraintCache moved_particles_restraint_cache_;
171  // cache of particles that are affected by each moved particle
172  internal::MovedParticlesParticleCache moved_particles_particle_cache_;
173  // time when moved_particles_*_cache_ were last updated, or 0
174  unsigned moved_particles_cache_age_;
175 
176  void register_unique_id();
177 
178  friend class cereal::access;
179 
180  template<class Archive> void serialize(Archive &ar,
181  std::uint32_t const version) {
182  ar(cereal::base_class<Object>(this));
183  // We need to get unique_id_ early on read, so that any ModelObjects
184  // that reference it get correctly associated with this model
185  ar(unique_id_);
186  if (std::is_base_of<cereal::detail::InputArchiveBase, Archive>::value) {
187  register_unique_id();
188  }
189  ar(cereal::base_class<internal::FloatAttributeTable>(this),
190  cereal::base_class<internal::StringAttributeTable>(this),
191  cereal::base_class<internal::IntAttributeTable>(this),
192  cereal::base_class<internal::IntsAttributeTable>(this),
193  cereal::base_class<internal::FloatsAttributeTable>(this),
194  cereal::base_class<internal::ParticleAttributeTable>(this),
195  cereal::base_class<internal::ParticlesAttributeTable>(this),
196  cereal::base_class<internal::SparseStringAttributeTable>(this),
197  cereal::base_class<internal::SparseIntAttributeTable>(this),
198  cereal::base_class<internal::SparseFloatAttributeTable>(this),
199  cereal::base_class<internal::SparseParticleAttributeTable>(this));
200 
201  if (std::is_base_of<cereal::detail::InputArchiveBase, Archive>::value) {
202  size_t count;
203  free_particles_.clear();
204  ar(count);
205  particle_index_.clear();
206  while(count-- > 0) {
207  std::string name;
208  ar(name);
209  add_particle(name);
210  }
211  ParticleIndexes to_free;
212  ar(to_free);
213  for (auto pi : to_free) {
214  remove_particle(pi);
215  }
216  } else {
217  size_t count = particle_index_.size();
218  ar(count);
219  for (size_t i = 0; i < count; ++i) {
220  std::string name;
221  if (get_has_particle(ParticleIndex(i))) {
222  name = get_particle_name(ParticleIndex(i));
223  }
224  ar(name);
225  }
226  ar(free_particles_);
227  }
228 
229  // Need particle info before anything that might refer to a particle
230  // (ScoreState, or arbitrary Object)
231  ar(cereal::base_class<internal::ObjectAttributeTable>(this),
232  cereal::base_class<internal::ObjectsAttributeTable>(this),
233  cereal::base_class<internal::WeakObjectAttributeTable>(this),
234  model_data_, mutable_access_score_states());
235 
236  if (std::is_base_of<cereal::detail::InputArchiveBase, Archive>::value) {
237  // clear caches
238  age_counter_ = 1;
239  trigger_age_.clear();
240  dependencies_age_ = 0;
241  saved_dependencies_age_ = 0;
242  dependencies_saved_ = false;
243  moved_particles_cache_age_ = 0;
244  }
245  }
246 
247  // update model age (can never be zero, even if it wraps)
248  void increase_age() {
249  age_counter_++;
250  if (age_counter_ == 0) {
251  age_counter_ = 1;
252  }
253  }
254 
255  template <class MOType, class MOVector>
256  void do_get_dependent(ModelObject *mo, MOVector &ret) {
257  const auto &node = dependency_graph_.find(mo);
259  "Object " << mo->get_name()
260  << " does not have dependencies.");
261  IMP_INTERNAL_CHECK(node != dependency_graph_.end(),
262  "Node not in dependency_graph.");
263  MOType *r = dynamic_cast<MOType *>(mo);
264  if (r) {
265  ret.push_back(r);
266  }
267  for (ModelObject *cur : node->second.get_outputs()) {
268  do_get_dependent<MOType, MOVector>(cur, ret);
269  }
270  for (ModelObject *cur : node->second.get_readers()) {
271  do_get_dependent<MOType, MOVector>(cur, ret);
272  }
273  }
274 
275 #if !defined(IMP_DOXYGEN) && !defined(SWIG)
276  // things the evaluate template functions need, can't be bothered with friends
277  public:
278 #endif
279  // check more things on the first call
280  bool first_call_;
281  // the stage of evaluation
282  internal::Stage cur_stage_;
283 
284  //! Get all Restraints that depend on the given particle
285  const std::set<Restraint *> &get_dependent_restraints(ParticleIndex pi) {
286  return moved_particles_restraint_cache_.get_dependent_restraints(pi);
287  }
288 
289  //! Get all particles that depend on the given particle
290  const ParticleIndexes &get_dependent_particles(ParticleIndex pi) {
291  return moved_particles_particle_cache_.get_dependent_particles(pi);
292  }
293 
294  ModelObjectsTemp get_dependency_graph_inputs(const ModelObject *mo) const;
295  ModelObjectsTemp get_dependency_graph_outputs(const ModelObject *mo) const;
296  bool do_get_has_dependencies(const ModelObject *mo) const {
297  return no_dependencies_.find(mo) == no_dependencies_.end();
298  }
299  void do_set_has_dependencies(const ModelObject *mo, bool tf);
300  void do_set_has_all_dependencies(bool tf);
301 
302  void validate_computed_derivatives() const {}
303  void set_has_all_dependencies(bool tf);
304  bool get_has_all_dependencies() const;
305  void check_dependency_invariants() const;
306  void check_dependency_invariants(const ModelObject *mo) const;
307  ScoreStatesTemp get_ancestor_score_states(const ModelObject *mo) const;
308  ScoreStatesTemp get_descendent_score_states(const ModelObject *mo) const;
309 
310  void before_evaluate(const ScoreStatesTemp &states);
311  void after_evaluate(const ScoreStatesTemp &states, bool calc_derivs);
312 
313  internal::Stage get_stage() const { return cur_stage_; }
314  ParticleIndex add_particle_internal(Particle *p);
315  static void do_remove_score_state(ScoreState *obj);
316  void do_add_score_state(ScoreState *obj);
317  void do_remove_particle(ParticleIndex pi);
318  bool do_get_has_required_score_states(const ModelObject *mo) const;
319  void do_set_has_required_score_states(ModelObject *mo, bool tf);
320  const ScoreStatesTemp &do_get_required_score_states(const ModelObject *mo)
321  const {
322  IMP_USAGE_CHECK(do_get_has_required_score_states(mo),
323  "Doesn't have score states");
324  return required_score_states_.find(mo)->second;
325  }
326  void do_add_model_object(ModelObject *mo);
327  void do_remove_model_object(ModelObject *mo);
328 
329  public:
330  //! Construct an empty model
331  Model(std::string name = "Model %1%");
332 
333  public:
334 #if !defined(SWIG) && !defined(IMP_DOXYGEN)
335  IMP_MODEL_IMPORT(internal::FloatAttributeTable);
336  IMP_MODEL_IMPORT(internal::StringAttributeTable);
337  IMP_MODEL_IMPORT(internal::IntAttributeTable);
338  IMP_MODEL_IMPORT(internal::ObjectAttributeTable);
339  IMP_MODEL_IMPORT(internal::WeakObjectAttributeTable);
340  IMP_MODEL_IMPORT(internal::IntsAttributeTable);
341  IMP_MODEL_IMPORT(internal::FloatsAttributeTable);
342  IMP_MODEL_IMPORT(internal::ObjectsAttributeTable);
343  IMP_MODEL_IMPORT(internal::ParticleAttributeTable);
344  IMP_MODEL_IMPORT(internal::ParticlesAttributeTable);
345  IMP_MODEL_SPARSE_IMPORT(internal::SparseStringAttributeTable);
346  IMP_MODEL_SPARSE_IMPORT(internal::SparseIntAttributeTable);
347  IMP_MODEL_SPARSE_IMPORT(internal::SparseFloatAttributeTable);
348  IMP_MODEL_SPARSE_IMPORT(internal::SparseParticleAttributeTable);
349 #endif
350  //! Clear all the cache attributes of a given particle.
351  void clear_particle_caches(ParticleIndex pi);
352 
353  //! Add particle to the model
354  ParticleIndex add_particle(std::string name);
355 
356  //! Get the name of a particle
357  std::string get_particle_name(ParticleIndex pi);
358 
359  //! Add the passed Undecorator to the particle.
360  void add_undecorator(ParticleIndex pi, Undecorator *d);
361 
362 #if !defined(IMP_DOXYGEN)
363  RestraintsTemp get_dependent_restraints_uncached(ParticleIndex pi);
364 
365  ParticlesTemp get_dependent_particles_uncached(ParticleIndex pi);
366 
367  ScoreStatesTemp get_dependent_score_states_uncached(ParticleIndex pi);
368 #endif
369 
370  /** @name States
371 
372  ScoreStates maintain invariants in the Model (see ScoreState
373  for more information.)
374 
375  ScoreStates do not need to be explicitly added to the Model, but they
376  can be if desired in order to keep them alive as long as the model is
377  alive.
378 
379  \advancedmethod
380  */
381  /**@{*/
382  IMP_LIST_ACTION(public, ScoreState, ScoreStates, score_state, score_states,
383  ScoreState *, ScoreStates, do_add_score_state(obj), {},
384  do_remove_score_state(obj));
385  /**@}*/
386 
387  public:
388 #ifndef SWIG
389  using Object::clear_caches;
390 #endif
391 
392  //! Sometimes it is useful to be able to make sure the model is up to date
393  /** This method updates all the state but does not necessarily compute the
394  score. Use this to make sure that your containers and rigid bodies are
395  up to date.
396  */
397  void update();
398 
399 #ifdef IMP_DOXYGEN
400  /** \name Accessing attributes
401  \anchor model_attributes
402  All the attribute data associated with each Particle are stored in the
403  Model. For each type of attribute, there are the methods detailed below
404  (where, eg, TypeKey is FloatKey or StringKey)
405  @{
406  */
407  //! add particle attribute with the specified key and initial value
408  /** \pre get_has_attribute(attribute_key, particle) is false*/
409  void add_attribute(TypeKey attribute_key, ParticleIndex particle, Type value);
410 
411  //! remove particle attribute with the specified key
412  /** \pre get_has_attribute(attribute_key, particle) is true*/
413  void remove_attribute(TypeKey attribute_key, ParticleIndex particle);
414 
415  //! return true if particle has attribute with the specified key
416  bool get_has_attribute(TypeKey attribute_key, ParticleIndex particle) const;
417 
418  //! set the value of particle attribute with the specified key
419  /** \pre get_has_attribute(attribute_key, particle) is true*/
420  void set_attribute(TypeKey attribute_key, ParticleIndex particle, Type value);
421 
422  //! get the value of the particle attribute with the specified key
423  /** \pre get_has_attribute(attribute_key, particle) is true*/
424  Type get_attribute(TypeKey attribute_key, ParticleIndex particle);
425 
426  /** Cache attributes, unlike normal attributes, can be added during
427  evaluation. They are also cleared by the clear_cache_attributes() method.
428  Cache attributes should be used when one is adding data to a particle
429  to aid scoring (eg cache the rigid body collision acceleration structure).
430 
431  When some pertinent aspect of the particle changes, the clear method
432  should
433  be called (yes, this is a bit vague). Examples where it should be cleared
434  include changing the set of members of a core::RigidBody or their
435  coordinates, changing the members of an atom::Hierarchy.
436  */
437  void add_cache_attribute(TypeKey attribute_key, ParticleIndex particle,
438  Type value);
439 
440  //! Optimized attributes are the parameters of the model that are
441  //! allowed to be modified by samplers and optimizers
442  void set_is_optimized(TypeKey attribute_key, ParticleIndex particle,
443  bool true_or_false);
444 /** @} */
445 #endif
446 
447 #ifdef SWIG
448 #define IMP_MODEL_ATTRIBUTE_METHODS(Type, Value) \
449  void add_attribute(Type##Key attribute_key, ParticleIndex particle, \
450  Value value); \
451  void remove_attribute(Type##Key attribute_key, ParticleIndex particle); \
452  bool get_has_attribute(Type##Key attribute_key, \
453  ParticleIndex particle) const; \
454  void set_attribute(Type##Key attribute_key, ParticleIndex particle, \
455  Value value); \
456  Value get_attribute(Type##Key attribute_key, ParticleIndex particle); \
457  void add_cache_attribute(Type##Key attribute_key, ParticleIndex particle, \
458  Value value)
459 
460 #define IMP_MODEL_SPARSE_ATTRIBUTE_METHODS(Type, Value) \
461  void add_attribute(Type##Key attribute_key, ParticleIndex particle, \
462  Value value); \
463  void remove_attribute(Type##Key attribute_key, ParticleIndex particle); \
464  bool get_has_attribute(Type##Key attribute_key, \
465  ParticleIndex particle) const; \
466  void set_attribute(Type##Key attribute_key, ParticleIndex particle, \
467  Value value); \
468  Value get_attribute(Type##Key attribute_key, ParticleIndex particle)
469 
470  IMP_MODEL_ATTRIBUTE_METHODS(Float, Float);
471  IMP_MODEL_ATTRIBUTE_METHODS(Int, Int);
472  IMP_MODEL_ATTRIBUTE_METHODS(Floats, Floats);
473  IMP_MODEL_ATTRIBUTE_METHODS(Ints, Ints);
474  IMP_MODEL_ATTRIBUTE_METHODS(String, String);
475  IMP_MODEL_ATTRIBUTE_METHODS(ParticleIndexes, ParticleIndexes);
476  IMP_MODEL_ATTRIBUTE_METHODS(ParticleIndex, ParticleIndex);
477  IMP_MODEL_ATTRIBUTE_METHODS(Object, Object *);
478  IMP_MODEL_ATTRIBUTE_METHODS(WeakObject, Object *);
479  IMP_MODEL_SPARSE_ATTRIBUTE_METHODS(SparseString, String);
480  IMP_MODEL_SPARSE_ATTRIBUTE_METHODS(SparseInt, Int);
481  IMP_MODEL_SPARSE_ATTRIBUTE_METHODS(SparseFloat, Float);
482  IMP_MODEL_SPARSE_ATTRIBUTE_METHODS(SparseParticleIndex, ParticleIndex);
483  void set_is_optimized(FloatKey, ParticleIndex, bool);
484  void add_to_derivative(FloatKey k, ParticleIndex particle, double v,
485  const DerivativeAccumulator &da);
486 #endif
487 
488  //! Get the particle from an index.
490  IMP_USAGE_CHECK(get_has_particle(p), "Invalid particle requested");
491  return particle_index_[p];
492  }
493 
494  //! Check whether a given particle index exists.
496  if (particle_index_.size() <= get_as_unsigned_int(p)) return false;
497  return particle_index_[p];
498  }
499 
500  //! Get all particle indexes
502 
503  //! Get all the ModelObjects associated with this Model.
504  ModelObjectsTemp get_model_objects() const;
505 
506  //! Remove a particle from the Model.
507  /** The particle will then be inactive and cannot be used for anything
508  and all data stored in the particle is lost.
509  */
510  void remove_particle(ParticleIndex pi);
511 
512  /** \name Storing data in the model
513 
514  One can store data associated with the model. This is used, for example,
515  to keep a central ScoreState to normalize rigid body rotational variables.
516  @{ */
517  //! Store a piece of data in the model referenced by the key.
518  void add_data(ModelKey mk, Object *o);
519  //! Get back some data stored in the model.
520  Object *get_data(ModelKey mk) const;
521  //! Remove data stored in the model.
522  void remove_data(ModelKey mk);
523  //! Check if the model has a certain piece of data attached.
524  bool get_has_data(ModelKey mk) const;
525  /** @} */
526 
527  /** \name Model triggers
528 
529  Triggers can be used to track when to clear and rebuild caches
530  of derived model properties. For example, a Restraint may restrain
531  two particles as a function of the number of chemical bonds between
532  them. To speed up this restraint, the bond graph can be cached; however,
533  this graph needs to be rebuilt if bonds are created or removed. This
534  can be achieved by checking that the model time (see get_age()) of the
535  cache matches the time when the 'bond added/removed' Trigger was last
536  updated (see get_trigger_last_updated()), either when the Restraint is
537  evaluated or in an associated ScoreState.
538 
539  Triggers are intended for events that are rare during a typical
540  optimization. Triggers can be created by any IMP module in either C++
541  or Python by creating a new TriggerKey, much as model attributes
542  are handled. To avoid name collisions, it is recommended to prepend
543  the module and/or class name to the trigger, e.g. "atom.Bond.changed".
544 
545  For an example, see IMP::score_functor::OrientedSoap, which uses
546  a cache built from the molecular hierarchy, which is cleared when the
547  IMP::core::Hierarchy::get_changed_key() trigger is updated.
548 
549  @{ */
550 
551  //! Get the current 'model time'.
552  /** This is a number 1 or more that tracks the 'age' of the model;
553  it is incremented every time before_evaluate() is called.
554  It may wrap (and so should not be assumed to always increase)
555  but will never be 0. */
556  unsigned get_age() { return age_counter_; }
557 
558  //! Get the time when the given trigger was last updated, or 0.
559  /** Return the 'model time' (as given by get_age()) when the given
560  trigger was last updated on this model, or 0 if never. */
562  if (trigger_age_.size() > tk.get_index()) {
563  return trigger_age_[tk.get_index()];
564  } else {
565  return 0;
566  }
567  }
568 
569  //! Update the given trigger
571  if (tk.get_index() >= trigger_age_.size()) {
572  trigger_age_.resize(tk.get_index() + 1, 0);
573  }
574  trigger_age_[tk.get_index()] = age_counter_;
575  }
576  /** @} */
577 
578  //! Get the model age when ModelObject dependencies were last changed, or 0.
579  /** This gives the Model age (see get_age()) when Particles, Restraints,
580  or ScoreStates were last added or removed. It is typically used to
581  help maintain caches that depend on the model's dependency graph. */
582  unsigned get_dependencies_updated() { return dependencies_age_; }
583 
584  //! Mark a 'restore point' for ModelObject dependencies.
585  /** \see restore_dependencies() */
587  dependencies_saved_ = true;
588  saved_dependencies_age_ = dependencies_age_;
590  mos_added_since_save_.clear();
591  mos_removed_since_save_.clear();
592  }
593  }
594 
595  //! Restore ModelObject dependencies to previous restore point.
596  /** This method, when paired with save_dependencies(), can be used to
597  avoid triggering a model dependency update due to a temporary change
598  in the model dependency graph, for example due to adding a temporary
599  restraint, evaluating it, then removing that same restraint. It should
600  only be called in cases where it is known that the dependency graph
601  is the same as when save_dependencies() was called (this is only checked
602  in debug mode). Save/restore call pairs cannot be nested, although it
603  is OK to skip the call to restore_dependencies(), e.g. if an exception
604  occurs.
605 
606  \see get_dependencies_updated()
607  \see save_dependencies()
608  */
610  if (dependencies_saved_) {
611  dependencies_saved_ = false;
612  dependencies_age_ = saved_dependencies_age_;
614  // Need to sort pointers since we may not add/remove in the same order
615  std::sort(mos_added_since_save_.begin(), mos_added_since_save_.end());
616  std::sort(mos_removed_since_save_.begin(),
617  mos_removed_since_save_.end());
618  IMP_INTERNAL_CHECK(mos_added_since_save_ == mos_removed_since_save_,
619  "ModelObjects added do not match those removed");
620  }
621  }
622  }
623 
624  //! Get an upper bound on the number of particles in the Model.
625  /** This value is guaranteed to be at least the number of particles in
626  the model (there may be fewer particles if any have been removed)
627  and every ParticleIndex will be smaller than this value. */
628  unsigned get_particles_size() const { return particle_index_.size(); }
629 
630  //! Get the unique ID of this Model.
631  /** When multiple Models exist simultaneously, each has a different unique ID.
632  */
633  uint32_t get_unique_id() const {
634  return unique_id_;
635  }
636 
637  //! Return the Model with the given unique ID.
638  /** If no Model with this ID exists, nullptr is returned. */
639  static Model* get_by_unique_id(uint32_t id) {
640  return model_map_.get(id);
641  }
642 
644 
645  public:
646 #if !defined(IMP_DOXYGEN)
647  virtual void do_destroy() override;
648 #endif
649 };
650 
651 IMPKERNEL_END_NAMESPACE
652 
653 CEREAL_SPECIALIZE_FOR_ALL_ARCHIVES(
654  IMP::Model, cereal::specialization::member_serialize);
655 
656 CEREAL_CLASS_VERSION(IMP::Model, 1);
657 
658 // This is needed for per cpp compilations, a not even sure why
659 // (perhaps cause Model returns ParticleIterator here and there?)
660 // - Feel free to remove if you *really* know what you're doing
661 #include "IMP/Particle.h"
662 
663 #endif /* IMPKERNEL_MODEL_H */
Particle * get_particle(ParticleIndex p) const
Get the particle from an index.
Definition: Model.h:489
Basic types used by IMP.
#define IMP_IF_CHECK(level)
Execute the code block if a certain level checks are on.
Definition: check_macros.h:104
Used to hold a set of related restraints.
boost::graph DependencyGraph
Directed graph on the interactions between the various objects in the model.
The base class for undecorators.
#define IMP_OBJECT_METHODS(Name)
Define the basic things needed by any Object.
Definition: object_macros.h:25
void restore_dependencies()
Restore ModelObject dependencies to previous restore point.
Definition: Model.h:609
Index< ParticleIndexTag > ParticleIndex
Definition: base_types.h:178
void add_particle(RMF::FileHandle fh, Particle *hs)
Macros to help in defining tuple classes.
virtual void clear_caches()
Definition: Object.h:270
unsigned get_dependencies_updated()
Get the model age when ModelObject dependencies were last changed, or 0.
Definition: Model.h:582
A more IMP-like version of the std::vector.
Definition: Vector.h:50
unsigned get_particles_size() const
Get an upper bound on the number of particles in the Model.
Definition: Model.h:628
unsigned get_age()
Get the current 'model time'.
Definition: Model.h:556
bool get_has_particle(ParticleIndex p) const
Check whether a given particle index exists.
Definition: Model.h:495
Macros to define containers of objects.
unsigned get_trigger_last_updated(TriggerKey tk)
Get the time when the given trigger was last updated, or 0.
Definition: Model.h:561
#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
Class for storing model, its restraints, constraints, and particles.
Definition: Model.h:86
Base class for objects in a Model that depend on other objects.
Definition: ModelObject.h:28
virtual void do_destroy()
Definition: Object.h:274
Common base class for heavy weight IMP objects.
Definition: Object.h:111
ParticleIndexes get_particle_indexes(ParticlesTemp const &particles)
ScoreStates maintain invariants in the Model.
Definition: ScoreState.h:56
static Model * get_by_unique_id(uint32_t id)
Return the Model with the given unique ID.
Definition: Model.h:639
uint32_t get_unique_id() const
Get the unique ID of this Model.
Definition: Model.h:633
Implements a vector tied to a particular index of type Index<Tag>.
Definition: Index.h:90
Shared score state.
Base class for objects in a Model that depend on other objects.
Classes to handle individual model particles. (Note that implementation of inline functions is in int...
A nullptr-initialized pointer to an IMP Object.
void save_dependencies()
Mark a 'restore point' for ModelObject dependencies.
Definition: Model.h:586
A shared base class to help in debugging and things.
Represents a scoring function on the model.
double Float
Basic floating-point value (could be float, double...)
Definition: types.h:19
Class to handle individual particles of a Model object.
Definition: Particle.h:43
bool get_has_dependencies() const
Return whether this object has dependencies computed.
#define IMP_USAGE_CHECK(expr, message)
A runtime test for incorrect usage of a class or method.
Definition: check_macros.h:168
Abstract base class for all restraints.
int Int
Basic integer value.
Definition: types.h:34
void set_trigger_updated(TriggerKey tk)
Update the given trigger.
Definition: Model.h:570
std::string String
Basic string value.
Definition: types.h:43
Class for adding derivatives from restraints to the model.