Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooAbsOptTestStatistic.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 RooAbsOptTestStatistic.cxx
19\class RooAbsOptTestStatistic
20\ingroup Roofitcore
21
22Abstract base class for test
23statistics objects that evaluate a function or PDF at each point of a given
24dataset. This class provides generic optimizations, such as
25caching and precalculation of constant terms that can be made for
26all such quantities.
27
28Implementations should define evaluatePartition(), which calculates the
29value of a (sub)range of the dataset and optionally combinedValue(),
30which combines the values calculated for each partition. If combinedValue()
31is not overloaded, the default implementation will add the partition results
32to obtain the combined result.
33
34Support for calculation in partitions is needed to allow multi-core
35parallelized calculation of test statistics.
36**/
37
39
40#include "Riostream.h"
41#include "TClass.h"
42#include <cstring>
43
44#include "RooAbsData.h"
45#include "RooAbsDataStore.h"
46#include "RooAbsPdf.h"
47#include "RooAddPdf.h"
48#include "RooArgSet.h"
49#include "RooBinSamplingPdf.h"
50#include "RooBinning.h"
51#include "RooCategory.h"
52#include "RooDataHist.h"
53#include "RooDataSet.h"
54#include "RooErrorHandler.h"
55#include "RooFitImplHelpers.h"
56#include "RooGlobalFunc.h"
57#include "RooMsgService.h"
58#include "RooProdPdf.h"
59#include "RooProduct.h"
60#include "RooRealSumPdf.h"
61#include "RooRealVar.h"
62#include "RooTrace.h"
63#include "RooVectorDataStore.h"
64
65#include "ROOT/StringUtils.hxx"
66
67using namespace std;
68
70
71
72////////////////////////////////////////////////////////////////////////////////
73/// Create a test statistic, and optimise its calculation.
74/// \param[in] name Name of the instance.
75/// \param[in] title Title (for e.g. plotting).
76/// \param[in] real Function to evaluate.
77/// \param[in] indata Dataset for which to compute test statistic.
78/// \param[in] projDeps A set of projected observables.
79/// \param[in] cfg the statistic configuration
80///
81/// cfg contains:
82/// - rangeName If not null, only events in the dataset inside the range will be used in the test
83/// statistic calculation.
84/// - addCoefRangeName If not null, all RooAddPdf components of `real` will be
85/// instructed to fix their fraction definitions to the given named range.
86/// - nCPU If > 1, the test statistic calculation will be parallelised over multiple processes. By default, the data
87/// is split with 'bulk' partitioning (each process calculates a contiguous block of fraction 1/nCPU
88/// of the data). For binned data, this approach may be suboptimal as the number of bins with >0 entries
89/// in each processing block may vary greatly; thereby distributing the workload rather unevenly.
90/// - interleave Strategy how to distribute events among workers. If an interleave partitioning strategy is used where each partition
91/// i takes all bins for which (ibin % ncpu == i), an even distribution of work is more likely.
92/// - splitCutRange If true, a different rangeName constructed as `rangeName_{catName}` will be used
93/// as range definition for each index state of a RooSimultaneous.
94/// - cloneInputData Not used. Data is always cloned.
95/// - integrateOverBinsPrecision If > 0, PDF in binned fits are integrated over the bins. This sets the precision. If = 0,
96/// only unbinned PDFs fit to RooDataHist are integrated. If < 0, PDFs are never integrated.
98 RooAbsData &indata, const RooArgSet &projDeps,
100 : RooAbsTestStatistic(name, title, real, indata, projDeps, cfg),
101 _integrateBinsPrecision(cfg.integrateOverBinsPrecision)
102{
103 // Don't do a thing in master mode
104 if (operMode() != Slave) {
105 return;
106 }
107
108 initSlave(real, indata, projDeps, _rangeName.c_str(), _addCoefRangeName.c_str());
109}
110
111////////////////////////////////////////////////////////////////////////////////
112/// Copy constructor
113
115 : RooAbsTestStatistic(other, name),
116 _sealed(other._sealed),
120{
121 // Don't do a thing in master mode
122 if (operMode() != Slave) {
123
124 if (other._normSet) {
125 _normSet = new RooArgSet;
126 other._normSet->snapshot(*_normSet);
127 }
128 return;
129 }
130
131 initSlave(*other._funcClone, *other._dataClone, other._projDeps ? *other._projDeps : RooArgSet(),
132 other._rangeName.c_str(), other._addCoefRangeName.c_str());
133}
134
135
136
137////////////////////////////////////////////////////////////////////////////////
138
139void RooAbsOptTestStatistic::initSlave(RooAbsReal& real, RooAbsData& indata, const RooArgSet& projDeps, const char* rangeName,
140 const char* addCoefRangeName) {
141 // ******************************************************************
142 // *** PART 1 *** Clone incoming pdf, attach to each other *
143 // ******************************************************************
144
145 // Clone FUNC
146 _funcClone = RooHelpers::cloneTreeWithSameParameters(real, indata.get()).release();
147 _funcCloneSet = nullptr ;
148
149 // Attach FUNC to data set
150 _funcObsSet = std::unique_ptr<RooArgSet>{_funcClone->getObservables(indata)}.release();
151
152 if (_funcClone->getAttribute("BinnedLikelihood")) {
153 _funcClone->setAttribute("BinnedLikelihoodActive") ;
154 }
155
156 // Mark all projected dependents as such
157 if (!projDeps.empty()) {
158 std::unique_ptr<RooArgSet> projDataDeps{static_cast<RooArgSet*>(_funcObsSet->selectCommon(projDeps))};
159 projDataDeps->setAttribAll("projectedDependent") ;
160 }
161
162 // If PDF is a RooProdPdf (with possible constraint terms)
163 // analyze pdf for actual parameters (i.e those in unconnected constraint terms should be
164 // ignored as here so that the test statistic will not be recalculated if those
165 // are changed
166 RooProdPdf* pdfWithCons = dynamic_cast<RooProdPdf*>(_funcClone) ;
167 if (pdfWithCons) {
168
169 std::unique_ptr<RooArgSet> connPars{pdfWithCons->getConnectedParameters(*indata.get())};
170 // Add connected parameters as servers
171 _paramSet.add(*connPars) ;
172
173 } else {
174 // Add parameters as servers
176 }
177
178 // Store normalization set
179 _normSet = new RooArgSet;
180 indata.get()->snapshot(*_normSet, false);
181
182 // Expand list of observables with any observables used in parameterized ranges.
183 // This NEEDS to be a counting loop since we are inserting during the loop.
184 for (std::size_t i = 0; i < _funcObsSet->size(); ++i) {
185 auto realDepRLV = dynamic_cast<const RooAbsRealLValue*>((*_funcObsSet)[i]);
186 if (realDepRLV && realDepRLV->isDerived()) {
187 RooArgSet tmp2;
188 realDepRLV->leafNodeServerList(&tmp2, nullptr, true);
189 _funcObsSet->add(tmp2,true);
190 }
191 }
192
193
194
195 // ******************************************************************
196 // *** PART 2 *** Clone and adjust incoming data, attach to PDF *
197 // ******************************************************************
198
199 // Check if the fit ranges of the dependents in the data and in the FUNC are consistent
200 const RooArgSet* dataDepSet = indata.get() ;
201 for (const auto arg : *_funcObsSet) {
202
203 // Check that both dataset and function argument are of type RooRealVar
204 RooRealVar* realReal = dynamic_cast<RooRealVar*>(arg) ;
205 if (!realReal) continue ;
206 RooRealVar* datReal = dynamic_cast<RooRealVar*>(dataDepSet->find(realReal->GetName())) ;
207 if (!datReal) continue ;
208
209 // Check that range of observables in pdf is equal or contained in range of observables in data
210
211 if (!realReal->getBinning().lowBoundFunc() && realReal->getMin()<(datReal->getMin()-1e-6)) {
212 coutE(InputArguments) << "RooAbsOptTestStatistic: ERROR minimum of FUNC observable " << arg->GetName()
213 << "(" << realReal->getMin() << ") is smaller than that of "
214 << arg->GetName() << " in the dataset (" << datReal->getMin() << ")" << endl ;
216 return ;
217 }
218
219 if (!realReal->getBinning().highBoundFunc() && realReal->getMax()>(datReal->getMax()+1e-6)) {
220 coutE(InputArguments) << "RooAbsOptTestStatistic: ERROR maximum of FUNC observable " << arg->GetName()
221 << " is larger than that of " << arg->GetName() << " in the dataset" << endl ;
223 return ;
224 }
225 }
226
227 // Copy data and strip entries lost by adjusted fit range, _dataClone ranges will be copied from realDepSet ranges
228 if (rangeName && strlen(rangeName)) {
229 _dataClone = std::unique_ptr<RooAbsData>{indata.reduce(RooFit::SelectVars(*_funcObsSet),RooFit::CutRange(rangeName))}.release();
230 // cout << "RooAbsOptTestStatistic: reducing dataset to fit in range named " << rangeName << " resulting dataset has " << _dataClone->sumEntries() << " events" << endl ;
231 } else {
232 _dataClone = static_cast<RooAbsData*>(indata.Clone()) ;
233 }
234 _ownData = true ;
235
236
237 // ******************************************************************
238 // *** PART 3 *** Make adjustments for fit ranges, if specified *
239 // ******************************************************************
240
241 std::unique_ptr<RooArgSet> origObsSet( real.getObservables(indata) );
242 if (rangeName && strlen(rangeName)) {
243 cxcoutI(Fitting) << "RooAbsOptTestStatistic::ctor(" << GetName() << ") constructing test statistic for sub-range named " << rangeName << endl ;
244
245 if(auto pdfClone = dynamic_cast<RooAbsPdf*>(_funcClone)) {
246 pdfClone->setNormRange(rangeName);
247 }
248
249 // Print warnings if the requested ranges are not available for the observable
250 for (const auto arg : *_funcObsSet) {
251
252 if (auto realObs = dynamic_cast<RooRealVar*>(arg)) {
253
254 auto tokens = ROOT::Split(rangeName, ",");
255 for(std::string const& token : tokens) {
256 if(!realObs->hasRange(token.c_str())) {
257 std::stringstream errMsg;
258 errMsg << "The observable \"" << realObs->GetName() << "\" doesn't define the requested range \""
259 << token << "\". Replacing it with the default range." << std::endl;
260 coutI(Fitting) << errMsg.str() << std::endl;
261 }
262 }
263 }
264 }
265 }
266
267
268 // ******************************************************************
269 // *** PART 3.2 *** Binned fits *
270 // ******************************************************************
271
273
274
275 // Fix RooAddPdf coefficients to original normalization range
276 if (rangeName && strlen(rangeName)) {
277
278 // WVE Remove projected dependents from normalization
280
281 if (addCoefRangeName && strlen(addCoefRangeName)) {
282 cxcoutI(Fitting) << "RooAbsOptTestStatistic::ctor(" << GetName()
283 << ") fixing interpretation of coefficients of any RooAddPdf component to range " << addCoefRangeName << endl ;
284 _funcClone->fixAddCoefRange(addCoefRangeName,false) ;
285 }
286 }
287
288
289 // This is deferred from part 2 - but must happen after part 3 - otherwise invalid bins cannot be properly marked in cacheValidEntries
292
293
294
295
296 // *********************************************************************
297 // *** PART 4 *** Adjust normalization range for projected observables *
298 // *********************************************************************
299
300 // Remove projected dependents from normalization set
301 if (!projDeps.empty()) {
302
303 _projDeps = new RooArgSet;
304 projDeps.snapshot(*_projDeps, false) ;
305
306 //RooArgSet* tobedel = (RooArgSet*) _normSet->selectCommon(*_projDeps) ;
307 _normSet->remove(*_projDeps,true,true) ;
308
309 // Mark all projected dependents as such
310 RooArgSet projDataDeps;
311 _funcObsSet->selectCommon(*_projDeps, projDataDeps);
312 projDataDeps.setAttribAll("projectedDependent") ;
313 }
314
315
316 coutI(Optimization) << "RooAbsOptTestStatistic::ctor(" << GetName() << ") optimizing internal clone of p.d.f for likelihood evaluation."
317 << "Lazy evaluation and associated change tracking will disabled for all nodes that depend on observables" << endl ;
318
319
320 // *********************************************************************
321 // *** PART 4 *** Finalization and activation of optimization *
322 // *********************************************************************
323
324 // Redirect pointers of base class to clone
325 _func = _funcClone ;
326 _data = _dataClone ;
327
329
331
332 // It would be unusual if the global observables are used in the likelihood
333 // outside of the constraint terms, but if they are we have to be consistent
334 // and also redirect them to the snapshots in the dataset if appropriate.
337 }
338
339}
340
341
342////////////////////////////////////////////////////////////////////////////////
343/// Destructor
344
346{
347 if (operMode()==Slave) {
348 delete _funcClone ;
349 delete _funcObsSet ;
350 if (_projDeps) {
351 delete _projDeps ;
352 }
353 if (_ownData) {
354 delete _dataClone ;
355 }
356 }
357 delete _normSet ;
358}
359
360
361
362////////////////////////////////////////////////////////////////////////////////
363/// Method to combined test statistic results calculated into partitions into
364/// the global result. This default implementation adds the partition return
365/// values
366
368{
369 // Default implementation returns sum of components
370 double sum(0);
371 double carry(0);
372 for (Int_t i = 0; i < n; ++i) {
373 double y = array[i]->getValV();
374 carry += reinterpret_cast<RooAbsOptTestStatistic*>(array[i])->getCarry();
375 y -= carry;
376 const double t = sum + y;
377 carry = (t - sum) - y;
378 sum = t;
379 }
380 _evalCarry = carry;
381 return sum ;
382}
383
384
385
386////////////////////////////////////////////////////////////////////////////////
387/// Catch server redirect calls and forward to internal clone of function
388
389bool RooAbsOptTestStatistic::redirectServersHook(const RooAbsCollection& newServerList, bool mustReplaceAll, bool nameChange, bool isRecursive)
390{
391 RooAbsTestStatistic::redirectServersHook(newServerList,mustReplaceAll,nameChange,isRecursive) ;
392 if (operMode()!=Slave) return false ;
393 bool ret = _funcClone->recursiveRedirectServers(newServerList,false,nameChange) ;
394 return ret || RooAbsReal::redirectServersHook(newServerList, mustReplaceAll, nameChange, isRecursive);
395}
396
397
398
399////////////////////////////////////////////////////////////////////////////////
400/// Catch print hook function and forward to function clone
401
403{
405 if (operMode()!=Slave) return ;
406 TString indent2(indent) ;
407 indent2 += "opt >>" ;
408 _funcClone->printCompactTree(os,indent2.Data()) ;
409 os << indent2 << " dataset clone = " << _dataClone << " first obs = " << _dataClone->get()->first() << endl ;
410}
411
412
413
414////////////////////////////////////////////////////////////////////////////////
415/// Driver function to propagate constant term optimizations in test statistic.
416/// If code Activate is sent, constant term optimization will be executed.
417/// If code Deactivate is sent, any existing constant term optimizations will
418/// be abandoned. If codes ConfigChange or ValueChange are sent, any existing
419/// constant term optimizations will be redone.
420
422{
423 // cout << "ROATS::constOpt(" << GetName() << ") funcClone structure dump BEFORE const-opt" << endl ;
424 // _funcClone->Print("t") ;
425
426 RooAbsTestStatistic::constOptimizeTestStatistic(opcode,doAlsoTrackingOpt);
427 if (operMode()!=Slave) return ;
428
429 if (_dataClone->hasFilledCache() && _dataClone->store()->cacheOwner()!=this) {
430 if (opcode==Activate) {
431 cxcoutW(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName()
432 << ") dataset cache is owned by another object, no constant term optimization can be applied" << endl ;
433 }
434 return ;
435 }
436
437 if (!allowFunctionCache()) {
438 if (opcode==Activate) {
439 cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName()
440 << ") function caching prohibited by test statistic, no constant term optimization is applied" << endl ;
441 }
442 return ;
443 }
444
445 if (_dataClone->hasFilledCache() && opcode==Activate) {
446 opcode=ValueChange ;
447 }
448
449 switch(opcode) {
450 case Activate:
451 cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName()
452 << ") optimizing evaluation of test statistic by finding all nodes in p.d.f that depend exclusively"
453 << " on observables and constant parameters and precalculating their values" << endl ;
454 optimizeConstantTerms(true,doAlsoTrackingOpt) ;
455 break ;
456
457 case DeActivate:
458 cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName()
459 << ") deactivating optimization of constant terms in test statistic" << endl ;
460 optimizeConstantTerms(false) ;
461 break ;
462
463 case ConfigChange:
464 cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName()
465 << ") one ore more parameter were changed from constant to floating or vice versa, "
466 << "re-evaluating constant term optimization" << endl ;
467 optimizeConstantTerms(false) ;
468 optimizeConstantTerms(true,doAlsoTrackingOpt) ;
469 break ;
470
471 case ValueChange:
472 cxcoutI(Optimization) << "RooAbsOptTestStatistic::constOptimize(" << GetName()
473 << ") the value of one ore more constant parameter were changed re-evaluating constant term optimization" << endl ;
474 // Request a forcible cache update of all cached nodes
476
477 break ;
478 }
479
480// cout << "ROATS::constOpt(" << GetName() << ") funcClone structure dump AFTER const-opt" << endl ;
481// _funcClone->Print("t") ;
482}
483
484
485
486////////////////////////////////////////////////////////////////////////////////
487/// This method changes the value caching logic for all nodes that depends on any of the observables
488/// as defined by the given dataset. When evaluating a test statistic constructed from the RooAbsReal
489/// with a dataset the observables are guaranteed to change with every call, thus there is no point
490/// in tracking these changes which result in a net overhead. Thus for observable-dependent nodes,
491/// the evaluation mechanism is changed from being dependent on a 'valueDirty' flag to guaranteed evaluation.
492/// On the dataset side, the observables objects are modified to no longer send valueDirty messages
493/// to their client
494
496{
497// cout << "RooAbsOptTestStatistic::optimizeCaching(" << GetName() << "," << this << ")" << endl ;
498
499 // Trigger create of all object caches now in nodes that have deferred object creation
500 // so that cache contents can be processed immediately
502
503 // Set value caching mode for all nodes that depend on any of the observables to ADirty
505
506 // Disable propagation of dirty state flags for observables
507 _dataClone->setDirtyProp(false) ;
508
509 // Disable reading of observables that are not used
511}
512
513
514
515////////////////////////////////////////////////////////////////////////////////
516/// Driver function to activate global constant term optimization.
517/// If activated, constant terms are found and cached with the dataset.
518/// The operation mode of cached nodes is set to AClean meaning that
519/// their getVal() call will never result in an evaluate call.
520/// Finally the branches in the dataset that correspond to observables
521/// that are exclusively used in constant terms are disabled as
522/// they serve no more purpose
523
524void RooAbsOptTestStatistic::optimizeConstantTerms(bool activate, bool applyTrackingOpt)
525{
526 if(activate) {
527
528 if (_optimized) {
529 return ;
530 }
531
532 // Trigger create of all object caches now in nodes that have deferred object creation
533 // so that cache contents can be processed immediately
535
536
537 // WVE - Patch to allow customization of optimization level per component pdf
538 if (_funcClone->getAttribute("NoOptimizeLevel1")) {
539 coutI(Minimization) << " Optimization customization: Level-1 constant-term optimization prohibited by attribute NoOptimizeLevel1 set on top-level pdf "
540 << _funcClone->ClassName() << "::" << _funcClone->GetName() << endl ;
541 return ;
542 }
543 if (_funcClone->getAttribute("NoOptimizeLevel2")) {
544 coutI(Minimization) << " Optimization customization: Level-2 constant-term optimization prohibited by attribute NoOptimizeLevel2 set on top-level pdf "
545 << _funcClone->ClassName() << "::" << _funcClone->GetName() << endl ;
546 applyTrackingOpt=false ;
547 }
548
549 // Apply tracking optimization here. Default strategy is to track components
550 // of RooAddPdfs and RooRealSumPdfs. If these components are a RooProdPdf
551 // or a RooProduct respectively, track the components of these products instead
552 // of the product term
553 RooArgSet trackNodes ;
554
555
556 // Add safety check here - applyTrackingOpt will only be applied if present
557 // dataset is constructed in terms of a RooVectorDataStore
558 if (applyTrackingOpt) {
559 if (!dynamic_cast<RooVectorDataStore*>(_dataClone->store())) {
560 coutW(Optimization) << "RooAbsOptTestStatistic::optimizeConstantTerms(" << GetName()
561 << ") WARNING Cache-and-track optimization (Optimize level 2) is only available for datasets"
562 << " implement in terms of RooVectorDataStore - ignoring this option for current dataset" << endl ;
563 applyTrackingOpt = false ;
564 }
565 }
566
567 if (applyTrackingOpt) {
568 RooArgSet branches ;
569 _funcClone->branchNodeServerList(&branches) ;
570 for (auto arg : branches) {
571 arg->setCacheAndTrackHints(trackNodes);
572 }
573 // Do not set CacheAndTrack on constant expressions
574 RooArgSet* constNodes = static_cast<RooArgSet*>(trackNodes.selectByAttrib("Constant",true)) ;
575 trackNodes.remove(*constNodes) ;
576 delete constNodes ;
577
578 // Set CacheAndTrack flag on all remaining nodes
579 trackNodes.setAttribAll("CacheAndTrack",true) ;
580 }
581
582 // Find all nodes that depend exclusively on constant parameters
584
586
587 // Cache constant nodes with dataset - also cache entries corresponding to zero-weights in data when using BinnedLikelihood
589
590 // Put all cached nodes in AClean value caching mode so that their evaluate() is never called
591 for (auto cacheArg : _cachedNodes) {
592 cacheArg->setOperMode(RooAbsArg::AClean) ;
593 }
594
595 RooArgSet* constNodes = static_cast<RooArgSet*>(_cachedNodes.selectByAttrib("ConstantExpressionCached",true)) ;
596 RooArgSet actualTrackNodes(_cachedNodes) ;
597 actualTrackNodes.remove(*constNodes) ;
598 if (!constNodes->empty()) {
599 if (constNodes->size()<20) {
600 coutI(Minimization) << " The following expressions have been identified as constant and will be precalculated and cached: " << *constNodes << endl ;
601 } else {
602 coutI(Minimization) << " A total of " << constNodes->size() << " expressions have been identified as constant and will be precalculated and cached." << endl ;
603 }
604 }
605 if (!actualTrackNodes.empty()) {
606 if (actualTrackNodes.size()<20) {
607 coutI(Minimization) << " The following expressions will be evaluated in cache-and-track mode: " << actualTrackNodes << endl ;
608 } else {
609 coutI(Minimization) << " A total of " << constNodes->size() << " expressions will be evaluated in cache-and-track-mode." << endl ;
610 }
611 }
612 delete constNodes ;
613
614 // Disable reading of observables that are no longer used
616
617 _optimized = true ;
618
619 } else {
620
621 // Delete the cache
623
624 // Reactivate all tree branches
626
627 // Reset all nodes to ADirty
629
630 // Disable propagation of dirty state flags for observables
631 _dataClone->setDirtyProp(false) ;
632
634
635
636 _optimized = false ;
637 }
638}
639
640
641
642////////////////////////////////////////////////////////////////////////////////
643/// Change dataset that is used to given one. If cloneData is true, a clone of
644/// in the input dataset is made. If the test statistic was constructed with
645/// a range specification on the data, the cloneData argument is ignored and
646/// the data is always cloned.
647bool RooAbsOptTestStatistic::setDataSlave(RooAbsData& indata, bool cloneData, bool ownNewData)
648{
649
650 if (operMode()==SimMaster) {
651 //cout << "ROATS::setDataSlave() ERROR this is SimMaster _funcClone = " << _funcClone << endl ;
652 return false ;
653 }
654
655 //cout << "ROATS::setDataSlave() new dataset size = " << indata.numEntries() << endl ;
656 //indata.Print("v") ;
657
658
659 // If the current dataset is owned, transfer the ownership to unique pointer
660 // that will get out of scope at the end of this function. We can't delete it
661 // right now, because there might be global observables in the model that
662 // first need to be redirected to the new dataset with a later call to
663 // RooAbsArg::recursiveRedirectServers.
664 std::unique_ptr<RooAbsData> oldOwnedData;
665 if (_ownData) {
666 oldOwnedData.reset(_dataClone);
667 _dataClone = nullptr ;
668 }
669
670 if (!cloneData && !_rangeName.empty()) {
671 coutW(InputArguments) << "RooAbsOptTestStatistic::setData(" << GetName() << ") WARNING: test statistic was constructed with range selection on data, "
672 << "ignoring request to _not_ clone the input dataset" << endl ;
673 cloneData = true ;
674 }
675
676 if (cloneData) {
677 // Cloning input dataset
678 if (_rangeName.empty()) {
679 _dataClone = std::unique_ptr<RooAbsData>{indata.reduce(*indata.get())}.release();
680 } else {
681 _dataClone = std::unique_ptr<RooAbsData>{indata.reduce(RooFit::SelectVars(*indata.get()),RooFit::CutRange(_rangeName.c_str()))}.release();
682 }
683 _ownData = true ;
684
685 } else {
686
687 // Taking input dataset
688 _dataClone = &indata ;
689 _ownData = ownNewData ;
690
691 }
692
693 // Attach function clone to dataset
695 _dataClone->setDirtyProp(false) ;
696 _data = _dataClone ;
697
698 // ReCache constant nodes with dataset
699 if (!_cachedNodes.empty()) {
701 }
702
703 // Adjust internal event count
704 setEventCount(indata.numEntries()) ;
705
706 setValueDirty() ;
707
708 // It would be unusual if the global observables are used in the likelihood
709 // outside of the constraint terms, but if they are we have to be consistent
710 // and also redirect them to the snapshots in the dataset if appropriate.
713 }
714
715 return true ;
716}
717
718
719
720
721////////////////////////////////////////////////////////////////////////////////
722
724{
725 if (_sealed) {
726 bool notice = (sealNotice() && strlen(sealNotice())) ;
727 coutW(ObjectHandling) << "RooAbsOptTestStatistic::data(" << GetName()
728 << ") WARNING: object sealed by creator - access to data is not permitted: "
729 << (notice?sealNotice():"<no user notice>") << endl ;
730 static RooDataSet dummy ("dummy","dummy",RooArgSet()) ;
731 return dummy ;
732 }
733 return *_dataClone ;
734}
735
736
737////////////////////////////////////////////////////////////////////////////////
738
740{
741 if (_sealed) {
742 bool notice = (sealNotice() && strlen(sealNotice())) ;
743 coutW(ObjectHandling) << "RooAbsOptTestStatistic::data(" << GetName()
744 << ") WARNING: object sealed by creator - access to data is not permitted: "
745 << (notice?sealNotice():"<no user notice>") << endl ;
746 static RooDataSet dummy ("dummy","dummy",RooArgSet()) ;
747 return dummy ;
748 }
749 return *_dataClone ;
750}
751
752
753////////////////////////////////////////////////////////////////////////////////
754/// Inspect PDF to find out if we are doing a binned fit to a 1-dimensional unbinned PDF.
755/// If this is the case, enable finer sampling of bins by wrapping PDF into a RooBinSamplingPdf.
756/// The member _integrateBinsPrecision decides how we act:
757/// - < 0: Don't do anything.
758/// - = 0: Only enable feature if fitting unbinned PDF to RooDataHist.
759/// - > 0: Enable as requested.
761
762 auto& pdf = static_cast<RooAbsPdf&>(*_funcClone);
765 _funcClone = newPdf.release();
766 }
767
768}
769
770
771/// Returns a suffix string that is unique for RooAbsOptTestStatistic
772/// instances that don't share the same cloned input data object.
774 return Form("_%lx", _dataClone->uniqueId().value()) ;
775}
776
777
778void RooAbsOptTestStatistic::runRecalculateCache(std::size_t firstEvent, std::size_t lastEvent, std::size_t stepSize) const
779{
780 _dataClone->store()->recalculateCache(_projDeps, firstEvent, lastEvent, stepSize, _skipZeroWeights);
781}
#define e(i)
Definition RSha256.hxx:103
bool _sealed
Is test statistic sealed – i.e. no access to data.
bool _skipZeroWeights
! Whether to skip entries with weight zero in the evaluation
double _integrateBinsPrecision
TString _sealNotice
User-defined notice shown when reading a sealed likelihood.
#define coutI(a)
#define cxcoutI(a)
#define coutW(a)
#define cxcoutW(a)
#define coutE(a)
#define ClassImp(name)
Definition Rtypes.h:377
static void indent(ostringstream &buf, int indent_level)
char name[80]
Definition TGX11.cxx:110
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2489
bool recursiveRedirectServers(const RooAbsCollection &newServerList, bool mustReplaceAll=false, bool nameChange=false, bool recurseInNewSet=true)
Recursively replace all servers with the new servers in newSet.
RooFit::OwningPtr< RooArgSet > getParameters(const RooAbsData *data, bool stripDisconnected=true) const
Create a list of leaf nodes in the arg tree starting with ourself as top node that don't match any of...
RooFit::OwningPtr< RooArgSet > getObservables(const RooArgSet &set, bool valueOnly=true) const
Given a set of possible observables, return the observables that this PDF depends on.
bool addOwnedComponents(const RooAbsCollection &comps)
Take ownership of the contents of 'comps'.
bool findConstantNodes(const RooArgSet &observables, RooArgSet &cacheList)
Find branch nodes with all-constant parameters, and add them to the list of nodes that can be cached ...
void printCompactTree(const char *indent="", const char *fileName=nullptr, const char *namePat=nullptr, RooAbsArg *client=nullptr)
Print tree structure of expression tree on stdout, or to file if filename is specified.
void setValueDirty()
Mark the element dirty. This forces a re-evaluation when a value is requested.
Definition RooAbsArg.h:488
bool getAttribute(const Text_t *name) const
Check if a named attribute is set. By default, all attributes are unset.
virtual void optimizeCacheMode(const RooArgSet &observables)
Activate cache mode optimization with given definition of observables.
void setAttribute(const Text_t *name, bool value=true)
Set (default) or clear a named boolean attribute of this object.
void branchNodeServerList(RooAbsCollection *list, const RooAbsArg *arg=nullptr, bool recurseNonDerived=false) const
Fill supplied list with all branch nodes of the arg tree starting with ourself as top node.
virtual RooAbsReal * highBoundFunc() const
Return pointer to RooAbsReal parameterized upper bound, if any.
virtual RooAbsReal * lowBoundFunc() const
Return pointer to RooAbsReal parameterized lower bound, if any.
Abstract container object that can hold multiple RooAbsArg objects.
RooAbsCollection * selectByAttrib(const char *name, bool value) const
Create a subset of the current collection, consisting only of those elements with the specified attri...
virtual void removeAll()
Remove all arguments from our set, deleting them if we own them.
virtual bool remove(const RooAbsArg &var, bool silent=false, bool matchByNameOnly=false)
Remove the specified argument from our list.
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
void setAttribAll(const Text_t *name, bool value=true)
Set given attribute in each element of the collection by calling each elements setAttribute() functio...
Storage_t::size_type size() const
RooAbsArg * first() const
bool selectCommon(const RooAbsCollection &refColl, RooAbsCollection &outColl) const
Create a subset of the current collection, consisting only of those elements that are contained as we...
RooAbsArg * find(const char *name) const
Find object with given name in list.
virtual const RooAbsArg * cacheOwner()=0
virtual void forceCacheUpdate()
virtual void recalculateCache(const RooArgSet *, Int_t, Int_t, Int_t, bool)
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:57
virtual const RooArgSet * get() const
Definition RooAbsData.h:101
RooAbsDataStore * store()
Definition RooAbsData.h:77
RooFit::UniqueId< RooAbsData > const & uniqueId() const
Returns a unique ID that is different for every instantiated RooAbsData object.
Definition RooAbsData.h:308
void setDirtyProp(bool flag)
Control propagation of dirty flags from observables in dataset.
RooFit::OwningPtr< RooAbsData > reduce(const RooCmdArg &arg1, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={})
Create a reduced copy of this dataset.
virtual void setArgStatus(const RooArgSet &set, bool active)
virtual void cacheArgs(const RooAbsArg *owner, RooArgSet &varSet, const RooArgSet *nset=nullptr, bool skipZeroWeights=false)
Internal method – Cache given set of functions with data.
virtual void optimizeReadingWithCaching(RooAbsArg &arg, const RooArgSet &cacheList, const RooArgSet &keepObsList)
Prepare dataset for use with cached constant terms listed in 'cacheList' of expression 'arg'.
bool hasFilledCache() const
virtual Int_t numEntries() const
Return number of entries in dataset, i.e., count unweighted entries.
RooArgSet const * getGlobalObservables() const
Returns snapshot of global observables stored in this data.
Definition RooAbsData.h:288
virtual void resetCache()
Internal method – Remove cached function values.
void attachBuffers(const RooArgSet &extObs)
Abstract base class for test statistics objects that evaluate a function or PDF at each point of a gi...
bool setDataSlave(RooAbsData &data, bool cloneData=true, bool ownNewDataAnyway=false) override
Change dataset that is used to given one.
~RooAbsOptTestStatistic() override
Destructor.
RooAbsReal * _funcClone
Pointer to internal clone of input function.
bool _sealed
Is test statistic sealed – i.e. no access to data.
void optimizeConstantTerms(bool, bool=true)
Driver function to activate global constant term optimization.
double combinedValue(RooAbsReal **gofArray, Int_t nVal) const override
Method to combined test statistic results calculated into partitions into the global result.
void runRecalculateCache(std::size_t firstEvent, std::size_t lastEvent, std::size_t stepSize) const override
bool _ownData
Do we own the dataset.
void optimizeCaching()
This method changes the value caching logic for all nodes that depends on any of the observables as d...
const char * sealNotice() const
bool _skipZeroWeights
! Whether to skip entries with weight zero in the evaluation
RooArgSet * _funcObsSet
List of observables in the pdf expression.
RooAbsOptTestStatistic(const char *name, const char *title, RooAbsReal &real, RooAbsData &data, const RooArgSet &projDeps, RooAbsTestStatistic::Configuration const &cfg)
Create a test statistic, and optimise its calculation.
void constOptimizeTestStatistic(ConstOpCode opcode, bool doAlsoTrackingOpt=true) override
Driver function to propagate constant term optimizations in test statistic.
void setUpBinSampling()
Inspect PDF to find out if we are doing a binned fit to a 1-dimensional unbinned PDF.
bool redirectServersHook(const RooAbsCollection &newServerList, bool mustReplaceAll, bool nameChange, bool isRecursive) override
Catch server redirect calls and forward to internal clone of function.
RooArgSet _cachedNodes
! List of nodes that are cached as constant expressions
void initSlave(RooAbsReal &real, RooAbsData &indata, const RooArgSet &projDeps, const char *rangeName, const char *addCoefRangeName)
void printCompactTreeHook(std::ostream &os, const char *indent="") override
Catch print hook function and forward to function clone.
RooArgSet * _normSet
Pointer to set with observables used for normalization.
const char * cacheUniqueSuffix() const override
Returns a suffix string that is unique for RooAbsOptTestStatistic instances that don't share the same...
RooArgSet * _funcCloneSet
Set owning all components of internal clone of input function.
RooAbsData * _dataClone
Pointer to internal clone if input data.
virtual RooArgSet requiredExtraObservables() const
RooArgSet * _projDeps
Set of projected observable.
Abstract interface for all probability density functions.
Definition RooAbsPdf.h:40
Abstract base class for objects that represent a real value that may appear on the left hand side of ...
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.
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:59
double getVal(const RooArgSet *normalisationSet=nullptr) const
Evaluate object.
Definition RooAbsReal.h:103
virtual double getValV(const RooArgSet *normalisationSet=nullptr) const
Return value of object.
virtual void fixAddCoefNormalization(const RooArgSet &addNormSet=RooArgSet(), bool force=true)
Fix the interpretation of the coefficient of any RooAddPdf component in the expression tree headed by...
bool redirectServersHook(const RooAbsCollection &newServerList, bool mustReplaceAll, bool nameChange, bool isRecursiveStep) override
Function that is called at the end of redirectServers().
virtual void fixAddCoefRange(const char *rangeName=nullptr, bool force=true)
Fix the interpretation of the coefficient of any RooAddPdf component in the expression tree headed by...
Abstract base class for all test statistics.
double _evalCarry
! carry of Kahan sum in evaluatePartition
std::string _addCoefRangeName
Name of reference to be used for RooAddPdf components.
GOFOpMode operMode() const
RooSetProxy _paramSet
Parameters of the test statistic (=parameters of the input function)
RooAbsReal * _func
Pointer to original input function.
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.
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.
void setEventCount(Int_t nEvents)
virtual double getCarry() const
RooAbsData * _data
Pointer to original input dataset.
const bool _takeGlobalObservablesFromData
If the global observable values are taken from data.
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:55
RooArgSet * snapshot(bool deepCopy=true) const
Use RooAbsCollection::snapshot(), but return as RooArgSet.
Definition RooArgSet.h:178
static std::unique_ptr< RooAbsPdf > create(RooAbsPdf &pdf, RooAbsData const &data, double precision)
Creates a wrapping RooBinSamplingPdf if appropriate.
bool add(const RooAbsArg &var, bool valueServer, bool shapeServer, bool silent)
Overloaded RooCollection_t::add() method insert object into set and registers object as server to own...
Container class to hold unbinned data.
Definition RooDataSet.h:57
static void softAbort()
Soft abort function that interrupts macro execution but doesn't kill ROOT.
Efficient implementation of a product of PDFs of the form.
Definition RooProdPdf.h:33
RooArgSet * getConnectedParameters(const RooArgSet &observables) const
Return all parameter constraint p.d.f.s on parameters listed in constrainedParams.
Variable that can be changed from the outside.
Definition RooRealVar.h:37
const RooAbsBinning & getBinning(const char *name=nullptr, bool verbose=true, bool createOnTheFly=false) const override
Return binning definition with name.
Uses std::vector to store data columns.
TObject * Clone(const char *newname="") const override
Make a clone of an object using the Streamer facility.
Definition TNamed.cxx:74
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:207
Basic string class.
Definition TString.h:139
const char * Data() const
Definition TString.h:378
RooCmdArg SelectVars(const RooArgSet &vars)
RooCmdArg CutRange(const char *rangeName)
Double_t y[n]
Definition legend1.C:17
const Int_t n
Definition legend1.C:16
std::vector< std::string > Split(std::string_view str, std::string_view delims, bool skipEmpty=false)
Splits a string at each character in delims.
std::unique_ptr< T > cloneTreeWithSameParameters(T const &arg, RooArgSet const *observables=nullptr)
Clone RooAbsArg object and reattach to original parameters.
constexpr Value_t value() const
Return numerical value of ID.
Definition UniqueId.h:59
static uint64_t sum(uint64_t i)
Definition Factory.cxx:2345