IMP logo
IMP Reference Guide  2.20.1
The Integrative Modeling Platform
QuadScore.h
Go to the documentation of this file.
1 // Autogenerated by ../../../../tmp/nightly-build-8871/imp-2.20.1/tools/build/make_containers.py
2 // from ../../../../tmp/nightly-build-8871/imp-2.20.1/tools/build/container_templates/kernel/ClassnameScore.h
3 // Do not edit - any changes will be lost!
4 
5 /**
6  * \file IMP/QuadScore.h
7  * \brief Define QuadScore.
8  *
9  * Copyright 2007-2022 IMP Inventors. All rights reserved.
10  */
11 
12 #ifndef IMPKERNEL_QUAD_SCORE_H
13 #define IMPKERNEL_QUAD_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 ParticleIndexQuad.
27 /** QuadScore will evaluate the score and derivatives
28  for passed object(s) of type ParticleIndexQuad.
29 
30  Use in conjunction with various
31  restraints such as IMP::container::QuadsRestraint or
32  IMP::core::QuadRestraint. The restraints couple the score
33  functions with appropriate lists of object(s) of type ParticleIndexQuad.
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_QUAD_SCORE().
41 
42  \see PredicateQuadRestraint
43 */
44 class IMPKERNELEXPORT QuadScore : public ParticleInputs,
45  public Object {
46  public:
47  typedef ParticleQuad Argument;
49  typedef const ParticleQuad& PassArgument;
50  typedef const ParticleIndexQuad& PassIndexArgument;
51  typedef QuadModifier Modifier;
52  QuadScore(std::string name = "QuadScore %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 ParticleQuad
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, const ParticleIndexQuad& 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 ParticleQuad, 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_QUAD_SCORE() macro.
75  */
76  virtual double evaluate_indexes(Model *m, const ParticleIndexQuads &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 ParticleIndexQuads &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 ParticleIndexQuads &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, const ParticleIndexQuad& 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_QUAD_SCORE()
118  macro.
119  */
120  virtual double evaluate_if_good_indexes(Model *m,
121  const ParticleIndexQuads &o,
122  DerivativeAccumulator *da, double max,
123  unsigned int lower_bound,
124  unsigned int upper_bound) const;
125 
126  //! Decompose this QuadScore 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  const ParticleIndexQuad& vt) const;
135 
136  protected:
137  //! Override this to return your own decomposition.
138  virtual Restraints do_create_current_decomposition(Model *m,
139  const ParticleIndexQuad& 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_QUAD_SCORE_H */
Basic types used by IMP.
A class to store a fixed array of same-typed values.
Definition: Array.h:35
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
Abstract class for scoring object(s) of type ParticleIndexQuad.
Definition: QuadScore.h:44
Common base class for heavy weight IMP objects.
Definition: Object.h:111
Classes used in the construction of ModelObjects.
Various general useful macros for IMP.
A base class for modifiers of ParticleQuadsTemp.
Definition: QuadModifier.h:32
Class for adding derivatives from restraints to the model.