IMP logo
IMP Reference Guide  2.20.0
The Integrative Modeling Platform
SingletonScore.h
Go to the documentation of this file.
1 // Autogenerated by ../../../../tmp/nightly-build-18515/imp-2.20.0/tools/build/make_containers.py
2 // from ../../../../tmp/nightly-build-18515/imp-2.20.0/tools/build/container_templates/kernel/ClassnameScore.h
3 // Do not edit - any changes will be lost!
4 
5 /**
6  * \file IMP/SingletonScore.h
7  * \brief Define SingletonScore.
8  *
9  * Copyright 2007-2022 IMP Inventors. All rights reserved.
10  */
11 
12 #ifndef IMPKERNEL_SINGLETON_SCORE_H
13 #define IMPKERNEL_SINGLETON_SCORE_H
14 
15 #include <IMP/kernel_config.h>
16 #include "base_types.h"
17 #include "DerivativeAccumulator.h"
18 #include "internal/container_helpers.h"
19 #include <IMP/utility_macros.h>
20 #include <cereal/access.hpp>
21 #include <cereal/types/base_class.hpp>
22 #include "model_object_helpers.h"
23 
24 IMPKERNEL_BEGIN_NAMESPACE
25 
26 //! Abstract class for scoring object(s) of type ParticleIndex.
27 /** SingletonScore will evaluate the score and derivatives
28  for passed object(s) of type ParticleIndex.
29 
30  Use in conjunction with various
31  restraints such as IMP::container::SingletonsRestraint or
32  IMP::core::SingletonRestraint. The restraints couple the score
33  functions with appropriate lists of object(s) of type ParticleIndex.
34 
35  It is possible to call the various evaluate* methods directly, but
36  this is not recommended as they do not ensure that Model invariants
37  (e.g. ScoreStates) are preserved. Use a Restraint or ScoringFunction
38  to score the model instead.
39 
40  Implementers should check out IMP_SINGLETON_SCORE().
41 
42  \see PredicateSingletonRestraint
43 */
44 class IMPKERNELEXPORT SingletonScore : public ParticleInputs,
45  public Object {
46  public:
47  typedef Particle* Argument;
49  typedef Particle* PassArgument;
52  SingletonScore(std::string name = "SingletonScore %1%");
53 
54  //! Compute the score and the derivative if needed.
55  /** @param m the model of vt
56  @param vt the index in m of an object of type Particle
57  @param da a DerivativeAccumulator that weights
58  computed derivatives. If nullptr, derivatives
59  will not be computed.
60  */
61  virtual double evaluate_index(Model *m, ParticleIndex vt,
62  DerivativeAccumulator *da) const = 0;
63 
64  //! Compute the score and the derivative if needed over a set.
65  /** @param m the model of o
66  @param o objects of type Particle, specified by index
67  @param da a derivative accumulator that weights
68  computed derivatives. If nullptr, derivatives
69  will not be computed.
70  @param lower_bound index of first item in o to evaluate
71  @param upper_bound index one past last item in o to evaluate
72 
73  @note Implementations for these are provided by
74  the IMP_SINGLETON_SCORE() macro.
75  */
76  virtual double evaluate_indexes(Model *m, const ParticleIndexes &o,
78  unsigned int lower_bound,
79  unsigned int upper_bound) const;
80 
81  //! Compute the score and the derivative if needed over a set.
82  /** Like regular evaluate_indexes(), but the score for each o[x] is also
83  returned as score[x]. */
84  virtual double evaluate_indexes_scores(
85  Model *m, const ParticleIndexes &o,
87  unsigned int lower_bound,
88  unsigned int upper_bound,
89  std::vector<double> &score) const;
90 
91  //! Compute the change in score and the derivative if needed over a set.
92  /** The score for each o[indexes[x]] is updated in score[indexes[x]]
93  and the total difference between the old and new score values (over the
94  set) is returned. */
95  virtual double evaluate_indexes_delta(
96  Model *m, const ParticleIndexes &o,
98  const std::vector<unsigned> &indexes,
99  std::vector<double> &score) const;
100 
101  //! Compute the score and the derivative if needed, only if "good".
102  /** This functions similarly to evaluate_index(),
103  but may terminate the computation early if the score is higher than max.
104 
105  @return the score if score<= max or some arbitrary value > max otherwise.
106  */
107  virtual double evaluate_if_good_index(Model *m, ParticleIndex vt,
109  double max) const;
110 
111  /** Compute the score and the derivative if needed over a set, only if "good".
112  This functions similarly to evaluate_indexes(), but may terminate
113  the computation early if the total score is higher than max.
114 
115  @return the score if score<= max or some arbitrary value > max otherwise.
116 
117  @note Implementations for these are provided by the IMP_SINGLETON_SCORE()
118  macro.
119  */
120  virtual double evaluate_if_good_indexes(Model *m,
121  const ParticleIndexes &o,
122  DerivativeAccumulator *da, double max,
123  unsigned int lower_bound,
124  unsigned int upper_bound) const;
125 
126  //! Decompose this SingletonScore into a set of
127  //! currently positive restraints over vt.
128  /** The scoring function and derivatives should
129  be equal to the current score. The default implementation
130  returns a single restraint with this score bound to vt,
131  or zero restraints if the score equals zero.
132  */
133  Restraints create_current_decomposition(Model *m,
134  ParticleIndex vt) const;
135 
136  protected:
137  //! Override this to return your own decomposition.
138  virtual Restraints do_create_current_decomposition(Model *m,
139  ParticleIndex vt) const;
140 
142 
143  private:
144  friend class cereal::access;
145 
146  template<class Archive> void serialize(Archive &ar) {
147  // Neither we nor ParticleInputs stores data, but Object does
148  ar(cereal::base_class<Object>(this));
149  }
150 };
151 
152 IMPKERNEL_END_NAMESPACE
153 
154 #endif /* IMPKERNEL_SINGLETON_SCORE_H */
A base class for modifiers of ParticlesTemp.
Basic types used by IMP.
Class for adding derivatives from restraints to the model.
Base class for objects that take particle arguments and read from them.
#define IMP_REF_COUNTED_DESTRUCTOR(Name)
Set up destructor for a ref counted object.
Class for storing model, its restraints, constraints, and particles.
Definition: Model.h:86
Common base class for heavy weight IMP objects.
Definition: Object.h:111
Abstract class for scoring object(s) of type ParticleIndex.
Classes used in the construction of ModelObjects.
Various general useful macros for IMP.
Class to handle individual particles of a Model object.
Definition: Particle.h:43
Class for adding derivatives from restraints to the model.