ROOT logo
/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id: RooSimPdfBuilder.cxx 28259 2009-04-16 16:21:16Z wouter $
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2005, Regents of the University of California          *
 *                          and Stanford University. All rights reserved.    *
 *                                                                           *
 * Redistribution and use in source and binary forms,                        *
 * with or without modification, are permitted according to the terms        *
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
 *****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
//
// BEGIN_HTML
//
// <b>This tool has now been superceded by RooSimWSTool</b>
// 
//Begin_Html
//  </pre>
//  <p>
//    <tt>RooSimPdfBuilder</tt> is a powerful tool to build <tt>RooSimultaneous</tt>
//    PDFs that are defined in terms component PDFs that are identical in
//    structure, but have different parameters. 
//  </p>
//
//  <h2>Example</h2>
//
//  <p>
//    The following example demonstrates the essence of <tt>RooSimPdfBuilder</tt>:
//    Given a dataset D with a <tt>RooRealVar X</tt> and a <tt>RooCategory C</tt> that has
//    state C1 and C2. 
//    <ul>
//    <li> We want to fit the distribution of <tt>X</tt> with a Gaussian+ArgusBG PDF, 
//    <li> We want to fit the data subsets <tt>D(C==C1)</tt> and <tt>D(C==C2)</tt> separately and simultaneously. 
//    <li> The PDFs to fit data subsets D_C1 and D_C2 are identical except for 
//         <ul>
//         <li> the kappa parameter of the ArgusBG PDF and 
//         <li> the sigma parameter of the gaussian PDF
//         </ul>
//         where each PDF will have its own copy of the parameter
//    </ul>
//  </p>
//  <p>
//    Coding this example directly with RooFit classes gives
//    (we assume dataset D and variables C and X have been declared previously)
//  </p>
//  <pre>
// RooRealVar m("m","mean of gaussian",-10,10) ;
// RooRealVar s_C1("s_C1","sigma of gaussian C1",0,20) ;
// RooRealVar s_C2("s_C2","sigma of gaussian C2",0,20) ;
// RooGaussian gauss_C1("gauss_C1","gaussian C1",X,m,s_C1) ;
// RooGaussian gauss_C2("gauss_C2","gaussian C2",X,m,s_C2) ;
//
// RooRealVar k_C1("k_C1","ArgusBG kappa parameter C1",-50,0) ;
// RooRealVar k_C2("k_C2","ArgusBG kappa parameter C2",-50,0) ;
// RooRealVar xm("xm","ArgusBG cutoff point",5.29) ;
// RooArgusBG argus_C1("argus_C1","argus background C1",X,k_C1,xm) ;
// RooArgusBG argus_C2("argus_C2","argus background C2",X,k_C2,xm) ;
//
// RooRealVar gfrac("gfrac","fraction of gaussian",0.,1.) ;
// RooAddPdf pdf_C1("pdf_C1","gauss+argus_C1",RooArgList(gauss_C1,argus_C1),gfrac) ;
// RooAddPdf pdf_C2("pdf_C2","gauss+argus_C2",RooArgList(gauss_C2,argus_C2),gfrac) ;
//
// RooSimultaneous simPdf("simPdf","simPdf",C) ;   
// simPdf.addPdf(pdf_C1,"C1") ;
// simPdf.addPdf(pdf_C2,"C2") ;
//  </pre>
//  <p>
//    Coding this example with RooSimPdfBuilder gives
//  </p>
//  <pre>
// RooRealVar m("m","mean of gaussian",-10,10) ;
// RooRealVar s("s","sigma of gaussian",0,20) ;
// RooGaussian gauss("gauss","gaussian",X,m,s) ;
//
// RooRealVar k("k","ArgusBG kappa parameter",-50,0) ;
// RooRealVar xm("xm","ArgusBG cutoff point",5.29) ;
// RooArgusBG argus("argus","argus background",X,k,xm) ;
//
// RooRealVar gfrac("gfrac","fraction of gaussian",0.,1.) ;
// RooAddPdf pdf("pdf","gauss+argus",RooArgList(gauss,argus),gfrac) ;
//
// RooSimPdfBuilder builder(pdf) ;
// RooArgSet* config = builder.createProtoBuildConfig() ;
// (*config)["physModels"] = "pdf" ;      // Name of the PDF we are going to work with
// (*config)["splitCats"]  = "C" ;        // Category used to differentiate sub-datasets
// (*config)["pdf"]        = "C : k,s" ;  // Prescription to taylor PDF parameters k and s 
//                                        // for each data subset designated by C states
// RooSimultaneous* simPdf = builder.buildPdf(*config,&D) ;
//  </pre>
//  <p>
//    The above snippet of code demonstrates the concept of <tt>RooSimPdfBuilder</tt>:
//    the user defines a single <i>'prototype' PDF</i> that defines the structure of all
//    PDF components of the <tt>RooSimultaneous</tt> PDF to be built. <tt>RooSimPdfBuilder</tt> 
//    then takes this prototype and replicates it as a component 
//    PDF for each state of the C index category.
//  </p>
//  <p>
//    In the above example </tt>RooSimPdfBuilder</tt>
//    will first replicate <tt>k</tt> and <tt>s</tt> into 
//    <tt>k_C1,k_C2</tt> and <tt>s_C1,s_C2</tt>, as prescribed in the
//    configuration. Then it will recursively replicate all PDF nodes that depend on
//    the 'split' parameter nodes: <tt>gauss</tt> into <tt>gauss_C1,C2</tt>, <tt>argus</tt> 
//    into <tt>argus_C1,C2</tt> and finally <tt>pdf</tt> into <tt>pdf_C1,pdf_C2</tt>. 
//     When PDFs for all states of C have been replicated
//    they are assembled into a <tt>RooSimultaneous</tt> PDF, which is returned by the <tt>buildPdf()</tt>
//    method.
//  </p>
//  <p>
//    Although in this very simple example the use of <tt>RooSimPdfBuilder</tt> doesn't
//    reduce the amount of code much, it is already easier to read and maintain
//    because there is no duplicate code. As the complexity of the <tt>RooSimultaneous</tt>
//    to be built increases, the advantages of <tt>RooSimPdfBuilder</tt> will become more and
//    more apparent.
//  </p>
//
//
//  <h2>Builder configuration rules for a single prototype PDF</h2>
//  <p>
//    Each builder configuration needs at minumum two lines, <tt>physModels</tt> and <tt>splitCats</tt>, which identify
//    the ingredients of the build. In this section we only explain the building rules for
//    builds from a single prototype PDF. In that case the <tt>physModels</tt> line always reads
//  </p>
//  <pre>
//  physModels = {pdfName}
//  </pre>
//  <p>
//    The second line, <tt>splitCats</tt>, indicates which categories are going to be used to 
//    differentiate the various subsets of the 'master' input data set. You can enter
//    a single category here, or multiple if necessary:
//  </p>
//  <pre>
// splitCats = {catName} [{catName} ...]
//  </pre>
//  <p>
//    All listed splitcats must be <tt>RooCategories</tt> that appear in the dataset provided to
//    <tt>RooSimPdfBuilder::buildPdf()</tt>
//  </p>
//  <p>
//    The parameter splitting prescriptions, the essence of each build configuration
//    can be supplied in a third line carrying the name of the pdf listed in <tt>physModels</tt>
//  </p>
//  <pre>
// pdfName = {splitCat} : {parameter} [,{parameter},....]
//  </pre>
//  <p>     
//    Each pdf can have only one line with splitting rules, but multiple rules can be
//    supplied in each line, e.g.
//  </p>
//  <pre>
// pdfName = {splitCat} : {parameter} [,{parameter},....] 
//           {splitCat} : {parameter} [,{parameter},....]
//  </pre>
//  <p>
//    Conversely, each parameter can only have one splitting prescription, but it may be split
//    by multiple categories, e.g.
//  </p>
//  <pre>
// pdfName = {splitCat1},{splitCat2} : {parameter}
//  </pre>
//  <p>
//    instructs <tt>RooSimPdfBuilder</tt> to build a <tt>RooSuperCategory</tt> 
//    of <tt>{splitCat1}</tt> and <tt>{splitCat2}</tt>
//    and split <tt>{parameter}</tt> with that <tt>RooSuperCategory</tt>
//  </p>
//  <p>
//    Here is an example of a builder configuration that uses several of the options discussed
//    above:
//  </p>
//  <pre>
//   physModels = pdf
//   splitCats  = tagCat runBlock
//   pdf        = tagCat          : signalRes,bkgRes 
//                runBlock        : fudgeFactor      
//                tagCat,runBlock : kludgeParam
//  </pre>
//
//  <h2>How to enter configuration data</h2>
//
//  <p>
//    The prototype builder configuration returned by 
//    <tt>RooSimPdfBuilder::createProtoBuildConfig()</tt> is a pointer to a <tt>RooArgSet</tt> filled with
//    initially blank <tt>RooStringVars</tt> named <tt>physModels,splitCats</tt> and one additional for each
//    PDF supplied to the <tt>RooSimPdfBuilders</tt> constructor (with the same name)
//  </p>
//  <p>
//    In macro code, the easiest way to assign new values to these <tt>RooStringVars</tt>
//    is to use <tt>RooArgSet</tt>s array operator and the <tt>RooStringVar</tt>s assignment operator, e.g.
//  </p>
//  <pre>
// (*config)["physModels"] = "Blah" ;
//  </pre>
//  <p>
//    To enter multiple splitting rules simply separate consecutive rules by whitespace
//    (not newlines), e.g.           
//  </p>
//  <pre>
// (*config)["physModels"] = "Blah " // << note trailing space here
//                          "Blah 2" ;
//  </pre>
//  <p>
//    In this example, the C++ compiler will concatenate the two string literals (without inserting
//    any whitespace), so the extra space after 'Blah' is important here.
//  </p>
//  <p>      
//    Alternatively, you can read the configuration from an ASCII file, as you can
//    for any <tt>RooArgSet</tt> using <tt>RooArgSet::readFromFile()</tt>. In that case the ASCII file
//    can follow the syntax of the examples above and the '<tt>\\</tt>' line continuation 
//    sequence can be used to fold a long splitting rule over multiple lines.
//  </p>
//  <pre>
// RooArgSet* config = builder.createProtoBuildConfig() ;
// config->readFromFile("config.txt") ;
//
// --- config.txt ----------------    
// physModels = pdf
// splitCats  = tagCat
// pdf        = tagCat : bogusPar
// -------------------------------
//  </pre>
//
//
//  <h2>Working with multiple prototype PDFs</h2>
//  <p>
//    It is also possible to build a <tt>RooSimultaneous</tt> PDF from multiple PDF prototypes.
//    This is appropriate for cases where the input prototype PDF would otherwise be 
//    a <tt>RooSimultaneous</tt> PDF by itself. In such cases we don't feed a single
//    <tt>RooSimultaneous</tt> PDF into <tt>RooSimPdfBuilder</tt>, instead we feed it its ingredients and
//    add a prescription to the builder configuration that corresponds to the 
//    PDF-category state mapping of the prototype <tt>RooSimultaneous</tt>.
//  </p>
//  <p>
//    The constructor of the <tt>RooSimPdfBuilder</tt> will look as follows:
//  </p>
//  <pre>
//  RooSimPdfBuilder builder(RooArgSet(pdfA,pdfB,...)) ;
//  </pre>
//  <p>
//    The <tt>physModels</tt> line is now expanded to carry the pdf->state mapping information
//    that the prototype <tt>RooSimultaneous</tt> would have. I.e.
//  </p>
//  <pre>
// physModels = mode : pdfA=modeA  pdfB=modeB
//  </pre>
//  <p>
//    is equivalent to a prototype <tt>RooSimultaneous</tt> constructed as
//  </p>
//  <pre>
// RooSimultanous simPdf("simPdf","simPdf",mode);
// simPdf.addPdf(pdfA,"modeA") ;
// simPdf.addPdf(pdfB,"modeB") ;
//  </pre>
//  <p>
//    The rest of the builder configuration works the same, except that
//    each prototype PDF now has its own set of splitting rules, e.g.
//  </p>
//  <pre>
// physModels = mode : pdfA=modeA  pdfB=modeB
// splitCats  = tagCat
// pdfA       = tagCat : bogusPar
// pdfB       = tagCat : fudgeFactor   
//  </pre>
//  <p>
//    Please note that 
//    <ul>
//    <li> The master index category ('mode' above) doesn't have to be listed in 
//         <tt>splitCats</tt>, this is implicit.
//
//    <li> The number of splitting prescriptions goes by the
//          number of prototype PDFs and not by the number of states of the
//          master index category (mode in the above and below example). 
//  </ul>
//
//  In the following case:
//</p>
//  <pre>
//    physModels = mode : pdfA=modeA  pdfB=modeB  pdfA=modeC  pdfB=modeD
//  </pre>
//  <p>
//    there are still only 2 sets of splitting rules: one for <tt>pdfA</tt> and one
//    for <tt>pdfB</tt>. However, you <i>can</i> differentiate between <tt>modeA</tt> and <tt>modeC</tt> in 
//    the above example. The technique is to use <tt>mode</tt> as splitting category, e.g.
//  </p>
//  <pre>
//    physModels = mode : pdfA=modeA  pdfB=modeB  pdfA=modeC  pdfB=modeD
//    splitCats = tagCat
//    pdfA      = tagCat : bogusPar 
//                mode   : funnyPar
//    pdfB      = mode   : kludgeFactor
//  </pre>
//  <p>
//    will result in an individual set of <tt>funnyPar</tt> parameters for <tt>modeA</tt> and <tt>modeC</tt>
//    labeled <tt>funnyPar_modeA</tt> and <tt>funnyPar_modeB</tt> and an individual set of
//    kludgeFactor parameters for <tt>pdfB</tt>, <tt>kludgeFactor_modeB</tt> and <tt>kludgeFactor_modeD</tt>. 
//    Please note that for splits in the master index category (mode) only the 
//    applicable states are built (A,C for <tt>pdfA</tt>, B,D for <tt>pdfB</tt>)
//  </p>
//
//
//  <h2>Advanced options</h2>
//
//  <h4>Partial splits</h4>
//  <p>
//    You can request to limit the list of states of each splitCat that
//    will be considered in the build. This limitation is requested in the 
//    each build as follows:
//  </p>
//  <pre>
// splitCats = tagCat(Lep,Kao) RunBlock(Run1)
//  </pre>
//  <p>
//    In this example the splitting of <tt>tagCat</tt> is limited to states <tt>Lep,Kao</tt>
//    and the splitting of <tt>runBlock</tt> is limited to <tt>Run1</tt>. The splits apply
//    globally to each build, i.e. every parameter split requested in this
//    build will be limited according to these specifications. 
//  </p>
//  <p>      
//    NB: Partial builds have no pdf associated with the unbuilt states of the 
//    limited splits. Running such a pdf on a dataset that contains data with 
//    unbuilt states will result in this data being ignored completely.
//  </p>
//
//
//  <h4>Non-trivial splits</h4>
//  <p>
//    It is possible to make non-trivial parameter splits with <tt>RooSimPdfBuilder</tt>.
//    Trivial splits are considered simple splits in one (fundamental) category
//    in the dataset or a split in a <tt>RooSuperCategory</tt> 'product' of multiple
//    fundamental categories in the dataset. Non-trivial splits can be performed
//    using an intermediate 'category function' (<tt>RooMappedCategory,
//    RooGenericCategory,RooThresholdCategory</tt> etc), i.e. any <tt>RooAbsCategory</tt>
//    derived objects that calculates its output as function of one or more
//    input <tt>RooRealVars</tt> and/or <tt>RooCategories</tt>.
//  </p>
//  <p>
//    Such 'function categories' objects must be constructed by the user prior
//    to building the PDF. In the <tt>RooSimPdfBuilder::buildPdf()</tt> function these
//    objects can be passed in an optional <tt>RooArgSet</tt> called 'auxiliary categories':
//  </p>
//  <pre>
//   const <tt>RooSimultaneous</tt>* buildPdf(const RooArgSet& buildConfig, const RooAbsData* dataSet, 
//                                   const RooArgSet& auxSplitCats, Bool_t verbose=kFALSE) {
//                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//  </pre>
//  <p>
//    Objects passed in this argset can subsequently be used in the build configuration, e.g.
//  </p>
//  <pre>
// RooMappedCategory tagMap("tagMap","Mapped tagging category",tagCat,"CutBased") ;
// tagMap.map("Lep","CutBased") ;
// tagMap.map("Kao","CutBased") ;
// tagMap.map("NT*","NeuralNet") ;                                                                                          
// ...
// builder.buildPdf(config,D,tagMap) ;
//                          ^^^^^^
//<Contents of config>
//   physModels = pdf
//   splitCats  = tagCat runBlock
//   pdf        = tagCat          : signalRes 
//                tagMap          : fudgeFactor      
//                ^^^^^^
//  </pre>
//  <p>
//    In the above example <tt>signalRes</tt> will be split in <tt>signalRes_Kao,signalRes_Lep,
//    signalRes_NT1,signalRes_NT2</tt>, while <tt>fudgeFactor</tt> will be split in <tt>fudgeFactor_CutBased</tt>
//    and <tt>fudgeFactor_NeuralNet</tt>.
//  </p>
//  <p>
//    Category functions passed in the auxSplitCats <tt>RooArgSet</tt> can be used regularly
//    in the splitting configuration. They should not be listed in <tt>splitCats</tt>,
//    but must be able to be expressed <i>completely</i> in terms of the <tt>splitCats</tt> that 
//    are listed.
//  </p>
//
//  
//  <h4>Multiple connected builds</h4>
//  <p>
//    Sometimes you want to build multiple PDFs for independent consecutive fits 
//    that share some of their parameters. For example, we have two prototype PDFs 
//    <tt>pdfA(x;p,q)</tt> and <tt>pdfB(x;p,r)</tt> that have a common parameter <tt>p</tt>. 
//    We want to build a <tt>RooSimultaneous</tt> for both <tt>pdfA</tt> and <tt>B</tt>, 
//    which involves a split of parameter <tt>p</tt> and we would like to build the
//    simultaneous pdfs </tt>simA</tt> and <tt>simB</tt> such that still share their (now split) parameters
//    <tt>p_XXX</tt>. This is accomplished by letting a single instance of <tt>RooSimPdfBuilder</tt> handle
//    the builds of both <tt>pdfA</tt> and <tt>pdfB</tt>, as illustrated in this example:
//  </p>
//  <pre>
// RooSimPdfBuilder builder(RooArgSet(pdfA,pdfB)) ;
//
// RooArgSet* configA = builder.createProtoBuildConfig() ;
// (*configA)["physModels"] = "pdfA" ;     
// (*configA)["splitCats"]  = "C" ;        
// (*configA)["pdf"]        = "C : p" ;  
// RooSimultaneous* simA = builder.buildPdf(*configA,&D) ;
//
// RooArgSet* configB = builder.createProtoBuildConfig() ;
// (*configA)["physModels"] = "pdfB" ;     
// (*configA)["splitCats"]  = "C" ;        
// (*configA)["pdf"]        = "C : p" ;  
// RooSimultaneous* simB = builder.buildPdf(*configB,&D) ;
//  </pre>
//
//  <h2>Ownership of constructed PDFs</h2>
//  <p>
//    The <tt>RooSimPdfBuilder</tt> instance owns all the objects it creates, including the top-level
//    <tt>RooSimultaneous</tt> returned by <tt>buildPdf()</tt>. Therefore the builder instance should 
//    exist as long as the constructed PDFs needs to exist.
//  </p>
//  <pre>
//End_Html
//
// END_HTMLEND_HTML
//



