Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooErrorVar.cxx
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * @(#)root/roofitcore:$Id$
5 * Authors: *
6 * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7 * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8 * *
9 * Copyright (c) 2000-2005, Regents of the University of California *
10 * and Stanford University. All rights reserved. *
11 * *
12 * Redistribution and use in source and binary forms, *
13 * with or without modification, are permitted according to the terms *
14 * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15 *****************************************************************************/
16
17/**
18\file RooErrorVar.cxx
19\class RooErrorVar
20\ingroup Roofitcore
21
22RooErrorVar is an auxilary class that represents the error
23of a RooRealVar as a seperate object. The main reason of
24existence of this class is to facilitate the reuse of existing
25techniques to perform calculations that involve a RooRealVars
26error, such as calculating the pull value.
27**/
28
29#include "RooErrorVar.h"
30#include "RooAbsBinning.h"
31#include "RooStreamParser.h"
32#include "RooRangeBinning.h"
33#include "RooMsgService.h"
34#include "RooUniformBinning.h"
35
36using namespace std;
37
39;
40
41
42
43////////////////////////////////////////////////////////////////////////////////
44/// Construct an lvalue variable representing the error of RooRealVar input
45
46RooErrorVar::RooErrorVar(const char *name, const char *title, const RooRealVar& input) :
48 _realVar("realVar","RooRealVar with error",this,(RooAbsReal&)input)
49{
50 _binning = new RooUniformBinning(-1,1,100) ;
51}
52
53
54
55////////////////////////////////////////////////////////////////////////////////
56
57RooErrorVar::RooErrorVar(const RooErrorVar& other, const char* name) :
59 _realVar("realVar",this,other._realVar)
60{
61 _binning = other._binning->clone() ;
62
63 // Copy constructor
64 for(auto * binning : static_range_cast<RooAbsBinning*>(other._altBinning)) _altBinning.Add(binning->clone());
65}
66
67
68
69////////////////////////////////////////////////////////////////////////////////
70/// Destructor
71
73{
74 delete _binning ;
75}
76
77
78
79////////////////////////////////////////////////////////////////////////////////
80/// Return value, i.e. error on input variable
81
82double RooErrorVar::getValV(const RooArgSet*) const
83{
84 return evaluate();
85}
86
87
88
89////////////////////////////////////////////////////////////////////////////////
90/// Return true if we have binning with given name
91
92bool RooErrorVar::hasBinning(const char* name) const
93{
94 return _altBinning.FindObject(name) ? true : false ;
95}
96
97
98
99////////////////////////////////////////////////////////////////////////////////
100/// Return binning with given name. If no binning exists with such a name, clone the default
101/// binning on the fly if so requested
102
103const RooAbsBinning& RooErrorVar::getBinning(const char* name, bool verbose, bool createOnTheFly) const
104{
105 return const_cast<RooErrorVar*>(this)->getBinning(name,verbose,createOnTheFly) ;
106}
107
108
109
110////////////////////////////////////////////////////////////////////////////////
111/// Return binning with given name. If no binning exists with such a name, clone the default
112/// binning on the fly if so requested
113
114RooAbsBinning& RooErrorVar::getBinning(const char* name, bool /*verbose*/, bool createOnTheFly)
115{
116 // Return default (normalization) binning and range if no name is specified
117 if (name==0) {
118 return *_binning ;
119 }
120
121 // Check if binning with this name has been created already
123 if (binning) {
124 return *binning ;
125 }
126
127 // Return default binning if binning is not found and no creation is requested
128 if (!createOnTheFly) {
129 return *_binning ;
130 }
131
132 // Create a new RooRangeBinning with this name with default range
133 binning = new RooRangeBinning(getMin(),getMax(),name) ;
134 coutI(Contents) << "RooErrorVar::getBinning(" << GetName() << ") new range named '"
135 << name << "' created with default bounds" << endl ;
136
137 _altBinning.Add(binning) ;
138
139 return *binning ;
140}
141
142////////////////////////////////////////////////////////////////////////////////
143/// Get a list of all binning names. An empty name implies the default binning.
144/// A 0 pointer should be passed to getBinning in this case.
145
146std::list<std::string> RooErrorVar::getBinningNames() const
147{
148 std::list<std::string> binningNames(1, "");
149
150 for(auto * binning : _altBinning) {
151 const char* name = binning->GetName();
152 binningNames.push_back(name);
153 }
154 return binningNames;
155}
156
157
158/// Remove lower bound from named binning, or default binning if name is null
159void RooErrorVar::removeMin(const char* name) {
161}
162
163
164/// Remove upper bound from named binning, or default binning if name is null
165void RooErrorVar::removeMax(const char* name) {
167}
168
169
170/// Remove both upper and lower bounds from named binning, or
171/// default binning if name is null
174}
175
176
177////////////////////////////////////////////////////////////////////////////////
178/// Store given binning with this variable under the given name
179
180void RooErrorVar::setBinning(const RooAbsBinning& binning, const char* name)
181{
182 if (!name) {
183 if (_binning) delete _binning ;
184 _binning = binning.clone() ;
185 } else {
186
187 // Remove any old binning with this name
189 if (oldBinning) {
190 _altBinning.Remove(oldBinning) ;
191 delete oldBinning ;
192 }
193
194 // Insert new binning in list of alternative binnings
195 RooAbsBinning* newBinning = binning.clone() ;
196 newBinning->SetName(name) ;
197 newBinning->SetTitle(name) ;
198 _altBinning.Add(newBinning) ;
199
200 }
201
202
203}
204
205
206
207////////////////////////////////////////////////////////////////////////////////
208/// Set the lower bound of the range with the given name to the given value
209/// If name is a null pointer, set the lower bound of the default range
210
211void RooErrorVar::setMin(const char* name, double value)
212{
213 // Set new minimum of fit range
214 RooAbsBinning& binning = getBinning(name) ;
215
216 // Check if new limit is consistent
217 if (value >= getMax()) {
218 coutW(InputArguments) << "RooErrorVar::setMin(" << GetName()
219 << "): Proposed new fit min. larger than max., setting min. to max." << endl ;
220 binning.setMin(getMax()) ;
221 } else {
222 binning.setMin(value) ;
223 }
224
225 // Clip current value in window if it fell out
226 if (!name) {
227 double clipValue ;
228 if (!inRange(_value,0,&clipValue)) {
229 setVal(clipValue) ;
230 }
231 }
232
233 setShapeDirty() ;
234}
235
236
237////////////////////////////////////////////////////////////////////////////////
238/// Set the upper bound of the range with the given name to the given value
239/// If name is a null pointer, set the upper bound of the default range
240
241void RooErrorVar::setMax(const char* name, double value)
242{
243 // Set new maximum of fit range
244 RooAbsBinning& binning = getBinning(name) ;
245
246 // Check if new limit is consistent
247 if (value < getMin()) {
248 coutW(InputArguments) << "RooErrorVar::setMax(" << GetName()
249 << "): Proposed new fit max. smaller than min., setting max. to min." << endl ;
250 binning.setMax(getMin()) ;
251 } else {
252 binning.setMax(value) ;
253 }
254
255 // Clip current value in window if it fell out
256 if (!name) {
257 double clipValue ;
258 if (!inRange(_value,0,&clipValue)) {
259 setVal(clipValue) ;
260 }
261 }
262
263 setShapeDirty() ;
264}
265
266/// Set default binning to nBins uniform bins
269}
270
271////////////////////////////////////////////////////////////////////////////////
272/// Set the upper and lower lower bound of the range with the given name to the given values
273/// If name is a null pointer, set the upper and lower bounds of the default range
274
275void RooErrorVar::setRange( const char* name, double min, double max)
276{
277 bool exists = name ? (_altBinning.FindObject(name)?true:false) : true ;
278
279 // Set new fit range
280 RooAbsBinning& binning = getBinning(name,false) ;
281
282 // Check if new limit is consistent
283 if (min>max) {
284 coutW(InputArguments) << "RooErrorVar::setRange(" << GetName()
285 << "): Proposed new fit max. smaller than min., setting max. to min." << endl ;
286 binning.setRange(min,min) ;
287 } else {
288 binning.setRange(min,max) ;
289 }
290
291 if (!exists) {
292 coutI(InputArguments) << "RooErrorVar::setRange(" << GetName()
293 << ") new range named '" << name << "' created with bounds ["
294 << min << "," << max << "]" << endl ;
295 }
296
297 setShapeDirty() ;
298}
299
300
301
302////////////////////////////////////////////////////////////////////////////////
303/// Read object contents from given stream
304
305bool RooErrorVar::readFromStream(istream& is, bool /*compact*/, bool verbose)
306{
307 TString token,errorPrefix("RooErrorVar::readFromStream(") ;
308 errorPrefix.Append(GetName()) ;
309 errorPrefix.Append(")") ;
310 RooStreamParser parser(is,errorPrefix) ;
311 double value(0) ;
312
313 // Compact mode: Read single token
314 if (parser.readDouble(value,verbose)) return true ;
315 if (isValidReal(value,verbose)) {
316 setVal(value) ;
317 return false ;
318 } else {
319 return true ;
320 }
321}
322
323
324
325////////////////////////////////////////////////////////////////////////////////
326/// Write value to stream
327
328void RooErrorVar::writeToStream(ostream& os, bool /*compact*/) const
329{
330 os << getVal() ;
331}
332
333
334////////////////////////////////////////////////////////////////////////////////
335/// Force the internal value cache to be up to date
336
338{
339 _value = evaluate() ;
340}
341
342
343
#define coutI(a)
#define coutW(a)
#define ClassImp(name)
Definition Rtypes.h:377
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void input
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
char name[80]
Definition TGX11.cxx:110
void setShapeDirty()
Notify that a shape-like property (e.g. binning) has changed.
Definition RooAbsArg.h:492
RooAbsBinning is the abstract base class for RooRealVar binning definitions.
virtual void setRange(double xlo, double xhi)=0
virtual void setMin(double xlo)
Change lower bound to xlo.
virtual void setMax(double xhi)
Change upper bound to xhi.
virtual RooAbsBinning * clone(const char *name=nullptr) const =0
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
bool isValidReal(double value, bool printError=false) const override
Check if given value is valid.
virtual double getMax(const char *name=nullptr) const
Get maximum of currently defined range.
virtual double getMin(const char *name=nullptr) const
Get minimum of currently defined range.
bool inRange(const char *name) const override
Check if current value is inside range with given name.
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition RooAbsReal.h:62
double getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition RooAbsReal.h:91
double _value
Cache for current value of object.
Definition RooAbsReal.h:509
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:55
RooErrorVar is an auxilary class that represents the error of a RooRealVar as a seperate object.
Definition RooErrorVar.h:28
bool hasBinning(const char *name) const override
Return true if we have binning with given name.
void removeMin(const char *name=nullptr)
Remove lower bound from named binning, or default binning if name is null.
void setBinning(const RooAbsBinning &binning, const char *name=nullptr)
Store given binning with this variable under the given name.
~RooErrorVar() override
Destructor.
void removeRange(const char *name=nullptr)
Remove both upper and lower bounds from named binning, or default binning if name is null.
void setMax(double value)
Set upper bound of default range to value.
Definition RooErrorVar.h:66
std::list< std::string > getBinningNames() const override
Get a list of all binning names.
RooLinkedList _altBinning
! Optional alternative ranges and binnings
Definition RooErrorVar.h:94
void setRange(double min, double max)
Set default ranges to [min,max].
Definition RooErrorVar.h:70
void setVal(double value) override
Set the current value of the object. Needs to be overridden by implementations.
Definition RooErrorVar.h:46
double getValV(const RooArgSet *set=nullptr) const override
Return value, i.e. error on input variable.
RooErrorVar()
Default constructor.
Definition RooErrorVar.h:32
void setMin(double value)
Set lower bound of default range to value.
Definition RooErrorVar.h:62
void syncCache(const RooArgSet *set=nullptr) override
Force the internal value cache to be up to date.
void writeToStream(std::ostream &os, bool compact) const override
Write value to stream.
RooAbsBinning * _binning
! Pointer to default binning definition
Definition RooErrorVar.h:99
void removeMax(const char *name=nullptr)
Remove upper bound from named binning, or default binning if name is null.
const RooAbsBinning & getBinning(const char *name=nullptr, bool verbose=true, bool createOnTheFly=false) const override
Return binning with given name.
double evaluate() const override
Evaluate this PDF / function / constant. Needs to be overridden by all derived classes.
Definition RooErrorVar.h:41
bool readFromStream(std::istream &is, bool compact, bool verbose=false) override
Read object contents from given stream.
void setBins(Int_t nBins)
Set default binning to nBins uniform bins.
virtual void Add(TObject *arg)
TObject * FindObject(const char *name) const override
Return pointer to obejct with given name.
virtual bool Remove(TObject *arg)
Remove object from collection.
static constexpr double infinity()
Return internal infinity representation.
Definition RooNumber.h:24
RooRangeBinning is binning/range definition that only defines a range but no binning.
RooRealVar represents a variable that can be changed from the outside.
Definition RooRealVar.h:40
bool readDouble(double &value, bool zapOnError=false)
Read the next token and convert it to a double.
RooUniformBinning is an implementation of RooAbsBinning that provides a uniform binning in 'n' bins b...
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:140
Basic string class.
Definition TString.h:139
TString & Append(const char *cs)
Definition TString.h:576