Logo ROOT   6.14/05
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 // Begin_Html
20 //
21 // <b>This tool has now been superceded 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* config = builder.createProtoBuildConfig() ;
88 // (*config)["physModels"] = "pdf" ; // Name of the PDF we are going to work with
89 // (*config)["splitCats"] = "C" ; // Category used to differentiate sub-datasets
90 // (*config)["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(*config,&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_t verbose=kFALSE) {
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 // End_Html
414 //
415 
416 
417 
418 #include "RooFit.h"
419 
420 #include <string.h>
421 
422 #ifndef _WIN32
423 #include <strings.h>
424 #else
425 
426 
427 static char *strtok_r(char *s1, const char *s2, char **lasts)
428 {
429  char *ret;
430 
431  if (s1 == NULL)
432  s1 = *lasts;
433  while(*s1 && strchr(s2, *s1))
434  ++s1;
435  if(*s1 == '\0')
436  return NULL;
437  ret = s1;
438  while(*s1 && !strchr(s2, *s1))
439  ++s1;
440  if(*s1)
441  *s1++ = '\0';
442  *lasts = s1;
443  return ret;
444 }
445 
446 #endif
447 
448 #include "Riostream.h"
449 #include "RooSimPdfBuilder.h"
450 
451 #include "RooRealVar.h"
452 #include "RooFormulaVar.h"
453 #include "RooAbsCategory.h"
454 #include "RooCategory.h"
455 #include "RooStringVar.h"
456 #include "RooMappedCategory.h"
457 #include "RooRealIntegral.h"
458 #include "RooDataSet.h"
459 #include "RooArgSet.h"
460 #include "RooPlot.h"
461 #include "RooAddPdf.h"
462 #include "RooLinearVar.h"
463 #include "RooTruthModel.h"
464 #include "RooAddModel.h"
465 #include "RooProdPdf.h"
466 #include "RooCustomizer.h"
467 #include "RooThresholdCategory.h"
468 #include "RooMultiCategory.h"
469 #include "RooSuperCategory.h"
470 #include "RooSimultaneous.h"
471 #include "RooTrace.h"
472 #include "RooFitResult.h"
473 #include "RooDataHist.h"
474 #include "RooGenericPdf.h"
475 #include "RooMsgService.h"
476 
477 using namespace std ;
478 
480 ;
481 
482 
483 
484 ////////////////////////////////////////////////////////////////////////////////
485 
487  _protoPdfSet(protoPdfSet)
488 {
492 }
493 
494 
495 
496 
497 ////////////////////////////////////////////////////////////////////////////////
498 /// Make RooArgSet of configuration objects
499 
501 {
502  RooArgSet* buildConfig = new RooArgSet ;
503  buildConfig->addOwned(* new RooStringVar("physModels","List and mapping of physics models to include in build","",4096)) ;
504  buildConfig->addOwned(* new RooStringVar("splitCats","List of categories used for splitting","",1024)) ;
505 
507  RooAbsPdf* proto ;
508  while ((proto=(RooAbsPdf*)iter->Next())) {
509  buildConfig->addOwned(* new RooStringVar(proto->GetName(),proto->GetName(),"",4096)) ;
510  }
511  delete iter ;
512 
513  return buildConfig ;
514 }
515 
516 
517 
518 ////////////////////////////////////////////////////////////////////////////////
519 
521 {
522  _splitNodeList.add(specSet) ;
523 }
524 
525 
526 
527 ////////////////////////////////////////////////////////////////////////////////
528 /// Initialize needed components
529 
530 RooSimultaneous* RooSimPdfBuilder::buildPdf(const RooArgSet& buildConfig, const RooArgSet& dependents,
531  const RooArgSet* auxSplitCats, Bool_t verbose)
532 {
533  const char* spaceChars = " \t" ;
534 
535  // Retrieve physics index category
536  Int_t buflen = strlen(((RooStringVar*)buildConfig.find("physModels"))->getVal())+1 ;
537  char *buf = new char[buflen] ;
538 
539  strlcpy(buf,((RooStringVar*)buildConfig.find("physModels"))->getVal(),buflen) ;
540  RooAbsCategoryLValue* physCat(0) ;
541  if (strstr(buf," : ")) {
542  const char* physCatName = strtok(buf,spaceChars) ;
543  physCat = dynamic_cast<RooAbsCategoryLValue*>(dependents.find(physCatName)) ;
544  if (!physCat) {
545  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR physics index category " << physCatName
546  << " not found in dataset variables" << endl ;
547  delete[] buf ;
548  return 0 ;
549  }
550  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: category indexing physics model: " << physCatName << endl ;
551  }
552 
553  // Create list of physics models to be built
554  char *physName ;
555  RooArgSet physModelSet ;
556  if (physCat) {
557  // Absorb colon token
558  strtok(0,spaceChars) ;
559  physName = strtok(0,spaceChars) ;
560  } else {
561  physName = strtok(buf,spaceChars) ;
562  }
563 
564  if (!physName) {
565  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR: No models specified, nothing to do!" << endl ;
566  delete[] buf ;
567  return 0 ;
568  }
569 
570  Bool_t first(kTRUE) ;
571  RooArgSet stateMap ;
572  while(physName) {
573 
574  char *stateName(0) ;
575 
576  // physName may be <state>=<pdfName> or just <pdfName> is state and pdf have identical names
577  if (strchr(physName,'=')) {
578  // Must have a physics category for mapping to make sense
579  if (!physCat) {
580  coutW(ObjectHandling) << "RooSimPdfBuilder::buildPdf: WARNING: without physCat specification "
581  << "<physCatState>=<pdfProtoName> association is meaningless" << endl ;
582  }
583  stateName = physName ;
584  physName = strchr(stateName,'=') ;
585  if (physName) {
586  *(physName++) = 0 ;
587  }
588  } else {
589  stateName = physName ;
590  }
591 
592  RooAbsPdf* physModel = (RooAbsPdf*) (physName ? _protoPdfSet.find(physName) : 0 );
593  if (!physModel) {
594  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR requested physics model "
595  << (physName?physName:"(null)") << " is not defined" << endl ;
596  delete[] buf ;
597  return 0 ;
598  }
599 
600  // Check if state mapping has already been defined
601  if (stateMap.find(stateName)) {
602  coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: multiple PDFs specified for state "
603  << stateName << ", only first will be used" << endl ;
604  continue ;
605  }
606 
607  // Add pdf to list of models to be processed
608  physModelSet.add(*physModel,kTRUE) ; // silence duplicate insertion warnings
609 
610  // Store state->pdf mapping
611  stateMap.addOwned(* new RooStringVar(stateName,stateName,physName)) ;
612 
613  // Continue with next mapping
614  physName = strtok(0,spaceChars) ;
615  if (first) {
616  first = kFALSE ;
617  } else if (physCat==0) {
618  coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: without physCat specification, only the first model will be used" << endl ;
619  break ;
620  }
621  }
622  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of physics models " << physModelSet << endl ;
623 
624 
625 
626  // Create list of dataset categories to be used in splitting
627  TList splitStateList ;
628  RooArgSet splitCatSet ;
629 
630  delete[] buf ;
631  buflen = strlen(((RooStringVar*)buildConfig.find("splitCats"))->getVal())+1 ;
632  buf = new char[buflen] ;
633  strlcpy(buf,((RooStringVar*)buildConfig.find("splitCats"))->getVal(),buflen) ;
634 
635  char *catName = strtok(buf,spaceChars) ;
636  char *stateList(0) ;
637  while(catName) {
638 
639  // Chop off optional list of selected states
640  char* tokenPtr(0) ;
641  if (strchr(catName,'(')) {
642 
643  catName = strtok_r(catName,"(",&tokenPtr) ;
644  stateList = strtok_r(0,")",&tokenPtr) ;
645 
646  } else {
647  stateList = 0 ;
648  }
649 
650  RooCategory* splitCat = catName ? dynamic_cast<RooCategory*>(dependents.find(catName)) : 0 ;
651  if (!splitCat) {
652  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR requested split category " << (catName?catName:"(null)")
653  << " is not a RooCategory in the dataset" << endl ;
654  delete[] buf ;
655  return 0 ;
656  }
657  splitCatSet.add(*splitCat) ;
658 
659  // Process optional state list
660  if (stateList) {
661  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: splitting of category " << catName
662  << " restricted to states (" << stateList << ")" << endl ;
663 
664  // Create list named after this splitCat holding its selected states
665  TList* slist = new TList ;
666  slist->SetName(catName) ;
667  splitStateList.Add(slist) ;
668 
669  char* stateLabel = strtok_r(stateList,",",&tokenPtr) ;
670 
671  while(stateLabel) {
672  // Lookup state label and require it exists
673  const RooCatType* type = splitCat->lookupType(stateLabel) ;
674  if (!type) {
675  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR splitCat " << splitCat->GetName()
676  << " doesn't have a state named " << stateLabel << endl ;
677  splitStateList.Delete() ;
678  delete[] buf ;
679  return 0 ;
680  }
681  slist->Add((TObject*)type) ;
682 
683  stateLabel = strtok_r(0,",",&tokenPtr) ;
684  }
685  }
686 
687  catName = strtok(0,spaceChars) ;
688  }
689  if (physCat) splitCatSet.add(*physCat) ;
690  RooSuperCategory masterSplitCat("masterSplitCat","Master splitting category",splitCatSet) ;
691 
692  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of splitting categories " << splitCatSet << endl ;
693 
694  // Clone auxiliary split cats and attach to splitCatSet
695  RooArgSet auxSplitSet ;
696  RooArgSet* auxSplitCloneSet(0) ;
697  if (auxSplitCats) {
698  // Deep clone auxililary split cats
699  auxSplitCloneSet = (RooArgSet*) auxSplitCats->snapshot(kTRUE) ;
700  if (!auxSplitCloneSet) {
701  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf(" << GetName() << ") Couldn't deep-clone set auxiliary splitcats, abort." << endl ;
702  delete[] buf ;
703  return 0 ;
704  }
705 
706  TIterator* iter = auxSplitCats->createIterator() ;
707  RooAbsArg* arg ;
708  while((arg=(RooAbsArg*)iter->Next())) {
709  // Find counterpart in cloned set
710  RooAbsArg* aux = auxSplitCats->find(arg->GetName()) ;
711 
712  // Check that there is no fundamental splitCat in the dataset with the bane of the auxiliary split
713  if (splitCatSet.find(aux->GetName())) {
714  coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: dataset contains a fundamental splitting category " << endl
715  << " with the same name as an auxiliary split function (" << aux->GetName() << "). " << endl
716  << " Auxiliary split function will be ignored" << endl ;
717  continue ;
718  }
719 
720  // Check that all servers of this aux cat are contained in splitCatSet
721  RooArgSet* parSet = aux->getParameters(splitCatSet) ;
722  if (parSet->getSize()>0) {
723  coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: ignoring auxiliary category " << aux->GetName()
724  << " because it has servers that are not listed in splitCatSet: " << *parSet << endl ;
725  delete parSet ;
726  continue ;
727  }
728 
729  // Redirect servers to splitCatSet
730  aux->recursiveRedirectServers(splitCatSet) ;
731 
732  // Add top level nodes to auxSplitSet
733  auxSplitSet.add(*aux) ;
734  }
735  delete iter ;
736 
737  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of auxiliary splitting categories " << auxSplitSet << endl ;
738  }
739 
740 
741  TList* customizerList = new TList ;
742 
743  // Loop over requested physics models and build components
744  TIterator* physIter = physModelSet.createIterator() ;
745  RooAbsPdf* physModel ;
746  while((physModel=(RooAbsPdf*)physIter->Next())) {
747  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: processing physics model " << physModel->GetName() << endl ;
748 
749  RooCustomizer* physCustomizer = new RooCustomizer(*physModel,masterSplitCat,_splitNodeList) ;
750  customizerList->Add(physCustomizer) ;
751 
752  // Parse the splitting rules for this physics model
753  RooStringVar* ruleStr = (RooStringVar*) buildConfig.find(physModel->GetName()) ;
754  if (ruleStr) {
755 
756  delete[] buf ;
757  buflen = strlen(ruleStr->getVal())+1 ;
758  buf = new char[buflen] ;
759 
760  strlcpy(buf,ruleStr->getVal(),buflen) ;
761  char *tokenPtr(0) ;
762 
763  char* token = strtok_r(buf,spaceChars,&tokenPtr) ;
764 
765  enum Mode { SplitCat, Colon, ParamList } ;
766  Mode mode(SplitCat) ;
767 
768  char* splitCatName ;
769  RooAbsCategory* splitCat(0) ;
770 
771  while(token) {
772 
773  switch (mode) {
774  case SplitCat:
775  {
776  splitCatName = token ;
777 
778  if (strchr(splitCatName,',')) {
779  // Composite splitting category
780 
781  // Check if already instantiated
782  splitCat = (RooAbsCategory*) _compSplitCatSet.find(splitCatName) ;
783  TString origCompCatName(splitCatName) ;
784  if (!splitCat) {
785  // Build now
786 
787  char *tokptr = 0;
788  char *catName2 = strtok_r(token,",",&tokptr) ;
789 
790  RooArgSet compCatSet ;
791  while(catName2) {
792  RooAbsArg* cat = splitCatSet.find(catName2) ;
793 
794  // If not, check if it is an auxiliary splitcat
795  if (!cat) {
796  cat = (RooAbsCategory*) auxSplitSet.find(catName2) ;
797  }
798 
799  if (!cat) {
800  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << catName2
801  << " not found in the primary or auxilary splitcat list" << endl ;
802  customizerList->Delete() ;
803  delete customizerList ;
804 
805  splitStateList.Delete() ;
806  delete[] buf ;
807  return 0 ;
808  }
809  compCatSet.add(*cat) ;
810 
811  catName2 = strtok_r(0,",",&tokptr) ;
812  }
813 
814 
815  // check that any auxSplitCats in compCatSet do not depend on any other
816  // fundamental or auxiliary splitting categories in the composite set.
817  TIterator* iter = compCatSet.createIterator() ;
818  RooAbsArg* arg ;
819  while((arg=(RooAbsArg*)iter->Next())) {
820  RooArgSet tmp(compCatSet) ;
821  tmp.remove(*arg) ;
822  if (arg->dependsOnValue(tmp)) {
823  coutE(InputArguments) << "RooSimPdfBuilder::buildPDF: ERROR: Ill defined split: auxiliary splitting category " << arg->GetName()
824  << " used in composite split " << compCatSet << " depends on one or more of the other splitting categories in the composite split" << endl ;
825 
826  // Cleanup and axit
827  customizerList->Delete() ;
828  delete customizerList ;
829  splitStateList.Delete() ;
830  delete[] buf ;
831  return 0 ;
832  }
833  }
834  delete iter ;
835 
836  splitCat = new RooMultiCategory(origCompCatName,origCompCatName,compCatSet) ;
837  _compSplitCatSet.addOwned(*splitCat) ;
838  //cout << "composite splitcat: " << splitCat->GetName() ;
839  }
840  } else {
841  // Simple splitting category
842 
843  // First see if it is a simple splitting category
844  splitCat = (RooAbsCategory*) splitCatSet.find(splitCatName) ;
845 
846  // If not, check if it is an auxiliary splitcat
847  if (!splitCat) {
848  splitCat = (RooAbsCategory*) auxSplitSet.find(splitCatName) ;
849  }
850 
851  if (!splitCat) {
852  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR splitting category "
853  << splitCatName << " not found in the primary or auxiliary splitcat list" << endl ;
854  customizerList->Delete() ;
855  delete customizerList ;
856  splitStateList.Delete() ;
857  delete[] buf ;
858  return 0 ;
859  }
860  }
861 
862  mode = Colon ;
863  break ;
864  }
865  case Colon:
866  {
867  if (strcmp(token,":")) {
868  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR in parsing, expected ':' after "
869  << splitCat << ", found " << token << endl ;
870  customizerList->Delete() ;
871  delete customizerList ;
872  splitStateList.Delete() ;
873  delete[] buf ;
874  return 0 ;
875  }
876  mode = ParamList ;
877  break ;
878  }
879  case ParamList:
880  {
881  // Verify the validity of the parameter list and build the corresponding argset
882  RooArgSet splitParamList ;
883  RooArgSet* paramList = physModel->getParameters(dependents) ;
884 
885  // wve -- add nodes to parameter list
886  RooArgSet* compList = physModel->getComponents() ;
887  paramList->add(*compList) ;
888  delete compList ;
889 
890  Bool_t lastCharIsComma = (token[strlen(token)-1]==',') ;
891 
892  char *tokptr = 0 ;
893  char *paramName = strtok_r(token,",",&tokptr) ;
894 
895  // Check for fractional split option 'param_name[remainder_state]'
896  char *remainderState = 0 ;
897  char *tokptr2 = 0 ;
898  if (paramName && strtok_r(paramName,"[",&tokptr2)) {
899  remainderState = strtok_r(0,"]",&tokptr2) ;
900  }
901 
902  while(paramName) {
903 
904  // If fractional split is specified, check that remainder state is a valid state of this split cat
905  if (remainderState) {
906  if (!splitCat->lookupType(remainderState)) {
907  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR fraction split of parameter "
908  << paramName << " has invalid remainder state name: " << remainderState << endl ;
909  delete paramList ;
910  customizerList->Delete() ;
911  delete customizerList ;
912  splitStateList.Delete() ;
913  delete[] buf ;
914  return 0 ;
915  }
916  }
917 
918  RooAbsArg* param = paramList->find(paramName) ;
919  if (!param) {
920  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << paramName
921  << " is not a parameter of physics model " << physModel->GetName() << endl ;
922  delete paramList ;
923  customizerList->Delete() ;
924  delete customizerList ;
925  splitStateList.Delete() ;
926  delete[] buf ;
927  return 0 ;
928  }
929  splitParamList.add(*param) ;
930 
931  // Build split leaf of fraction splits here
932  if (remainderState) {
933 
934  // Check if we are splitting a real-valued parameter
935  if (!dynamic_cast<RooAbsReal*>(param)) {
936  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR fraction split requested of non-real valued parameter "
937  << param->GetName() << endl ;
938  delete paramList ;
939  customizerList->Delete() ;
940  delete customizerList ;
941  splitStateList.Delete() ;
942  delete[] buf ;
943  return 0 ;
944  }
945 
946  // Check if we are doing a restricted build
947  TList* remStateSplitList = static_cast<TList*>(splitStateList.FindObject(splitCat->GetName())) ;
948 
949  // If so, check if remainder state is actually being built.
950  if (remStateSplitList && !remStateSplitList->FindObject(remainderState)) {
951  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << paramName
952  << " remainder state " << remainderState << " in parameter split "
953  << param->GetName() << " is not actually being built" << endl ;
954  delete paramList ;
955  customizerList->Delete() ;
956  delete customizerList ;
957  splitStateList.Delete() ;
958  delete[] buf ;
959  return 0 ;
960  }
961 
962  TIterator* iter = splitCat->typeIterator() ;
963  RooCatType* type ;
964  RooArgList fracLeafList ;
965  TString formExpr("1") ;
966  Int_t i(0) ;
967 
968  while((type=(RooCatType*)iter->Next())) {
969 
970  // Skip remainder state
971  if (!TString(type->GetName()).CompareTo(remainderState)) continue ;
972 
973  // If restricted build is requested, skip states of splitcat that are not built
974  if (remStateSplitList && !remStateSplitList->FindObject(type->GetName())) {
975  continue ;
976  }
977 
978  // Construct name of split leaf
979  TString splitLeafName(param->GetName()) ;
980  splitLeafName.Append("_") ;
981  splitLeafName.Append(type->GetName()) ;
982 
983  // Check if split leaf already exists
984  RooAbsArg* splitLeaf = _splitNodeList.find(splitLeafName) ;
985  if (!splitLeaf) {
986  // If not create it now
987  splitLeaf = (RooAbsArg*) param->clone(splitLeafName) ;
988  _splitNodeList.add(*splitLeaf) ;
989  _splitNodeListOwned.addOwned(*splitLeaf) ;
990  }
991  fracLeafList.add(*splitLeaf) ;
992  formExpr.Append(Form("-@%d",i++)) ;
993  }
994  delete iter ;
995 
996  // Construct RooFormulaVar expresssing remainder of fraction
997  TString remLeafName(param->GetName()) ;
998  remLeafName.Append("_") ;
999  remLeafName.Append(remainderState) ;
1000 
1001  // Check if no specialization was already specified for remainder state
1002  if (!_splitNodeList.find(remLeafName)) {
1003  RooAbsArg* remLeaf = new RooFormulaVar(remLeafName,formExpr,fracLeafList) ;
1004  _splitNodeList.add(*remLeaf) ;
1005  _splitNodeListOwned.addOwned(*remLeaf) ;
1006  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: creating remainder fraction formula for " << remainderState
1007  << " specialization of split parameter " << param->GetName() << " " << formExpr << endl ;
1008  }
1009  }
1010 
1011  // Parse next parameter name
1012  paramName = strtok_r(0,",",&tokptr) ;
1013  if (paramName && strtok_r(paramName,"[",&tokptr2)) {
1014  remainderState = strtok_r(0,"]",&tokptr2) ;
1015  }
1016  }
1017 
1018  // Add the rule to the appropriate customizer ;
1019  physCustomizer->splitArgs(splitParamList,*splitCat) ;
1020 
1021  delete paramList ;
1022 
1023  if (!lastCharIsComma) mode = SplitCat ;
1024  break ;
1025  }
1026  }
1027 
1028  token = strtok_r(0,spaceChars,&tokenPtr) ;
1029 
1030  }
1031  if (mode!=SplitCat) {
1032  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR in parsing, expected "
1033  << (mode==Colon?":":"parameter list") << " after " << (token?token:"(null)") << endl ;
1034  }
1035 
1036  //RooArgSet* paramSet = physModel->getParameters(dependents) ;
1037  } else {
1038  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: no splitting rules for " << physModel->GetName() << endl ;
1039  }
1040  }
1041 
1042  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: configured customizers for all physics models" << endl ;
1043  if (oodologI((TObject*)0,ObjectHandling)) {
1044  customizerList->Print() ;
1045  }
1046 
1047  // Create fit category from physCat and splitCatList ;
1048  RooArgSet fitCatList ;
1049  if (physCat) fitCatList.add(*physCat) ;
1050  fitCatList.add(splitCatSet) ;
1051  TIterator* fclIter = fitCatList.createIterator() ;
1052  RooSuperCategory *fitCat = new RooSuperCategory("fitCat","fitCat",fitCatList) ;
1053 
1054  // Create master PDF
1055  RooSimultaneous* simPdf = new RooSimultaneous("simPdf","simPdf",*fitCat) ;
1056 
1057  // Add component PDFs to master PDF
1058  TIterator* fcIter = fitCat->typeIterator() ;
1059 
1060  RooCatType* fcState ;
1061  while((fcState=(RooCatType*)fcIter->Next())) {
1062  // Select fitCat state
1063  fitCat->setLabel(fcState->GetName()) ;
1064 
1065  // Check if this fitCat state is selected
1066  fclIter->Reset() ;
1067  RooAbsCategory* splitCat ;
1068  Bool_t select(kTRUE) ;
1069  while((splitCat=(RooAbsCategory*)fclIter->Next())) {
1070  // Find selected state list
1071  TList* slist = (TList*) splitStateList.FindObject(splitCat->GetName()) ;
1072  if (!slist) continue ;
1073  RooCatType* type = (RooCatType*) slist->FindObject(splitCat->getLabel()) ;
1074  if (!type) {
1075  select = kFALSE ;
1076  }
1077  }
1078  if (!select) continue ;
1079 
1080 
1081  // Select appropriate PDF for this physCat state
1082  RooCustomizer* physCustomizer ;
1083  if (physCat) {
1084  RooStringVar* physNameVar = (RooStringVar*) stateMap.find(physCat->getLabel()) ;
1085  if (!physNameVar) continue ;
1086  physCustomizer = (RooCustomizer*) customizerList->FindObject(physNameVar->getVal());
1087  } else {
1088  physCustomizer = (RooCustomizer*) customizerList->First() ;
1089  }
1090 
1091  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: Customizing physics model " << physCustomizer->GetName()
1092  << " for mode " << fcState->GetName() << endl ;
1093 
1094  // Customizer PDF for current state and add to master simPdf
1095  RooAbsPdf* fcPdf = (RooAbsPdf*) physCustomizer->build(masterSplitCat.getLabel(),verbose) ;
1096  simPdf->addPdf(*fcPdf,fcState->GetName()) ;
1097  }
1098  delete fcIter ;
1099 
1100  // Move customizers (owning the cloned branch node components) to the attic
1101  _retiredCustomizerList.AddAll(customizerList) ;
1102  delete customizerList ;
1103 
1104  delete fclIter ;
1105  splitStateList.Delete() ;
1106 
1107  if (auxSplitCloneSet) delete auxSplitCloneSet ;
1108  delete physIter ;
1109 
1110  delete[] buf ;
1111  _simPdfList.push_back(simPdf) ;
1112  _fitCatList.push_back(fitCat) ;
1113  return simPdf ;
1114 }
1115 
1116 
1117 
1118 
1119 
1120 ////////////////////////////////////////////////////////////////////////////////
1121 
1123 {
1125 
1126  std::list<RooSimultaneous*>::iterator iter = _simPdfList.begin() ;
1127  while(iter != _simPdfList.end()) {
1128  delete *iter ;
1129  ++iter ;
1130  }
1131 
1132  std::list<RooSuperCategory*>::iterator iter2 = _fitCatList.begin() ;
1133  while(iter2 != _fitCatList.end()) {
1134  delete *iter2 ;
1135  ++iter2 ;
1136  }
1137 
1138 }
1139 
1140 
virtual TObject * clone(const char *newname=0) const =0
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
TIterator * createIterator(Bool_t dir=kIterForward) const
#define coutE(a)
Definition: RooMsgService.h:34
virtual Bool_t add(const RooAbsArg &var, Bool_t silent=kFALSE)
Add the specified argument to list.
virtual const char * getVal() const
Return value of object. Calculated if dirty, otherwise cached value is returned.
Definition: RooStringVar.h:34
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:467
virtual Bool_t add(const RooAbsCollection &col, Bool_t silent=kFALSE)
Add a collection of arguments to this collection by calling add() for each element in the source coll...
Definition: RooArgSet.h:86
virtual void Reset()=0
std::list< RooSimultaneous * > _simPdfList
#define coutI(a)
Definition: RooMsgService.h:31
virtual void AddAll(const TCollection *col)
Add all objects from collection col to this collection.
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
STL namespace.
#define coutW(a)
Definition: RooMsgService.h:33
Iterator abstract base class.
Definition: TIterator.h:30
virtual TObject * FindObject(const char *name) const
Delete a TObjLink object.
Definition: TList.cxx:574
Bool_t addPdf(const RooAbsPdf &pdf, const char *catLabel)
Associate given PDF with index category state label &#39;catLabel&#39;.
RooCatType is an auxilary class for RooAbsCategory and defines a a single category state...
Definition: RooCatType.h:22
RooAbsCategoryLValue is the common abstract base class for objects that represent a discrete value th...
RooArgSet _splitNodeListOwned
A doubly linked list.
Definition: TList.h:44
Int_t getSize() const
RooAbsCollection * snapshot(Bool_t deepCopy=kTRUE) const
Take a snap shot of current collection contents: An owning collection is returned containing clones o...
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TList.cxx:655
RooSimultaneous * buildPdf(const RooArgSet &buildConfig, const RooArgSet &dependents, const RooArgSet *auxSplitCats=0, Bool_t verbose=kFALSE)
Initialize needed components.
TIterator * typeIterator() const
Return iterator over all defined states.
virtual const Text_t * GetName() const
Returns name of object.
Definition: RooCatType.h:44
RooArgSet * getComponents() const
Definition: RooAbsArg.cxx:679
const RooCatType * lookupType(Int_t index, Bool_t printError=kFALSE) const
Find our type corresponding to the specified index, or return 0 for no match.
char * Form(const char *fmt,...)
virtual Bool_t addOwned(const RooAbsCollection &col, Bool_t silent=kFALSE)
Add a collection of arguments to this collection by calling addOwned() for each element in the source...
Definition: RooArgSet.h:90
#define s1(x)
Definition: RSha256.hxx:91
virtual const char * getLabel() const
Return label string of current state.
void SetName(const char *name)
Definition: TCollection.h:204
RooArgSet _splitNodeList
RooCategory represents a fundamental (non-derived) discrete value object.
Definition: RooCategory.h:24
std::list< RooSuperCategory * > _fitCatList
const Bool_t kFALSE
Definition: RtypesCore.h:88
RooMultiCategory consolidates several RooAbsCategory objects into a single category.
#define ClassImp(name)
Definition: Rtypes.h:359
RooAbsArg * find(const char *name) const
Find object with given name in list.
RooArgSet _compSplitCatSet
RooArgSet * getParameters(const RooAbsData *data, Bool_t stripDisconnected=kTRUE) const
Create a list of leaf nodes in the arg tree starting with ourself as top node that don&#39;t match any of...
Definition: RooAbsArg.cxx:532
#define oodologI(o, a)
Definition: RooMsgService.h:71
int type
Definition: TGX11.cxx:120
void addSpecializations(const RooArgSet &specSet)
Bool_t dependsOnValue(const RooAbsCollection &serverList, const RooAbsArg *ignoreArg=0) const
Definition: RooAbsArg.h:88
Mother of all ROOT objects.
Definition: TObject.h:37
void splitArgs(const RooArgSet &argSet, const RooAbsCategory &splitCat)
Split all arguments in &#39;set&#39; into individualized clones for each defined state of &#39;splitCat&#39;...
virtual Bool_t remove(const RooAbsArg &var, Bool_t silent=kFALSE, Bool_t matchByNameOnly=kFALSE)
Remove the specified argument from our list.
RooAbsPdf is the abstract interface for all probability density functions The class provides hybrid a...
Definition: RooAbsPdf.h:41
RooArgSet _protoPdfSet
RooAbsArg * build(const char *masterCatState, Bool_t verbose=kFALSE)
Build a clone of the prototype executing all registered &#39;replace&#39; rules and &#39;split&#39; rules for the mas...
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual TObject * Next()=0
RooAbsCategory is the common abstract base class for objects that represent a discrete value with a f...
const char * proto
Definition: civetweb.c:15049
RooSimPdfBuilder(const RooArgSet &pdfProtoList)
RooSuperCategory consolidates several RooAbsCategoryLValue objects into a single category.
Definition: first.py:1
RooAbsArg is the common abstract base class for objects that represent a value (of arbitrary type) an...
Definition: RooAbsArg.h:66
void setHashTableSize(Int_t i)
virtual void Print(Option_t *option="") const
Default print for collections, calls Print(option, 1).
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:357
Bool_t recursiveRedirectServers(const RooAbsCollection &newServerList, Bool_t mustReplaceAll=kFALSE, Bool_t nameChange=kFALSE, Bool_t recurseInNewSet=kTRUE)
Definition: RooAbsArg.cxx:1079
RooStringVar implements a string values RooAbsArg.
Definition: RooStringVar.h:23
virtual Bool_t setLabel(const char *label, Bool_t printError=kTRUE)
Set the value of the super category by specifying the state name by setting the state names of the co...
RooSimultaneous facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset...
const Bool_t kTRUE
Definition: RtypesCore.h:87
RooArgSet * createProtoBuildConfig()
Make RooArgSet of configuration objects.