#include "RooFit.h"

#include <string.h>
#include <string.h>

#ifndef _WIN32
#include <strings.h>
#else


static char *strtok_r(char *s1, const char *s2, char **lasts)
{
  char *ret;
  
  if (s1 == NULL)
    s1 = *lasts;
  while(*s1 && strchr(s2, *s1))
    ++s1;
  if(*s1 == '\0')
    return NULL;
  ret = s1;
  while(*s1 && !strchr(s2, *s1))
    ++s1;
  if(*s1)
    *s1++ = '\0';
  *lasts = s1;
  return ret;
}

#endif

#include "Riostream.h"
#include "RooSimPdfBuilder.h"

#include "RooRealVar.h"
#include "RooFormulaVar.h"
#include "RooAbsCategory.h"
#include "RooCategory.h"
#include "RooStringVar.h"
#include "RooMappedCategory.h"
#include "RooRealIntegral.h"
#include "RooDataSet.h"
#include "RooArgSet.h"
#include "RooPlot.h"
#include "RooAddPdf.h"
#include "RooLinearVar.h"
#include "RooTruthModel.h"
#include "RooAddModel.h"
#include "RooProdPdf.h"
#include "RooCustomizer.h"
#include "RooThresholdCategory.h"
#include "RooMultiCategory.h"
#include "RooSuperCategory.h"
#include "RooSimultaneous.h"
#include "RooTrace.h"
#include "RooFitResult.h"
#include "RooDataHist.h"
#include "RooGenericPdf.h"
#include "RooMsgService.h"

using namespace std ;

ClassImp(RooSimPdfBuilder)
;



//_____________________________________________________________________________
RooSimPdfBuilder::RooSimPdfBuilder(const RooArgSet& protoPdfSet) :
  _protoPdfSet(protoPdfSet)
{
  _compSplitCatSet.setHashTableSize(1000) ;
  _splitNodeList.setHashTableSize(10000) ;
  _splitNodeListOwned.setHashTableSize(10000) ;
}




//_____________________________________________________________________________
RooArgSet* RooSimPdfBuilder::createProtoBuildConfig()
{
  // Make RooArgSet of configuration objects
  RooArgSet* buildConfig = new RooArgSet ;
  buildConfig->addOwned(* new RooStringVar("physModels","List and mapping of physics models to include in build","",4096)) ;
  buildConfig->addOwned(* new RooStringVar("splitCats","List of categories used for splitting","",1024)) ;

  TIterator* iter = _protoPdfSet.createIterator() ;
  RooAbsPdf* proto ;
  while ((proto=(RooAbsPdf*)iter->Next())) {
    buildConfig->addOwned(* new RooStringVar(proto->GetName(),proto->GetName(),"",4096)) ;
  }
  delete iter ;

  return buildConfig ;
}



//_____________________________________________________________________________
void RooSimPdfBuilder::addSpecializations(const RooArgSet& specSet) 
{
  _splitNodeList.add(specSet) ;
}



