Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
HistoToWorkspaceFactoryFast.cxx
Go to the documentation of this file.
1// @(#)root/roostats:$Id: cranmer $
2// Author: Kyle Cranmer, Akira Shibata
3/*************************************************************************
4 * Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
5 * All rights reserved. *
6 * *
7 * For the licensing terms see $ROOTSYS/LICENSE. *
8 * For the list of contributors see $ROOTSYS/README/CREDITS. *
9 *************************************************************************/
10
11////////////////////////////////////////////////////////////////////////////////
12
13/** \class RooStats::HistFactory::HistoToWorkspaceFactoryFast
14 * \ingroup HistFactory
15 * This class provides helper functions for creating likelihood models from histograms.
16 * It is used by RooStats::HistFactory::MakeModelAndMeasurementFast.
17 *
18 * A tutorial showing how to create a HistFactory model is hf001_example.C
19 */
20
21
22#include <RooAddition.h>
23#include <RooBinWidthFunction.h>
24#include <RooBinning.h>
25#include <RooCategory.h>
26#include <RooConstVar.h>
27#include <RooDataHist.h>
28#include <RooDataSet.h>
29#include <RooFit/ModelConfig.h>
30#include <RooFitResult.h>
31#include <RooFormulaVar.h>
32#include <RooGamma.h>
33#include <RooGaussian.h>
34#include <RooGlobalFunc.h>
35#include <RooHelpers.h>
36#include <RooHistFunc.h>
37#include <RooNumIntConfig.h>
38#include <RooPoisson.h>
39#include <RooPolyVar.h>
40#include <RooProdPdf.h>
41#include <RooProduct.h>
42#include <RooRandom.h>
43#include <RooRealSumPdf.h>
44#include <RooRealVar.h>
45#include <RooSimultaneous.h>
46#include <RooWorkspace.h>
47
52
53#include "HFMsgService.h"
54
55#include "TH1.h"
56
57// specific to this package
64
65#include <algorithm>
66#include <fstream>
67#include <iomanip>
68#include <memory>
69#include <set>
70#include <utility>
71
72constexpr double alphaLow = -5.0;
73constexpr double alphaHigh = 5.0;
74
75std::vector<double> histToVector(TH1 const &hist)
76{
77 // Must get the full size of the TH1 (No direct method to do this...)
78 int numBins = hist.GetNbinsX() * hist.GetNbinsY() * hist.GetNbinsZ();
79 std::vector<double> out(numBins);
80 int histIndex = 0;
81 for (int i = 0; i < numBins; ++i) {
82 while (hist.IsBinUnderflow(histIndex) || hist.IsBinOverflow(histIndex)) {
83 ++histIndex;
84 }
85 out[i] = hist.GetBinContent(histIndex);
86 ++histIndex;
87 }
88 return out;
89}
90
91// use this order for safety on library loading
92using namespace RooStats;
93using std::string, std::vector;
94
95using namespace RooStats::HistFactory::Detail;
97
98namespace RooStats::HistFactory {
99
104
106 Configuration const& cfg) :
107 fSystToFix( measurement.GetConstantParams() ),
108 fParamValues( measurement.GetParamValues() ),
109 fNomLumi( measurement.GetLumi() ),
110 fLumiError( measurement.GetLumi()*measurement.GetLumiRelErr() ),
111 fLowBin( measurement.GetBinLow() ),
112 fHighBin( measurement.GetBinHigh() ),
113 fCfg{cfg} {
114
115 // Set Preprocess functions
116 SetFunctionsToPreprocess( measurement.GetPreprocessFunctions() );
117
118 }
119
120 void HistoToWorkspaceFactoryFast::ConfigureWorkspaceForMeasurement( const std::string& ModelName, RooWorkspace* ws_single, Measurement& measurement ) {
121
122 // Configure a workspace by doing any
123 // necessary post-processing and by
124 // creating a ModelConfig
125
126 // Make a ModelConfig and configure it
127 ModelConfig * proto_config = static_cast<ModelConfig *>(ws_single->obj("ModelConfig"));
128 if( proto_config == nullptr ) {
129 cxcoutFHF << "Error: Did not find 'ModelConfig' object in file: " << ws_single->GetName() << std::endl;
130 throw hf_exc();
131 }
132
133 if( measurement.GetPOIList().empty() ) {
134 cxcoutWHF << "No Parametetrs of interest are set" << std::endl;
135 }
136
137
138 std::stringstream sstream;
139 sstream << "Setting Parameter(s) of Interest as: ";
140 for(auto const& item : measurement.GetPOIList()) {
141 sstream << item << " ";
142 }
143 cxcoutIHF << sstream.str() << std::endl;
144
145 RooArgSet params;
146 for(auto const& poi_name : measurement.GetPOIList()) {
147 if(RooRealVar* poi = (RooRealVar*) ws_single->var(poi_name)){
148 params.add(*poi);
149 }
150 else {
151 cxcoutWHF << "WARNING: Can't find parameter of interest: " << poi_name
152 << " in Workspace. Not setting in ModelConfig." << std::endl;
153 // throw hf_exc();
154 }
155 }
156 proto_config->SetParametersOfInterest(params);
157
158 // Name of an 'edited' model, if necessary
159 std::string NewModelName = "newSimPdf"; // <- This name is hard-coded in HistoToWorkspaceFactoryFast::EditSyt. Probably should be changed to : std::string("new") + ModelName;
160
161 // Get the pdf
162 // Notice that we get the "new" pdf, this is the one that is
163 // used in the creation of these asimov datasets since they
164 // are fitted (or may be, at least).
165 RooAbsPdf* pdf = ws_single->pdf(NewModelName);
166 if( !pdf ) pdf = ws_single->pdf( ModelName );
167 const RooArgSet* observables = ws_single->set("observables");
168
169 // Set the ModelConfig's Params of Interest
170 if(!measurement.GetPOIList().empty()){
171 proto_config->GuessObsAndNuisance(*observables, RooMsgService::instance().isActive(nullptr, RooFit::HistFactory, RooFit::INFO));
172 }
173
174 // Now, let's loop over any additional asimov datasets
175 // that we need to make
176
177 // Create a SnapShot of the nominal values
178 std::string SnapShotName = "NominalParamValues";
179 ws_single->saveSnapshot(SnapShotName, ws_single->allVars());
180
181 for( unsigned int i=0; i<measurement.GetAsimovDatasets().size(); ++i) {
182
183 // Set the variable values and "const" ness with the workspace
184 RooStats::HistFactory::Asimov& asimov = measurement.GetAsimovDatasets().at(i);
185 std::string AsimovName = asimov.GetName();
186
187 cxcoutPHF << "Generating additional Asimov Dataset: " << AsimovName << std::endl;
188 asimov.ConfigureWorkspace(ws_single);
189 std::unique_ptr<RooAbsData> asimov_dataset{AsymptoticCalculator::GenerateAsimovData(*pdf, *observables)};
190
191 cxcoutPHF << "Importing Asimov dataset" << std::endl;
192 bool failure = ws_single->import(*asimov_dataset, RooFit::Rename(AsimovName.c_str()));
193 if( failure ) {
194 cxcoutFHF << "Error: Failed to import Asimov dataset: " << AsimovName << std::endl;
195 throw hf_exc();
196 }
197
198 // Load the snapshot at the end of every loop iteration
199 // so we start each loop with a "clean" snapshot
200 ws_single->loadSnapshot(SnapShotName.c_str());
201 }
202
203 // Cool, we're done
204 return; // ws_single;
205 }
206
207
208 // We want to eliminate this interface and use the measurement directly
210
211 // This is a pretty light-weight wrapper function
212 //
213 // Take a fully configured measurement as well as
214 // one of its channels
215 //
216 // Return a workspace representing that channel
217 // Do this by first creating a vector of EstimateSummary's
218 // and this by configuring the workspace with any post-processing
219
220 // Get the channel's name
221 string ch_name = channel.GetName();
222
223 // Create a workspace for a SingleChannel from the Measurement Object
224 std::unique_ptr<RooWorkspace> ws_single{this->MakeSingleChannelWorkspace(measurement, channel)};
225 if( ws_single == nullptr ) {
226 cxcoutFHF << "Error: Failed to make Single-Channel workspace for channel: " << ch_name
227 << " and measurement: " << measurement.GetName() << std::endl;
228 throw hf_exc();
229 }
230
231 // Finally, configure that workspace based on
232 // properties of the measurement
233 HistoToWorkspaceFactoryFast::ConfigureWorkspaceForMeasurement( "model_"+ch_name, ws_single.get(), measurement );
234
235 return RooFit::makeOwningPtr(std::move(ws_single));
236
237 }
238
240
241 // This function takes a fully configured measurement
242 // which may contain several channels and returns
243 // a workspace holding the combined model
244 //
245 // This can be used, for example, within a script to produce
246 // a combined workspace on-the-fly
247 //
248 // This is a static function (for now) to make
249 // it a one-liner
250
251
252 Configuration config;
253 return MakeCombinedModel(measurement,config);
254 }
255
257
258 // This function takes a fully configured measurement
259 // which may contain several channels and returns
260 // a workspace holding the combined model
261 //
262 // This can be used, for example, within a script to produce
263 // a combined workspace on-the-fly
264 //
265 // This is a static function (for now) to make
266 // it a one-liner
267
269
270 // First, we create an instance of a HistFactory
271 HistoToWorkspaceFactoryFast histFactory(measurement, config);
272
273 // Loop over the channels and create the individual workspaces
274 std::vector<std::unique_ptr<RooWorkspace>> channel_workspaces;
275 std::vector<std::string> channel_names;
276
277 for(HistFactory::Channel& channel : measurement.GetChannels()) {
278
279 if( ! channel.CheckHistograms() ) {
280 cxcoutFHF << "MakeModelAndMeasurementsFast: Channel: " << channel.GetName()
281 << " has uninitialized histogram pointers" << std::endl;
282 throw hf_exc();
283 }
284
285 string ch_name = channel.GetName();
286 channel_names.push_back(ch_name);
287
288 // GHL: Renaming to 'MakeSingleChannelWorkspace'
289 channel_workspaces.emplace_back(histFactory.MakeSingleChannelModel(measurement, channel));
290 }
291
292
293 // Now, combine the individual channel workspaces to
294 // form the combined workspace
295 std::unique_ptr<RooWorkspace> ws{histFactory.MakeCombinedModel( channel_names, channel_workspaces )};
296
297
298 // Configure the workspace
300
301 // Done. Return the pointer
302 return RooFit::makeOwningPtr(std::move(ws));
303
304 }
305
306namespace {
307
308template <class Arg_t, typename... Args_t>
309Arg_t &emplace(RooWorkspace &ws, std::string const &name, Args_t &&...args)
310{
311 Arg_t arg{name.c_str(), name.c_str(), std::forward<Args_t>(args)...};
313 return *dynamic_cast<Arg_t *>(ws.arg(name));
314}
315
316
317/// Check whether all channel workspaces contain consistent datasets.
318///
319/// This function compares the datasets stored in each channel workspace against
320/// those in the first workspace.
321///
322/// \param chs Vector of channel workspaces to compare (first is the reference).
323/// \param ch_names Names of the channels, used for error reporting.
324/// \param allowedInconsistent Dataset names that are allowed to differ between channels.
325///
326/// \return A pair consisting of:
327/// - bool: true if all channels are consistent (after ignoring allowed datasets),
328/// false otherwise.
329/// - std::string: empty if consistent; otherwise, a detailed error message
330/// describing the inconsistencies.
331
332std::pair<bool, std::string> isChannelDataConsistent(std::vector<std::unique_ptr<RooWorkspace>> const &chs,
333 std::vector<std::string> const &ch_names,
334 std::set<std::string> const &allowedInconsistent)
335{
336 // Collect the reference list of dataset names from the first workspace
337 std::set<std::string> referenceDataNames;
338 for (RooAbsData *data : chs[0]->allData()) {
339 referenceDataNames.insert(data->GetName());
340 }
341
342 // Check that all other workspaces have the same datasets
343 for (std::size_t i = 1; i < chs.size(); ++i) {
344 std::set<std::string> thisDataNames;
345 for (RooAbsData *data : chs[i]->allData()) {
346 thisDataNames.insert(data->GetName());
347 }
348
349 // Find missing and extra datasets in this workspace
350 std::vector<std::string> missing;
351 std::vector<std::string> extra;
352 std::set_difference(referenceDataNames.begin(), referenceDataNames.end(), thisDataNames.begin(),
353 thisDataNames.end(), std::back_inserter(missing));
354 std::set_difference(thisDataNames.begin(), thisDataNames.end(), referenceDataNames.begin(),
355 referenceDataNames.end(), std::back_inserter(extra));
356
357 // Remove allowed inconsistencies
358 auto isAllowed = [&](std::string const &name) { return allowedInconsistent.count(name) != 0; };
359
360 missing.erase(std::remove_if(missing.begin(), missing.end(), isAllowed), missing.end());
361 extra.erase(std::remove_if(extra.begin(), extra.end(), isAllowed), extra.end());
362
363 if (!missing.empty() || !extra.empty()) {
364 std::stringstream errMsg;
365 errMsg << "ERROR: Inconsistent datasets across channel workspaces.\n"
366 << "Workspace for channel \"" << ch_names[i] << "\" does not match "
367 << "the datasets in channel \"" << ch_names[0] << "\".\n";
368
369 if (!missing.empty()) {
370 errMsg << " Missing datasets:\n";
371 for (const auto &name : missing) {
372 errMsg << " - " << name << "\n";
373 }
374 }
375
376 if (!extra.empty()) {
377 errMsg << " Extra datasets:\n";
378 for (const auto &name : extra) {
379 errMsg << " - " << name << "\n";
380 }
381 }
382
383 errMsg << "All channel workspaces must contain exactly the same datasets.\n";
384 return {false, errMsg.str()};
385 }
386 }
387 return {true, ""};
388}
389
390} // namespace
391
392/// Create observables of type RooRealVar. Creates 1 to 3 observables, depending on the type of the histogram.
394 RooArgList observables;
395
396 for (unsigned int idx=0; idx < fObsNameVec.size(); ++idx) {
397 if (!proto.var(fObsNameVec[idx])) {
398 const TAxis *axis = (idx == 0) ? hist->GetXaxis() : (idx == 1 ? hist->GetYaxis() : hist->GetZaxis());
399 int nbins = axis->GetNbins();
400 // create observable
401 RooRealVar &obs = emplace<RooRealVar>(proto, fObsNameVec[idx], axis->GetXmin(), axis->GetXmax());
402 if(strlen(axis->GetTitle())>0) obs.SetTitle(axis->GetTitle());
403 obs.setBins(nbins);
404 if (axis->IsVariableBinSize()) {
405 RooBinning binning(nbins, axis->GetXbins()->GetArray());
406 obs.setBinning(binning);
407 }
408 }
409
410 observables.add(*proto.var(fObsNameVec[idx]));
411 }
412
413 return observables;
414}
415
416 /// Create the nominal hist function from `hist`, and register it in the workspace.
418 const RooArgList& observables) const {
419 if(hist) {
420 cxcoutI(HistFactory) << "processing hist " << hist->GetName() << std::endl;
421 } else {
422 cxcoutF(HistFactory) << "hist is empty" << std::endl;
423 R__ASSERT(hist != nullptr);
424 return nullptr;
425 }
426
427 // determine histogram dimensionality
428 unsigned int histndim(1);
429 std::string classname = hist->ClassName();
430 if (classname.find("TH1")==0) { histndim=1; }
431 else if (classname.find("TH2")==0) { histndim=2; }
432 else if (classname.find("TH3")==0) { histndim=3; }
433 R__ASSERT( histndim==fObsNameVec.size() );
434
435 prefix += "_Hist_alphanominal";
436
437 RooDataHist histDHist(prefix + "DHist","",observables,hist);
438
439 return &emplace<RooHistFunc>(proto, prefix, observables,histDHist,0);
440 }
441
442 namespace {
443
444 void makeGaussianConstraint(RooAbsArg& param, RooWorkspace& proto, bool isUniform,
445 std::vector<std::string> & constraintTermNames) {
446 std::string paramName = param.GetName();
447 std::string nomName = "nom_" + paramName;
448 std::string constraintName = paramName + "Constraint";
449
450 // do nothing if the constraint term already exists
451 if(proto.pdf(constraintName)) return;
452
453 // case systematic is uniform (assume they are like a Gaussian but with
454 // a large width (100 instead of 1)
455 const double gaussSigma = isUniform ? 100. : 1.0;
456 if (isUniform) {
457 cxcoutIHF << "Added a uniform constraint for " << paramName << " as a Gaussian constraint with a very large sigma " << std::endl;
458 }
459
460 constraintTermNames.emplace_back(constraintName);
461 RooRealVar &paramVar = *proto.var(paramName);
462 RooRealVar &nomParam = emplace<RooRealVar>(proto, nomName, 0., -10., 10.);
463 nomParam.setConstant();
464 emplace<RooGaussian>(proto, constraintName, paramVar, nomParam, gaussSigma);
465 paramVar.setError(gaussSigma); // give param initial error to match gaussSigma
466 const_cast<RooArgSet*>(proto.set("globalObservables"))->add(nomParam);
467 }
468
469 /// Make list of abstract parameters that interpolate in space of variations.
470 RooArgList makeInterpolationParameters(std::vector<HistoSys> const& histoSysList, RooWorkspace& proto) {
471 RooArgList params( ("alpha_Hist") );
472
473 for(auto const& histoSys : histoSysList) {
474 params.add(getOrCreate<RooRealVar>(proto, "alpha_" + histoSys.GetName(), alphaLow, alphaHigh));
475 }
476
477 return params;
478 }
479
480 /// Create a linear interpolation object that holds nominal and systematics, import it into the workspace,
481 /// and return a pointer to it.
482 RooAbsArg* makeLinInterp(RooArgList const& interpolationParams,
483 RooHistFunc* nominalFunc,
484 RooWorkspace& proto, const std::vector<HistoSys>& histoSysList,
485 const string& prefix,
486 const RooArgList& obsList) {
487
488 // now make function that linearly interpolates expectation between variations
489 // get low/high variations to interpolate between
490 RooArgSet lowSet;
491 RooArgSet highSet;
492 for(unsigned int j=0; j<histoSysList.size(); ++j){
493 std::string str = prefix + "_" + std::to_string(j);
494
495 const HistoSys& histoSys = histoSysList.at(j);
496 auto lowDHist = std::make_unique<RooDataHist>(str+"lowDHist","",obsList, histoSys.GetHistoLow());
497 auto highDHist = std::make_unique<RooDataHist>(str+"highDHist","",obsList, histoSys.GetHistoHigh());
498 lowSet.addOwned(std::make_unique<RooHistFunc>((str+"low").c_str(),"",obsList,std::move(lowDHist),0));
499 highSet.addOwned(std::make_unique<RooHistFunc>((str+"high").c_str(),"",obsList,std::move(highDHist),0));
500 }
501
502 // this is sigma(params), a piece-wise linear interpolation
503 PiecewiseInterpolation interp(prefix.c_str(),"",*nominalFunc,lowSet,highSet,interpolationParams);
504 interp.setPositiveDefinite();
505 interp.setAllInterpCodes(4); // LM: change to 4 (piece-wise linear to 6th order polynomial interpolation + linear extrapolation )
506 // KC: interpo codes 1 etc. don't have proper analytic integral.
507 RooArgSet obsSet(obsList);
508 interp.setBinIntegrator(obsSet);
509 interp.forceNumInt();
510
511 proto.import(interp, RooFit::RecycleConflictNodes()); // individual params have already been imported in first loop of this function
512
513 return proto.arg(prefix);
514 }
515
516 }
517
518 // GHL: Consider passing the NormFactor list instead of the entire sample
519 std::unique_ptr<RooProduct> HistoToWorkspaceFactoryFast::CreateNormFactor(RooWorkspace& proto, string& channel, string& sigmaEpsilon, Sample& sample, bool doRatio){
520
521 std::vector<string> prodNames;
522
523 vector<NormFactor> normList = sample.GetNormFactorList();
524 vector<string> normFactorNames;
525 vector<string> rangeNames;
526
527 string overallNorm_times_sigmaEpsilon = sample.GetName() + "_" + channel + "_scaleFactors";
528 auto sigEps = proto.arg(sigmaEpsilon);
529 assert(sigEps);
530 auto normFactor = std::make_unique<RooProduct>(overallNorm_times_sigmaEpsilon.c_str(), overallNorm_times_sigmaEpsilon.c_str(), RooArgList(*sigEps));
531
532 if(!normList.empty()){
533
534 for(NormFactor &norm : normList) {
535 string varname = norm.GetName();
536 if(doRatio) {
537 varname += "_" + channel;
538 }
539
540 // GHL: Check that the NormFactor doesn't already exist
541 // (it may have been created as a function expression
542 // during preprocessing)
543 std::stringstream range;
544 range << "[" << norm.GetVal() << "," << norm.GetLow() << "," << norm.GetHigh() << "]";
545
546 if( proto.obj(varname) == nullptr) {
547 cxcoutI(HistFactory) << "making normFactor: " << norm.GetName() << std::endl;
548 // remove "doRatio" and name can be changed when ws gets imported to the combined model.
549 emplace<RooRealVar>(proto, varname, norm.GetVal(), norm.GetLow(), norm.GetHigh());
550 proto.var(varname)->setError(0); // ensure factor is assigned an initial error, even if its zero
551 }
552
553 prodNames.push_back(varname);
554 rangeNames.push_back(range.str());
555 normFactorNames.push_back(varname);
556 }
557
558
559 for (const auto& name : prodNames) {
560 auto arg = proto.arg(name);
561 assert(arg);
562 normFactor->addTerm(arg);
563 }
564
565 }
566
567 unsigned int rangeIndex=0;
568 for( vector<string>::iterator nit = normFactorNames.begin(); nit!=normFactorNames.end(); ++nit){
569 if( count (normFactorNames.begin(), normFactorNames.end(), *nit) > 1 ){
570 cxcoutI(HistFactory) <<"<NormFactor Name =\""<<*nit<<"\"> is duplicated for <Sample Name=\""
571 << sample.GetName() << "\">, but only one factor will be included. \n Instead, define something like"
572 << "\n\t<Function Name=\""<<*nit<<"Squared\" Expression=\""<<*nit<<"*"<<*nit<<"\" Var=\""<<*nit<<rangeNames.at(rangeIndex)
573 << "\"> \nin your top-level XML's <Measurement> entry and use <NormFactor Name=\""<<*nit<<"Squared\" in your channel XML file."<< std::endl;
574 }
575 ++rangeIndex;
576 }
577
578 return normFactor;
579 }
580
582 string interpName,
583 std::vector<OverallSys>& systList,
584 vector<string>& constraintTermNames,
585 vector<string>& totSystTermNames) {
586
587 // add variables for all the relative overall uncertainties we expect
588 totSystTermNames.push_back(prefix);
589
590 RooArgSet params(prefix.c_str());
591 vector<double> lowVec;
592 vector<double> highVec;
593
594 std::map<std::string, double>::iterator itconstr;
595 for(unsigned int i = 0; i < systList.size(); ++i) {
596
597 OverallSys& sys = systList.at(i);
598 std::string strname = sys.GetName();
599 const char * name = strname.c_str();
600
601 // case of no systematic (is it possible)
602 if (meas.GetNoSyst().count(sys.GetName()) > 0 ) {
603 cxcoutI(HistFactory) << "HistoToWorkspaceFast::AddConstraintTerm - skip systematic " << sys.GetName() << std::endl;
604 continue;
605 }
606 // case systematic is a gamma constraint
607 if (meas.GetGammaSyst().count(sys.GetName()) > 0 ) {
608 double relerr = meas.GetGammaSyst().find(sys.GetName() )->second;
609 if (relerr <= 0) {
610 cxcoutI(HistFactory) << "HistoToWorkspaceFast::AddConstraintTerm - zero uncertainty assigned - skip systematic " << sys.GetName() << std::endl;
611 continue;
612 }
613 const double tauVal = 1./(relerr*relerr);
614 const double sqtau = 1./relerr;
615 RooRealVar &beta = emplace<RooRealVar>(proto, "beta_" + strname, 1., 0., 10.);
616 // the global observable (y_s)
617 RooRealVar &yvar = emplace<RooRealVar>(proto, "nom_" + std::string{beta.GetName()}, tauVal, 0., 10.);
618 // the rate of the gamma distribution (theta)
619 RooRealVar &theta = emplace<RooRealVar>(proto, "theta_" + strname, 1./tauVal);
620 // find alpha as function of beta
621 RooPolyVar &alphaOfBeta = emplace<RooPolyVar>(proto, "alphaOfBeta_" + strname, beta, RooArgList{-sqtau, sqtau});
622
623 // add now the constraint itself Gamma_beta_constraint(beta, y+1, tau, 0 )
624 // build the gamma parameter k = as y_s + 1
625 RooAddition &kappa = emplace<RooAddition>(proto, "k_" + std::string{yvar.GetName()}, RooArgList{yvar, 1.0});
626 RooGamma &gamma = emplace<RooGamma>(proto, std::string{beta.GetName()} + "Constraint", beta, kappa, theta, RooFit::RooConst(0.0));
628 alphaOfBeta.Print("t");
629 gamma.Print("t");
630 }
631 constraintTermNames.push_back(gamma.GetName());
632 // set global observables
633 yvar.setConstant(true);
634 const_cast<RooArgSet*>(proto.set("globalObservables"))->add(yvar);
635
636 // add alphaOfBeta in the list of params to interpolate
637 params.add(alphaOfBeta);
638 cxcoutI(HistFactory) << "Added a gamma constraint for " << name << std::endl;
639
640 }
641 else {
642 RooRealVar& alpha = getOrCreate<RooRealVar>(proto, prefix + sys.GetName(), 0, alphaLow, alphaHigh);
643 // add the Gaussian constraint part
644 const bool isUniform = meas.GetUniformSyst().count(sys.GetName()) > 0;
645 makeGaussianConstraint(alpha, proto, isUniform, constraintTermNames);
646
647 // check if exists a log-normal constraint
648 if (meas.GetLogNormSyst().count(sys.GetName()) == 0 && meas.GetGammaSyst().count(sys.GetName()) == 0 ) {
649 // just add the alpha for the parameters of the FlexibleInterpVar function
650 params.add(alpha);
651 }
652 // case systematic is a log-normal constraint
653 if (meas.GetLogNormSyst().count(sys.GetName()) > 0 ) {
654 // log normal constraint for parameter
655 const double relerr = meas.GetLogNormSyst().find(sys.GetName() )->second;
656
657 RooFormulaVar &alphaOfBeta = emplace<RooFormulaVar>(
658 proto, "alphaOfBeta_" + sys.GetName(), "x[0]*(pow(x[1],x[2])-1.)",
659 RooArgList{emplace<RooRealVar>(proto, "tau_" + sys.GetName(), 1. / relerr),
660 emplace<RooRealVar>(proto, "kappa_" + sys.GetName(), 1. + relerr), alpha});
661
662 cxcoutI(HistFactory) << "Added a log-normal constraint for " << name << std::endl;
664 alphaOfBeta.Print("t");
665 }
666 params.add(alphaOfBeta);
667 }
668
669 }
670 // add low/high vectors
671 lowVec.push_back(sys.GetLow());
672 highVec.push_back(sys.GetHigh());
673
674 } // end sys loop
675
676 if(!systList.empty()){
677 // this is epsilon(alpha_j), a piece-wise linear interpolation
678 // LinInterpVar interp( (interpName).c_str(), "", params, 1., lowVec, highVec);
679
680 assert(!params.empty());
681 assert(lowVec.size() == params.size());
682
683 FlexibleInterpVar interp( (interpName).c_str(), "", params, 1., lowVec, highVec);
684 interp.setAllInterpCodes(5); // LM: change to 5 (piece-wise exponential to 6th order polynomial interpolation + exponential extrapolation )
685 //interp.setAllInterpCodes(0); // simple linear interpolation
686 proto.import(interp); // params have already been imported in first loop of this function
687 } else{
688 // some strange behavior if params,lowVec,highVec are empty.
689 //cout << "WARNING: No OverallSyst terms" << std::endl;
690 emplace<RooConstVar>(proto, interpName, 1.); // params have already been imported in first loop of this function
691 }
692 }
693
694
696 const vector<RooProduct*>& sampleScaleFactors, std::vector<vector<RooAbsArg*>>& sampleHistFuncs) const {
697 assert(sampleScaleFactors.size() == sampleHistFuncs.size());
698
699 // for ith bin calculate totN_i = lumi * sum_j expected_j * syst_j
700
701 if (fObsNameVec.empty() && !fObsName.empty())
702 throw std::logic_error("HistFactory didn't process the observables correctly. Please file a bug report.");
703
704 auto firstHistFunc = dynamic_cast<const RooHistFunc*>(sampleHistFuncs.front().front());
705 if (!firstHistFunc) {
706 auto piecewiseInt = dynamic_cast<const PiecewiseInterpolation*>(sampleHistFuncs.front().front());
707 firstHistFunc = dynamic_cast<const RooHistFunc*>(piecewiseInt->nominalHist());
708 }
709 assert(firstHistFunc);
710
711 // Prepare a function to divide all bin contents by bin width to get a density:
712 auto &binWidth = emplace<RooBinWidthFunction>(proto, totName + "_binWidth", *firstHistFunc, true);
713
714 // Loop through samples and create products of their functions:
715 RooArgSet coefList;
716 RooArgSet shapeList;
717 for (unsigned int i=0; i < sampleHistFuncs.size(); ++i) {
718 assert(!sampleHistFuncs[i].empty());
719 coefList.add(*sampleScaleFactors[i]);
720
721 std::vector<RooAbsArg*>& thisSampleHistFuncs = sampleHistFuncs[i];
722 thisSampleHistFuncs.push_back(&binWidth);
723
724 if (thisSampleHistFuncs.size() == 1) {
725 // Just one function. Book it.
726 shapeList.add(*thisSampleHistFuncs.front());
727 } else {
728 // Have multiple functions. We need to multiply them.
729 std::string name = thisSampleHistFuncs.front()->GetName();
730 auto pos = name.find("Hist_alpha");
731 if (pos != std::string::npos) {
732 name = name.substr(0, pos) + "shapes";
733 } else if ( (pos = name.find("nominal")) != std::string::npos) {
734 name = name.substr(0, pos) + "shapes";
735 }
736
737 RooProduct shapeProduct(name.c_str(), thisSampleHistFuncs.front()->GetTitle(), RooArgSet(thisSampleHistFuncs.begin(), thisSampleHistFuncs.end()));
738 proto.import(shapeProduct, RooFit::RecycleConflictNodes());
739 shapeList.add(*proto.function(name));
740 }
741 }
742
743 // Sum all samples
744 RooRealSumPdf tot(totName.c_str(), totName.c_str(), shapeList, coefList, true);
745 tot.specialIntegratorConfig(true)->method1D().setLabel("RooBinIntegrator") ;
746 tot.specialIntegratorConfig(true)->method2D().setLabel("RooBinIntegrator") ;
747 tot.specialIntegratorConfig(true)->methodND().setLabel("RooBinIntegrator") ;
748 tot.forceNumInt();
749
750 // for mixed generation in RooSimultaneous
751 tot.setAttribute("GenerateBinned"); // for use with RooSimultaneous::generate in mixed mode
752
753 // Enable the binned likelihood optimization
755 tot.setAttribute("BinnedLikelihood");
756 }
757
758 proto.import(tot, RooFit::RecycleConflictNodes());
759 }
760
761 //////////////////////////////////////////////////////////////////////////////
762
764
765 std::ofstream covFile(filename);
766
767 covFile << " ";
768 for (auto const *myargi : static_range_cast<RooRealVar *>(*params)) {
769 if (myargi->isConstant())
770 continue;
771 covFile << " & " << myargi->GetName();
772 }
773 covFile << "\\\\ \\hline \n";
774 for (auto const *myargi : static_range_cast<RooRealVar *>(*params)) {
775 if(myargi->isConstant()) continue;
776 covFile << myargi->GetName();
777 for (auto const *myargj : static_range_cast<RooRealVar *>(*params)) {
778 if(myargj->isConstant()) continue;
779 std::cout << myargi->GetName() << "," << myargj->GetName();
780 double corr = result->correlation(*myargi, *myargj);
781 covFile << " & " << std::fixed << std::setprecision(2) << corr;
782 }
783 std::cout << std::endl;
784 covFile << " \\\\\n";
785 }
786
787 covFile.close();
788 }
789
790
791 ///////////////////////////////////////////////
792 std::unique_ptr<RooWorkspace> HistoToWorkspaceFactoryFast::MakeSingleChannelWorkspace(Measurement& measurement, Channel& channel) {
793
794 // check inputs (see JIRA-6890 )
795
796 if (channel.GetSamples().empty()) {
797 Error("MakeSingleChannelWorkspace",
798 "The input Channel does not contain any sample - return a nullptr");
799 return nullptr;
800 }
801
802 const TH1* channel_hist_template = channel.GetSamples().front().GetHisto();
803 if (channel_hist_template == nullptr) {
804 channel.CollectHistograms();
805 channel_hist_template = channel.GetSamples().front().GetHisto();
806 }
807 if (channel_hist_template == nullptr) {
808 std::ostringstream stream;
809 stream << "The sample " << channel.GetSamples().front().GetName()
810 << " in channel " << channel.GetName() << " does not contain a histogram. This is the channel:\n";
811 channel.Print(stream);
812 Error("MakeSingleChannelWorkspace", "%s", stream.str().c_str());
813 return nullptr;
814 }
815
816 if( ! channel.CheckHistograms() ) {
817 cxcoutFHF << "MakeSingleChannelWorkspace: Channel: " << channel.GetName()
818 << " has uninitialized histogram pointers" << std::endl;
819 throw hf_exc();
820 }
821
822
823
824 // Set these by hand inside the function
825 vector<string> systToFix = measurement.GetConstantParams();
826 bool doRatio=false;
827
828 //ES// string channel_name=summary[0].channel;
829 string channel_name = channel.GetName();
830
831 /// MB: reset observable names for each new channel.
832 fObsNameVec.clear();
833
834 /// MB: label observables x,y,z, depending on histogram dimensionality
835 /// GHL: Give it the first sample's nominal histogram as a template
836 /// since the data histogram may not be present
837 if (fObsNameVec.empty()) { GuessObsNameVec(channel_hist_template); }
838
839 for ( unsigned int idx=0; idx<fObsNameVec.size(); ++idx ) {
840 fObsNameVec[idx] = "obs_" + fObsNameVec[idx] + "_" + channel_name ;
841 }
842
843 if (fObsNameVec.empty()) {
844 fObsName= "obs_" + channel_name; // set name ov observable
845 fObsNameVec.push_back( fObsName );
846 }
847
848 if (fObsNameVec.empty() || fObsNameVec.size() > 3) {
849 throw hf_exc("HistFactory is limited to 1- to 3-dimensional histograms.");
850 }
851
852 cxcoutP(HistFactory) << "\n-----------------------------------------\n"
853 << "\tStarting to process '"
854 << channel_name << "' channel with " << fObsNameVec.size() << " observables"
855 << "\n-----------------------------------------\n" << std::endl;
856
857 //
858 // our main workspace that we are using to construct the model
859 //
860 auto protoOwner = std::make_unique<RooWorkspace>(channel_name.c_str(), (channel_name+" workspace").c_str());
861 RooWorkspace &proto = *protoOwner;
862 auto proto_config = std::make_unique<ModelConfig>("ModelConfig", &proto);
863
864 // preprocess functions
865 for(auto const& func : fPreprocessFunctions){
866 cxcoutI(HistFactory) << "will preprocess this line: " << func << std::endl;
867 proto.factory(func);
868 proto.Print();
869 }
870
871 RooArgSet likelihoodTerms("likelihoodTerms");
872 RooArgSet constraintTerms("constraintTerms");
873 vector<string> likelihoodTermNames;
874 vector<string> constraintTermNames;
875 vector<string> totSystTermNames;
876 // All histogram functions to be multiplied in each sample
877 std::vector<std::vector<RooAbsArg*>> allSampleHistFuncs;
878 std::vector<RooProduct*> sampleScaleFactors;
879
880 std::vector<std::pair<const TH1 *, std::unique_ptr<TH1>>> statHistPairs; // <nominal, error>
881 const std::string statFuncName = "mc_stat_" + channel_name;
882
883 /////////////////////////////
884 // shared parameters
885 // this is ratio of lumi to nominal lumi. We will include relative uncertainty in model
886 auto &lumiVar = getOrCreate<RooRealVar>(proto, "Lumi", fNomLumi, 0.0, 10 * fNomLumi);
887
888 // only include a lumiConstraint if there's a lumi uncert, otherwise just set the lumi constant
889 if(fLumiError != 0) {
890 auto &nominalLumiVar = emplace<RooRealVar>(proto, "nominalLumi", fNomLumi, 0., fNomLumi + 10. * fLumiError);
891 emplace<RooGaussian>(proto, "lumiConstraint", lumiVar, nominalLumiVar, fLumiError);
892 proto.var("Lumi")->setError(fLumiError/fNomLumi); // give initial error value
893 proto.var("nominalLumi")->setConstant();
894 proto.defineSet("globalObservables","nominalLumi");
895 //likelihoodTermNames.push_back("lumiConstraint");
896 constraintTermNames.push_back("lumiConstraint");
897 } else {
898 proto.var("Lumi")->setConstant();
899 proto.defineSet("globalObservables",RooArgSet()); // create empty set as is assumed it exists later
900 }
901 ///////////////////////////////////
902 // loop through estimates, add expectation, floating bin predictions,
903 // and terms that constrain floating to expectation via uncertainties
904 // GHL: Loop over samples instead, which doesn't contain the data
905 for (Sample& sample : channel.GetSamples()) {
906 string overallSystName = sample.GetName() + "_" + channel_name + "_epsilon";
907
908 string systSourcePrefix = "alpha_";
909
910 // constraintTermNames and totSystTermNames are vectors that are passed
911 // by reference and filled by this method
912 AddConstraintTerms(proto,measurement, systSourcePrefix, overallSystName,
913 sample.GetOverallSysList(), constraintTermNames , totSystTermNames);
914
915 allSampleHistFuncs.emplace_back();
916 std::vector<RooAbsArg*>& sampleHistFuncs = allSampleHistFuncs.back();
917
918 // GHL: Consider passing the NormFactor list instead of the entire sample
919 auto normFactors = CreateNormFactor(proto, channel_name, overallSystName, sample, doRatio);
920 assert(normFactors);
921
922 // Create the string for the object
923 // that is added to the RooRealSumPdf
924 // for this channel
925// string syst_x_expectedPrefix = "";
926
927 // get histogram
928 //ES// TH1* nominal = it->nominal;
929 const TH1* nominal = sample.GetHisto();
930
931 // MB : HACK no option to have both non-hist variations and hist variations ?
932 // get histogram
933 // GHL: Okay, this is going to be non-trivial.
934 // We will loop over histosys's, which contain both
935 // the low hist and the high hist together.
936
937 // Logic:
938 // - If we have no HistoSys's, do part A
939 // - else, if the histo syst's don't match, return (we ignore this case)
940 // - finally, we take the syst's and apply the linear interpolation w/ constraint
941 string expPrefix = sample.GetName() + "_" + channel_name;
942 // create roorealvar observables
943 RooArgList observables = createObservables(sample.GetHisto(), proto);
944 RooHistFunc* nominalHistFunc = MakeExpectedHistFunc(sample.GetHisto(), proto, expPrefix, observables);
945 assert(nominalHistFunc);
946
947 if(sample.GetHistoSysList().empty()) {
948 // If no HistoSys
949 cxcoutI(HistFactory) << sample.GetName() + "_" + channel_name + " has no variation histograms " << std::endl;
950
951 sampleHistFuncs.push_back(nominalHistFunc);
952 } else {
953 // If there ARE HistoSys(s)
954 // name of source for variation
955 string constraintPrefix = sample.GetName() + "_" + channel_name + "_Hist_alpha";
956
957 // make list of abstract parameters that interpolate in space of variations
958 RooArgList interpParams = makeInterpolationParameters(sample.GetHistoSysList(), proto);
959
960 // next, create the constraint terms
961 for(std::size_t i = 0; i < interpParams.size(); ++i) {
962 bool isUniform = measurement.GetUniformSyst().count(sample.GetHistoSysList()[i].GetName()) > 0;
963 makeGaussianConstraint(interpParams[i], proto, isUniform, constraintTermNames);
964 }
965
966 // finally, create the interpolated function
967 sampleHistFuncs.push_back( makeLinInterp(interpParams, nominalHistFunc, proto,
968 sample.GetHistoSysList(), constraintPrefix, observables) );
969 }
970
971 sampleHistFuncs.front()->SetTitle( (nominal && strlen(nominal->GetTitle())>0) ? nominal->GetTitle() : sample.GetName().c_str() );
972
973 ////////////////////////////////////
974 // Add StatErrors to this Channel //
975 ////////////////////////////////////
976
977 if( sample.GetStatError().GetActivate() ) {
978
979 if( fObsNameVec.size() > 3 ) {
980 cxcoutFHF << "Cannot include Stat Error for histograms of more than 3 dimensions." << std::endl;
981 throw hf_exc();
982 } else {
983
984 // If we are using StatUncertainties, we multiply this object
985 // by the ParamHistFunc and then pass that to the
986 // RooRealSumPdf by appending it's name to the list
987
988 cxcoutI(HistFactory) << "Sample: " << sample.GetName() << " to be included in Stat Error "
989 << "for channel " << channel_name
990 << std::endl;
991
992 string UncertName = sample.GetName() + "_" + channel_name + "_StatAbsolUncert";
993 std::unique_ptr<TH1> statErrorHist;
994
995 if( sample.GetStatError().GetErrorHist() == nullptr ) {
996 // Make the absolute stat error
997 cxcoutI(HistFactory) << "Making Statistical Uncertainty Hist for "
998 << " Channel: " << channel_name
999 << " Sample: " << sample.GetName()
1000 << std::endl;
1001 statErrorHist.reset(MakeAbsolUncertaintyHist( UncertName, nominal));
1002 } else {
1003 // clone the error histograms because in case the sample has not error hist
1004 // it is created in MakeAbsolUncertainty
1005 // we need later to clean statErrorHist
1006 statErrorHist.reset(static_cast<TH1*>(sample.GetStatError().GetErrorHist()->Clone()));
1007 // We assume the (relative) error is provided.
1008 // We must turn it into an absolute error
1009 // using the nominal histogram
1010 cxcoutI(HistFactory) << "Using external histogram for Stat Errors for "
1011 << "\tChannel: " << channel_name
1012 << "\tSample: " << sample.GetName()
1013 << "\tError Histogram: " << statErrorHist->GetName() << std::endl;
1014 // Multiply the relative stat uncertainty by the
1015 // nominal to get the overall stat uncertainty
1016 statErrorHist->Multiply( nominal );
1017 statErrorHist->SetName( UncertName.c_str() );
1018 }
1019
1020 // Save the nominal and error hists
1021 // for the building of constraint terms
1022 statHistPairs.emplace_back(nominal, std::move(statErrorHist));
1023
1024 // To do the 'conservative' version, we would need to do some
1025 // intervention here. We would probably need to create a different
1026 // ParamHistFunc for each sample in the channel. The would nominally
1027 // use the same gamma's, so we haven't increased the number of parameters
1028 // However, if a bin in the 'nominal' histogram is 0, we simply need to
1029 // change the parameter in that bin in the ParamHistFunc for this sample.
1030 // We also need to add a constraint term.
1031 // Actually, we'd probably not use the ParamHistFunc...?
1032 // we could remove the dependence in this ParamHistFunc on the ith gamma
1033 // and then create the poisson term: Pois(tau | n_exp)Pois(data | n_exp)
1034
1035
1036 // Next, try to get the common ParamHistFunc (it may have been
1037 // created by another sample in this channel)
1038 // or create it if it doesn't yet exist:
1039 RooAbsReal* paramHist = dynamic_cast<ParamHistFunc*>(proto.function(statFuncName) );
1040 if( paramHist == nullptr ) {
1041
1042 // Get a RooArgSet of the observables:
1043 // Names in the list fObsNameVec:
1044 RooArgList theObservables;
1045 for (const auto &obsName : fObsNameVec) {
1046 theObservables.add( *proto.var(obsName) );
1047 }
1048
1049 // Create the list of terms to
1050 // control the bin heights:
1051 std::string ParamSetPrefix = "gamma_stat_" + channel_name;
1052 RooArgList statFactorParams = ParamHistFunc::createParamSet(proto,
1053 ParamSetPrefix,
1054 theObservables,
1056
1057 ParamHistFunc statUncertFunc(statFuncName.c_str(), statFuncName.c_str(),
1058 theObservables, statFactorParams );
1059
1060 proto.import( statUncertFunc, RooFit::RecycleConflictNodes() );
1061
1062 paramHist = proto.function( statFuncName);
1063 }
1064
1065 // apply stat function to sample
1066 sampleHistFuncs.push_back(paramHist);
1067 }
1068 } // END: if DoMcStat
1069
1070
1071 ///////////////////////////////////////////
1072 // Create a ShapeFactor for this channel //
1073 ///////////////////////////////////////////
1074
1075 if( !sample.GetShapeFactorList().empty() ) {
1076
1077 if( fObsNameVec.size() > 3 ) {
1078 cxcoutFHF << "Cannot include Stat Error for histograms of more than 3 dimensions." << std::endl;
1079 throw hf_exc();
1080 } else {
1081
1082 cxcoutI(HistFactory) << "Sample: " << sample.GetName() << " in channel: " << channel_name
1083 << " to be include a ShapeFactor."
1084 << std::endl;
1085
1086 for(ShapeFactor& shapeFactor : sample.GetShapeFactorList()) {
1087
1088 std::string funcName = channel_name + "_" + shapeFactor.GetName() + "_shapeFactor";
1089 RooAbsArg *paramHist = proto.function(funcName);
1090 if( paramHist == nullptr ) {
1091
1092 RooArgList theObservables;
1093 for(std::string const& varName : fObsNameVec) {
1094 theObservables.add( *proto.var(varName) );
1095 }
1096
1097 // Create the Parameters
1098 RooArgList shapeFactorParams =
1099 ParamHistFunc::createParamSet(proto, "gamma_" + shapeFactor.GetName(), theObservables);
1100 for (auto *comp : shapeFactorParams) {
1101 // If the gamma is subject to a preprocess function, it is a RooAbsReal and
1102 // we don't need to set the initial value.
1103 if (auto var = dynamic_cast<RooRealVar *>(comp)) {
1104 var->setVal(shapeFactor.GetVal());
1105 var->setMin(shapeFactor.GetLow());
1106 var->setMax(shapeFactor.GetHigh());
1107 }
1108 }
1109
1110 // Create the Function
1111 ParamHistFunc shapeFactorFunc( funcName.c_str(), funcName.c_str(),
1112 theObservables, shapeFactorParams );
1113
1114 // Set an initial shape, if requested
1115 if( shapeFactor.GetInitialShape() != nullptr ) {
1116 TH1* initialShape = static_cast<TH1*>(shapeFactor.GetInitialShape()->Clone());
1117 cxcoutI(HistFactory) << "Setting Shape Factor: " << shapeFactor.GetName()
1118 << " to have initial shape from hist: "
1119 << initialShape->GetName()
1120 << std::endl;
1121 shapeFactorFunc.setShape( initialShape );
1122 }
1123
1124 // Set the variables constant, if requested
1125 if( shapeFactor.IsConstant() ) {
1126 cxcoutI(HistFactory) << "Setting Shape Factor: " << shapeFactor.GetName()
1127 << " to be constant" << std::endl;
1128 shapeFactorFunc.setConstant(true);
1129 }
1130
1131 proto.import( shapeFactorFunc, RooFit::RecycleConflictNodes() );
1132 paramHist = proto.function(funcName);
1133
1134 } // End: Create ShapeFactor ParamHistFunc
1135
1136 sampleHistFuncs.push_back(paramHist);
1137 } // End loop over ShapeFactor Systematics
1138 }
1139 } // End: if ShapeFactorName!=""
1140
1141
1142 ////////////////////////////////////////
1143 // Create a ShapeSys for this channel //
1144 ////////////////////////////////////////
1145
1146 if( !sample.GetShapeSysList().empty() ) {
1147
1148 if( fObsNameVec.size() > 3 ) {
1149 cxcoutFHF << "Cannot include Stat Error for histograms of more than 3 dimensions.\n";
1150 throw hf_exc();
1151 }
1152
1153 // List of ShapeSys ParamHistFuncs
1154 std::vector<string> ShapeSysNames;
1155
1156 for(RooStats::HistFactory::ShapeSys& shapeSys : sample.GetShapeSysList()) {
1157
1158 // Create the ParamHistFunc's
1159 // Create their constraint terms and add them
1160 // to the list of constraint terms
1161
1162 // Create a single RooProduct over all of these
1163 // paramHistFunc's
1164
1165 // Send the name of that product to the RooRealSumPdf
1166
1167 cxcoutI(HistFactory) << "Sample: " << sample.GetName() << " in channel: " << channel_name
1168 << " to include a ShapeSys." << std::endl;
1169
1170 std::string funcName = channel_name + "_" + shapeSys.GetName() + "_ShapeSys";
1171 ShapeSysNames.push_back( funcName );
1172 auto paramHist = static_cast<ParamHistFunc*>(proto.function(funcName));
1173 if( paramHist == nullptr ) {
1174
1175 //std::string funcParams = "gamma_" + it->shapeFactorName;
1176 //paramHist = CreateParamHistFunc( proto, fObsNameVec, funcParams, funcName );
1177
1178 RooArgList theObservables;
1179 for(std::string const& varName : fObsNameVec) {
1180 theObservables.add( *proto.var(varName) );
1181 }
1182
1183 // Create the Parameters
1184 std::string funcParams = "gamma_" + shapeSys.GetName();
1185 RooArgList shapeFactorParams = ParamHistFunc::createParamSet(proto,
1186 funcParams,
1187 theObservables, defaultGammaMin, defaultShapeSysGammaMax);
1188
1189 // Create the Function
1190 ParamHistFunc shapeFactorFunc( funcName.c_str(), funcName.c_str(),
1191 theObservables, shapeFactorParams );
1192
1193 proto.import( shapeFactorFunc, RooFit::RecycleConflictNodes() );
1194 paramHist = static_cast<ParamHistFunc*>(proto.function(funcName));
1195
1196 } // End: Create ShapeFactor ParamHistFunc
1197
1198 // Create the constraint terms and add
1199 // them to the workspace (proto)
1200 // as well as the list of constraint terms (constraintTermNames)
1201
1202 // The syst should be a fractional error
1203 const TH1* shapeErrorHist = shapeSys.GetErrorHist();
1204
1205 // Constraint::Type shapeConstraintType = Constraint::Gaussian;
1206 Constraint::Type systype = shapeSys.GetConstraintType();
1207 if( systype == Constraint::Gaussian) {
1208 systype = Constraint::Gaussian;
1209 }
1210 if( systype == Constraint::Poisson ) {
1211 systype = Constraint::Poisson;
1212 }
1213
1214 auto shapeConstraintsInfo = createGammaConstraints(
1215 paramHist->paramList(), histToVector(*shapeErrorHist),
1217 systype);
1218 for (auto const& term : shapeConstraintsInfo.constraints) {
1219 proto.import(*term, RooFit::RecycleConflictNodes());
1220 constraintTermNames.emplace_back(term->GetName());
1221 }
1222 // Add the "observed" value to the list of global observables:
1223 RooArgSet *globalSet = const_cast<RooArgSet *>(proto.set("globalObservables"));
1224 for (RooAbsArg * glob : shapeConstraintsInfo.globalObservables) {
1225 globalSet->add(*proto.var(glob->GetName()));
1226 }
1227
1228
1229 } // End: Loop over ShapeSys vector in this EstimateSummary
1230
1231 // Now that we have the list of ShapeSys ParamHistFunc names,
1232 // we create the total RooProduct
1233 // we multiply the expected function
1234
1235 for(std::string const& name : ShapeSysNames) {
1236 sampleHistFuncs.push_back(proto.function(name));
1237 }
1238
1239 } // End: !GetShapeSysList.empty()
1240
1241
1242 // GHL: This was pretty confusing before,
1243 // hopefully using the measurement directly
1244 // will improve it
1245 RooAbsArg *lumi = proto.arg("Lumi");
1246 if( !sample.GetNormalizeByTheory() ) {
1247 if (!lumi) {
1248 lumi = &emplace<RooRealVar>(proto, "Lumi", measurement.GetLumi());
1249 } else {
1250 static_cast<RooAbsRealLValue*>(lumi)->setVal(measurement.GetLumi());
1251 }
1252 }
1253 assert(lumi);
1254 normFactors->addTerm(lumi);
1255
1256 // Append the name of the "node"
1257 // that is to be summed with the
1258 // RooRealSumPdf
1259 proto.import(*normFactors, RooFit::RecycleConflictNodes());
1260 auto normFactorsInWS = dynamic_cast<RooProduct*>(proto.arg(normFactors->GetName()));
1261 assert(normFactorsInWS);
1262
1263 sampleScaleFactors.push_back(normFactorsInWS);
1264 } // END: Loop over EstimateSummaries
1265
1266 // If a non-zero number of samples call for
1267 // Stat Uncertainties, create the statFactor functions
1268 if(!statHistPairs.empty()) {
1269
1270 // Create the histogram of (binwise)
1271 // stat uncertainties:
1272 std::unique_ptr<TH1> fracStatError(
1273 MakeScaledUncertaintyHist(channel_name + "_StatUncert" + "_RelErr", statHistPairs));
1274 if( fracStatError == nullptr ) {
1275 cxcoutFHF << "Error: Failed to make ScaledUncertaintyHist for: " << channel_name + "_StatUncert" + "_RelErr\n";
1276 throw hf_exc();
1277 }
1278
1279 // Using this TH1* of fractinal stat errors,
1280 // create a set of constraint terms:
1281 auto chanStatUncertFunc = static_cast<ParamHistFunc*>(proto.function( statFuncName ));
1282 cxcoutI(HistFactory) << "About to create Constraint Terms from: "
1283 << chanStatUncertFunc->GetName()
1284 << " params: " << chanStatUncertFunc->paramList()
1285 << std::endl;
1286
1287 // Get the constraint type and the
1288 // rel error threshold from the (last)
1289 // EstimateSummary looped over (but all
1290 // should be the same)
1291
1292 // Get the type of StatError constraint from the channel
1293 Constraint::Type statConstraintType = channel.GetStatErrorConfig().GetConstraintType();
1294 if( statConstraintType == Constraint::Gaussian) {
1295 cxcoutI(HistFactory) << "Using Gaussian StatErrors in channel: " << channel.GetName() << std::endl;
1296 }
1297 if( statConstraintType == Constraint::Poisson ) {
1298 cxcoutI(HistFactory) << "Using Poisson StatErrors in channel: " << channel.GetName() << std::endl;
1299 }
1300
1301 double statRelErrorThreshold = channel.GetStatErrorConfig().GetRelErrorThreshold();
1302 auto statConstraintsInfo = createGammaConstraints(
1303 chanStatUncertFunc->paramList(), histToVector(*fracStatError),
1304 statRelErrorThreshold,
1305 statConstraintType);
1306 for (auto const& term : statConstraintsInfo.constraints) {
1307 proto.import(*term, RooFit::RecycleConflictNodes());
1308 constraintTermNames.emplace_back(term->GetName());
1309 }
1310 // Add the "observed" value to the list of global observables:
1311 RooArgSet *globalSet = const_cast<RooArgSet *>(proto.set("globalObservables"));
1312 for (RooAbsArg * glob : statConstraintsInfo.globalObservables) {
1313 globalSet->add(*proto.var(glob->GetName()));
1314 }
1315
1316 } // END: Loop over stat Hist Pairs
1317
1318
1319 ///////////////////////////////////
1320 // for ith bin calculate totN_i = lumi * sum_j expected_j * syst_j
1321 MakeTotalExpected(proto, channel_name+"_model",
1322 sampleScaleFactors, allSampleHistFuncs);
1323 likelihoodTermNames.push_back(channel_name+"_model");
1324
1325 //////////////////////////////////////
1326 // fix specified parameters
1327 for(unsigned int i=0; i<systToFix.size(); ++i){
1328 RooRealVar* temp = proto.var(systToFix.at(i));
1329 if(!temp) {
1330 cxcoutW(HistFactory) << "could not find variable " << systToFix.at(i)
1331 << " could not set it to constant" << std::endl;
1332 } else {
1333 // set the parameter constant
1334 temp->setConstant();
1335 }
1336 }
1337
1338 //////////////////////////////////////
1339 // final proto model
1340 for(unsigned int i=0; i<constraintTermNames.size(); ++i){
1341 RooAbsArg* proto_arg = proto.arg(constraintTermNames[i]);
1342 if( proto_arg==nullptr ) {
1343 cxcoutFHF << "Error: Cannot find arg set: " << constraintTermNames.at(i)
1344 << " in workspace: " << proto.GetName() << std::endl;
1345 throw hf_exc();
1346 }
1347 constraintTerms.add( *proto_arg );
1348 // constraintTerms.add(* proto_arg(proto.arg(constraintTermNames[i].c_str())) );
1349 }
1350 for(unsigned int i=0; i<likelihoodTermNames.size(); ++i){
1351 RooAbsArg* proto_arg = (proto.arg(likelihoodTermNames[i]));
1352 if( proto_arg==nullptr ) {
1353 cxcoutFHF << "Error: Cannot find arg set: " << likelihoodTermNames.at(i)
1354 << " in workspace: " << proto.GetName() << std::endl;
1355 throw hf_exc();
1356 }
1357 likelihoodTerms.add( *proto_arg );
1358 }
1359 proto.defineSet("constraintTerms",constraintTerms);
1360 proto.defineSet("likelihoodTerms",likelihoodTerms);
1361
1362 // list of observables
1363 RooArgList observables;
1364 std::string observablesStr;
1365
1366 for(std::string const& name : fObsNameVec) {
1367 observables.add( *proto.var(name) );
1368 if (!observablesStr.empty()) { observablesStr += ","; }
1369 observablesStr += name;
1370 }
1371
1372 // We create two sets, one for backwards compatibility
1373 // The other to make a consistent naming convention
1374 // between individual channels and the combined workspace
1375 proto.defineSet("observables", observablesStr.c_str());
1376 proto.defineSet("observablesSet", observablesStr.c_str());
1377
1378 // Create the ParamHistFunc
1379 // after observables have been made
1380 cxcoutP(HistFactory) << "\n-----------------------------------------\n"
1381 << "\timport model into workspace"
1382 << "\n-----------------------------------------\n" << std::endl;
1383
1384 auto model = std::make_unique<RooProdPdf>(
1385 ("model_" + channel_name).c_str(), // MB : have changed this into conditional pdf. Much faster for toys!
1386 "product of Poissons across bins for a single channel", constraintTerms,
1387 RooFit::Conditional(likelihoodTerms, observables));
1388 // can give channel a title by setting title of corresponding data histogram
1389 if (channel.GetData().GetHisto() && strlen(channel.GetData().GetHisto()->GetTitle())>0) {
1390 model->SetTitle(channel.GetData().GetHisto()->GetTitle());
1391 }
1392 proto.import(*model,RooFit::RecycleConflictNodes());
1393
1394 proto_config->SetPdf(*model);
1395 proto_config->SetObservables(observables);
1396 proto_config->SetGlobalObservables(*proto.set("globalObservables"));
1397 // proto.writeToFile(("results/model_"+channel+".root").c_str());
1398 // fill out nuisance parameters in model config
1399 // proto_config->GuessObsAndNuisance(*proto.data("asimovData"));
1400 proto.import(*proto_config,proto_config->GetName());
1401 proto.importClassCode();
1402
1403 ///////////////////////////
1404 // make data sets
1405 // THis works and is natural, but the memory size of the simultaneous dataset grows exponentially with channels
1406 // New Asimov Generation: Use the code in the Asymptotic calculator
1407 // Need to get the ModelConfig...
1408 int asymcalcPrintLevel = 0;
1409 if (RooMsgService::instance().isActive(nullptr, RooFit::HistFactory, RooFit::INFO)) asymcalcPrintLevel = 1;
1410 if (RooMsgService::instance().isActive(nullptr, RooFit::HistFactory, RooFit::DEBUG)) asymcalcPrintLevel = 2;
1411 AsymptoticCalculator::SetPrintLevel(asymcalcPrintLevel);
1413 // Creating the per-channel asimov dataset is only meaningful if we
1414 // actually create the files with the stored per-channel workspaces.
1415 // Otherwise, we just spend time calculating something that gets thrown
1416 // away anyway (for the combined workspace, we'll create a new Asimov).
1417 std::unique_ptr<RooAbsData> asimov_dataset(AsymptoticCalculator::GenerateAsimovData(*model, observables));
1418 proto.import(*asimov_dataset, RooFit::Rename("asimovData"));
1419 }
1420
1421 // GHL: Determine to use data if the hist isn't 'nullptr'
1422 if(TH1 const* mnominal = channel.GetData().GetHisto()) {
1423 // This works and is natural, but the memory size of the simultaneous
1424 // dataset grows exponentially with channels.
1425 std::unique_ptr<RooDataSet> dataset;
1426 if(!fCfg.storeDataError){
1427 dataset = std::make_unique<RooDataSet>("obsData","",*proto.set("observables"), RooFit::WeightVar("weightVar"));
1428 } else {
1429 const char* weightErrName="weightErr";
1430 proto.factory(TString::Format("%s[0,-1e10,1e10]",weightErrName));
1431 dataset = std::make_unique<RooDataSet>("obsData","",*proto.set("observables"), RooFit::WeightVar("weightVar"), RooFit::StoreError(*proto.var(weightErrName)));
1432 }
1433 ConfigureHistFactoryDataset( *dataset, *mnominal, proto, fObsNameVec );
1434 proto.import(*dataset);
1435 } // End: Has non-null 'data' entry
1436
1437
1438 for(auto const& data : channel.GetAdditionalData()) {
1439 if(data.GetName().empty()) {
1440 cxcoutFHF << "Error: Additional Data histogram for channel: " << channel.GetName()
1441 << " has no name! The name always needs to be set for additional datasets, "
1442 << "either via the \"Name\" tag in the XML or via RooStats::HistFactory::Data::SetName().\n";
1443 throw hf_exc();
1444 }
1445 std::string const& dataName = data.GetName();
1446 TH1 const* mnominal = data.GetHisto();
1447 if( !mnominal ) {
1448 cxcoutFHF << "Error: Additional Data histogram for channel: " << channel.GetName()
1449 << " with name: " << dataName << " is nullptr\n";
1450 throw hf_exc();
1451 }
1452
1453 // THis works and is natural, but the memory size of the simultaneous dataset grows exponentially with channels
1454 RooDataSet dataset{dataName, "", *proto.set("observables"), RooFit::WeightVar("weightVar")};
1455 ConfigureHistFactoryDataset( dataset, *mnominal, proto, fObsNameVec );
1456 proto.import(dataset);
1457
1458 }
1459
1460 if (RooMsgService::instance().isActive(nullptr, RooFit::HistFactory, RooFit::INFO)) {
1461 proto.Print();
1462 }
1463
1464 return protoOwner;
1465 }
1466
1467
1469 TH1 const& mnominal,
1470 RooWorkspace& proto,
1471 std::vector<std::string> const& obsNameVec) {
1472
1473 // Take a RooDataSet and fill it with the entries
1474 // from a TH1*, using the observable names to
1475 // determine the columns
1476
1477 if (obsNameVec.empty() ) {
1478 Error("ConfigureHistFactoryDataset","Invalid input - return");
1479 return;
1480 }
1481
1482 TAxis const* ax = mnominal.GetXaxis();
1483 TAxis const* ay = mnominal.GetYaxis();
1484 TAxis const* az = mnominal.GetZaxis();
1485
1486 // check whether the dataset needs the errors stored explicitly
1487 const bool storeWeightErr = obsDataUnbinned.weightVar()->getAttribute("StoreError");
1488
1489 for (int i=1; i<=ax->GetNbins(); ++i) { // 1 or more dimension
1490
1491 double xval = ax->GetBinCenter(i);
1492 proto.var( obsNameVec[0] )->setVal( xval );
1493
1494 if(obsNameVec.size()==1) {
1495 double fval = mnominal.GetBinContent(i);
1496 double ferr = storeWeightErr ? mnominal.GetBinError(i) : 0.;
1497 obsDataUnbinned.add( *proto.set("observables"), fval, ferr );
1498 } else { // 2 or more dimensions
1499
1500 for(int j=1; j<=ay->GetNbins(); ++j) {
1501 double yval = ay->GetBinCenter(j);
1502 proto.var( obsNameVec[1] )->setVal( yval );
1503
1504 if(obsNameVec.size()==2) {
1505 double fval = mnominal.GetBinContent(i,j);
1506 double ferr = storeWeightErr ? mnominal.GetBinError(i, j) : 0.;
1507 obsDataUnbinned.add( *proto.set("observables"), fval, ferr );
1508 } else { // 3 dimensions
1509
1510 for(int k=1; k<=az->GetNbins(); ++k) {
1511 double zval = az->GetBinCenter(k);
1512 proto.var( obsNameVec[2] )->setVal( zval );
1513 double fval = mnominal.GetBinContent(i,j,k);
1514 double ferr = storeWeightErr ? mnominal.GetBinError(i, j, k) : 0.;
1515 obsDataUnbinned.add( *proto.set("observables"), fval, ferr );
1516 }
1517 }
1518 }
1519 }
1520 }
1521 }
1522
1524 {
1525 fObsNameVec = std::vector<string>{"x", "y", "z"};
1526 fObsNameVec.resize(hist->GetDimension());
1527 }
1528
1529
1531 HistoToWorkspaceFactoryFast::MakeCombinedModel(std::vector<std::string> ch_names,
1532 std::vector<std::unique_ptr<RooWorkspace>> &chs)
1533 {
1535
1536 // check first the inputs (see JIRA-6890)
1537 if (ch_names.empty() || chs.empty() ) {
1538 Error("MakeCombinedModel","Input vectors are empty - return a nullptr");
1539 return nullptr;
1540 }
1541 if (chs.size() < ch_names.size() ) {
1542 Error("MakeCombinedModel","Input vector of workspace has an invalid size - return a nullptr");
1543 return nullptr;
1544 }
1545 std::set<std::string> ch_names_set{ch_names.begin(), ch_names.end()};
1546 if (ch_names.size() != ch_names_set.size()) {
1547 Error("MakeCombinedModel", "Input vector of channel names has duplicate names - return a nullptr");
1548 return nullptr;
1549 }
1550
1551 //
1552 /// These things were used for debugging. Maybe useful in the future
1553 //
1554
1555 std::map<string, RooAbsPdf *> pdfMap;
1556 vector<RooAbsPdf *> models;
1557
1558 RooArgList obsList;
1559 for (unsigned int i = 0; i < ch_names.size(); ++i) {
1560 obsList.add(*static_cast<ModelConfig *>(chs[i]->obj("ModelConfig"))->GetObservables());
1561 }
1562 cxcoutI(HistFactory) <<"full list of observables:\n" << obsList << std::endl;
1563
1564 RooArgSet globalObs;
1565 std::map<std::string, int> channelMap;
1566 for(unsigned int i = 0; i< ch_names.size(); ++i){
1567 string channel_name=ch_names[i];
1568 if (i == 0 && isdigit(channel_name[0])) {
1569 throw std::invalid_argument("The first channel name for HistFactory cannot start with a digit. Got " + channel_name);
1570 }
1571 if (channel_name.find(',') != std::string::npos) {
1572 throw std::invalid_argument("Channel names for HistFactory cannot contain ','. Got " + channel_name);
1573 }
1574
1575 channelMap[channel_name] = i;
1576 RooWorkspace * ch=chs[i].get();
1577
1578 RooAbsPdf* model = ch->pdf("model_"+channel_name);
1579 if (!model) {
1580 cxcoutFHF << "failed to find model for channel\n";
1581 throw hf_exc();
1582 }
1583 models.push_back(model);
1584 auto &modelConfig = *static_cast<ModelConfig *>(chs[i]->obj("ModelConfig"));
1585 // silent because observables might exist in other channel:
1586 globalObs.add(*modelConfig.GetGlobalObservables(), /*silent=*/true);
1587
1588 // constrainedParams->add( * ch->set("constrainedParams") );
1589 pdfMap[channel_name]=model;
1590 }
1591
1592 cxcoutP(HistFactory) << "\n-----------------------------------------\n"
1593 << "\tEntering combination"
1594 << "\n-----------------------------------------\n" << std::endl;
1595 auto combined = std::make_unique<RooWorkspace>("combined");
1596
1597
1598 RooCategory& channelCat = emplace<RooCategory>(*combined, "channelCat", channelMap);
1599
1600 auto simPdf= std::make_unique<RooSimultaneous>("simPdf","",pdfMap, channelCat);
1601 auto combined_config = std::make_unique<ModelConfig>("ModelConfig", combined.get());
1602 combined_config->SetWorkspace(*combined);
1603 // combined_config->SetNuisanceParameters(*constrainedParams);
1604
1605 combined->import(globalObs);
1606 combined->defineSet("globalObservables",globalObs);
1607 combined_config->SetGlobalObservables(*combined->set("globalObservables"));
1608
1609 combined->defineSet("observables",{obsList, channelCat}, /*importMissing=*/true);
1610 combined_config->SetObservables(*combined->set("observables"));
1611
1612 // Check if the channel datasets are consistent
1613 {
1614 bool isConsistent = false;
1615 std::string errMsg;
1616 std::set<std::string> allowedInconsistent{"asimovData"};
1617 std::tie(isConsistent, errMsg) = isChannelDataConsistent(chs, ch_names, allowedInconsistent);
1618 if (!isConsistent) {
1619 cxcoutFHF << errMsg;
1620 throw hf_exc();
1621 }
1622 }
1623
1624 // Now merge the observable datasets across the channels
1625 for(RooAbsData * data : chs[0]->allData()) {
1626 // We are excluding the Asimov data, because it needs to be regenerated
1627 // later after the parameter values are set.
1628 if(std::string("asimovData") == data->GetName()) {
1629 continue;
1630 }
1631 // Loop through channels, get their individual datasets,
1632 // and add them to the combined dataset
1633 std::map<std::string, RooAbsData*> dataMap;
1634 for(unsigned int i = 0; i < ch_names.size(); ++i){
1635 dataMap[ch_names[i]] = chs[i]->data(data->GetName());
1636 }
1637 combined->import(RooDataSet{data->GetName(), "", obsList, RooFit::Index(channelCat),
1638 RooFit::WeightVar("weightVar"), RooFit::Import(dataMap)});
1639 }
1640
1641
1643 combined->Print();
1644
1645 cxcoutP(HistFactory) << "\n-----------------------------------------\n"
1646 << "\tImporting combined model"
1647 << "\n-----------------------------------------\n" << std::endl;
1648 combined->import(*simPdf,RooFit::RecycleConflictNodes());
1649
1650 for(auto const& param_itr : fParamValues) {
1651 // make sure they are fixed
1652 std::string paramName = param_itr.first;
1653 double paramVal = param_itr.second;
1654
1655 if(RooRealVar* temp = combined->var( paramName )) {
1656 temp->setVal( paramVal );
1657 cxcoutI(HistFactory) <<"setting " << paramName << " to the value: " << paramVal << std::endl;
1658 } else
1659 cxcoutE(HistFactory) << "could not find variable " << paramName << " could not set its value" << std::endl;
1660 }
1661
1662
1663 for(unsigned int i=0; i<fSystToFix.size(); ++i){
1664 // make sure they are fixed
1665 if(RooRealVar* temp = combined->var(fSystToFix[i])) {
1666 temp->setConstant();
1667 cxcoutI(HistFactory) <<"setting " << fSystToFix.at(i) << " constant" << std::endl;
1668 } else
1669 cxcoutE(HistFactory) << "could not find variable " << fSystToFix.at(i) << " could not set it to constant" << std::endl;
1670 }
1671
1672 ///
1673 /// writing out the model in graphViz
1674 ///
1675 // RooAbsPdf* customized=combined->pdf("simPdf");
1676 //combined_config->SetPdf(*customized);
1677 combined_config->SetPdf(*simPdf);
1678 // combined_config->GuessObsAndNuisance(*simData);
1679 // customized->graphVizTree(("results/"+fResultsPrefixStr.str()+"_simul.dot").c_str());
1680 combined->import(*combined_config,combined_config->GetName());
1681 combined->importClassCode();
1682 // combined->writeToFile("results/model_combined.root");
1683
1684
1685 ////////////////////////////////////////////
1686 // Make toy simultaneous dataset
1687 cxcoutP(HistFactory) << "\n-----------------------------------------\n"
1688 << "\tcreate toy data"
1689 << "\n-----------------------------------------\n" << std::endl;
1690
1691
1692 // now with weighted datasets
1693 // First Asimov
1694
1695 // Create Asimov data for the combined dataset
1696 std::unique_ptr<RooAbsData> asimov_combined{AsymptoticCalculator::GenerateAsimovData(
1697 *combined->pdf("simPdf"),
1698 obsList)};
1699 if( asimov_combined ) {
1700 combined->import( *asimov_combined, RooFit::Rename("asimovData"));
1701 }
1702 else {
1703 cxcoutFHF << "Error: Failed to create combined asimov dataset\n";
1704 throw hf_exc();
1705 }
1706
1707 return RooFit::makeOwningPtr(std::move(combined));
1708 }
1709
1710
1711 TH1* HistoToWorkspaceFactoryFast::MakeAbsolUncertaintyHist( const std::string& Name, const TH1* Nominal ) {
1712
1713 // Take a nominal TH1* and create
1714 // a TH1 representing the binwise
1715 // errors (taken from the nominal TH1)
1716
1717 auto ErrorHist = static_cast<TH1*>(Nominal->Clone( Name.c_str() ));
1718 ErrorHist->Reset();
1719
1720 int numBins = Nominal->GetNbinsX()*Nominal->GetNbinsY()*Nominal->GetNbinsZ();
1721 int binNumber = 0;
1722
1723 // Loop over bins
1724 for( int i_bin = 0; i_bin < numBins; ++i_bin) {
1725
1726 binNumber++;
1727 // Ignore underflow / overflow
1728 while( Nominal->IsBinUnderflow(binNumber) || Nominal->IsBinOverflow(binNumber) ){
1729 binNumber++;
1730 }
1731
1732 double histError = Nominal->GetBinError( binNumber );
1733
1734 // Check that histError != NAN
1735 if( histError != histError ) {
1736 cxcoutFHF << "Warning: In histogram " << Nominal->GetName() << " bin error for bin " << i_bin
1737 << " is NAN. Not using Error!!!\n";
1738 throw hf_exc();
1739 // histError = sqrt( histContent );
1740 // histError = 0;
1741 }
1742
1743 // Check that histError ! < 0
1744 if( histError < 0 ) {
1745 cxcoutWHF << "Warning: In histogram " << Nominal->GetName() << " bin error for bin " << binNumber
1746 << " is < 0. Setting Error to 0" << std::endl;
1747 // histError = sqrt( histContent );
1748 histError = 0;
1749 }
1750
1751 ErrorHist->SetBinContent( binNumber, histError );
1752
1753 }
1754
1755 return ErrorHist;
1756
1757 }
1758
1759 // Take a list of < nominal, absolError > TH1* pairs
1760 // and construct a single histogram representing the
1761 // total fractional error as:
1762
1763 // UncertInQuad(bin i) = Sum: absolUncert*absolUncert
1764 // Total(bin i) = Sum: Value
1765 //
1766 // TotalFracError(bin i) = Sqrt( UncertInQuad(i) ) / TotalBin(i)
1767 std::unique_ptr<TH1> HistoToWorkspaceFactoryFast::MakeScaledUncertaintyHist( const std::string& Name, std::vector< std::pair<const TH1*, std::unique_ptr<TH1>> > const& HistVec ) const {
1768
1769
1770 unsigned int numHists = HistVec.size();
1771
1772 if( numHists == 0 ) {
1773 cxcoutE(HistFactory) << "Warning: Empty Hist Vector, cannot create total uncertainty" << std::endl;
1774 return nullptr;
1775 }
1776
1777 const TH1* HistTemplate = HistVec.at(0).first;
1778 int numBins = HistTemplate->GetNbinsX()*HistTemplate->GetNbinsY()*HistTemplate->GetNbinsZ();
1779
1780 // Check that all histograms
1781 // have the same bins
1782 for( unsigned int i = 0; i < HistVec.size(); ++i ) {
1783
1784 const TH1* nominal = HistVec.at(i).first;
1785 const TH1* error = HistVec.at(i).second.get();
1786
1787 if( nominal->GetNbinsX()*nominal->GetNbinsY()*nominal->GetNbinsZ() != numBins ) {
1788 cxcoutE(HistFactory) << "Error: Provided hists have unequal bins" << std::endl;
1789 return nullptr;
1790 }
1791 if( error->GetNbinsX()*error->GetNbinsY()*error->GetNbinsZ() != numBins ) {
1792 cxcoutE(HistFactory) << "Error: Provided hists have unequal bins" << std::endl;
1793 return nullptr;
1794 }
1795 }
1796
1797 std::vector<double> TotalBinContent( numBins, 0.0);
1798 std::vector<double> HistErrorsSqr( numBins, 0.0);
1799
1800 int binNumber = 0;
1801
1802 // Loop over bins
1803 for( int i_bins = 0; i_bins < numBins; ++i_bins) {
1804
1805 binNumber++;
1806 while( HistTemplate->IsBinUnderflow(binNumber) || HistTemplate->IsBinOverflow(binNumber) ){
1807 binNumber++;
1808 }
1809
1810 for( unsigned int i_hist = 0; i_hist < numHists; ++i_hist ) {
1811
1812 const TH1* nominal = HistVec.at(i_hist).first;
1813 const TH1* error = HistVec.at(i_hist).second.get();
1814
1815 //int binNumber = i_bins + 1;
1816
1817 double histValue = nominal->GetBinContent( binNumber );
1818 double histError = error->GetBinContent( binNumber );
1819
1820 if( histError != histError ) {
1821 cxcoutFHF << "In histogram " << error->GetName() << " bin error for bin " << binNumber
1822 << " is NAN. Not using error!!";
1823 throw hf_exc();
1824 }
1825
1826 TotalBinContent.at(i_bins) += histValue;
1827 HistErrorsSqr.at(i_bins) += histError*histError; // Add in quadrature
1828
1829 }
1830 }
1831
1832 binNumber = 0;
1833
1834 // Creat the output histogram
1835 TH1* ErrorHist = static_cast<TH1*>(HistTemplate->Clone( Name.c_str() ));
1836 ErrorHist->Reset();
1837
1838 // Fill the output histogram
1839 for( int i = 0; i < numBins; ++i) {
1840
1841 // int binNumber = i + 1;
1842 binNumber++;
1843 while( ErrorHist->IsBinUnderflow(binNumber) || ErrorHist->IsBinOverflow(binNumber) ){
1844 binNumber++;
1845 }
1846
1847 double ErrorsSqr = HistErrorsSqr.at(i);
1848 double TotalVal = TotalBinContent.at(i);
1849
1850 if( TotalVal <= 0 ) {
1851 cxcoutW(HistFactory) << "Warning: Sum of histograms for bin: " << binNumber
1852 << " is <= 0. Setting error to 0"
1853 << std::endl;
1854
1855 ErrorHist->SetBinContent( binNumber, 0.0 );
1856 continue;
1857 }
1858
1859 double RelativeError = sqrt(ErrorsSqr) / TotalVal;
1860
1861 // If we otherwise get a NAN
1862 // it's an error
1863 if( RelativeError != RelativeError ) {
1864 cxcoutE(HistFactory) << "Error: bin " << i << " error is NAN\n"
1865 << " HistErrorsSqr: " << ErrorsSqr
1866 << " TotalVal: " << TotalVal;
1867 throw hf_exc();
1868 }
1869
1870 // 0th entry in vector is
1871 // the 1st bin in TH1
1872 // (we ignore underflow)
1873
1874 // Error and bin content are interchanged because for some reason, the other functions
1875 // use the bin content to convey the error ...
1876 ErrorHist->SetBinError(binNumber, TotalVal);
1877 ErrorHist->SetBinContent(binNumber, RelativeError);
1878
1879 cxcoutI(HistFactory) << "Making Total Uncertainty for bin " << binNumber
1880 << " Error = " << sqrt(ErrorsSqr)
1881 << " CentralVal = " << TotalVal
1882 << " RelativeError = " << RelativeError << "\n";
1883
1884 }
1885
1886 return std::unique_ptr<TH1>(ErrorHist);
1887}
1888
1889} // namespace RooStats::HistFactory
#define cxcoutPHF
#define cxcoutFHF
#define cxcoutIHF
#define cxcoutWHF
std::vector< double > histToVector(TH1 const &hist)
constexpr double alphaHigh
constexpr double alphaLow
#define cxcoutI(a)
#define cxcoutW(a)
#define cxcoutF(a)
#define cxcoutE(a)
#define cxcoutP(a)
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Definition TError.h:139
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
char name[80]
Definition TGX11.cxx:142
A class which maps the current values of a RooRealVar (or a set of RooRealVars) to one of a number of...
static RooArgList createParamSet(RooWorkspace &w, const std::string &, const RooArgList &Vars)
Create the list of RooRealVar parameters which represent the height of the histogram bins.
The PiecewiseInterpolation is a class that can morph distributions into each other,...
Common abstract base class for objects that represent a value and a "shape" in RooFit.
Definition RooAbsArg.h:77
virtual bool add(const RooAbsArg &var, bool silent=false)
Add the specified argument to list.
Storage_t::size_type size() const
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:55
Abstract interface for all probability density functions.
Definition RooAbsPdf.h:32
Abstract base class for objects that represent a real value that may appear on the left hand side of ...
void setConstant(bool value=true)
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:63
Calculates the sum of a set of RooAbsReal terms, or when constructed with two sets,...
Definition RooAddition.h:27
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition RooArgList.h:22
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:24
Implements a RooAbsBinning in terms of an array of boundary values, posing no constraints on the choi...
Definition RooBinning.h:27
Object to represent discrete states.
Definition RooCategory.h:28
Container class to hold N-dimensional binned data.
Definition RooDataHist.h:40
Container class to hold unbinned data.
Definition RooDataSet.h:32
RooFitResult is a container class to hold the input and output of a PDF fit to a dataset.
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Implementation of the Gamma PDF for RooFit/RooStats.
Definition RooGamma.h:20
Switches the message service to a different level while the instance is alive.
Definition RooHelpers.h:37
A real-valued function sampled from a multidimensional histogram.
Definition RooHistFunc.h:29
static RooMsgService & instance()
Return reference to singleton instance.
A RooAbsReal implementing a polynomial in terms of a list of RooAbsReal coefficients.
Definition RooPolyVar.h:25
Represents the product of a given set of RooAbsReal objects.
Definition RooProduct.h:29
Implements a PDF constructed from a sum of functions:
Variable that can be changed from the outside.
Definition RooRealVar.h:37
void setBins(Int_t nBins, const char *name=nullptr, bool shared=true)
Create a uniform binning under name 'name' for this variable.
void setBinning(const RooAbsBinning &binning, const char *name=nullptr, bool shared=true)
Add given binning under name 'name' with this variable.
static void SetPrintLevel(int level)
set print level (static function)
static RooAbsData * GenerateAsimovData(const RooAbsPdf &pdf, const RooArgSet &observables)
generate the asimov data for the observables (not the global ones) need to deal with the case of a si...
TODO Here, we are missing some documentation.
void ConfigureWorkspace(RooWorkspace *)
This class encapsulates all information for the statistical interpretation of one experiment.
std::vector< RooStats::HistFactory::Data > & GetAdditionalData()
retrieve vector of additional data objects
void Print(std::ostream &=std::cout)
HistFactory::StatErrorConfig & GetStatErrorConfig()
get information about threshold for statistical uncertainties and constraint term
RooStats::HistFactory::Data & GetData()
get data object
std::vector< RooStats::HistFactory::Sample > & GetSamples()
get vector of samples for this channel
std::string GetName() const
get name of channel
Configuration for a constrained, coherent shape variation of affected samples.
This class provides helper functions for creating likelihood models from histograms.
std::unique_ptr< RooProduct > CreateNormFactor(RooWorkspace &proto, std::string &channel, std::string &sigmaEpsilon, Sample &sample, bool doRatio)
std::unique_ptr< RooWorkspace > MakeSingleChannelWorkspace(Measurement &measurement, Channel &channel)
void AddConstraintTerms(RooWorkspace &proto, Measurement &measurement, std::string prefix, std::string interpName, std::vector< OverallSys > &systList, std::vector< std::string > &constraintTermNames, std::vector< std::string > &totSystTermNames)
void MakeTotalExpected(RooWorkspace &proto, const std::string &totName, const std::vector< RooProduct * > &sampleScaleFactors, std::vector< std::vector< RooAbsArg * > > &sampleHistFuncs) const
std::unique_ptr< TH1 > MakeScaledUncertaintyHist(const std::string &Name, std::vector< std::pair< const TH1 *, std::unique_ptr< TH1 > > > const &HistVec) const
RooHistFunc * MakeExpectedHistFunc(const TH1 *hist, RooWorkspace &proto, std::string prefix, const RooArgList &observables) const
Create the nominal hist function from hist, and register it in the workspace.
void SetFunctionsToPreprocess(std::vector< std::string > lines)
TH1 * MakeAbsolUncertaintyHist(const std::string &Name, const TH1 *Nominal)
RooFit::OwningPtr< RooWorkspace > MakeSingleChannelModel(Measurement &measurement, Channel &channel)
RooFit::OwningPtr< RooWorkspace > MakeCombinedModel(std::vector< std::string >, std::vector< std::unique_ptr< RooWorkspace > > &)
static void ConfigureWorkspaceForMeasurement(const std::string &ModelName, RooWorkspace *ws_single, Measurement &measurement)
void ConfigureHistFactoryDataset(RooDataSet &obsData, TH1 const &nominal, RooWorkspace &proto, std::vector< std::string > const &obsNameVec)
static void PrintCovarianceMatrix(RooFitResult *result, RooArgSet *params, std::string filename)
RooArgList createObservables(const TH1 *hist, RooWorkspace &proto) const
Create observables of type RooRealVar. Creates 1 to 3 observables, depending on the type of the histo...
The RooStats::HistFactory::Measurement class can be used to construct a model by combining multiple R...
Configuration for an un- constrained overall systematic to scale sample normalisations.
Definition Measurement.h:60
Configuration for a constrained overall systematic to scale sample normalisations.
Definition Measurement.h:36
const std::string & GetName() const
Definition Measurement.h:40
*Un*constrained bin-by-bin variation of affected histogram.
Constrained bin-by-bin variation of affected histogram.
Constraint::Type GetConstraintType() const
< A class that holds configuration information for a model using a workspace as a store
Definition ModelConfig.h:34
Persistable container for RooFit projects.
RooAbsPdf * pdf(RooStringView name) const
Retrieve p.d.f (RooAbsPdf) with given name. A null pointer is returned if not found.
RooAbsArg * arg(RooStringView name) const
Return RooAbsArg with given name. A null pointer is returned if none is found.
bool import(const RooAbsArg &arg, const RooCmdArg &arg1={}, const RooCmdArg &arg2={}, const RooCmdArg &arg3={}, const RooCmdArg &arg4={}, const RooCmdArg &arg5={}, const RooCmdArg &arg6={}, const RooCmdArg &arg7={}, const RooCmdArg &arg8={}, const RooCmdArg &arg9={})
Import a RooAbsArg object, e.g.
const Double_t * GetArray() const
Definition TArrayD.h:43
Class to manage histogram axis.
Definition TAxis.h:32
Bool_t IsVariableBinSize() const
Definition TAxis.h:144
const char * GetTitle() const override
Returns title of object.
Definition TAxis.h:137
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition TAxis.cxx:489
const TArrayD * GetXbins() const
Definition TAxis.h:138
Double_t GetXmax() const
Definition TAxis.h:142
Double_t GetXmin() const
Definition TAxis.h:141
Int_t GetNbins() const
Definition TAxis.h:127
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:125
TAxis * GetZaxis()
Definition TH1.h:602
virtual Int_t GetNbinsY() const
Definition TH1.h:571
virtual Int_t GetNbinsZ() const
Definition TH1.h:572
virtual Int_t GetDimension() const
Definition TH1.h:556
virtual void Reset(Option_t *option="")
Reset this histogram: contents, errors, etc.
Definition TH1.cxx:7324
TAxis * GetXaxis()
Definition TH1.h:600
virtual Int_t GetNbinsX() const
Definition TH1.h:570
TAxis * GetYaxis()
Definition TH1.h:601
Bool_t IsBinUnderflow(Int_t bin, Int_t axis=0) const
Return true if the bin is underflow.
Definition TH1.cxx:5392
Bool_t IsBinOverflow(Int_t bin, Int_t axis=0) const
Return true if the bin is overflow.
Definition TH1.cxx:5360
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition TH1.cxx:5239
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:173
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
const char * GetTitle() const override
Returns title of object.
Definition TNamed.h:50
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:226
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:1096
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2460
RooCmdArg RecycleConflictNodes(bool flag=true)
RooCmdArg Rename(const char *suffix)
RooCmdArg Conditional(const RooArgSet &pdfSet, const RooArgSet &depSet, bool depsAreCond=false)
RooConstVar & RooConst(double val)
RooCmdArg Index(RooCategory &icat)
RooCmdArg StoreError(const RooArgSet &aset)
RooCmdArg WeightVar(const char *name="weight", bool reinterpretAsWeight=false)
RooCmdArg Import(const char *state, TH1 &histo)
T * OwningPtr
An alias for raw pointers for indicating that the return type of a RooFit function is an owning point...
Definition Config.h:35
@ ObjectHandling
OwningPtr< T > makeOwningPtr(std::unique_ptr< T > &&ptr)
Internal helper to turn a std::unique_ptr<T> into an OwningPtr.
Definition Config.h:40
CreateGammaConstraintsOutput createGammaConstraints(RooArgList const &paramSet, std::span< const double > relSigmas, double minSigma, Constraint::Type type)
Namespace for the RooStats classes.
Definition CodegenImpl.h:67
bool createPerRegionWorkspaces
Control whether individual workspace files are created for each channel (default true).
bool binnedFitOptimization
Enable or disable optimization for binned likelihood fits (default true).
bool storeDataError
Control whether errors on the data histograms are stored in the workspace (default false).