IMP  2.1.0
The Integrative Modeling Platform
kernel/ScoreAccumulator.h
Go to the documentation of this file.
1 /**
2  * \file IMP/kernel/ScoreAccumulator.h \brief Class for adding scores from
3  * restraints to the model.
4  *
5  * Copyright 2007-2013 IMP Inventors. All rights reserved.
6  *
7  */
8 
9 #ifndef IMPKERNEL_SCORE_ACCUMULATOR_H
10 #define IMPKERNEL_SCORE_ACCUMULATOR_H
11 
12 #include <IMP/kernel/kernel_config.h>
13 #include "DerivativeAccumulator.h"
14 #include "constants.h"
16 #include <IMP/base/value_macros.h>
17 #include <IMP/base/thread_macros.h>
18 #include <IMP/base/log_macros.h>
19 #include <IMP/base/tuple_macros.h>
20 #include <IMP/base/math.h>
21 #include <IMP/base/nullptr.h>
22 #include <IMP/base/exception.h>
23 
24 IMPKERNEL_BEGIN_NAMESPACE
25 
26 class Restraint;
27 
28 /** A class for storing evaluation state.*/
30  double score;
31  bool good;
32  EvaluationState(double oscore, bool ogood) : score(oscore), good(ogood) {}
33  EvaluationState() : score(BAD_SCORE), good(false) {}
34  IMP_SHOWABLE_INLINE(EvaluationState, out << score << " " << good;);
35 };
37 
38 //! Class for adding up scores during ScoringFunction evaluation.
39 /** This provides a place to accumulate scores from Restraint
40  evaluation. A new ScoreAccumulator is created for each Restraint
41  evaluation context (eg each Restraint::add_score_and_derivatives() call).
42  As a result, the ScoreAccumulator can automatically handle
43  restraint and derivative weights, keeping track of maximum scores
44  and other needed bookkeeping.
45 */
46 class IMPKERNELEXPORT ScoreAccumulator : public base::Value {
47  EvaluationState *score_;
48  DerivativeAccumulator weight_;
49  double global_max_;
50  double local_max_;
51  bool deriv_;
52  bool abort_on_bad_;
53  friend class ScoringFunction;
54  friend class Restraint;
55  ScoreAccumulator(EvaluationState *s, double weight, bool deriv,
56  double global_max, double local_max, bool abort_on_bad)
57  : score_(s),
58  weight_(weight),
59  global_max_(global_max),
60  local_max_(local_max),
61  deriv_(deriv),
62  abort_on_bad_(abort_on_bad) {}
63 
64  public:
65  IMP_CXX11_DEFAULT_COPY_CONSTRUCTOR(ScoreAccumulator);
66  /** For swig, makes invalid (not null) state.*/
67  ScoreAccumulator() : score_(nullptr) {}
68  /** Compose outer accumulator with one for this restraint. */
70 
71  /** Compose outer accumulator with one for this restraint. */
72  ScoreAccumulator(ScoreAccumulator o, double weight, double local_max) {
73  operator=(o);
74  weight_ = DerivativeAccumulator(o.weight_, weight);
75  local_max_ = std::min(local_max, o.local_max_);
76  }
77 
78  /** Add to the total score. It will be weighted appropriately
79  internally. */
80  void add_score(double score) {
81  double wscore = weight_.get_weight() * score;
82  IMP_OMP_PRAGMA(atomic)
83  score_->score += wscore;
84  if (score > local_max_) {
85  IMP_OMP_PRAGMA(critical(imp_abort))
86  score_->good = false;
87  }
88  IMP_LOG_VERBOSE("Score is now " << score_->score << std::endl);
89  }
90 
91  //! Return if the score already exceeds the maximum
92  /** Expensive restraints can check this during evaluation to determin
93  if another restraint has aborted evaluation.
94  */
95  bool get_abort_evaluation() const {
96  if (global_max_ == NO_MAX && !abort_on_bad_) return false;
97  if (abort_on_bad_) {
98  bool good;
99  IMP_OMP_PRAGMA(critical(imp_abort))
100  good = score_->good;
101  return !good;
102  } else {
103  // be lazy for now
104  //#pragma omp flush (score_->score)
105  double score = score_->score;
106  return score > global_max_;
107  }
108  }
109 
110  /** Return true if the current evaluation being done is one where
111  scores are only consider if they are below some threshold
112  (get_maximum()). */
113  bool get_is_evaluate_if_below() const { return global_max_ != NO_MAX; }
114  /** Return true if the current evaluation should abort if any restraint
115  is above its maximum allowed good score. Restraints that take
116  advantage of this in evaluation should simply consult
117  get_maximum() as that will take into account both their maximum
118  and that on any RestraintSets that contain them and are being
119  evaluated.
120  */
121  bool get_is_evaluate_if_good() const { return abort_on_bad_; }
122  /** The maximum allowed score for the
123  Restraint::do_add_score_and_derivatives() call. */
124  double get_maximum() const { return std::min(global_max_, local_max_); }
125 
126  DerivativeAccumulator *get_derivative_accumulator() {
127  if (deriv_) {
128  return &weight_;
129  } else {
130  return nullptr;
131  }
132  }
133 
134  IMP_SHOWABLE_INLINE(ScoreAccumulator, out << *score_);
135 };
136 
138 
139 IMPKERNEL_END_NAMESPACE
140 
141 #endif /* IMPKERNEL_SCORE_ACCUMULATOR_H */
Class for adding derivatives from restraints to the model.
const double NO_MAX
Use this value when you want to turn off maximum for restraint evaluation.
Declare an efficient stl-compatible map.
Class for adding derivatives from restraints to the model.
IMP::kernel::DerivativeAccumulator DerivativeAccumulator
IMP::kernel::EvaluationState EvaluationState
#define IMP_VALUES(Name, PluralName)
Define the type for storing sets of values.
#define IMP_SHOWABLE_INLINE(Name, how_to_show)
Declare the methods needed by an object that can be printed.
Provide a nullptr keyword analog.
const double BAD_SCORE
Various general useful macros for IMP.
IMP::kernel::ScoreAccumulator ScoreAccumulator
Logging and error reporting support.
Class for adding up scores during ScoringFunction evaluation.
A restraint is a term in an IMP ScoringFunction.
#define IMP_OMP_PRAGMA(x)
Exception definitions and assertions.
bool get_abort_evaluation() const
Return if the score already exceeds the maximum.
ScoreAccumulator(ScoreAccumulator o, double weight, double local_max)
Various general useful macros for IMP.
Various general useful macros for IMP.
IMP::kernel::Restraint Restraint
Control for OpenMP.
Various useful constants.
const std::nullptr_t nullptr
Definition: base/nullptr.h:27
#define IMP_LOG_VERBOSE(expr)