//_____________________________________________________________________________
RooSimultaneous* RooSimPdfBuilder::buildPdf(const RooArgSet& buildConfig, const RooArgSet& dependents,
					    const RooArgSet* auxSplitCats, Bool_t verbose)
{
  // Initialize needed components
  const char* spaceChars = " \t" ;

  // Retrieve physics index category
  Int_t buflen = strlen(((RooStringVar*)buildConfig.find("physModels"))->getVal())+1 ;
  char *buf = new char[buflen] ;

  strcpy(buf,((RooStringVar*)buildConfig.find("physModels"))->getVal()) ;
  RooAbsCategoryLValue* physCat(0) ;
  if (strstr(buf," : ")) {
    const char* physCatName = strtok(buf,spaceChars) ;
    physCat = dynamic_cast<RooAbsCategoryLValue*>(dependents.find(physCatName)) ;
    if (!physCat) {
      coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR physics index category " << physCatName 
			    << " not found in dataset variables" << endl ;
      delete[] buf ;
      return 0 ;      
    }
    coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: category indexing physics model: " << physCatName << endl ;
  }

  // Create list of physics models to be built
  char *physName ;
  RooArgSet physModelSet ;
  if (physCat) {
    // Absorb colon token
    strtok(0,spaceChars) ;
    physName = strtok(0,spaceChars) ;
  } else {
    physName = strtok(buf,spaceChars) ;
  }

  if (!physName) {
    coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR: No models specified, nothing to do!" << endl ;
    delete[] buf ;
    return 0 ;
  }

  Bool_t first(kTRUE) ;
  RooArgSet stateMap ;
  while(physName) {

    char *stateName(0) ;

    // physName may be <state>=<pdfName> or just <pdfName> is state and pdf have identical names
    if (strchr(physName,'=')) {
      // Must have a physics category for mapping to make sense
      if (!physCat) {
	coutW(ObjectHandling) << "RooSimPdfBuilder::buildPdf: WARNING: without physCat specification "
			 << "<physCatState>=<pdfProtoName> association is meaningless" << endl ;
      }
      stateName = physName ;
      physName = strchr(stateName,'=') ;
      *(physName++) = 0 ;      
    } else {
      stateName = physName ;
    }

    RooAbsPdf* physModel = (RooAbsPdf*) _protoPdfSet.find(physName) ;
    if (!physModel) {
      coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR requested physics model " 
			    << physName << " is not defined" << endl ;
      delete[] buf ;
      return 0 ;
    }    

    // Check if state mapping has already been defined
    if (stateMap.find(stateName)) {
      coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: multiple PDFs specified for state " 
			    << stateName << ", only first will be used" << endl ;
      continue ;
    }

    // Add pdf to list of models to be processed
    physModelSet.add(*physModel,kTRUE) ; // silence duplicate insertion warnings

    // Store state->pdf mapping    
    stateMap.addOwned(* new RooStringVar(stateName,stateName,physName)) ;

    // Continue with next mapping
    physName = strtok(0,spaceChars) ;
    if (first) {
      first = kFALSE ;
    } else if (physCat==0) {
      coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: without physCat specification, only the first model will be used" << endl ;
      break ;
    }
  }
  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of physics models " << physModelSet << endl ;



  // Create list of dataset categories to be used in splitting
  TList splitStateList ;
  RooArgSet splitCatSet ;

  delete[] buf ; 
  buflen = strlen(((RooStringVar*)buildConfig.find("splitCats"))->getVal())+1 ;
  buf = new char[buflen] ;
  strcpy(buf,((RooStringVar*)buildConfig.find("splitCats"))->getVal()) ;

  char *catName = strtok(buf,spaceChars) ;
  char *stateList(0) ;
  while(catName) {

    // Chop off optional list of selected states
    char* tokenPtr(0) ;
    if (strchr(catName,'(')) {

      catName = strtok_r(catName,"(",&tokenPtr) ;
      stateList = strtok_r(0,")",&tokenPtr) ;

    } else {
      stateList = 0 ;
    }

    RooCategory* splitCat = dynamic_cast<RooCategory*>(dependents.find(catName)) ;
    if (!splitCat) {
      coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR requested split category " << catName 
			    << " is not a RooCategory in the dataset" << endl ;
      delete[] buf ;
      return 0 ;
    }
    splitCatSet.add(*splitCat) ;

    // Process optional state list
    if (stateList) {
      coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: splitting of category " << catName 
		       << " restricted to states (" << stateList << ")" << endl ;

      // Create list named after this splitCat holding its selected states
      TList* slist = new TList ;
      slist->SetName(catName) ;
      splitStateList.Add(slist) ;

      char* stateLabel = strtok_r(stateList,",",&tokenPtr) ;

      while(stateLabel) {
	// Lookup state label and require it exists
	const RooCatType* type = splitCat->lookupType(stateLabel) ;
	if (!type) {
	  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR splitCat " << splitCat->GetName() 
				<< " doesn't have a state named " << stateLabel << endl ;
	  splitStateList.Delete() ;
	  delete[] buf ;
	  return 0 ;
	}
	slist->Add((TObject*)type) ;

	stateLabel = strtok_r(0,",",&tokenPtr) ;
      }
    }
    
    catName = strtok(0,spaceChars) ;
  }
  if (physCat) splitCatSet.add(*physCat) ;
  RooSuperCategory masterSplitCat("masterSplitCat","Master splitting category",splitCatSet) ;
  
  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of splitting categories " << splitCatSet << endl ;

  // Clone auxiliary split cats and attach to splitCatSet
  RooArgSet auxSplitSet ;
  RooArgSet* auxSplitCloneSet(0) ;
  if (auxSplitCats) {
    // Deep clone auxililary split cats
    auxSplitCloneSet = (RooArgSet*) auxSplitCats->snapshot(kTRUE) ;
    if (!auxSplitCloneSet) {
      coutE(InputArguments) << "RooSimPdfBuilder::buildPdf(" << GetName() << ") Couldn't deep-clone set auxiliary splitcats, abort." << endl ;
      delete[] buf ;
      return 0 ;
    }

    TIterator* iter = auxSplitCats->createIterator() ;
    RooAbsArg* arg ;
    while((arg=(RooAbsArg*)iter->Next())) {
      // Find counterpart in cloned set
      RooAbsArg* aux = auxSplitCats->find(arg->GetName()) ;

      // Check that there is no fundamental splitCat in the dataset with the bane of the auxiliary split
      if (splitCatSet.find(aux->GetName())) {
	coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: dataset contains a fundamental splitting category " << endl 
			      << " with the same name as an auxiliary split function (" << aux->GetName() << "). " << endl 
			      << " Auxiliary split function will be ignored" << endl ;
	continue ;
      }

      // Check that all servers of this aux cat are contained in splitCatSet
      RooArgSet* parSet = aux->getParameters(splitCatSet) ;
      if (parSet->getSize()>0) {
	coutW(InputArguments) << "RooSimPdfBuilder::buildPdf: WARNING: ignoring auxiliary category " << aux->GetName() 
			      << " because it has servers that are not listed in splitCatSet: " << *parSet << endl ;
	delete parSet ;
	continue ;
      }

      // Redirect servers to splitCatSet
      aux->recursiveRedirectServers(splitCatSet) ;

      // Add top level nodes to auxSplitSet
      auxSplitSet.add(*aux) ;
    }
    delete iter ;

    coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: list of auxiliary splitting categories " << auxSplitSet << endl ;
  }


  TList* customizerList = new TList ;

  // Loop over requested physics models and build components
  TIterator* physIter = physModelSet.createIterator() ;
  RooAbsPdf* physModel ;
  while((physModel=(RooAbsPdf*)physIter->Next())) {
    coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: processing physics model " << physModel->GetName() << endl ;

    RooCustomizer* physCustomizer = new RooCustomizer(*physModel,masterSplitCat,_splitNodeList) ;
    customizerList->Add(physCustomizer) ;

    // Parse the splitting rules for this physics model
    RooStringVar* ruleStr = (RooStringVar*) buildConfig.find(physModel->GetName()) ;
    if (ruleStr) {

      delete[] buf ; 
      buflen = strlen(ruleStr->getVal())+1 ;
      buf = new char[buflen] ;

      strcpy(buf,ruleStr->getVal()) ;
      char *tokenPtr(0) ;

      char* token = strtok_r(buf,spaceChars,&tokenPtr) ;
      
      enum Mode { SplitCat, Colon, ParamList } ;
      Mode mode(SplitCat) ;

      char* splitCatName ;
      RooAbsCategory* splitCat(0) ;

      while(token) {

	switch (mode) {
	case SplitCat:
	  {
	    splitCatName = token ;
	   	    
	    if (strchr(splitCatName,',')) {
	      // Composite splitting category
	      
	      // Check if already instantiated
	      splitCat = (RooAbsCategory*) _compSplitCatSet.find(splitCatName) ;	      
	      TString origCompCatName(splitCatName) ;
	      if (!splitCat) {
		// Build now

		char *tokptr = 0;
		char *catName2 = strtok_r(token,",",&tokptr) ;

		RooArgSet compCatSet ;
		while(catName2) {
		  RooAbsArg* cat = splitCatSet.find(catName2) ;
		  
		  // If not, check if it is an auxiliary splitcat
		  if (!cat) {
		    cat = (RooAbsCategory*) auxSplitSet.find(catName2) ;
		  }

		  if (!cat) {
		    coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << catName2
					  << " not found in the primary or auxilary splitcat list" << endl ;
		    customizerList->Delete() ;
		    delete customizerList ;

		    splitStateList.Delete() ;
		    delete[] buf ;
		    return 0 ;
		  }
		  compCatSet.add(*cat) ;

		  catName2 = strtok_r(0,",",&tokptr) ;
		}		


		// check that any auxSplitCats in compCatSet do not depend on any other
		// fundamental or auxiliary splitting categories in the composite set.
		TIterator* iter = compCatSet.createIterator() ;
		RooAbsArg* arg ;
		while((arg=(RooAbsArg*)iter->Next())) {
		  RooArgSet tmp(compCatSet) ;
		  tmp.remove(*arg) ;
		  if (arg->dependsOnValue(tmp)) {
		    coutE(InputArguments) << "RooSimPdfBuilder::buildPDF: ERROR: Ill defined split: auxiliary splitting category " << arg->GetName() 
					  << " used in composite split " << compCatSet << " depends on one or more of the other splitting categories in the composite split" << endl ;
		    
		    // Cleanup and axit
		    customizerList->Delete() ;
		    delete customizerList ;
		    splitStateList.Delete() ;
		    delete[] buf ;
		    return 0 ;
		  }
		}
		delete iter ;

		splitCat = new RooMultiCategory(origCompCatName,origCompCatName,compCatSet) ;
		_compSplitCatSet.addOwned(*splitCat) ;
		//cout << "composite splitcat: " << splitCat->GetName() ;
	      }
	    } else {
	      // Simple splitting category
	      
	      // First see if it is a simple splitting category
	      splitCat = (RooAbsCategory*) splitCatSet.find(splitCatName) ;

	      // If not, check if it is an auxiliary splitcat
	      if (!splitCat) {
		splitCat = (RooAbsCategory*) auxSplitSet.find(splitCatName) ;
	      }

	      if (!splitCat) {
		coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR splitting category " 
				      << splitCatName << " not found in the primary or auxiliary splitcat list" << endl ;
		customizerList->Delete() ;
		delete customizerList ;
		splitStateList.Delete() ;
		delete[] buf ;
		return 0 ;
	      }
	    }
	    
	    mode = Colon ;
	    break ;
	  }
	case Colon:
	  {
	    if (strcmp(token,":")) {
	      coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR in parsing, expected ':' after " 
				    << splitCat << ", found " << token << endl ;
	      customizerList->Delete() ;
	      delete customizerList ;
	      splitStateList.Delete() ;
	      delete[] buf ;
	      return 0 ;	    
	    }
	    mode = ParamList ;
	    break ;
	  }
	case ParamList:
	  {
	    // Verify the validity of the parameter list and build the corresponding argset
	    RooArgSet splitParamList ;
	    RooArgSet* paramList = physModel->getParameters(dependents) ;

	    // wve -- add nodes to parameter list
	    RooArgSet* compList = physModel->getComponents() ;
	    paramList->add(*compList) ;
	    delete compList ;

	    Bool_t lastCharIsComma = (token[strlen(token)-1]==',') ;

	    char *tokptr = 0 ;
	    char *paramName = strtok_r(token,",",&tokptr) ;

	    // Check for fractional split option 'param_name[remainder_state]'
	    char *remainderState = 0 ;
	    char *tokptr2 = 0 ;
	    if (paramName && strtok_r(paramName,"[",&tokptr2)) {
	      remainderState = strtok_r(0,"]",&tokptr2) ;
	    }

	    while(paramName) {

	      // If fractional split is specified, check that remainder state is a valid state of this split cat
	      if (remainderState) {
		if (!splitCat->lookupType(remainderState)) {
		  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR fraction split of parameter " 
					<< paramName << " has invalid remainder state name: " << remainderState << endl ;
		  delete paramList ;
		  customizerList->Delete() ;
		  delete customizerList ;
		  splitStateList.Delete() ;
		  delete[] buf ;
		  return 0 ;
		}
	      }	      

	      RooAbsArg* param = paramList->find(paramName) ;
	      if (!param) {
		coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << paramName 
				      << " is not a parameter of physics model " << physModel->GetName() << endl ;
		delete paramList ;
		customizerList->Delete() ;
		delete customizerList ;
		splitStateList.Delete() ;
		delete[] buf ;
		return 0 ;
	      }
	      splitParamList.add(*param) ;
	      
	      // Build split leaf of fraction splits here
	      if (remainderState) {

		// Check if we are splitting a real-valued parameter
		if (!dynamic_cast<RooAbsReal*>(param)) {
		  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR fraction split requested of non-real valued parameter " 
					<< param->GetName() << endl ;
		  delete paramList ;
		  customizerList->Delete() ;
		  delete customizerList ;
		  splitStateList.Delete() ;
		  delete[] buf ;
		  return 0 ;
		}

		// Check if we are doing a restricted build
		TList* remStateSplitList = static_cast<TList*>(splitStateList.FindObject(splitCat->GetName())) ;

		// If so, check if remainder state is actually being built.
		if (remStateSplitList && !remStateSplitList->FindObject(remainderState)) {
		  coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR " << paramName 
					<< " remainder state " << remainderState << " in parameter split " 
					<< param->GetName() << " is not actually being built" << endl ;
		  delete paramList ;
		  customizerList->Delete() ;
		  delete customizerList ;
		  splitStateList.Delete() ;
		  delete[] buf ;
		  return 0 ;		  
		}

		TIterator* iter = splitCat->typeIterator() ;
		RooCatType* type ;
		RooArgList fracLeafList ;
		TString formExpr("1") ;
		Int_t i(0) ;

		while((type=(RooCatType*)iter->Next())) {

		  // Skip remainder state
		  if (!TString(type->GetName()).CompareTo(remainderState)) continue ;

		  // If restricted build is requested, skip states of splitcat that are not built
		  if (remStateSplitList && !remStateSplitList->FindObject(type->GetName())) {
		    continue ;
		  }
		  
		  // Construct name of split leaf
		  TString splitLeafName(param->GetName()) ;
		  splitLeafName.Append("_") ;
		  splitLeafName.Append(type->GetName()) ;
		  
		  // Check if split leaf already exists
		  RooAbsArg* splitLeaf = _splitNodeList.find(splitLeafName) ;
		  if (!splitLeaf) {
		    // If not create it now
		    splitLeaf = (RooAbsArg*) param->clone(splitLeafName) ;
		    _splitNodeList.add(*splitLeaf) ;
		    _splitNodeListOwned.addOwned(*splitLeaf) ;
		  }
		  fracLeafList.add(*splitLeaf) ;
		  formExpr.Append(Form("-@%d",i++)) ;
		}
		delete iter ;		

		// Construct RooFormulaVar expresssing remainder of fraction		
		TString remLeafName(param->GetName()) ;
		remLeafName.Append("_") ;
		remLeafName.Append(remainderState) ;

		// Check if no specialization was already specified for remainder state
		if (!_splitNodeList.find(remLeafName)) {
		  RooAbsArg* remLeaf = new RooFormulaVar(remLeafName,formExpr,fracLeafList) ;
		  _splitNodeList.add(*remLeaf) ;
		  _splitNodeListOwned.addOwned(*remLeaf) ;
		  coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: creating remainder fraction formula for " << remainderState 
				   << " specialization of split parameter " << param->GetName() << " " << formExpr << endl ;
		}
	      }

	      // Parse next parameter name
	      paramName = strtok_r(0,",",&tokptr) ;
	      if (paramName && strtok_r(paramName,"[",&tokptr2)) {
		remainderState = strtok_r(0,"]",&tokptr2) ;
	      }
	    }

	    // Add the rule to the appropriate customizer ;
	    physCustomizer->splitArgs(splitParamList,*splitCat) ;

	    delete paramList ;

	    if (!lastCharIsComma) mode = SplitCat ;
	    break ;
	  }
	}

	token = strtok_r(0,spaceChars,&tokenPtr) ;

      }
      if (mode!=SplitCat) {
	coutE(InputArguments) << "RooSimPdfBuilder::buildPdf: ERROR in parsing, expected " 
			      << (mode==Colon?":":"parameter list") << " after " << token << endl ;
      }

      //RooArgSet* paramSet = physModel->getParameters(dependents) ;
    } else {
      coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: no splitting rules for " << physModel->GetName() << endl ;
    }    
  }
  
  coutI(ObjectHandling)  << "RooSimPdfBuilder::buildPdf: configured customizers for all physics models" << endl ;
  if (oodologI((TObject*)0,ObjectHandling)) {
    customizerList->Print() ;
  }

  // Create fit category from physCat and splitCatList ;
  RooArgSet fitCatList ;
  if (physCat) fitCatList.add(*physCat) ;
  fitCatList.add(splitCatSet) ;
  TIterator* fclIter = fitCatList.createIterator() ;
  RooSuperCategory *fitCat = new RooSuperCategory("fitCat","fitCat",fitCatList) ;

  // Create master PDF 
  RooSimultaneous* simPdf = new RooSimultaneous("simPdf","simPdf",*fitCat) ;

  // Add component PDFs to master PDF
  TIterator* fcIter = fitCat->typeIterator() ;

  RooCatType* fcState ;  
  while((fcState=(RooCatType*)fcIter->Next())) {
    // Select fitCat state
    fitCat->setLabel(fcState->GetName()) ;

    // Check if this fitCat state is selected
    fclIter->Reset() ;
    RooAbsCategory* splitCat ;
    Bool_t select(kTRUE) ;
    while((splitCat=(RooAbsCategory*)fclIter->Next())) {
      // Find selected state list 
      TList* slist = (TList*) splitStateList.FindObject(splitCat->GetName()) ;
      if (!slist) continue ;
      RooCatType* type = (RooCatType*) slist->FindObject(splitCat->getLabel()) ;
      if (!type) {
	select = kFALSE ;
      }
    }
    if (!select) continue ;

    
    // Select appropriate PDF for this physCat state
    RooCustomizer* physCustomizer ;
    if (physCat) {      
      RooStringVar* physNameVar = (RooStringVar*) stateMap.find(physCat->getLabel()) ;
      if (!physNameVar) continue ;
      physCustomizer = (RooCustomizer*) customizerList->FindObject(physNameVar->getVal());  
    } else {
      physCustomizer = (RooCustomizer*) customizerList->First() ;
    }

    coutI(ObjectHandling) << "RooSimPdfBuilder::buildPdf: Customizing physics model " << physCustomizer->GetName() 
		     << " for mode " << fcState->GetName() << endl ;    

    // Customizer PDF for current state and add to master simPdf
    RooAbsPdf* fcPdf = (RooAbsPdf*) physCustomizer->build(masterSplitCat.getLabel(),verbose) ;
    simPdf->addPdf(*fcPdf,fcState->GetName()) ;
  }
  delete fcIter ;

  // Move customizers (owning the cloned branch node components) to the attic
  _retiredCustomizerList.AddAll(customizerList) ;
  delete customizerList ;

  delete fclIter ;
  splitStateList.Delete() ;

  if (auxSplitCloneSet) delete auxSplitCloneSet ;
  delete physIter ;

  delete[] buf ;
  _simPdfList.push_back(simPdf) ;
  _fitCatList.push_back(fitCat) ;
  return simPdf ;
}





