Logo ROOT  
Reference Guide
RooSimPdfBuilder.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 ///
19 /// \class RooSimPdfBuilder
20 ///
21 /// <b>This tool has now been superseded by RooSimWSTool</b>
22 ///
23 /// <p>
24 /// <tt>RooSimPdfBuilder</tt> is a powerful tool to build <tt>RooSimultaneous</tt>
25 /// PDFs that are defined in terms component PDFs that are identical in
26 /// structure, but have different parameters.
27 /// </p>
28 ///
29 /// <h2>Example</h2>
30 ///
31 /// <p>
32 /// The following example demonstrates the essence of <tt>RooSimPdfBuilder</tt>:
33 /// Given a dataset D with a <tt>RooRealVar X</tt> and a <tt>RooCategory C</tt> that has
34 /// state C1 and C2.
35 /// <ul>
36 /// <li> We want to fit the distribution of <tt>X</tt> with a Gaussian+ArgusBG PDF,
37 /// <li> We want to fit the data subsets <tt>D(C==C1)</tt> and <tt>D(C==C2)</tt> separately and simultaneously.
38 /// <li> The PDFs to fit data subsets D_C1 and D_C2 are identical except for
39 /// <ul>
40 /// <li> the kappa parameter of the ArgusBG PDF and
41 /// <li> the sigma parameter of the gaussian PDF
42 /// </ul>
43 /// where each PDF will have its own copy of the parameter
44 /// </ul>
45 /// </p>
46 /// <p>
47 /// Coding this example directly with RooFit classes gives
48 /// (we assume dataset D and variables C and X have been declared previously)
49 /// </p>
50 /// <pre>
51 /// RooRealVar m("m","mean of gaussian",-10,10) ;
52 /// RooRealVar s_C1("s_C1","sigma of gaussian C1",0,20) ;
53 /// RooRealVar s_C2("s_C2","sigma of gaussian C2",0,20) ;
54 /// RooGaussian gauss_C1("gauss_C1","gaussian C1",X,m,s_C1) ;
55 /// RooGaussian gauss_C2("gauss_C2","gaussian C2",X,m,s_C2) ;
56 ///
57 /// RooRealVar k_C1("k_C1","ArgusBG kappa parameter C1",-50,0) ;
58 /// RooRealVar k_C2("k_C2","ArgusBG kappa parameter C2",-50,0) ;
59 /// RooRealVar xm("xm","ArgusBG cutoff point",5.29) ;
60 /// RooArgusBG argus_C1("argus_C1","argus background C1",X,k_C1,xm) ;
61 /// RooArgusBG argus_C2("argus_C2","argus background C2",X,k_C2,xm) ;
62 ///
63 /// RooRealVar gfrac("gfrac","fraction of gaussian",0.,1.) ;
64 /// RooAddPdf pdf_C1("pdf_C1","gauss+argus_C1",RooArgList(gauss_C1,argus_C1),gfrac) ;
65 /// RooAddPdf pdf_C2("pdf_C2","gauss+argus_C2",RooArgList(gauss_C2,argus_C2),gfrac) ;
66 ///
67 /// RooSimultaneous simPdf("simPdf","simPdf",C) ;
68 /// simPdf.addPdf(pdf_C1,"C1") ;
69 /// simPdf.addPdf(pdf_C2,"C2") ;
70 /// </pre>
71 /// <p>
72 /// Coding this example with RooSimPdfBuilder gives
73 /// </p>
74 /// <pre>
75 /// RooRealVar m("m","mean of gaussian",-10,10) ;
76 /// RooRealVar s("s","sigma of gaussian",0,20) ;
77 /// RooGaussian gauss("gauss","gaussian",X,m,s) ;
78 ///
79 /// RooRealVar k("k","ArgusBG kappa parameter",-50,0) ;
80 /// RooRealVar xm("xm","ArgusBG cutoff point",5.29) ;
81 /// RooArgusBG argus("argus","argus background",X,k,xm) ;
82 ///
83 /// RooRealVar gfrac("gfrac","fraction of gaussian",0.,1.) ;
84 /// RooAddPdf pdf("pdf","gauss+argus",RooArgList(gauss,argus),gfrac) ;
85 ///
86 /// RooSimPdfBuilder builder(pdf) ;
87 /// RooArgSet* cfg = builder.createProtoBuildConfig() ;
88 /// dynamic_cast<RooStringVar&>((*cfg)["physModels"]) = "pdf" ; /// Name of the PDF we are going to work with
89 /// dynamic_cast<RooStringVar&>((*cfg)["splitCats"]) = "C" ; /// Category used to differentiate sub-datasets
90 /// dynamic_cast<RooStringVar&>((*cfg)["pdf"]) = "C : k,s" ; /// Prescription to taylor PDF parameters k and s
91 /// /// for each data subset designated by C states
92 /// RooSimultaneous* simPdf = builder.buildPdf(*cfg,&D) ;
93 /// </pre>
94 /// <p>
95 /// The above snippet of code demonstrates the concept of <tt>RooSimPdfBuilder</tt>:
96 /// the user defines a single <i>'prototype' PDF</i> that defines the structure of all
97 /// PDF components of the <tt>RooSimultaneous</tt> PDF to be built. <tt>RooSimPdfBuilder</tt>
98 /// then takes this prototype and replicates it as a component
99 /// PDF for each state of the C index category.
100 /// </p>
101 /// <p>
102 /// In the above example <tt>RooSimPdfBuilder</tt>
103 /// will first replicate <tt>k</tt> and <tt>s</tt> into
104 /// <tt>k_C1,k_C2</tt> and <tt>s_C1,s_C2</tt>, as prescribed in the
105 /// configuration. Then it will recursively replicate all PDF nodes that depend on
106 /// the 'split' parameter nodes: <tt>gauss</tt> into <tt>gauss_C1,C2</tt>, <tt>argus</tt>
107 /// into <tt>argus_C1,C2</tt> and finally <tt>pdf</tt> into <tt>pdf_C1,pdf_C2</tt>.
108 /// When PDFs for all states of C have been replicated
109 /// they are assembled into a <tt>RooSimultaneous</tt> PDF, which is returned by the <tt>buildPdf()</tt>
110 /// method.
111 /// </p>
112 /// <p>
113 /// Although in this very simple example the use of <tt>RooSimPdfBuilder</tt> doesn't
114 /// reduce the amount of code much, it is already easier to read and maintain
115 /// because there is no duplicate code. As the complexity of the <tt>RooSimultaneous</tt>
116 /// to be built increases, the advantages of <tt>RooSimPdfBuilder</tt> will become more and
117 /// more apparent.
118 /// </p>
119 ///
120 ///
121 /// <h2>Builder configuration rules for a single prototype PDF</h2>
122 /// <p>
123 /// Each builder configuration needs at minumum two lines, <tt>physModels</tt> and <tt>splitCats</tt>, which identify
124 /// the ingredients of the build. In this section we only explain the building rules for
125 /// builds from a single prototype PDF. In that case the <tt>physModels</tt> line always reads
126 /// </p>
127 /// <pre>
128 /// physModels = {pdfName}
129 /// </pre>
130 /// <p>
131 /// The second line, <tt>splitCats</tt>, indicates which categories are going to be used to
132 /// differentiate the various subsets of the 'master' input data set. You can enter
133 /// a single category here, or multiple if necessary:
134 /// </p>
135 /// <pre>
136 /// splitCats = {catName} [{catName} ...]
137 /// </pre>
138 /// <p>
139 /// All listed splitcats must be <tt>RooCategories</tt> that appear in the dataset provided to
140 /// <tt>RooSimPdfBuilder::buildPdf()</tt>
141 /// </p>
142 /// <p>
143 /// The parameter splitting prescriptions, the essence of each build configuration
144 /// can be supplied in a third line carrying the name of the pdf listed in <tt>physModels</tt>
145 /// </p>
146 /// <pre>
147 /// pdfName = {splitCat} : {parameter} [,{parameter},....]
148 /// </pre>
149 /// <p>
150 /// Each pdf can have only one line with splitting rules, but multiple rules can be
151 /// supplied in each line, e.g.
152 /// </p>
153 /// <pre>
154 /// pdfName = {splitCat} : {parameter} [,{parameter},....]
155 /// {splitCat} : {parameter} [,{parameter},....]
156 /// </pre>
157 /// <p>
158 /// Conversely, each parameter can only have one splitting prescription, but it may be split
159 /// by multiple categories, e.g.
160 /// </p>
161 /// <pre>
162 /// pdfName = {splitCat1},{splitCat2} : {parameter}
163 /// </pre>
164 /// <p>
165 /// instructs <tt>RooSimPdfBuilder</tt> to build a <tt>RooSuperCategory</tt>
166 /// of <tt>{splitCat1}</tt> and <tt>{splitCat2}</tt>
167 /// and split <tt>{parameter}</tt> with that <tt>RooSuperCategory</tt>
168 /// </p>
169 /// <p>
170 /// Here is an example of a builder configuration that uses several of the options discussed
171 /// above:
172 /// </p>
173 /// <pre>
174 /// physModels = pdf
175 /// splitCats = tagCat runBlock
176 /// pdf = tagCat : signalRes,bkgRes
177 /// runBlock : fudgeFactor
178 /// tagCat,runBlock : kludgeParam
179 /// </pre>
180 ///
181 /// <h2>How to enter configuration data</h2>
182 ///
183 /// <p>
184 /// The prototype builder configuration returned by
185 /// <tt>RooSimPdfBuilder::createProtoBuildConfig()</tt> is a pointer to a <tt>RooArgSet</tt> filled with
186 /// initially blank <tt>RooStringVars</tt> named <tt>physModels,splitCats</tt> and one additional for each
187 /// PDF supplied to the <tt>RooSimPdfBuilders</tt> constructor (with the same name)
188 /// </p>
189 /// <p>
190 /// In macro code, the easiest way to assign new values to these <tt>RooStringVars</tt>
191 /// is to use <tt>RooArgSet</tt>s array operator and the <tt>RooStringVar</tt>s assignment operator, e.g.
192 /// </p>
193 /// <pre>
194 /// (*config)["physModels"] = "Blah" ;
195 /// </pre>
196 /// <p>
197 /// To enter multiple splitting rules simply separate consecutive rules by whitespace
198 /// (not newlines), e.g.
199 /// </p>
200 /// <pre>
201 /// (*config)["physModels"] = "Blah " /// << note trailing space here
202 /// "Blah 2" ;
203 /// </pre>
204 /// <p>
205 /// In this example, the C++ compiler will concatenate the two string literals (without inserting
206 /// any whitespace), so the extra space after 'Blah' is important here.
207 /// </p>
208 /// <p>
209 /// Alternatively, you can read the configuration from an ASCII file, as you can
210 /// for any <tt>RooArgSet</tt> using <tt>RooArgSet::readFromFile()</tt>. In that case the ASCII file
211 /// can follow the syntax of the examples above and the '<tt>\</tt>' line continuation
212 /// sequence can be used to fold a long splitting rule over multiple lines.
213 /// </p>
214 /// <pre>
215 /// RooArgSet* config = builder.createProtoBuildConfig() ;
216 /// config->readFromFile("config.txt") ;
217 ///
218 /// --- config.txt ----------------
219 /// physModels = pdf
220 /// splitCats = tagCat
221 /// pdf = tagCat : bogusPar
222 /// -------------------------------
223 /// </pre>
224 ///
225 ///
226 /// <h2>Working with multiple prototype PDFs</h2>
227 /// <p>
228 /// It is also possible to build a <tt>RooSimultaneous</tt> PDF from multiple PDF prototypes.
229 /// This is appropriate for cases where the input prototype PDF would otherwise be
230 /// a <tt>RooSimultaneous</tt> PDF by itself. In such cases we don't feed a single
231 /// <tt>RooSimultaneous</tt> PDF into <tt>RooSimPdfBuilder</tt>, instead we feed it its ingredients and
232 /// add a prescription to the builder configuration that corresponds to the
233 /// PDF-category state mapping of the prototype <tt>RooSimultaneous</tt>.
234 /// </p>
235 /// <p>
236 /// The constructor of the <tt>RooSimPdfBuilder</tt> will look as follows:
237 /// </p>
238 /// <pre>
239 /// RooSimPdfBuilder builder(RooArgSet(pdfA,pdfB,...)) ;
240 /// </pre>
241 /// <p>
242 /// The <tt>physModels</tt> line is now expanded to carry the pdf->state mapping information
243 /// that the prototype <tt>RooSimultaneous</tt> would have. I.e.
244 /// </p>
245 /// <pre>
246 /// physModels = mode : pdfA=modeA pdfB=modeB
247 /// </pre>
248 /// <p>
249 /// is equivalent to a prototype <tt>RooSimultaneous</tt> constructed as
250 /// </p>
251 /// <pre>
252 /// RooSimultanous simPdf("simPdf","simPdf",mode);
253 /// simPdf.addPdf(pdfA,"modeA") ;
254 /// simPdf.addPdf(pdfB,"modeB") ;
255 /// </pre>
256 /// <p>
257 /// The rest of the builder configuration works the same, except that
258 /// each prototype PDF now has its own set of splitting rules, e.g.
259 /// </p>
260 /// <pre>
261 /// physModels = mode : pdfA=modeA pdfB=modeB
262 /// splitCats = tagCat
263 /// pdfA = tagCat : bogusPar
264 /// pdfB = tagCat : fudgeFactor
265 /// </pre>
266 /// <p>
267 /// Please note that
268 /// <ul>
269 /// <li> The master index category ('mode' above) doesn't have to be listed in
270 /// <tt>splitCats</tt>, this is implicit.
271 ///
272 /// <li> The number of splitting prescriptions goes by the
273 /// number of prototype PDFs and not by the number of states of the
274 /// master index category (mode in the above and below example).
275 /// </ul>
276 ///
277 /// In the following case:
278 ///</p>
279 /// <pre>
280 /// physModels = mode : pdfA=modeA pdfB=modeB pdfA=modeC pdfB=modeD
281 /// </pre>
282 /// <p>
283 /// there are still only 2 sets of splitting rules: one for <tt>pdfA</tt> and one
284 /// for <tt>pdfB</tt>. However, you <i>can</i> differentiate between <tt>modeA</tt> and <tt>modeC</tt> in
285 /// the above example. The technique is to use <tt>mode</tt> as splitting category, e.g.
286 /// </p>
287 /// <pre>
288 /// physModels = mode : pdfA=modeA pdfB=modeB pdfA=modeC pdfB=modeD
289 /// splitCats = tagCat
290 /// pdfA = tagCat : bogusPar
291 /// mode : funnyPar
292 /// pdfB = mode : kludgeFactor
293 /// </pre>
294 /// <p>
295 /// will result in an individual set of <tt>funnyPar</tt> parameters for <tt>modeA</tt> and <tt>modeC</tt>
296 /// labeled <tt>funnyPar_modeA</tt> and <tt>funnyPar_modeB</tt> and an individual set of
297 /// kludgeFactor parameters for <tt>pdfB</tt>, <tt>kludgeFactor_modeB</tt> and <tt>kludgeFactor_modeD</tt>.
298 /// Please note that for splits in the master index category (mode) only the
299 /// applicable states are built (A,C for <tt>pdfA</tt>, B,D for <tt>pdfB</tt>)
300 /// </p>
301 ///
302 ///
303 /// <h2>Advanced options</h2>
304 ///
305 /// <h4>Partial splits</h4>
306 /// <p>
307 /// You can request to limit the list of states of each splitCat that
308 /// will be considered in the build. This limitation is requested in the
309 /// each build as follows:
310 /// </p>
311 /// <pre>
312 /// splitCats = tagCat(Lep,Kao) RunBlock(Run1)
313 /// </pre>
314 /// <p>
315 /// In this example the splitting of <tt>tagCat</tt> is limited to states <tt>Lep,Kao</tt>
316 /// and the splitting of <tt>runBlock</tt> is limited to <tt>Run1</tt>. The splits apply
317 /// globally to each build, i.e. every parameter split requested in this
318 /// build will be limited according to these specifications.
319 /// </p>
320 /// <p>
321 /// NB: Partial builds have no pdf associated with the unbuilt states of the
322 /// limited splits. Running such a pdf on a dataset that contains data with
323 /// unbuilt states will result in this data being ignored completely.
324 /// </p>
325 ///
326 ///
327 /// <h4>Non-trivial splits</h4>
328 /// <p>
329 /// It is possible to make non-trivial parameter splits with <tt>RooSimPdfBuilder</tt>.
330 /// Trivial splits are considered simple splits in one (fundamental) category
331 /// in the dataset or a split in a <tt>RooSuperCategory</tt> 'product' of multiple
332 /// fundamental categories in the dataset. Non-trivial splits can be performed
333 /// using an intermediate 'category function' (<tt>RooMappedCategory,
334 /// RooGenericCategory,RooThresholdCategory</tt> etc), i.e. any <tt>RooAbsCategory</tt>
335 /// derived objects that calculates its output as function of one or more
336 /// input <tt>RooRealVars</tt> and/or <tt>RooCategories</tt>.
337 /// </p>
338 /// <p>
339 /// Such 'function categories' objects must be constructed by the user prior
340 /// to building the PDF. In the <tt>RooSimPdfBuilder::buildPdf()</tt> function these
341 /// objects can be passed in an optional <tt>RooArgSet</tt> called 'auxiliary categories':
342 /// </p>
343 /// <pre>
344 /// const <tt>RooSimultaneous</tt>* buildPdf(const RooArgSet& buildConfig, const RooAbsData* dataSet,
345 /// const RooArgSet& auxSplitCats, bool verbose=false) {
346 /// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
347 /// </pre>
348 /// <p>
349 /// Objects passed in this argset can subsequently be used in the build configuration, e.g.
350 /// </p>
351 /// <pre>
352 /// RooMappedCategory tagMap("tagMap","Mapped tagging category",tagCat,"CutBased") ;
353 /// tagMap.map("Lep","CutBased") ;
354 /// tagMap.map("Kao","CutBased") ;
355 /// tagMap.map("NT*","NeuralNet") ;
356 /// ...
357 /// builder.buildPdf(config,D,tagMap) ;
358 /// ^^^^^^
359 ///<Contents of config>
360 /// physModels = pdf
361 /// splitCats = tagCat runBlock
362 /// pdf = tagCat : signalRes
363 /// tagMap : fudgeFactor
364 /// ^^^^^^
365 /// </pre>
366 /// <p>
367 /// In the above example <tt>signalRes</tt> will be split in <tt>signalRes_Kao,signalRes_Lep,
368 /// signalRes_NT1,signalRes_NT2</tt>, while <tt>fudgeFactor</tt> will be split in <tt>fudgeFactor_CutBased</tt>
369 /// and <tt>fudgeFactor_NeuralNet</tt>.
370 /// </p>
371 /// <p>
372 /// Category functions passed in the auxSplitCats <tt>RooArgSet</tt> can be used regularly
373 /// in the splitting configuration. They should not be listed in <tt>splitCats</tt>,
374 /// but must be able to be expressed <i>completely</i> in terms of the <tt>splitCats</tt> that
375 /// are listed.
376 /// </p>
377 ///
378 ///
379 /// <h4>Multiple connected builds</h4>
380 /// <p>
381 /// Sometimes you want to build multiple PDFs for independent consecutive fits
382 /// that share some of their parameters. For example, we have two prototype PDFs
383 /// <tt>pdfA(x;p,q)</tt> and <tt>pdfB(x;p,r)</tt> that have a common parameter <tt>p</tt>.
384 /// We want to build a <tt>RooSimultaneous</tt> for both <tt>pdfA</tt> and <tt>B</tt>,
385 /// which involves a split of parameter <tt>p</tt> and we would like to build the
386 /// simultaneous pdfs <tt>simA</tt> and <tt>simB</tt> such that still share their (now split) parameters
387 /// <tt>p_XXX</tt>. This is accomplished by letting a single instance of <tt>RooSimPdfBuilder</tt> handle
388 /// the builds of both <tt>pdfA</tt> and <tt>pdfB</tt>, as illustrated in this example:
389 /// </p>
390 /// <pre>
391 /// RooSimPdfBuilder builder(RooArgSet(pdfA,pdfB)) ;
392 ///
393 /// RooArgSet* configA = builder.createProtoBuildConfig() ;
394 /// (*configA)["physModels"] = "pdfA" ;
395 /// (*configA)["splitCats"] = "C" ;
396 /// (*configA)["pdf"] = "C : p" ;
397 /// RooSimultaneous* simA = builder.buildPdf(*configA,&D) ;
398 ///
399 /// RooArgSet* configB = builder.createProtoBuildConfig() ;
400 /// (*configA)["physModels"] = "pdfB" ;
401 /// (*configA)["splitCats"] = "C" ;
402 /// (*configA)["pdf"] = "C : p" ;
403 /// RooSimultaneous* simB = builder.buildPdf(*configB,&D) ;
404 /// </pre>
405 ///
406 /// <h2>Ownership of constructed PDFs</h2>
407 /// <p>
408 /// The <tt>RooSimPdfBuilder</tt> instance owns all the objects it creates, including the top-level
409 /// <tt>RooSimultaneous</tt> returned by <tt>buildPdf()</tt>. Therefore the builder instance should
410 /// exist as long as the constructed PDFs needs to exist.
411 /// </p>
412 ///
413 ///
414 ///
415 
416 
417 #include "RooFit.h"
418 
419 #include <cstring>
420 #include "strtok.h"
421 
422 #ifndef _WIN32
423 #include <strings.h>
424 #endif
425 
426 #include "Riostream.h"
427 #include "RooSimPdfBuilder.h"
428 
429 #include "RooRealVar.h"
430 #include "RooFormulaVar.h"
431 #include "RooAbsCategory.h"
432 #include "RooCategory.h"
433 #include "RooStringVar.h"
434 #include "RooMappedCategory.h"
435 #include "RooRealIntegral.h"
436 #include "RooDataSet.h"
437 #include "RooArgSet.h"
438 #include "RooPlot.h"
439 #include "RooAddPdf.h"
440 #include "RooLinearVar.h"
441 #include "RooTruthModel.h"
442 #include "RooAddModel.h"
443 #include "RooProdPdf.h"
444 #include "RooCustomizer.h"
445 #include "RooThresholdCategory.h"
446 #include "RooMultiCategory.h"
447 #include "RooSuperCategory.h"
448 #include "RooSimultaneous.h"
449 #include "RooTrace.h"
450 #include "RooFitResult.h"
451 #include "RooDataHist.h"
452 #include "RooGenericPdf.h"
453 #include "RooMsgService.h"
454 #include "RooHelpers.h"
455 
456 using namespace std ;
457 
459 ;
460 
461 
462 
463 ////////////////////////////////////////////////////////////////////////////////
464 
466  _protoPdfSet(protoPdfSet)
467 {
471 }
472 
473 
474 
475 
476 ////////////////////////////////////////////////////////////////////////////////
477 /// Make RooArgSet of configuration objects
478 
480 {
481  RooArgSet* buildConfig = new RooArgSet ;
482  buildConfig->addOwned(* new RooStringVar("physModels","List and mapping of physics models to include in build","",4096)) ;
483  buildConfig->addOwned(* new RooStringVar("splitCats","List of categories used for splitting","",1024)) ;
484 
485  for(auto * proto : _protoPdfSet) {
486  buildConfig->addOwned(* new RooStringVar(proto->GetName(),proto->GetName(),"",4096)) ;
487  }
488 
489  return buildConfig ;
490 }
491 
492 
493 
494 ////////////////////////////////////////////////////////////////////////////////
495 
497 {
498  _splitNodeList.add(specSet) ;
499 }
500 
501 
502 
503 ////////////////////////////////////////////////////////////////////////////////
504 /// Initialize needed components
505 
506 RooSimultaneous* RooSimPdfBuilder::buildPdf(const RooArgSet& buildConfig, const RooArgSet& dependents,
507  const RooArgSet* auxSplitCats, bool verbose)
508 {
509  const char* spaceChars = " \t" ;
510 
511  // Retrieve physics index category
512  int buflen = strlen(((RooStringVar*)buildConfig.find("physModels"))->getVal())+1 ;
513  std::vector<char> bufContainer(buflen);
514  char *buf = bufContainer.data() ;
515 
516  strlcpy(buf,((RooStringVar*)buildConfig.find("physModels"))->getVal(),buflen) ;
517  RooAbsCategoryLValue* physCat(0) ;
518  if (strstr(buf," : ")) {
519  const char* physCatName = strtok(buf,spaceChars) ;
520  physCat = dynamic_cast<RooAbsCategoryLValue*>(dependents.find(physCatName)) ;
521  if (!physCat) {
522  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR physics index category " << physCatName
523  << " not found in dataset variables" << endl ;
524  return 0 ;
525  }
526  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: category indexing physics model: " << physCatName << endl ;
527  }
528 
529  // Create list of physics models to be built
530  char *physName ;
531  RooArgSet physModelSet ;
532  if (physCat) {
533  // Absorb colon token
534  strtok(0,spaceChars) ;
535  physName = strtok(0,spaceChars) ;
536  } else {
537  physName = strtok(buf,spaceChars) ;
538  }
539 
540  if (!physName) {
541  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR: No models specified, nothing to do!" << endl ;
542  return 0 ;
543  }
544 
545  bool first{true} ;
546  RooArgSet stateMap ;
547  while(physName) {
548 
549  char *stateName(0) ;
550 
551  // physName may be <state>=<pdfName> or just <pdfName> is state and pdf have identical names
552  if (strchr(physName,'=')) {
553  // Must have a physics category for mapping to make sense
554  if (!physCat) {
555  coutW(ObjectHandling) << "RooSimPdfBuilder::buildPdf: WARNING: without physCat specification "
556  << "<physCatState>=<pdfProtoName> association is meaningless" << endl ;
557  }
558  stateName = physName ;
559  physName = strchr(stateName,'=') ;
560  if (physName) {
561  *(physName++) = 0 ;
562  }
563  } else {
564  stateName = physName ;
565  }
566 
567  RooAbsPdf* physModel = (RooAbsPdf*) (physName ? _protoPdfSet.find(physName) : 0 );
568  if (!physModel) {
569  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR requested physics model "
570  << (physName?physName:"(null)") << " is not defined" << endl ;
571  return 0 ;
572  }
573 
574  // Check if state mapping has already been defined
575  if (stateMap.find(stateName)) {
576  coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: multiple PDFs specified for state "
577  << stateName << ", only first will be used" << endl ;
578  continue ;
579  }
580 
581  // Add pdf to list of models to be processed
582  physModelSet.add(*physModel,true) ; // silence duplicate insertion warnings
583 
584  // Store state->pdf mapping
585  stateMap.addOwned(* new RooStringVar(stateName,stateName,physName)) ;
586 
587  // Continue with next mapping
588  physName = strtok(0,spaceChars) ;
589  if (first) {
590  first = false ;
591  } else if (physCat==0) {
592  coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: without physCat specification, only the first model will be used" << endl ;
593  break ;
594  }
595  }
596  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of physics models " << physModelSet << endl ;
597 
598 
599 
600  // Create list of dataset categories to be used in splitting
601  TList splitStateList ;
602  RooArgSet splitCatSet ;
603 
604  buflen = strlen(((RooStringVar*)buildConfig.find("splitCats"))->getVal())+1 ;
605  bufContainer.resize(buflen);
606  buf = bufContainer.data(); // memory might have been reallocated after resize, so reset the data pointer
607 
608  strlcpy(buf,((RooStringVar*)buildConfig.find("splitCats"))->getVal(),buflen) ;
609 
610  char *catName = strtok(buf,spaceChars) ;
611  char *stateList(0) ;
612  while(catName) {
613 
614  // Chop off optional list of selected states
615  char* tokenPtr(0) ;
616  if (strchr(catName,'(')) {
617 
618  catName = R__STRTOK_R(catName,"(",&tokenPtr) ;
619  stateList = R__STRTOK_R(0,")",&tokenPtr) ;
620 
621  } else {
622  stateList = 0 ;
623  }
624 
625  RooCategory* splitCat = catName ? dynamic_cast<RooCategory*>(dependents.find(catName)) : 0 ;
626  if (!splitCat) {
627  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR requested split category " << (catName?catName:"(null)")
628  << " is not a RooCategory in the dataset" << endl ;
629  return 0 ;
630  }
631  splitCatSet.add(*splitCat) ;
632 
633  // Process optional state list
634  if (stateList) {
635  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: splitting of category " << catName
636  << " restricted to states (" << stateList << ")" << endl ;
637 
638  // Create list named after this splitCat holding its selected states
639  TList* slist = new TList ;
640  slist->SetName(catName) ;
641  splitStateList.Add(slist) ;
642 
643  char* stateLabel = R__STRTOK_R(stateList,",",&tokenPtr) ;
644 
645  while(stateLabel) {
646  // Lookup state label and require it exists
647  const RooCatType* type = splitCat->lookupType(stateLabel) ;
648  if (!type) {
649  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR splitCat " << splitCat->GetName()
650  << " doesn't have a state named " << stateLabel << endl ;
651  splitStateList.Delete() ;
652  return 0 ;
653  }
654  slist->Add((TObject*)type) ;
655 
656  stateLabel = R__STRTOK_R(0,",",&tokenPtr) ;
657  }
658  }
659 
660  catName = strtok(0,spaceChars) ;
661  }
662  if (physCat) splitCatSet.add(*physCat) ;
663  RooSuperCategory masterSplitCat("masterSplitCat","Master splitting category",splitCatSet) ;
664 
665  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of splitting categories " << splitCatSet << endl ;
666 
667  // Clone auxiliary split cats and attach to splitCatSet
668  RooArgSet auxSplitSet ;
669  if (auxSplitCats) {
670  // Deep clone auxililary split cats
671  if (!std::unique_ptr<RooArgSet>{auxSplitCats->snapshot(true)}) {
672  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf(" << GetName() << ") Couldn't deep-clone set auxiliary splitcats, abort." << endl ;
673  return 0 ;
674  }
675 
676  for (const auto arg : *auxSplitCats) {
677  // Find counterpart in cloned set
678  RooAbsArg* aux = auxSplitCats->find(arg->GetName()) ;
679 
680  // Check that there is no fundamental splitCat in the dataset with the bane of the auxiliary split
681  if (splitCatSet.find(aux->GetName())) {
682  coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: dataset contains a fundamental splitting category " << endl
683  << " with the same name as an auxiliary split function (" << aux->GetName() << "). " << endl
684  << " Auxiliary split function will be ignored" << endl ;
685  continue ;
686  }
687 
688  // Check that all servers of this aux cat are contained in splitCatSet
689  std::unique_ptr<RooArgSet> parSet{aux->getParameters(splitCatSet)} ;
690  if (parSet->getSize()>0) {
691  coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: ignoring auxiliary category " << aux->GetName()
692  << " because it has servers that are not listed in splitCatSet: " << *parSet << endl ;
693  continue ;
694  }
695 
696  // Redirect servers to splitCatSet
697  aux->recursiveRedirectServers(splitCatSet) ;
698 
699  // Add top level nodes to auxSplitSet
700  auxSplitSet.add(*aux) ;
701  }
702 
703  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of auxiliary splitting categories " << auxSplitSet << endl ;
704  }
705 
706  TList customizerList;
707 
708  // Loop over requested physics models and build components
709  for (const auto arg : physModelSet) {
710  auto physModel = static_cast<const RooAbsPdf*>(arg);
711 
712  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: processing physics model " << physModel->GetName() << endl ;
713 
714  RooCustomizer* physCustomizer = new RooCustomizer(*physModel,masterSplitCat,_splitNodeList) ;
715  customizerList.Add(physCustomizer) ;
716 
717  // Parse the splitting rules for this physics model
718  RooStringVar* ruleStr = (RooStringVar*) buildConfig.find(physModel->GetName()) ;
719  if (ruleStr) {
720 
721  enum Mode { SplitCat, Colon, ParamList } ;
722  Mode mode(SplitCat) ;
723 
724  const char* splitCatName ;
725  RooAbsCategory* splitCat(0) ;
726 
727  for (const auto& token : RooHelpers::tokenise(ruleStr->getVal(), spaceChars)) {
728 
729  switch (mode) {
730  case SplitCat:
731  {
732  splitCatName = token.data();
733 
734  if (token.find(',') != std::string::npos) {
735  // Composite splitting category
736 
737  // Check if already instantiated
738  splitCat = (RooAbsCategory*) _compSplitCatSet.find(splitCatName) ;
739  const std::string origCompCatName{splitCatName} ;
740  if (!splitCat) {
741  // Build now
742 
743  RooArgSet compCatSet ;
744  for (const auto& catName2 : RooHelpers::tokenise(token, ",")) {
745  RooAbsArg* cat = splitCatSet.find(catName2.data()) ;
746 
747  // If not, check if it is an auxiliary splitcat
748  if (!cat) {
749  cat = (RooAbsCategory*) auxSplitSet.find(catName2.data()) ;
750  }
751 
752  if (!cat) {
753  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << catName2
754  << " not found in the primary or auxilary splitcat list" << endl ;
755  customizerList.Delete() ;
756 
757  splitStateList.Delete() ;
758  return 0 ;
759  }
760  compCatSet.add(*cat) ;
761  }
762 
763 
764  // check that any auxSplitCats in compCatSet do not depend on any other
765  // fundamental or auxiliary splitting categories in the composite set.
766  for (const auto theArg : compCatSet) {
767  RooArgSet tmp(compCatSet) ;
768  tmp.remove(*theArg) ;
769  if (theArg->dependsOnValue(tmp)) {
771  << "RooSimPdfBuilder::buildPDF: ERROR: Ill defined split: auxiliary splitting category "
772  << theArg->GetName() << " used in composite split " << compCatSet
773  << " depends on one or more of the other splitting categories in the composite split"
774  << std::endl ;
775 
776  // Cleanup and axit
777  customizerList.Delete() ;
778  splitStateList.Delete() ;
779  return 0 ;
780  }
781  }
782 
783  splitCat = new RooMultiCategory(origCompCatName.c_str(), origCompCatName.c_str(), compCatSet) ;
784  _compSplitCatSet.addOwned(*splitCat) ;
785  //cout << "composite splitcat: " << splitCat->GetName() ;
786  }
787  } else {
788  // Simple splitting category
789 
790  // First see if it is a simple splitting category
791  splitCat = (RooAbsCategory*) splitCatSet.find(splitCatName) ;
792 
793  // If not, check if it is an auxiliary splitcat
794  if (!splitCat) {
795  splitCat = (RooAbsCategory*) auxSplitSet.find(splitCatName) ;
796  }
797 
798  if (!splitCat) {
799  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR splitting category "
800  << splitCatName << " not found in the primary or auxiliary splitcat list" << endl ;
801  customizerList.Delete() ;
802  splitStateList.Delete() ;
803  return 0 ;
804  }
805  }
806 
807  mode = Colon ;
808  break ;
809  }
810  case Colon:
811  {
812  if (token != ":") {
813  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR in parsing, expected ':' after "
814  << splitCat << ", found " << token << endl ;
815  customizerList.Delete() ;
816  splitStateList.Delete() ;
817  return 0 ;
818  }
819  mode = ParamList ;
820  break ;
821  }
822  case ParamList:
823  {
824  // Verify the validity of the parameter list and build the corresponding argset
825  RooArgSet splitParamList ;
826  std::unique_ptr<RooArgSet> paramList{physModel->getParameters(dependents)} ;
827 
828  // wve -- add nodes to parameter list
829  std::unique_ptr<RooArgSet> compList{physModel->getComponents()} ;
830  paramList->add(*compList) ;
831 
832  const bool lastCharIsComma = (token[token.size()-1]==',') ;
833 
834  for (const auto& paramName : RooHelpers::tokenise(token, ",")) {
835  // Check for fractional split option 'param_name[remainder_state]'
836  std::string remainderState;
837  {
838  const auto pos = paramName.find('[');
839  if (pos != std::string::npos) {
840  const auto posEnd = paramName.find(']');
841  remainderState = paramName.substr(pos+1, posEnd - pos - 1);
842  }
843  }
844 
845 
846  // If fractional split is specified, check that remainder state is a valid state of this split cat
847  if (!remainderState.empty()) {
848  if (!splitCat->hasLabel(remainderState)) {
849  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR fraction split of parameter "
850  << paramName << " has invalid remainder state name: " << remainderState << endl ;
851  customizerList.Delete() ;
852  splitStateList.Delete() ;
853  return 0 ;
854  }
855  }
856 
857  RooAbsArg* param = paramList->find(paramName.data()) ;
858  if (!param) {
859  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << paramName
860  << " is not a parameter of physics model " << physModel->GetName() << endl ;
861  customizerList.Delete() ;
862  splitStateList.Delete() ;
863  return 0 ;
864  }
865  splitParamList.add(*param) ;
866 
867  // Build split leaf of fraction splits here
868  if (!remainderState.empty()) {
869 
870  // Check if we are splitting a real-valued parameter
871  if (!dynamic_cast<RooAbsReal*>(param)) {
872  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR fraction split requested of non-real valued parameter "
873  << param->GetName() << endl ;
874  customizerList.Delete() ;
875  splitStateList.Delete() ;
876  return 0 ;
877  }
878 
879  // Check if we are doing a restricted build
880  TList* remStateSplitList = static_cast<TList*>(splitStateList.FindObject(splitCat->GetName())) ;
881 
882  // If so, check if remainder state is actually being built.
883  if (remStateSplitList && !remStateSplitList->FindObject(remainderState.data())) {
884  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << paramName
885  << " remainder state " << remainderState << " in parameter split "
886  << param->GetName() << " is not actually being built" << endl ;
887  customizerList.Delete() ;
888  splitStateList.Delete() ;
889  return 0 ;
890  }
891 
892  std::unique_ptr<TIterator> iter{splitCat->typeIterator()} ;
893  RooCatType* type ;
894  RooArgList fracLeafList ;
895  std::string formExpr{"1"} ;
896  int i(0) ;
897 
898  while((type=(RooCatType*)iter->Next())) {
899 
900  // Skip remainder state
901  if (std::string{type->GetName()} != remainderState) continue ;
902 
903  // If restricted build is requested, skip states of splitcat that are not built
904  if (remStateSplitList && !remStateSplitList->FindObject(type->GetName())) {
905  continue ;
906  }
907 
908  // Construct name of split leaf
909  const auto splitLeafName = std::string{param->GetName()} + "_" + type->GetName();
910 
911  // Check if split leaf already exists
912  RooAbsArg* splitLeaf = _splitNodeList.find(splitLeafName.c_str()) ;
913  if (!splitLeaf) {
914  // If not create it now
915  splitLeaf = (RooAbsArg*) param->clone(splitLeafName.c_str()) ;
916  _splitNodeList.add(*splitLeaf) ;
917  _splitNodeListOwned.addOwned(*splitLeaf) ;
918  }
919  fracLeafList.add(*splitLeaf) ;
920  formExpr += Form("-@%d",i++) ;
921  }
922 
923  // Construct RooFormulaVar expresssing remainder of fraction
924  const auto remLeafName = std::string{param->GetName()} + "_" + remainderState;
925 
926  // Check if no specialization was already specified for remainder state
927  if (!_splitNodeList.find(remLeafName.c_str())) {
928  RooAbsArg* remLeaf = new RooFormulaVar(remLeafName.c_str(), formExpr.c_str(), fracLeafList) ;
929  _splitNodeList.add(*remLeaf) ;
930  _splitNodeListOwned.addOwned(*remLeaf) ;
931  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: creating remainder fraction formula for " << remainderState
932  << " specialization of split parameter " << param->GetName() << " " << formExpr << endl ;
933  }
934  }
935  }
936 
937  // Add the rule to the appropriate customizer ;
938  physCustomizer->splitArgs(splitParamList,*splitCat) ;
939 
940  if (!lastCharIsComma) mode = SplitCat ;
941  break ;
942  }
943  }
944  }
945  if (mode!=SplitCat) {
946  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR in parsing, expected "
947  << (mode==Colon?":":"parameter list") << " in " << ruleStr->getVal() << endl ;
948  }
949 
950  //RooArgSet* paramSet = physModel->getParameters(dependents) ;
951  } else {
952  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: no splitting rules for " << physModel->GetName() << endl ;
953  }
954  }
955 
956  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: configured customizers for all physics models" << endl ;
957  if (oodologI((TObject*)0,ObjectHandling)) {
958  customizerList.Print() ;
959  }
960 
961  // Create fit category from physCat and splitCatList ;
962  RooArgSet fitCatList ;
963  if (physCat) fitCatList.add(*physCat) ;
964  fitCatList.add(splitCatSet) ;
965  RooSuperCategory *fitCat = new RooSuperCategory("fitCat","fitCat",fitCatList) ;
966 
967  // Create master PDF
968  RooSimultaneous* simPdf = new RooSimultaneous("simPdf","simPdf",*fitCat) ;
969 
970  // Add component PDFs to master PDF
971  std::unique_ptr<TIterator> fcIter{fitCat->typeIterator()} ;
972 
973  RooCatType* fcState ;
974  while((fcState=(RooCatType*)fcIter->Next())) {
975  // Select fitCat state
976  fitCat->setLabel(fcState->GetName()) ;
977 
978  // Check if this fitCat state is selected
979  bool select{true} ;
980  for (const auto arg : fitCatList) {
981  auto splitCat = static_cast<const RooAbsCategory*>(arg);
982 
983  // Find selected state list
984  TList* slist = (TList*) splitStateList.FindObject(splitCat->GetName()) ;
985  if (!slist) continue ;
986  RooCatType* type = (RooCatType*) slist->FindObject(splitCat->getCurrentLabel()) ;
987  if (!type) {
988  select = false ;
989  }
990  }
991  if (!select) continue ;
992 
993 
994  // Select appropriate PDF for this physCat state
995  RooCustomizer* physCustomizer ;
996  if (physCat) {
997  RooStringVar* physNameVar = (RooStringVar*) stateMap.find(physCat->getCurrentLabel()) ;
998  if (!physNameVar) continue ;
999  physCustomizer = static_cast<RooCustomizer*>(customizerList.FindObject(physNameVar->getVal())) ;
1000  } else {
1001  physCustomizer = static_cast<RooCustomizer*>(customizerList.First()) ;
1002  }
1003 
1004  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: Customizing physics model " << physCustomizer->GetName()
1005  << " for mode " << fcState->GetName() << endl ;
1006 
1007  // Customizer PDF for current state and add to master simPdf
1008  RooAbsPdf* fcPdf = (RooAbsPdf*) physCustomizer->build(masterSplitCat.getCurrentLabel(),verbose) ;
1009  simPdf->addPdf(*fcPdf,fcState->GetName()) ;
1010  }
1011 
1012  // Move customizers (owning the cloned branch node components) to the attic
1013  _retiredCustomizerList.AddAll(&customizerList) ;
1014 
1015  splitStateList.Delete() ;
1016 
1017  _simPdfList.push_back(simPdf) ;
1018  _fitCatList.push_back(fitCat) ;
1019  return simPdf ;
1020 }
1021 
1022 
1023 
1024 
1025 
1026 ////////////////////////////////////////////////////////////////////////////////
1027 
1029 {
1031 
1032  for(auto * ptr : _simPdfList) {
1033  delete ptr;
1034  }
1035  for(auto * ptr : _fitCatList) {
1036  delete ptr;
1037  }
1038 }
1039 
1040 
RooFormulaVar.h
RooSuperCategory.h
RooTruthModel.h
first
Definition: first.py:1
RooHelpers.h
RooStringVar.h
RooStringVar::getVal
const char * getVal() const
Definition: RooStringVar.h:34
RooAddModel.h
TCollection::Print
virtual void Print(Option_t *option="") const
Default print for collections, calls Print(option, 1).
Definition: TCollection.cxx:476
RooMsgService.h
RooCustomizer::splitArgs
void splitArgs(const RooArgSet &argSet, const RooAbsCategory &splitCat)
Split all arguments in 'set' into individualized clones for each defined state of 'splitCat'.
Definition: RooCustomizer.cxx:295
RooFit.h
RooSimultaneous.h
RooFit::InputArguments
@ InputArguments
Definition: RooGlobalFunc.h:61
RooAbsArg::getParameters
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...
Definition: RooAbsArg.cxx:578
RooArgSet.h
TList::FindObject
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition: TList.cxx:578
TList::Delete
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:470
RooSimPdfBuilder::RooSimPdfBuilder
RooSimPdfBuilder(const RooArgSet &pdfProtoList)
Definition: RooSimPdfBuilder.cxx:465
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Form
char * Form(const char *fmt,...)
RooCustomizer
RooCustomizer is a factory class to produce clones of a prototype composite PDF object with the same ...
Definition: RooCustomizer.h:35
RooSimPdfBuilder::_splitNodeListOwned
RooArgSet _splitNodeListOwned
Definition: RooSimPdfBuilder.h:67
coutE
#define coutE(a)
Definition: RooMsgService.h:33
coutW
#define coutW(a)
Definition: RooMsgService.h:32
RooCatType::GetName
virtual const Text_t * GetName() const
Returns name of object.
Definition: RooCatTypeLegacy.h:45
RooArgList
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:21
ROOT::Math::MCIntegration::Mode
Mode
Definition: MCIntegrationTypes.h:49
RooThresholdCategory.h
RooSimPdfBuilder::buildPdf
RooSimultaneous * buildPdf(const RooArgSet &buildConfig, const RooArgSet &dependents, const RooArgSet *auxSplitCats=0, bool verbose=false)
Initialize needed components.
Definition: RooSimPdfBuilder.cxx:506
RooAbsCollection::remove
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE)
Remove the specified argument from our list.
Definition: RooAbsCollection.cxx:585
RooAbsCollection::find
RooAbsArg * find(const char *name) const
Find object with given name in list.
Definition: RooAbsCollection.cxx:810
RooSimPdfBuilder
This tool has now been superseded by RooSimWSTool
Definition: RooSimPdfBuilder.h:32
coutI
#define coutI(a)
Definition: RooMsgService.h:30
RooAddPdf.h
RooAbsReal
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:61
RooAbsArg::recursiveRedirectServers
Bool_t recursiveRedirectServers(const RooAbsCollection &newServerList, Bool_t mustReplaceAll=kFALSE, Bool_t nameChange=kFALSE, Bool_t recurseInNewSet=kTRUE)
Recursively replace all servers with the new servers in newSet.
Definition: RooAbsArg.cxx:1159
TCollection::AddAll
virtual void AddAll(const TCollection *col)
Add all objects from collection col to this collection.
Definition: TCollection.cxx:195
RooGenericPdf.h
RooSimPdfBuilder::createProtoBuildConfig
RooArgSet * createProtoBuildConfig()
Make RooArgSet of configuration objects.
Definition: RooSimPdfBuilder.cxx:479
RooCustomizer::build
RooAbsArg * build(const char *masterCatState, Bool_t verbose=kFALSE)
Build a clone of the prototype executing all registered 'replace' rules and 'split' rules for the mas...
Definition: RooCustomizer.cxx:397
RooAbsCategory::getCurrentLabel
virtual const char * getCurrentLabel() const
Return label string of current state.
Definition: RooAbsCategory.cxx:130
RooSimultaneous::addPdf
Bool_t addPdf(const RooAbsPdf &pdf, const char *catLabel)
Associate given PDF with index category state label 'catLabel'.
Definition: RooSimultaneous.cxx:373
RooDataSet.h
RooSimPdfBuilder::_retiredCustomizerList
TList _retiredCustomizerList
Definition: RooSimPdfBuilder.h:69
RooAbsCollection::useHashMapForFind
void useHashMapForFind(bool flag) const
Install an internal hash map for fast finding of elements by name.
Definition: RooAbsCollection.cxx:1483
RooAbsCategory
RooAbsCategory is the base class for objects that represent a discrete value with a finite number of ...
Definition: RooAbsCategory.h:37
RooArgSet::snapshot
RooArgSet * snapshot(bool deepCopy=true) const
Use RooAbsCollection::snapshot(), but return as RooArgSet.
Definition: RooArgSet.h:115
TList::First
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TList.cxx:659
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
RooAbsArg::clone
virtual TObject * clone(const char *newname=0) const =0
RooTrace.h
RooLinearVar.h
RooFormulaVar
A RooFormulaVar is a generic implementation of a real-valued object, which takes a RooArgList of serv...
Definition: RooFormulaVar.h:30
RooCustomizer.h
RooSimPdfBuilder::_fitCatList
std::list< RooSuperCategory * > _fitCatList
Definition: RooSimPdfBuilder.h:72
RooProdPdf.h
RooSimPdfBuilder::addSpecializations
void addSpecializations(const RooArgSet &specSet)
Definition: RooSimPdfBuilder.cxx:496
RooMultiCategory
RooMultiCategory connects several RooAbsCategory objects into a single category.
Definition: RooMultiCategory.h:28
RooMultiCategory.h
RooDataHist.h
RooPlot.h
oodologI
#define oodologI(o, a)
Definition: RooMsgService.h:73
RooAbsCollection::add
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
Definition: RooAbsCollection.cxx:455
RooSimPdfBuilder::_protoPdfSet
RooArgSet _protoPdfSet
Definition: RooSimPdfBuilder.h:64
RooAbsCategory::lookupType
const RooCatType * lookupType(value_type index, Bool_t printError=kFALSE) const
Find our type corresponding to the specified index, or return nullptr for no match.
Definition: RooAbsCategory.cxx:307
RooCategory.h
RooAbsCategory::typeIterator
TIterator * typeIterator() const
Definition: RooAbsCategory.cxx:671
RooFit::ObjectHandling
@ ObjectHandling
Definition: RooGlobalFunc.h:61
RooSuperCategory::setLabel
virtual Bool_t setLabel(const char *label, Bool_t printError=kTRUE) override
Set the value of the super category by specifying the state name.
Definition: RooSuperCategory.cxx:132
RooRealVar.h
RooSimPdfBuilder::_simPdfList
std::list< RooSimultaneous * > _simPdfList
Definition: RooSimPdfBuilder.h:71
RooAbsCollection::addOwned
virtual Bool_t addOwned(RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
Definition: RooAbsCollection.cxx:403
RooFitResult.h
RooSimPdfBuilder::_compSplitCatSet
RooArgSet _compSplitCatSet
Definition: RooSimPdfBuilder.h:66
RooHelpers::tokenise
std::vector< std::string > tokenise(const std::string &str, const std::string &delims, bool returnEmptyToken=true)
Tokenise the string by splitting at the characters in delims.
Definition: RooHelpers.cxx:67
proto
const char * proto
Definition: civetweb.c:16604
RooSimPdfBuilder::~RooSimPdfBuilder
~RooSimPdfBuilder()
Definition: RooSimPdfBuilder.cxx:1028
RooAbsCategory.h
RooSimPdfBuilder::_splitNodeList
RooArgSet _splitNodeList
Definition: RooSimPdfBuilder.h:68
RooStringVar
RooStringVar is a RooAbsArg implementing string values.
Definition: RooStringVar.h:23
RooCategory
RooCategory is an object to represent discrete states.
Definition: RooCategory.h:27
TCollection::SetName
void SetName(const char *name)
Definition: TCollection.h:204
RooSuperCategory
The RooSuperCategory can join several RooAbsCategoryLValue objects into a single category.
Definition: RooSuperCategory.h:27
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
RooAbsCategory::hasLabel
bool hasLabel(const std::string &label) const
Check if a state with name label exists.
Definition: RooAbsCategory.h:64
RooCatType
RooCatType is an auxilary class for RooAbsCategory and defines a a single category state.
Definition: RooCatTypeLegacy.h:23
genreflex::verbose
bool verbose
Definition: rootcling_impl.cxx:133
RooAbsArg
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooRealIntegral.h
RooAbsPdf
Definition: RooAbsPdf.h:41
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
type
int type
Definition: TGX11.cxx:121
RooSimultaneous
RooSimultaneous facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset.
Definition: RooSimultaneous.h:37
RooAbsCategoryLValue
RooAbsCategoryLValue is the common abstract base class for objects that represent a discrete value th...
Definition: RooAbsCategoryLValue.h:25
Riostream.h
RooSimPdfBuilder.h
RooMappedCategory.h
TList
A doubly linked list.
Definition: TList.h:44
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:33