IMP  2.1.0
The Integrative Modeling Platform
kernel/SingletonScore.h
Go to the documentation of this file.
1 /**
2  * \file IMP/kernel/SingletonScore.h
3  * \brief Define SingletonScore.
4  *
5  * WARNING This file was generated from SingletonScore.h
6  * in /tmp/nightly-build-90783/imp-2.1.0/tools/build/container_templates/kernel
7  * by tools/maintenance/setup_containers.py.
8  *
9  * Copyright 2007-2013 IMP Inventors. All rights reserved.
10  */
11 
12 #ifndef IMPKERNEL_SINGLETON_SCORE_H
13 #define IMPKERNEL_SINGLETON_SCORE_H
14 
15 #include <IMP/kernel/kernel_config.h>
16 #include "base_types.h"
17 #include "ParticleTuple.h"
18 #include "DerivativeAccumulator.h"
19 #include "internal/container_helpers.h"
20 #include <IMP/base/utility_macros.h>
21 #include "model_object_helpers.h"
22 
23 IMPKERNEL_BEGIN_NAMESPACE
24 
25 //! Abstract score function
26 /** SingletonScores will evaluate the score and derivatives
27  for the passed particles. Use in conjunction with various
28  restraints such as IMP::core::SingletonsRestraint or
29  IMP::core::SingletonRestraint.
30 
31  Implementers should check out IMP_SINGLETON_SCORE().
32 */
33 class IMPKERNELEXPORT SingletonScore : public ParticleInputs,
34  public base::Object {
35  public:
36  typedef Particle* Argument;
37  typedef ParticleIndex IndexArgument;
38  typedef Particle* PassArgument;
39  typedef ParticleIndex PassIndexArgument;
40  typedef SingletonModifier Modifier;
41  SingletonScore(std::string name = "SingletonScore %1%");
42  //! Compute the score and the derivative if needed.
43  /** \deprecated_at{2.1} Use the index-based evaluate instead. */
44  IMPKERNEL_DEPRECATED_METHOD_DECL(2.1)
45  virtual double evaluate(Particle* vt,
46  DerivativeAccumulator *da) const;
47 
48  //! Compute the score and the derivative if needed.
49  virtual double evaluate_index(kernel::Model *m, ParticleIndex vt,
50  DerivativeAccumulator *da) const;
51 
52  /** Implementations
53  for these are provided by the IMP_SINGLETON_SCORE()
54  macro.
55  */
56  virtual double evaluate_indexes(kernel::Model *m, const ParticleIndexes &o,
57  DerivativeAccumulator *da,
58  unsigned int lower_bound,
59  unsigned int upper_bound) const;
60 
61  //! Compute the score and the derivative if needed.
62  virtual double evaluate_if_good_index(kernel::Model *m, ParticleIndex vt,
63  DerivativeAccumulator *da,
64  double max) const;
65 
66  /** Implementations
67  for these are provided by the IMP_SINGLETON_SCORE()
68  macro.
69  */
70  virtual double evaluate_if_good_indexes(kernel::Model *m, const ParticleIndexes &o,
71  DerivativeAccumulator *da, double max,
72  unsigned int lower_bound,
73  unsigned int upper_bound) const;
74  /** Decompose this pair score acting on the pair into a set of
75  restraints. The scoring function and derivatives should
76  be equal to the current score. The defualt implementation
77  just returns this object bound to the pair.*/
78  Restraints create_current_decomposition(kernel::Model *m, ParticleIndex vt) const;
79 
80  protected:
81  /** Overide this to return your own decomposition.*/
82  virtual Restraints do_create_current_decomposition(kernel::Model *m,
83  ParticleIndex vt) const;
84 
85  IMP_REF_COUNTED_DESTRUCTOR(SingletonScore);
86 };
87 
88 IMPKERNEL_END_NAMESPACE
89 
90 #endif /* IMPKERNEL_SINGLETON_SCORE_H */
DerivativeAccumulator.h
Class for adding derivatives from restraints to the model.
IMP::kernel::DerivativeAccumulator
Class for adding derivatives from restraints to the model.
Definition: kernel/DerivativeAccumulator.h:25
base_types.h
Basic types used by IMP.
IMP_REF_COUNTED_DESTRUCTOR
#define IMP_REF_COUNTED_DESTRUCTOR(Name)
Ref counted objects should have private destructors.
Definition: base/ref_counted_macros.h:61
IMP::kernel::SingletonModifier
A base class for modifiers of ParticlesTemp.
Definition: kernel/SingletonModifier.h:33
model_object_helpers.h
Single variable function.
utility_macros.h
Various general useful macros for IMP.
IMP::kernel::Particle
Class to handle individual model particles.
Definition: kernel/declare_Particle.h:34
IMP::base::Object
Common base class for heavy weight IMP objects.
Definition: base/declare_Object.h:123
ParticleTuple.h
Classes to handle individual model particles.
IMP::kernel::SingletonScore
Abstract score function.
Definition: kernel/SingletonScore.h:33
IMP::SingletonScore
IMP::kernel::SingletonScore SingletonScore
Definition: kernel/doxygen.h:230
IMP::kernel::Model
Class for storing model, its restraints, constraints, and particles.
Definition: kernel/declare_Model.h:72