//_____________________________________________________________________________
RooSimPdfBuilder::~RooSimPdfBuilder() 
{
  _retiredCustomizerList.Delete() ;

  std::list<RooSimultaneous*>::iterator iter = _simPdfList.begin() ;
  while(iter != _simPdfList.end()) {
    delete *iter ;
    ++iter ;
  }

  std::list<RooSuperCategory*>::iterator iter2 = _fitCatList.begin() ;
  while(iter2 != _fitCatList.end()) {
    delete *iter2 ;
    ++iter2 ;
  }
  
}
 

 RooSimPdfBuilder.cxx:1
 RooSimPdfBuilder.cxx:2
 RooSimPdfBuilder.cxx:3
 RooSimPdfBuilder.cxx:4
 RooSimPdfBuilder.cxx:5
 RooSimPdfBuilder.cxx:6
 RooSimPdfBuilder.cxx:7
 RooSimPdfBuilder.cxx:8
 RooSimPdfBuilder.cxx:9
 RooSimPdfBuilder.cxx:10
 RooSimPdfBuilder.cxx:11
 RooSimPdfBuilder.cxx:12
 RooSimPdfBuilder.cxx:13
 RooSimPdfBuilder.cxx:14
 RooSimPdfBuilder.cxx:15
 RooSimPdfBuilder.cxx:16
 RooSimPdfBuilder.cxx:17
 RooSimPdfBuilder.cxx:18
 RooSimPdfBuilder.cxx:19
 RooSimPdfBuilder.cxx:20
 RooSimPdfBuilder.cxx:21
 RooSimPdfBuilder.cxx:22
 RooSimPdfBuilder.cxx:23
 RooSimPdfBuilder.cxx:24
 RooSimPdfBuilder.cxx:25
 RooSimPdfBuilder.cxx:26
 RooSimPdfBuilder.cxx:27
 RooSimPdfBuilder.cxx:28
 RooSimPdfBuilder.cxx:29
 RooSimPdfBuilder.cxx:30
 RooSimPdfBuilder.cxx:31
 RooSimPdfBuilder.cxx:32
 RooSimPdfBuilder.cxx:33
 RooSimPdfBuilder.cxx:34
 RooSimPdfBuilder.cxx:35
 RooSimPdfBuilder.cxx:36
 RooSimPdfBuilder.cxx:37
 RooSimPdfBuilder.cxx:38
 RooSimPdfBuilder.cxx:39
 RooSimPdfBuilder.cxx:40
 RooSimPdfBuilder.cxx:41
 RooSimPdfBuilder.cxx:42
 RooSimPdfBuilder.cxx:43
 RooSimPdfBuilder.cxx:44
 RooSimPdfBuilder.cxx:45
 RooSimPdfBuilder.cxx:46
 RooSimPdfBuilder.cxx:47
 RooSimPdfBuilder.cxx:48
 RooSimPdfBuilder.cxx:49
 RooSimPdfBuilder.cxx:50
 RooSimPdfBuilder.cxx:51
 RooSimPdfBuilder.cxx:52
 RooSimPdfBuilder.cxx:53
 RooSimPdfBuilder.cxx:54
 RooSimPdfBuilder.cxx:55
 RooSimPdfBuilder.cxx:56
 RooSimPdfBuilder.cxx:57
 RooSimPdfBuilder.cxx:58
 RooSimPdfBuilder.cxx:59
 RooSimPdfBuilder.cxx:60
 RooSimPdfBuilder.cxx:61
 RooSimPdfBuilder.cxx:62
 RooSimPdfBuilder.cxx:63
 RooSimPdfBuilder.cxx:64
 RooSimPdfBuilder.cxx:65
 RooSimPdfBuilder.cxx:66
 RooSimPdfBuilder.cxx:67
 RooSimPdfBuilder.cxx:68
 RooSimPdfBuilder.cxx:69
 RooSimPdfBuilder.cxx:70
 RooSimPdfBuilder.cxx:71
 RooSimPdfBuilder.cxx:72
 RooSimPdfBuilder.cxx:73
 RooSimPdfBuilder.cxx:74
 RooSimPdfBuilder.cxx:75
 RooSimPdfBuilder.cxx:76
 RooSimPdfBuilder.cxx:77
 RooSimPdfBuilder.cxx:78
 RooSimPdfBuilder.cxx:79
 RooSimPdfBuilder.cxx:80
 RooSimPdfBuilder.cxx:81
 RooSimPdfBuilder.cxx:82
 RooSimPdfBuilder.cxx:83
 RooSimPdfBuilder.cxx:84
 RooSimPdfBuilder.cxx:85
 RooSimPdfBuilder.cxx:86
 RooSimPdfBuilder.cxx:87
 RooSimPdfBuilder.cxx:88
 RooSimPdfBuilder.cxx:89
 RooSimPdfBuilder.cxx:90
 RooSimPdfBuilder.cxx:91
 RooSimPdfBuilder.cxx:92
 RooSimPdfBuilder.cxx:93
 RooSimPdfBuilder.cxx:94
 RooSimPdfBuilder.cxx:95
 RooSimPdfBuilder.cxx:96
 RooSimPdfBuilder.cxx:97
 RooSimPdfBuilder.cxx:98
 RooSimPdfBuilder.cxx:99
 RooSimPdfBuilder.cxx:100
 RooSimPdfBuilder.cxx:101
 RooSimPdfBuilder.cxx:102
 RooSimPdfBuilder.cxx:103
 RooSimPdfBuilder.cxx:104
 RooSimPdfBuilder.cxx:105
 RooSimPdfBuilder.cxx:106
 RooSimPdfBuilder.cxx:107
 RooSimPdfBuilder.cxx:108
 RooSimPdfBuilder.cxx:109
 RooSimPdfBuilder.cxx:110
 RooSimPdfBuilder.cxx:111
 RooSimPdfBuilder.cxx:112
 RooSimPdfBuilder.cxx:113
 RooSimPdfBuilder.cxx:114
 RooSimPdfBuilder.cxx:115
 RooSimPdfBuilder.cxx:116
 RooSimPdfBuilder.cxx:117
 RooSimPdfBuilder.cxx:118
 RooSimPdfBuilder.cxx:119
 RooSimPdfBuilder.cxx:120
 RooSimPdfBuilder.cxx:121
 RooSimPdfBuilder.cxx:122
 RooSimPdfBuilder.cxx:123
 RooSimPdfBuilder.cxx:124
 RooSimPdfBuilder.cxx:125
 RooSimPdfBuilder.cxx:126
 RooSimPdfBuilder.cxx:127
 RooSimPdfBuilder.cxx:128
 RooSimPdfBuilder.cxx:129
 RooSimPdfBuilder.cxx:130
 RooSimPdfBuilder.cxx:131
 RooSimPdfBuilder.cxx:132
 RooSimPdfBuilder.cxx:133
 RooSimPdfBuilder.cxx:134
 RooSimPdfBuilder.cxx:135
 RooSimPdfBuilder.cxx:136
 RooSimPdfBuilder.cxx:137
 RooSimPdfBuilder.cxx:138
 RooSimPdfBuilder.cxx:139
 RooSimPdfBuilder.cxx:140
 RooSimPdfBuilder.cxx:141
 RooSimPdfBuilder.cxx:142
 RooSimPdfBuilder.cxx:143
 RooSimPdfBuilder.cxx:144
 RooSimPdfBuilder.cxx:145
 RooSimPdfBuilder.cxx:146
 RooSimPdfBuilder.cxx:147
 RooSimPdfBuilder.cxx:148
 RooSimPdfBuilder.cxx:149
 RooSimPdfBuilder.cxx:150
 RooSimPdfBuilder.cxx:151
 RooSimPdfBuilder.cxx:152
 RooSimPdfBuilder.cxx:153
 RooSimPdfBuilder.cxx:154
 RooSimPdfBuilder.cxx:155
 RooSimPdfBuilder.cxx:156
 RooSimPdfBuilder.cxx:157
 RooSimPdfBuilder.cxx:158
 RooSimPdfBuilder.cxx:159
 RooSimPdfBuilder.cxx:160
 RooSimPdfBuilder.cxx:161
 RooSimPdfBuilder.cxx:162
 RooSimPdfBuilder.cxx:163
 RooSimPdfBuilder.cxx:164
 RooSimPdfBuilder.cxx:165
 RooSimPdfBuilder.cxx:166
 RooSimPdfBuilder.cxx:167
 RooSimPdfBuilder.cxx:168
 RooSimPdfBuilder.cxx:169
 RooSimPdfBuilder.cxx:170
 RooSimPdfBuilder.cxx:171
 RooSimPdfBuilder.cxx:172
 RooSimPdfBuilder.cxx:173
 RooSimPdfBuilder.cxx:174
 RooSimPdfBuilder.cxx:175
 RooSimPdfBuilder.cxx:176
 RooSimPdfBuilder.cxx:177
 RooSimPdfBuilder.cxx:178
 RooSimPdfBuilder.cxx:179
 RooSimPdfBuilder.cxx:180
 RooSimPdfBuilder.cxx:181
 RooSimPdfBuilder.cxx:182
 RooSimPdfBuilder.cxx:183
 RooSimPdfBuilder.cxx:184
 RooSimPdfBuilder.cxx:185
 RooSimPdfBuilder.cxx:186
 RooSimPdfBuilder.cxx:187
 RooSimPdfBuilder.cxx:188
 RooSimPdfBuilder.cxx:189
 RooSimPdfBuilder.cxx:190
 RooSimPdfBuilder.cxx:191
 RooSimPdfBuilder.cxx:192
 RooSimPdfBuilder.cxx:193
 RooSimPdfBuilder.cxx:194
 RooSimPdfBuilder.cxx:195
 RooSimPdfBuilder.cxx:196
 RooSimPdfBuilder.cxx:197
 RooSimPdfBuilder.cxx:198
 RooSimPdfBuilder.cxx:199
 RooSimPdfBuilder.cxx:200
 RooSimPdfBuilder.cxx:201
 RooSimPdfBuilder.cxx:202
 RooSimPdfBuilder.cxx:203
 RooSimPdfBuilder.cxx:204
 RooSimPdfBuilder.cxx:205
 RooSimPdfBuilder.cxx:206
 RooSimPdfBuilder.cxx:207
 RooSimPdfBuilder.cxx:208
 RooSimPdfBuilder.cxx:209
 RooSimPdfBuilder.cxx:210
 RooSimPdfBuilder.cxx:211
 RooSimPdfBuilder.cxx:212
 RooSimPdfBuilder.cxx:213
 RooSimPdfBuilder.cxx:214
 RooSimPdfBuilder.cxx:215
 RooSimPdfBuilder.cxx:216
 RooSimPdfBuilder.cxx:217
 RooSimPdfBuilder.cxx:218
 RooSimPdfBuilder.cxx:219
 RooSimPdfBuilder.cxx:220
 RooSimPdfBuilder.cxx:221
 RooSimPdfBuilder.cxx:222
 RooSimPdfBuilder.cxx:223
 RooSimPdfBuilder.cxx:224
 RooSimPdfBuilder.cxx:225
 RooSimPdfBuilder.cxx:226
 RooSimPdfBuilder.cxx:227
 RooSimPdfBuilder.cxx:228
 RooSimPdfBuilder.cxx:229
 RooSimPdfBuilder.cxx:230
 RooSimPdfBuilder.cxx:231
 RooSimPdfBuilder.cxx:232
 RooSimPdfBuilder.cxx:233
 RooSimPdfBuilder.cxx:234
 RooSimPdfBuilder.cxx:235
 RooSimPdfBuilder.cxx:236
 RooSimPdfBuilder.cxx:237
 RooSimPdfBuilder.cxx:238
 RooSimPdfBuilder.cxx:239
 RooSimPdfBuilder.cxx:240
 RooSimPdfBuilder.cxx:241
 RooSimPdfBuilder.cxx:242
 RooSimPdfBuilder.cxx:243
 RooSimPdfBuilder.cxx:244
 RooSimPdfBuilder.cxx:245
 RooSimPdfBuilder.cxx:246
 RooSimPdfBuilder.cxx:247
 RooSimPdfBuilder.cxx:248
 RooSimPdfBuilder.cxx:249
 RooSimPdfBuilder.cxx:250
 RooSimPdfBuilder.cxx:251
 RooSimPdfBuilder.cxx:252
 RooSimPdfBuilder.cxx:253
 RooSimPdfBuilder.cxx:254
 RooSimPdfBuilder.cxx:255
 RooSimPdfBuilder.cxx:256
 RooSimPdfBuilder.cxx:257
 RooSimPdfBuilder.cxx:258
 RooSimPdfBuilder.cxx:259
 RooSimPdfBuilder.cxx:260
 RooSimPdfBuilder.cxx:261
 RooSimPdfBuilder.cxx:262
 RooSimPdfBuilder.cxx:263
 RooSimPdfBuilder.cxx:264
 RooSimPdfBuilder.cxx:265
 RooSimPdfBuilder.cxx:266
 RooSimPdfBuilder.cxx:267
 RooSimPdfBuilder.cxx:268
 RooSimPdfBuilder.cxx:269
 RooSimPdfBuilder.cxx:270
 RooSimPdfBuilder.cxx:271
 RooSimPdfBuilder.cxx:272
 RooSimPdfBuilder.cxx:273
 RooSimPdfBuilder.cxx:274
 RooSimPdfBuilder.cxx:275
 RooSimPdfBuilder.cxx:276
 RooSimPdfBuilder.cxx:277
 RooSimPdfBuilder.cxx:278
 RooSimPdfBuilder.cxx:279
 RooSimPdfBuilder.cxx:280
 RooSimPdfBuilder.cxx:281
 RooSimPdfBuilder.cxx:282
 RooSimPdfBuilder.cxx:283
 RooSimPdfBuilder.cxx:284
 RooSimPdfBuilder.cxx:285
 RooSimPdfBuilder.cxx:286
 RooSimPdfBuilder.cxx:287
 RooSimPdfBuilder.cxx:288
 RooSimPdfBuilder.cxx:289
 RooSimPdfBuilder.cxx:290
 RooSimPdfBuilder.cxx:291
 RooSimPdfBuilder.cxx:292
 RooSimPdfBuilder.cxx:293
 RooSimPdfBuilder.cxx:294
 RooSimPdfBuilder.cxx:295
 RooSimPdfBuilder.cxx:296
 RooSimPdfBuilder.cxx:297
 RooSimPdfBuilder.cxx:298
 RooSimPdfBuilder.cxx:299
 RooSimPdfBuilder.cxx:300
 RooSimPdfBuilder.cxx:301
 RooSimPdfBuilder.cxx:302
 RooSimPdfBuilder.cxx:303
 RooSimPdfBuilder.cxx:304
 RooSimPdfBuilder.cxx:305
 RooSimPdfBuilder.cxx:306
 RooSimPdfBuilder.cxx:307
 RooSimPdfBuilder.cxx:308
 RooSimPdfBuilder.cxx:309
 RooSimPdfBuilder.cxx:310
 RooSimPdfBuilder.cxx:311
 RooSimPdfBuilder.cxx:312
 RooSimPdfBuilder.cxx:313
 RooSimPdfBuilder.cxx:314
 RooSimPdfBuilder.cxx:315
 RooSimPdfBuilder.cxx:316
 RooSimPdfBuilder.cxx:317
 RooSimPdfBuilder.cxx:318
 RooSimPdfBuilder.cxx:319
 RooSimPdfBuilder.cxx:320
 RooSimPdfBuilder.cxx:321
 RooSimPdfBuilder.cxx:322
 RooSimPdfBuilder.cxx:323
 RooSimPdfBuilder.cxx:324
 RooSimPdfBuilder.cxx:325
 RooSimPdfBuilder.cxx:326
 RooSimPdfBuilder.cxx:327
 RooSimPdfBuilder.cxx:328
 RooSimPdfBuilder.cxx:329
 RooSimPdfBuilder.cxx:330
 RooSimPdfBuilder.cxx:331
 RooSimPdfBuilder.cxx:332
 RooSimPdfBuilder.cxx:333
 RooSimPdfBuilder.cxx:334
 RooSimPdfBuilder.cxx:335
 RooSimPdfBuilder.cxx:336
 RooSimPdfBuilder.cxx:337
 RooSimPdfBuilder.cxx:338
 RooSimPdfBuilder.cxx:339
 RooSimPdfBuilder.cxx:340
 RooSimPdfBuilder.cxx:341
 RooSimPdfBuilder.cxx:342
 RooSimPdfBuilder.cxx:343
 RooSimPdfBuilder.cxx:344
 RooSimPdfBuilder.cxx:345
 RooSimPdfBuilder.cxx:346
 RooSimPdfBuilder.cxx:347
 RooSimPdfBuilder.cxx:348
 RooSimPdfBuilder.cxx:349
 RooSimPdfBuilder.cxx:350
 RooSimPdfBuilder.cxx:351
 RooSimPdfBuilder.cxx:352
 RooSimPdfBuilder.cxx:353
 RooSimPdfBuilder.cxx:354
 RooSimPdfBuilder.cxx:355
 RooSimPdfBuilder.cxx:356
 RooSimPdfBuilder.cxx:357
 RooSimPdfBuilder.cxx:358
 RooSimPdfBuilder.cxx:359
 RooSimPdfBuilder.cxx:360
 RooSimPdfBuilder.cxx:361
 RooSimPdfBuilder.cxx:362
 RooSimPdfBuilder.cxx:363
 RooSimPdfBuilder.cxx:364
 RooSimPdfBuilder.cxx:365
 RooSimPdfBuilder.cxx:366
 RooSimPdfBuilder.cxx:367
 RooSimPdfBuilder.cxx:368
 RooSimPdfBuilder.cxx:369
 RooSimPdfBuilder.cxx:370
 RooSimPdfBuilder.cxx:371
 RooSimPdfBuilder.cxx:372
 RooSimPdfBuilder.cxx:373
 RooSimPdfBuilder.cxx:374
 RooSimPdfBuilder.cxx:375
 RooSimPdfBuilder.cxx:376
 RooSimPdfBuilder.cxx:377
 RooSimPdfBuilder.cxx:378
 RooSimPdfBuilder.cxx:379
 RooSimPdfBuilder.cxx:380
 RooSimPdfBuilder.cxx:381
 RooSimPdfBuilder.cxx:382
 RooSimPdfBuilder.cxx:383
 RooSimPdfBuilder.cxx:384
 RooSimPdfBuilder.cxx:385
 RooSimPdfBuilder.cxx:386
 RooSimPdfBuilder.cxx:387
 RooSimPdfBuilder.cxx:388
 RooSimPdfBuilder.cxx:389
 RooSimPdfBuilder.cxx:390
 RooSimPdfBuilder.cxx:391
 RooSimPdfBuilder.cxx:392
 RooSimPdfBuilder.cxx:393
 RooSimPdfBuilder.cxx:394
 RooSimPdfBuilder.cxx:395
 RooSimPdfBuilder.cxx:396
 RooSimPdfBuilder.cxx:397
 RooSimPdfBuilder.cxx:398
 RooSimPdfBuilder.cxx:399
 RooSimPdfBuilder.cxx:400
 RooSimPdfBuilder.cxx:401
 RooSimPdfBuilder.cxx:402
 RooSimPdfBuilder.cxx:403
 RooSimPdfBuilder.cxx:404
 RooSimPdfBuilder.cxx:405
 RooSimPdfBuilder.cxx:406
 RooSimPdfBuilder.cxx:407
 RooSimPdfBuilder.cxx:408
 RooSimPdfBuilder.cxx:409
 RooSimPdfBuilder.cxx:410
 RooSimPdfBuilder.cxx:411
 RooSimPdfBuilder.cxx:412
 RooSimPdfBuilder.cxx:413
 RooSimPdfBuilder.cxx:414
 RooSimPdfBuilder.cxx:415
 RooSimPdfBuilder.cxx:416
 RooSimPdfBuilder.cxx:417
 RooSimPdfBuilder.cxx:418
 RooSimPdfBuilder.cxx:419
 RooSimPdfBuilder.cxx:420
 RooSimPdfBuilder.cxx:421
 RooSimPdfBuilder.cxx:422
 RooSimPdfBuilder.cxx:423
 RooSimPdfBuilder.cxx:424
 RooSimPdfBuilder.cxx:425
 RooSimPdfBuilder.cxx:426
 RooSimPdfBuilder.cxx:427
 RooSimPdfBuilder.cxx:428
 RooSimPdfBuilder.cxx:429
 RooSimPdfBuilder.cxx:430
 RooSimPdfBuilder.cxx:431
 RooSimPdfBuilder.cxx:432
 RooSimPdfBuilder.cxx:433
 RooSimPdfBuilder.cxx:434
 RooSimPdfBuilder.cxx:435
 RooSimPdfBuilder.cxx:436
 RooSimPdfBuilder.cxx:437
 RooSimPdfBuilder.cxx:438
 RooSimPdfBuilder.cxx:439
 RooSimPdfBuilder.cxx:440
 RooSimPdfBuilder.cxx:441
 RooSimPdfBuilder.cxx:442
 RooSimPdfBuilder.cxx:443
 RooSimPdfBuilder.cxx:444
 RooSimPdfBuilder.cxx:445
 RooSimPdfBuilder.cxx:446
 RooSimPdfBuilder.cxx:447
 RooSimPdfBuilder.cxx:448
 RooSimPdfBuilder.cxx:449
 RooSimPdfBuilder.cxx:450
 RooSimPdfBuilder.cxx:451
 RooSimPdfBuilder.cxx:452
 RooSimPdfBuilder.cxx:453
 RooSimPdfBuilder.cxx:454
 RooSimPdfBuilder.cxx:455
 RooSimPdfBuilder.cxx:456
 RooSimPdfBuilder.cxx:457
 RooSimPdfBuilder.cxx:458
 RooSimPdfBuilder.cxx:459
 RooSimPdfBuilder.cxx:460
 RooSimPdfBuilder.cxx:461
 RooSimPdfBuilder.cxx:462
 RooSimPdfBuilder.cxx:463
 RooSimPdfBuilder.cxx:464
 RooSimPdfBuilder.cxx:465
 RooSimPdfBuilder.cxx:466
 RooSimPdfBuilder.cxx:467
 RooSimPdfBuilder.cxx:468
 RooSimPdfBuilder.cxx:469
 RooSimPdfBuilder.cxx:470
 RooSimPdfBuilder.cxx:471
 RooSimPdfBuilder.cxx:472
 RooSimPdfBuilder.cxx:473
 RooSimPdfBuilder.cxx:474
 RooSimPdfBuilder.cxx:475
 RooSimPdfBuilder.cxx:476
 RooSimPdfBuilder.cxx:477
 RooSimPdfBuilder.cxx:478
 RooSimPdfBuilder.cxx:479
 RooSimPdfBuilder.cxx:480
 RooSimPdfBuilder.cxx:481
 RooSimPdfBuilder.cxx:482
 RooSimPdfBuilder.cxx:483
 RooSimPdfBuilder.cxx:484
 RooSimPdfBuilder.cxx:485
 RooSimPdfBuilder.cxx:486
 RooSimPdfBuilder.cxx:487
 RooSimPdfBuilder.cxx:488
 RooSimPdfBuilder.cxx:489
 RooSimPdfBuilder.cxx:490
 RooSimPdfBuilder.cxx:491
 RooSimPdfBuilder.cxx:492
 RooSimPdfBuilder.cxx:493
 RooSimPdfBuilder.cxx:494
 RooSimPdfBuilder.cxx:495
 RooSimPdfBuilder.cxx:496
 RooSimPdfBuilder.cxx:497
 RooSimPdfBuilder.cxx:498
 RooSimPdfBuilder.cxx:499
 RooSimPdfBuilder.cxx:500
 RooSimPdfBuilder.cxx:501
 RooSimPdfBuilder.cxx:502
 RooSimPdfBuilder.cxx:503
 RooSimPdfBuilder.cxx:504
 RooSimPdfBuilder.cxx:505
 RooSimPdfBuilder.cxx:506
 RooSimPdfBuilder.cxx:507
 RooSimPdfBuilder.cxx:508
 RooSimPdfBuilder.cxx:509
 RooSimPdfBuilder.cxx:510
 RooSimPdfBuilder.cxx:511
 RooSimPdfBuilder.cxx:512
 RooSimPdfBuilder.cxx:513
 RooSimPdfBuilder.cxx:514
 RooSimPdfBuilder.cxx:515
 RooSimPdfBuilder.cxx:516
 RooSimPdfBuilder.cxx:517
 RooSimPdfBuilder.cxx:518
 RooSimPdfBuilder.cxx:519
 RooSimPdfBuilder.cxx:520
 RooSimPdfBuilder.cxx:521
 RooSimPdfBuilder.cxx:522
 RooSimPdfBuilder.cxx:523
 RooSimPdfBuilder.cxx:524
 RooSimPdfBuilder.cxx:525
 RooSimPdfBuilder.cxx:526
 RooSimPdfBuilder.cxx:527
 RooSimPdfBuilder.cxx:528
 RooSimPdfBuilder.cxx:529
 RooSimPdfBuilder.cxx:530
 RooSimPdfBuilder.cxx:531
 RooSimPdfBuilder.cxx:532
 RooSimPdfBuilder.cxx:533
 RooSimPdfBuilder.cxx:534
 RooSimPdfBuilder.cxx:535
 RooSimPdfBuilder.cxx:536
 RooSimPdfBuilder.cxx:537
 RooSimPdfBuilder.cxx:538
 RooSimPdfBuilder.cxx:539
 RooSimPdfBuilder.cxx:540
 RooSimPdfBuilder.cxx:541
 RooSimPdfBuilder.cxx:542
 RooSimPdfBuilder.cxx:543
 RooSimPdfBuilder.cxx:544
 RooSimPdfBuilder.cxx:545
 RooSimPdfBuilder.cxx:546
 RooSimPdfBuilder.cxx:547
 RooSimPdfBuilder.cxx:548
 RooSimPdfBuilder.cxx:549
 RooSimPdfBuilder.cxx:550
 RooSimPdfBuilder.cxx:551
 RooSimPdfBuilder.cxx:552
 RooSimPdfBuilder.cxx:553
 RooSimPdfBuilder.cxx:554
 RooSimPdfBuilder.cxx:555
 RooSimPdfBuilder.cxx:556
 RooSimPdfBuilder.cxx:557
 RooSimPdfBuilder.cxx:558
 RooSimPdfBuilder.cxx:559
 RooSimPdfBuilder.cxx:560
 RooSimPdfBuilder.cxx:561
 RooSimPdfBuilder.cxx:562
 RooSimPdfBuilder.cxx:563
 RooSimPdfBuilder.cxx:564
 RooSimPdfBuilder.cxx:565
 RooSimPdfBuilder.cxx:566
 RooSimPdfBuilder.cxx:567
 RooSimPdfBuilder.cxx:568
 RooSimPdfBuilder.cxx:569
 RooSimPdfBuilder.cxx:570
 RooSimPdfBuilder.cxx:571
 RooSimPdfBuilder.cxx:572
 RooSimPdfBuilder.cxx:573
 RooSimPdfBuilder.cxx:574
 RooSimPdfBuilder.cxx:575
 RooSimPdfBuilder.cxx:576
 RooSimPdfBuilder.cxx:577
 RooSimPdfBuilder.cxx:578
 RooSimPdfBuilder.cxx:579
 RooSimPdfBuilder.cxx:580
 RooSimPdfBuilder.cxx:581
 RooSimPdfBuilder.cxx:582
 RooSimPdfBuilder.cxx:583
 RooSimPdfBuilder.cxx:584
 RooSimPdfBuilder.cxx:585
 RooSimPdfBuilder.cxx:586
 RooSimPdfBuilder.cxx:587
 RooSimPdfBuilder.cxx:588
 RooSimPdfBuilder.cxx:589
 RooSimPdfBuilder.cxx:590
 RooSimPdfBuilder.cxx:591
 RooSimPdfBuilder.cxx:592
 RooSimPdfBuilder.cxx:593
 RooSimPdfBuilder.cxx:594
 RooSimPdfBuilder.cxx:595
 RooSimPdfBuilder.cxx:596
 RooSimPdfBuilder.cxx:597
 RooSimPdfBuilder.cxx:598
 RooSimPdfBuilder.cxx:599
 RooSimPdfBuilder.cxx:600
 RooSimPdfBuilder.cxx:601
 RooSimPdfBuilder.cxx:602
 RooSimPdfBuilder.cxx:603
 RooSimPdfBuilder.cxx:604
 RooSimPdfBuilder.cxx:605
 RooSimPdfBuilder.cxx:606
 RooSimPdfBuilder.cxx:607
 RooSimPdfBuilder.cxx:608
 RooSimPdfBuilder.cxx:609
 RooSimPdfBuilder.cxx:610
 RooSimPdfBuilder.cxx:611
 RooSimPdfBuilder.cxx:612
 RooSimPdfBuilder.cxx:613
 RooSimPdfBuilder.cxx:614
 RooSimPdfBuilder.cxx:615
 RooSimPdfBuilder.cxx:616
 RooSimPdfBuilder.cxx:617
 RooSimPdfBuilder.cxx:618
 RooSimPdfBuilder.cxx:619
 RooSimPdfBuilder.cxx:620
 RooSimPdfBuilder.cxx:621
 RooSimPdfBuilder.cxx:622
 RooSimPdfBuilder.cxx:623
 RooSimPdfBuilder.cxx:624
 RooSimPdfBuilder.cxx:625
 RooSimPdfBuilder.cxx:626
 RooSimPdfBuilder.cxx:627
 RooSimPdfBuilder.cxx:628
 RooSimPdfBuilder.cxx:629
 RooSimPdfBuilder.cxx:630
 RooSimPdfBuilder.cxx:631
 RooSimPdfBuilder.cxx:632
 RooSimPdfBuilder.cxx:633
 RooSimPdfBuilder.cxx:634
 RooSimPdfBuilder.cxx:635
 RooSimPdfBuilder.cxx:636
 RooSimPdfBuilder.cxx:637
 RooSimPdfBuilder.cxx:638
 RooSimPdfBuilder.cxx:639
 RooSimPdfBuilder.cxx:640
 RooSimPdfBuilder.cxx:641
 RooSimPdfBuilder.cxx:642
 RooSimPdfBuilder.cxx:643
 RooSimPdfBuilder.cxx:644
 RooSimPdfBuilder.cxx:645
 RooSimPdfBuilder.cxx:646
 RooSimPdfBuilder.cxx:647
 RooSimPdfBuilder.cxx:648
 RooSimPdfBuilder.cxx:649
 RooSimPdfBuilder.cxx:650
 RooSimPdfBuilder.cxx:651
 RooSimPdfBuilder.cxx:652
 RooSimPdfBuilder.cxx:653
 RooSimPdfBuilder.cxx:654
 RooSimPdfBuilder.cxx:655
 RooSimPdfBuilder.cxx:656
 RooSimPdfBuilder.cxx:657
 RooSimPdfBuilder.cxx:658
 RooSimPdfBuilder.cxx:659
 RooSimPdfBuilder.cxx:660
 RooSimPdfBuilder.cxx:661
 RooSimPdfBuilder.cxx:662
 RooSimPdfBuilder.cxx:663
 RooSimPdfBuilder.cxx:664
 RooSimPdfBuilder.cxx:665
 RooSimPdfBuilder.cxx:666
 RooSimPdfBuilder.cxx:667
 RooSimPdfBuilder.cxx:668
 RooSimPdfBuilder.cxx:669
 RooSimPdfBuilder.cxx:670
 RooSimPdfBuilder.cxx:671
 RooSimPdfBuilder.cxx:672
 RooSimPdfBuilder.cxx:673
 RooSimPdfBuilder.cxx:674
 RooSimPdfBuilder.cxx:675
 RooSimPdfBuilder.cxx:676
 RooSimPdfBuilder.cxx:677
 RooSimPdfBuilder.cxx:678
 RooSimPdfBuilder.cxx:679
 RooSimPdfBuilder.cxx:680
 RooSimPdfBuilder.cxx:681
 RooSimPdfBuilder.cxx:682
 RooSimPdfBuilder.cxx:683
 RooSimPdfBuilder.cxx:684
 RooSimPdfBuilder.cxx:685
 RooSimPdfBuilder.cxx:686
 RooSimPdfBuilder.cxx:687
 RooSimPdfBuilder.cxx:688
 RooSimPdfBuilder.cxx:689
 RooSimPdfBuilder.cxx:690
 RooSimPdfBuilder.cxx:691
 RooSimPdfBuilder.cxx:692
 RooSimPdfBuilder.cxx:693
 RooSimPdfBuilder.cxx:694
 RooSimPdfBuilder.cxx:695
 RooSimPdfBuilder.cxx:696
 RooSimPdfBuilder.cxx:697
 RooSimPdfBuilder.cxx:698
 RooSimPdfBuilder.cxx:699
 RooSimPdfBuilder.cxx:700
 RooSimPdfBuilder.cxx:701
 RooSimPdfBuilder.cxx:702
 RooSimPdfBuilder.cxx:703
 RooSimPdfBuilder.cxx:704
 RooSimPdfBuilder.cxx:705
 RooSimPdfBuilder.cxx:706
 RooSimPdfBuilder.cxx:707
 RooSimPdfBuilder.cxx:708
 RooSimPdfBuilder.cxx:709
 RooSimPdfBuilder.cxx:710
 RooSimPdfBuilder.cxx:711
 RooSimPdfBuilder.cxx:712
 RooSimPdfBuilder.cxx:713
 RooSimPdfBuilder.cxx:714
 RooSimPdfBuilder.cxx:715
 RooSimPdfBuilder.cxx:716
 RooSimPdfBuilder.cxx:717
 RooSimPdfBuilder.cxx:718
 RooSimPdfBuilder.cxx:719
 RooSimPdfBuilder.cxx:720
 RooSimPdfBuilder.cxx:721
 RooSimPdfBuilder.cxx:722
 RooSimPdfBuilder.cxx:723
 RooSimPdfBuilder.cxx:724
 RooSimPdfBuilder.cxx:725
 RooSimPdfBuilder.cxx:726
 RooSimPdfBuilder.cxx:727
 RooSimPdfBuilder.cxx:728
 RooSimPdfBuilder.cxx:729
 RooSimPdfBuilder.cxx:730
 RooSimPdfBuilder.cxx:731
 RooSimPdfBuilder.cxx:732
 RooSimPdfBuilder.cxx:733
 RooSimPdfBuilder.cxx:734
 RooSimPdfBuilder.cxx:735
 RooSimPdfBuilder.cxx:736
 RooSimPdfBuilder.cxx:737
 RooSimPdfBuilder.cxx:738
 RooSimPdfBuilder.cxx:739
 RooSimPdfBuilder.cxx:740
 RooSimPdfBuilder.cxx:741
 RooSimPdfBuilder.cxx:742
 RooSimPdfBuilder.cxx:743
 RooSimPdfBuilder.cxx:744
 RooSimPdfBuilder.cxx:745
 RooSimPdfBuilder.cxx:746
 RooSimPdfBuilder.cxx:747
 RooSimPdfBuilder.cxx:748
 RooSimPdfBuilder.cxx:749
 RooSimPdfBuilder.cxx:750
 RooSimPdfBuilder.cxx:751
 RooSimPdfBuilder.cxx:752
 RooSimPdfBuilder.cxx:753
 RooSimPdfBuilder.cxx:754
 RooSimPdfBuilder.cxx:755
 RooSimPdfBuilder.cxx:756
 RooSimPdfBuilder.cxx:757
 RooSimPdfBuilder.cxx:758
 RooSimPdfBuilder.cxx:759
 RooSimPdfBuilder.cxx:760
 RooSimPdfBuilder.cxx:761
 RooSimPdfBuilder.cxx:762
 RooSimPdfBuilder.cxx:763
 RooSimPdfBuilder.cxx:764
 RooSimPdfBuilder.cxx:765
 RooSimPdfBuilder.cxx:766
 RooSimPdfBuilder.cxx:767
 RooSimPdfBuilder.cxx:768
 RooSimPdfBuilder.cxx:769
 RooSimPdfBuilder.cxx:770
 RooSimPdfBuilder.cxx:771
 RooSimPdfBuilder.cxx:772
 RooSimPdfBuilder.cxx:773
 RooSimPdfBuilder.cxx:774
 RooSimPdfBuilder.cxx:775
 RooSimPdfBuilder.cxx:776
 RooSimPdfBuilder.cxx:777
 RooSimPdfBuilder.cxx:778
 RooSimPdfBuilder.cxx:779
 RooSimPdfBuilder.cxx:780
 RooSimPdfBuilder.cxx:781
 RooSimPdfBuilder.cxx:782
 RooSimPdfBuilder.cxx:783
 RooSimPdfBuilder.cxx:784
 RooSimPdfBuilder.cxx:785
 RooSimPdfBuilder.cxx:786
 RooSimPdfBuilder.cxx:787
 RooSimPdfBuilder.cxx:788
 RooSimPdfBuilder.cxx:789
 RooSimPdfBuilder.cxx:790
 RooSimPdfBuilder.cxx:791
 RooSimPdfBuilder.cxx:792
 RooSimPdfBuilder.cxx:793
 RooSimPdfBuilder.cxx:794
 RooSimPdfBuilder.cxx:795
 RooSimPdfBuilder.cxx:796
 RooSimPdfBuilder.cxx:797
 RooSimPdfBuilder.cxx:798
 RooSimPdfBuilder.cxx:799
 RooSimPdfBuilder.cxx:800
 RooSimPdfBuilder.cxx:801
 RooSimPdfBuilder.cxx:802
 RooSimPdfBuilder.cxx:803
 RooSimPdfBuilder.cxx:804
 RooSimPdfBuilder.cxx:805
 RooSimPdfBuilder.cxx:806
 RooSimPdfBuilder.cxx:807
 RooSimPdfBuilder.cxx:808
 RooSimPdfBuilder.cxx:809
 RooSimPdfBuilder.cxx:810
 RooSimPdfBuilder.cxx:811
 RooSimPdfBuilder.cxx:812
 RooSimPdfBuilder.cxx:813
 RooSimPdfBuilder.cxx:814
 RooSimPdfBuilder.cxx:815
 RooSimPdfBuilder.cxx:816
 RooSimPdfBuilder.cxx:817
 RooSimPdfBuilder.cxx:818
 RooSimPdfBuilder.cxx:819
 RooSimPdfBuilder.cxx:820
 RooSimPdfBuilder.cxx:821
 RooSimPdfBuilder.cxx:822
 RooSimPdfBuilder.cxx:823
 RooSimPdfBuilder.cxx:824
 RooSimPdfBuilder.cxx:825
 RooSimPdfBuilder.cxx:826
 RooSimPdfBuilder.cxx:827
 RooSimPdfBuilder.cxx:828
 RooSimPdfBuilder.cxx:829
 RooSimPdfBuilder.cxx:830
 RooSimPdfBuilder.cxx:831
 RooSimPdfBuilder.cxx:832
 RooSimPdfBuilder.cxx:833
 RooSimPdfBuilder.cxx:834
 RooSimPdfBuilder.cxx:835
 RooSimPdfBuilder.cxx:836
 RooSimPdfBuilder.cxx:837
 RooSimPdfBuilder.cxx:838
 RooSimPdfBuilder.cxx:839
 RooSimPdfBuilder.cxx:840
 RooSimPdfBuilder.cxx:841
 RooSimPdfBuilder.cxx:842
 RooSimPdfBuilder.cxx:843
 RooSimPdfBuilder.cxx:844
 RooSimPdfBuilder.cxx:845
 RooSimPdfBuilder.cxx:846
 RooSimPdfBuilder.cxx:847
 RooSimPdfBuilder.cxx:848
 RooSimPdfBuilder.cxx:849
 RooSimPdfBuilder.cxx:850
 RooSimPdfBuilder.cxx:851
 RooSimPdfBuilder.cxx:852
 RooSimPdfBuilder.cxx:853
 RooSimPdfBuilder.cxx:854
 RooSimPdfBuilder.cxx:855
 RooSimPdfBuilder.cxx:856
 RooSimPdfBuilder.cxx:857
 RooSimPdfBuilder.cxx:858
 RooSimPdfBuilder.cxx:859
 RooSimPdfBuilder.cxx:860
 RooSimPdfBuilder.cxx:861
 RooSimPdfBuilder.cxx:862
 RooSimPdfBuilder.cxx:863
 RooSimPdfBuilder.cxx:864
 RooSimPdfBuilder.cxx:865
 RooSimPdfBuilder.cxx:866
 RooSimPdfBuilder.cxx:867
 RooSimPdfBuilder.cxx:868
 RooSimPdfBuilder.cxx:869
 RooSimPdfBuilder.cxx:870
 RooSimPdfBuilder.cxx:871
 RooSimPdfBuilder.cxx:872
 RooSimPdfBuilder.cxx:873
 RooSimPdfBuilder.cxx:874
 RooSimPdfBuilder.cxx:875
 RooSimPdfBuilder.cxx:876
 RooSimPdfBuilder.cxx:877
 RooSimPdfBuilder.cxx:878
 RooSimPdfBuilder.cxx:879
 RooSimPdfBuilder.cxx:880
 RooSimPdfBuilder.cxx:881
 RooSimPdfBuilder.cxx:882
 RooSimPdfBuilder.cxx:883
 RooSimPdfBuilder.cxx:884
 RooSimPdfBuilder.cxx:885
 RooSimPdfBuilder.cxx:886
 RooSimPdfBuilder.cxx:887
 RooSimPdfBuilder.cxx:888
 RooSimPdfBuilder.cxx:889
 RooSimPdfBuilder.cxx:890
 RooSimPdfBuilder.cxx:891
 RooSimPdfBuilder.cxx:892
 RooSimPdfBuilder.cxx:893
 RooSimPdfBuilder.cxx:894
 RooSimPdfBuilder.cxx:895
 RooSimPdfBuilder.cxx:896
 RooSimPdfBuilder.cxx:897
 RooSimPdfBuilder.cxx:898
 RooSimPdfBuilder.cxx:899
 RooSimPdfBuilder.cxx:900
 RooSimPdfBuilder.cxx:901
 RooSimPdfBuilder.cxx:902
 RooSimPdfBuilder.cxx:903
 RooSimPdfBuilder.cxx:904
 RooSimPdfBuilder.cxx:905
 RooSimPdfBuilder.cxx:906
 RooSimPdfBuilder.cxx:907
 RooSimPdfBuilder.cxx:908
 RooSimPdfBuilder.cxx:909
 RooSimPdfBuilder.cxx:910
 RooSimPdfBuilder.cxx:911
 RooSimPdfBuilder.cxx:912
 RooSimPdfBuilder.cxx:913
 RooSimPdfBuilder.cxx:914
 RooSimPdfBuilder.cxx:915
 RooSimPdfBuilder.cxx:916
 RooSimPdfBuilder.cxx:917
 RooSimPdfBuilder.cxx:918
 RooSimPdfBuilder.cxx:919
 RooSimPdfBuilder.cxx:920
 RooSimPdfBuilder.cxx:921
 RooSimPdfBuilder.cxx:922
 RooSimPdfBuilder.cxx:923
 RooSimPdfBuilder.cxx:924
 RooSimPdfBuilder.cxx:925
 RooSimPdfBuilder.cxx:926
 RooSimPdfBuilder.cxx:927
 RooSimPdfBuilder.cxx:928
 RooSimPdfBuilder.cxx:929
 RooSimPdfBuilder.cxx:930
 RooSimPdfBuilder.cxx:931
 RooSimPdfBuilder.cxx:932
 RooSimPdfBuilder.cxx:933
 RooSimPdfBuilder.cxx:934
 RooSimPdfBuilder.cxx:935
 RooSimPdfBuilder.cxx:936
 RooSimPdfBuilder.cxx:937
 RooSimPdfBuilder.cxx:938
 RooSimPdfBuilder.cxx:939
 RooSimPdfBuilder.cxx:940
 RooSimPdfBuilder.cxx:941
 RooSimPdfBuilder.cxx:942
 RooSimPdfBuilder.cxx:943
 RooSimPdfBuilder.cxx:944
 RooSimPdfBuilder.cxx:945
 RooSimPdfBuilder.cxx:946
 RooSimPdfBuilder.cxx:947
 RooSimPdfBuilder.cxx:948
 RooSimPdfBuilder.cxx:949
 RooSimPdfBuilder.cxx:950
 RooSimPdfBuilder.cxx:951
 RooSimPdfBuilder.cxx:952
 RooSimPdfBuilder.cxx:953
 RooSimPdfBuilder.cxx:954
 RooSimPdfBuilder.cxx:955
 RooSimPdfBuilder.cxx:956
 RooSimPdfBuilder.cxx:957
 RooSimPdfBuilder.cxx:958
 RooSimPdfBuilder.cxx:959
 RooSimPdfBuilder.cxx:960
 RooSimPdfBuilder.cxx:961
 RooSimPdfBuilder.cxx:962
 RooSimPdfBuilder.cxx:963
 RooSimPdfBuilder.cxx:964
 RooSimPdfBuilder.cxx:965
 RooSimPdfBuilder.cxx:966
 RooSimPdfBuilder.cxx:967
 RooSimPdfBuilder.cxx:968
 RooSimPdfBuilder.cxx:969
 RooSimPdfBuilder.cxx:970
 RooSimPdfBuilder.cxx:971
 RooSimPdfBuilder.cxx:972
 RooSimPdfBuilder.cxx:973
 RooSimPdfBuilder.cxx:974
 RooSimPdfBuilder.cxx:975
 RooSimPdfBuilder.cxx:976
 RooSimPdfBuilder.cxx:977
 RooSimPdfBuilder.cxx:978
 RooSimPdfBuilder.cxx:979
 RooSimPdfBuilder.cxx:980
 RooSimPdfBuilder.cxx:981
 RooSimPdfBuilder.cxx:982
 RooSimPdfBuilder.cxx:983
 RooSimPdfBuilder.cxx:984
 RooSimPdfBuilder.cxx:985
 RooSimPdfBuilder.cxx:986
 RooSimPdfBuilder.cxx:987
 RooSimPdfBuilder.cxx:988
 RooSimPdfBuilder.cxx:989
 RooSimPdfBuilder.cxx:990
 RooSimPdfBuilder.cxx:991
 RooSimPdfBuilder.cxx:992
 RooSimPdfBuilder.cxx:993
 RooSimPdfBuilder.cxx:994
 RooSimPdfBuilder.cxx:995
 RooSimPdfBuilder.cxx:996
 RooSimPdfBuilder.cxx:997
 RooSimPdfBuilder.cxx:998
 RooSimPdfBuilder.cxx:999
 RooSimPdfBuilder.cxx:1000
 RooSimPdfBuilder.cxx:1001
 RooSimPdfBuilder.cxx:1002
 RooSimPdfBuilder.cxx:1003
 RooSimPdfBuilder.cxx:1004
 RooSimPdfBuilder.cxx:1005
 RooSimPdfBuilder.cxx:1006
 RooSimPdfBuilder.cxx:1007
 RooSimPdfBuilder.cxx:1008
 RooSimPdfBuilder.cxx:1009
 RooSimPdfBuilder.cxx:1010
 RooSimPdfBuilder.cxx:1011
 RooSimPdfBuilder.cxx:1012
 RooSimPdfBuilder.cxx:1013
 RooSimPdfBuilder.cxx:1014
 RooSimPdfBuilder.cxx:1015
 RooSimPdfBuilder.cxx:1016
 RooSimPdfBuilder.cxx:1017
 RooSimPdfBuilder.cxx:1018
 RooSimPdfBuilder.cxx:1019
 RooSimPdfBuilder.cxx:1020
 RooSimPdfBuilder.cxx:1021
 RooSimPdfBuilder.cxx:1022
 RooSimPdfBuilder.cxx:1023
 RooSimPdfBuilder.cxx:1024
 RooSimPdfBuilder.cxx:1025
 RooSimPdfBuilder.cxx:1026
 RooSimPdfBuilder.cxx:1027
 RooSimPdfBuilder.cxx:1028
 RooSimPdfBuilder.cxx:1029
 RooSimPdfBuilder.cxx:1030
 RooSimPdfBuilder.cxx:1031
 RooSimPdfBuilder.cxx:1032
 RooSimPdfBuilder.cxx:1033
 RooSimPdfBuilder.cxx:1034
 RooSimPdfBuilder.cxx:1035
 RooSimPdfBuilder.cxx:1036
 RooSimPdfBuilder.cxx:1037
 RooSimPdfBuilder.cxx:1038
 RooSimPdfBuilder.cxx:1039
 RooSimPdfBuilder.cxx:1040
 RooSimPdfBuilder.cxx:1041
 RooSimPdfBuilder.cxx:1042
 RooSimPdfBuilder.cxx:1043
 RooSimPdfBuilder.cxx:1044
 RooSimPdfBuilder.cxx:1045
 RooSimPdfBuilder.cxx:1046
 RooSimPdfBuilder.cxx:1047
 RooSimPdfBuilder.cxx:1048
 RooSimPdfBuilder.cxx:1049
 RooSimPdfBuilder.cxx:1050
 RooSimPdfBuilder.cxx:1051
 RooSimPdfBuilder.cxx:1052
 RooSimPdfBuilder.cxx:1053
 RooSimPdfBuilder.cxx:1054
 RooSimPdfBuilder.cxx:1055
 RooSimPdfBuilder.cxx:1056
 RooSimPdfBuilder.cxx:1057
 RooSimPdfBuilder.cxx:1058
 RooSimPdfBuilder.cxx:1059
 RooSimPdfBuilder.cxx:1060
 RooSimPdfBuilder.cxx:1061
 RooSimPdfBuilder.cxx:1062
 RooSimPdfBuilder.cxx:1063
 RooSimPdfBuilder.cxx:1064
 RooSimPdfBuilder.cxx:1065
 RooSimPdfBuilder.cxx:1066
 RooSimPdfBuilder.cxx:1067
 RooSimPdfBuilder.cxx:1068
 RooSimPdfBuilder.cxx:1069
 RooSimPdfBuilder.cxx:1070
 RooSimPdfBuilder.cxx:1071
 RooSimPdfBuilder.cxx:1072
 RooSimPdfBuilder.cxx:1073
 RooSimPdfBuilder.cxx:1074
 RooSimPdfBuilder.cxx:1075
 RooSimPdfBuilder.cxx:1076
 RooSimPdfBuilder.cxx:1077
 RooSimPdfBuilder.cxx:1078
 RooSimPdfBuilder.cxx:1079
 RooSimPdfBuilder.cxx:1080
 RooSimPdfBuilder.cxx:1081
 RooSimPdfBuilder.cxx:1082
 RooSimPdfBuilder.cxx:1083
 RooSimPdfBuilder.cxx:1084
 RooSimPdfBuilder.cxx:1085
 RooSimPdfBuilder.cxx:1086
 RooSimPdfBuilder.cxx:1087
 RooSimPdfBuilder.cxx:1088
 RooSimPdfBuilder.cxx:1089
 RooSimPdfBuilder.cxx:1090
 RooSimPdfBuilder.cxx:1091
 RooSimPdfBuilder.cxx:1092
 RooSimPdfBuilder.cxx:1093
 RooSimPdfBuilder.cxx:1094
 RooSimPdfBuilder.cxx:1095
 RooSimPdfBuilder.cxx:1096
 RooSimPdfBuilder.cxx:1097
 RooSimPdfBuilder.cxx:1098
 RooSimPdfBuilder.cxx:1099
 RooSimPdfBuilder.cxx:1100
 RooSimPdfBuilder.cxx:1101
 RooSimPdfBuilder.cxx:1102
 RooSimPdfBuilder.cxx:1103
 RooSimPdfBuilder.cxx:1104
 RooSimPdfBuilder.cxx:1105
 RooSimPdfBuilder.cxx:1106
 RooSimPdfBuilder.cxx:1107
 RooSimPdfBuilder.cxx:1108
 RooSimPdfBuilder.cxx:1109
 RooSimPdfBuilder.cxx:1110
 RooSimPdfBuilder.cxx:1111
 RooSimPdfBuilder.cxx:1112
 RooSimPdfBuilder.cxx:1113
 RooSimPdfBuilder.cxx:1114
 RooSimPdfBuilder.cxx:1115
 RooSimPdfBuilder.cxx:1116
 RooSimPdfBuilder.cxx:1117
 RooSimPdfBuilder.cxx:1118
 RooSimPdfBuilder.cxx:1119
 RooSimPdfBuilder.cxx:1120
 RooSimPdfBuilder.cxx:1121
 RooSimPdfBuilder.cxx:1122
 RooSimPdfBuilder.cxx:1123
 RooSimPdfBuilder.cxx:1124
 RooSimPdfBuilder.cxx:1125
 RooSimPdfBuilder.cxx:1126
 RooSimPdfBuilder.cxx:1127
 RooSimPdfBuilder.cxx:1128
 RooSimPdfBuilder.cxx:1129
 RooSimPdfBuilder.cxx:1130
 RooSimPdfBuilder.cxx:1131
 RooSimPdfBuilder.cxx:1132
 RooSimPdfBuilder.cxx:1133
 RooSimPdfBuilder.cxx:1134
 RooSimPdfBuilder.cxx:1135
 RooSimPdfBuilder.cxx:1136
 RooSimPdfBuilder.cxx:1137
 RooSimPdfBuilder.cxx:1138