Logo ROOT  
Reference Guide
RooAbsTestStatistic.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * File: $Id: RooAbsGoodnessOfFit.h,v 1.15 2007/05/11 09:11:30 verkerke Exp $
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#ifndef ROO_ABS_TEST_STATISTIC
17#define ROO_ABS_TEST_STATISTIC
18
19#include "RooAbsReal.h"
20#include "RooSetProxy.h"
21#include "RooRealProxy.h"
22#include "TStopwatch.h"
23#include "Math/Util.h"
24
25#include <string>
26#include <vector>
27
28class RooArgSet ;
29class RooAbsData ;
30class RooAbsReal ;
31class RooSimultaneous ;
32class RooRealMPFE ;
33
37
39 friend class RooRealMPFE;
40public:
41
43 /// Stores the configuration parameters for RooAbsTestStatistic.
44 std::string rangeName = "";
45 std::string addCoefRangeName = "";
46 int nCPU = 1;
48 bool verbose = true;
49 bool splitCutRange = false;
50 bool cloneInputData = true;
52 bool binnedL = false;
54 };
55
56 // Constructors, assignment etc
58 RooAbsTestStatistic(const char *name, const char *title, RooAbsReal& real, RooAbsData& data,
59 const RooArgSet& projDeps, Configuration const& cfg);
60 RooAbsTestStatistic(const RooAbsTestStatistic& other, const char* name=nullptr);
61 ~RooAbsTestStatistic() override;
62 virtual RooAbsTestStatistic* create(const char *name, const char *title, RooAbsReal& real, RooAbsData& data,
63 const RooArgSet& projDeps, Configuration const& cfg) = 0;
64
65 void constOptimizeTestStatistic(ConstOpCode opcode, bool doAlsoTrackingOpt=true) override ;
66
67 virtual double combinedValue(RooAbsReal** gofArray, Int_t nVal) const = 0 ;
68 virtual double globalNormalization() const {
69 // Default value of global normalization factor is 1.0
70 return 1.0 ;
71 }
72
73 bool setData(RooAbsData& data, bool cloneData=true) override ;
74
75 void enableOffsetting(bool flag) override ;
76 bool isOffsetting() const override { return _doOffset ; }
77 double offset() const override { return _offset.Sum() ; }
78 virtual double offsetCarry() const { return _offset.Carry(); }
79
82 // Return test statistic operation mode of this instance (SimMaster, MPMaster or Slave)
83 return _gofOpMode ;
84 }
85
86protected:
87
88 void printCompactTreeHook(std::ostream& os, const char* indent="") override ;
89
90 bool redirectServersHook(const RooAbsCollection& newServerList, bool mustReplaceAll, bool nameChange, bool isRecursive) override ;
91 double evaluate() const override ;
92
93 virtual double evaluatePartition(std::size_t firstEvent, std::size_t lastEvent, std::size_t stepSize) const = 0 ;
94 virtual double getCarry() const;
95
97 void setSimCount(Int_t simCount) {
98 // Store total number of components p.d.f. of a RooSimultaneous in this component test statistic
99 _simCount = simCount ;
100 }
101
102 void setEventCount(Int_t nEvents) {
103 // Store total number of events in this component test statistic
104 _nEvents = nEvents ;
105 }
106
107 Int_t numSets() const {
108 // Return total number of sets for parallel calculation
109 return _numSets ;
110 }
111 Int_t setNum() const {
112 // Return parallel calculation set number for this instance
113 return _setNum ;
114 }
115
116 RooSetProxy _paramSet ; ///< Parameters of the test statistic (=parameters of the input function)
117
118
119 // Original arguments
120 RooAbsReal* _func = nullptr; ///< Pointer to original input function
121 RooAbsData* _data = nullptr; ///< Pointer to original input dataset
122 const RooArgSet* _projDeps = nullptr; ///< Pointer to set with projected observables
123 std::string _rangeName ; ///< Name of range in which to calculate test statistic
124 std::string _addCoefRangeName ; ///< Name of reference to be used for RooAddPdf components
125 bool _splitRange = false; ///< Split rangeName in RooSimultaneous index labels if true
126 Int_t _simCount = 1; ///< Total number of component p.d.f.s in RooSimultaneous (if any)
127 bool _verbose = false; ///< Verbose messaging if true
128
129 virtual bool setDataSlave(RooAbsData& /*data*/, bool /*cloneData*/=true, bool /*ownNewDataAnyway*/=false) { return true ; }
130
131 //private:
132
133
134 virtual bool processEmptyDataSets() const { return true ; }
135
136 bool initialize() ;
137 void initSimMode(RooSimultaneous* pdf, RooAbsData* data, const RooArgSet* projDeps, std::string const& rangeName, std::string const& addCoefRangeName) ;
138 void initMPMode(RooAbsReal* real, RooAbsData* data, const RooArgSet* projDeps, std::string const& rangeName, std::string const& addCoefRangeName) ;
139
140 mutable bool _init = false; ///<! Is object initialized
141 GOFOpMode _gofOpMode = Slave; ///< Operation mode of test statistic instance
142
143 Int_t _nEvents = 0; ///< Total number of events in test statistic calculation
144 Int_t _setNum = 0; ///< Partition number of this instance in parallel calculation mode
145 Int_t _numSets = 1; ///< Total number of partitions in parallel calculation mode
146 Int_t _extSet = 0; ///<! Number of designated set to calculated extended term
147
148 // Simultaneous mode data
149 std::vector<std::unique_ptr<RooAbsTestStatistic>> _gofArray; ///<! Array of sub-contexts representing part of the combined test statistic
150
151 // Parallel mode data
152 Int_t _nCPU = 1; ///< Number of processors to use in parallel calculation mode
153 pRooRealMPFE* _mpfeArray = nullptr; ///<! Array of parallel execution frond ends
154
155 RooFit::MPSplit _mpinterl = RooFit::BulkPartition; ///< Use interleaving strategy rather than N-wise split for partioning of dataset for multiprocessor-split
156 bool _doOffset = false; ///< Apply interval value offset to control numeric precision?
157 const bool _takeGlobalObservablesFromData = false; ///< If the global observable values are taken from data
158 mutable ROOT::Math::KahanSum<double> _offset {0.0}; ///<! Offset as KahanSum to avoid loss of precision
159 mutable double _evalCarry = 0.0; ///<! carry of Kahan sum in evaluatePartition
160
161 ClassDefOverride(RooAbsTestStatistic,0) // Abstract base class for real-valued test statistics
162
163};
164
165#endif
RooAbsData * pRooAbsData
RooRealMPFE * pRooRealMPFE
#define ClassDefOverride(name, id)
Definition: Rtypes.h:339
static void indent(ostringstream &buf, int indent_level)
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
char name[80]
Definition: TGX11.cxx:110
T Sum() const
Definition: Util.h:240
T Carry() const
Definition: Util.h:250
RooAbsCollection is an abstract container object that can hold multiple RooAbsArg objects.
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:61
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:60
RooAbsTestStatistic is the abstract base class for all test statistics.
Int_t _setNum
Partition number of this instance in parallel calculation mode.
virtual RooAbsTestStatistic * create(const char *name, const char *title, RooAbsReal &real, RooAbsData &data, const RooArgSet &projDeps, Configuration const &cfg)=0
virtual bool processEmptyDataSets() const
double _evalCarry
! carry of Kahan sum in evaluatePartition
std::string _addCoefRangeName
Name of reference to be used for RooAddPdf components.
Int_t _nEvents
Total number of events in test statistic calculation.
GOFOpMode operMode() const
Int_t _nCPU
Number of processors to use in parallel calculation mode.
RooSetProxy _paramSet
Parameters of the test statistic (=parameters of the input function)
virtual double globalNormalization() const
RooAbsReal * _func
Pointer to original input function.
bool setData(RooAbsData &data, bool cloneData=true) override
Change dataset that is used to given one.
void printCompactTreeHook(std::ostream &os, const char *indent="") override
Add extra information on component test statistics when printing itself as part of a tree structure.
Int_t _numSets
Total number of partitions in parallel calculation mode.
RooFit::MPSplit _mpinterl
Use interleaving strategy rather than N-wise split for partioning of dataset for multiprocessor-split...
bool isOffsetting() const override
double evaluate() const override
Calculate and return value of test statistic.
GOFOpMode _gofOpMode
Operation mode of test statistic instance.
virtual bool setDataSlave(RooAbsData &, bool=true, bool=false)
void initMPMode(RooAbsReal *real, RooAbsData *data, const RooArgSet *projDeps, std::string const &rangeName, std::string const &addCoefRangeName)
Initialize multi-processor calculation mode.
std::string _rangeName
Name of range in which to calculate test statistic.
void constOptimizeTestStatistic(ConstOpCode opcode, bool doAlsoTrackingOpt=true) override
Forward constant term optimization management calls to component test statistics.
bool _init
! Is object initialized
Int_t _simCount
Total number of component p.d.f.s in RooSimultaneous (if any)
ROOT::Math::KahanSum< double > _offset
! Offset as KahanSum to avoid loss of precision
void setSimCount(Int_t simCount)
Int_t _extSet
! Number of designated set to calculated extended term
void setEventCount(Int_t nEvents)
double offset() const override
std::vector< std::unique_ptr< RooAbsTestStatistic > > _gofArray
! Array of sub-contexts representing part of the combined test statistic
bool initialize()
One-time initialization of the test statistic.
virtual double offsetCarry() const
const RooArgSet * _projDeps
Pointer to set with projected observables.
void initSimMode(RooSimultaneous *pdf, RooAbsData *data, const RooArgSet *projDeps, std::string const &rangeName, std::string const &addCoefRangeName)
Initialize simultaneous p.d.f processing mode.
~RooAbsTestStatistic() override
Destructor.
virtual double getCarry() const
bool _verbose
Verbose messaging if true.
void enableOffsetting(bool flag) override
virtual double evaluatePartition(std::size_t firstEvent, std::size_t lastEvent, std::size_t stepSize) const =0
bool _splitRange
Split rangeName in RooSimultaneous index labels if true.
virtual double combinedValue(RooAbsReal **gofArray, Int_t nVal) const =0
pRooRealMPFE * _mpfeArray
! Array of parallel execution frond ends
bool _doOffset
Apply interval value offset to control numeric precision?
RooAbsData * _data
Pointer to original input dataset.
const bool _takeGlobalObservablesFromData
If the global observable values are taken from data.
void setMPSet(Int_t setNum, Int_t numSets)
Set MultiProcessor set number identification of this instance.
bool redirectServersHook(const RooAbsCollection &newServerList, bool mustReplaceAll, bool nameChange, bool isRecursive) override
Forward server redirect calls to component test statistics.
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:56
RooRealMPFE is the multi-processor front-end for parallel calculation of RooAbsReal objects.
Definition: RooRealMPFE.h:29
RooSimultaneous facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset.
@ BulkPartition
Definition: RooGlobalFunc.h:65
std::string rangeName
Stores the configuration parameters for RooAbsTestStatistic.