RooProdPdf

 Dummy constructor

 Constructor with 2 PDFs (most frequent use case).

 The optional cutOff parameter can be used as a speed optimization if
 one or more of the PDF have sizable regions with very small values,
 which would pull the entire product of PDFs to zero in those regions.

 After each PDF multiplication, the running product is compared with
 the cutOff parameter. If the running product is smaller than the
 cutOff value, the product series is terminated and remaining PDFs
 are not evaluated.

 There is no magic value of the cutOff, the user should experiment
 to find the appropriate balance between speed and precision.
 If a cutoff is specified, the PDFs most likely to be small should
 be put first in the product. The default cutOff value is zero.

 Constructor from a list of PDFs

 The optional cutOff parameter can be used as a speed optimization if
 one or more of the PDF have sizable regions with very small values,
 which would pull the entire product of PDFs to zero in those regions.

 After each PDF multiplication, the running product is compared with
 the cutOff parameter. If the running product is smaller than the
 cutOff value, the product series is terminated and remaining PDFs
 are not evaluated.

 There is no magic value of the cutOff, the user should experiment
 to find the appropriate balance between speed and precision.
 If a cutoff is specified, the PDFs most likely to be small should
 be put first in the product. The default cutOff value is zero.

 Constructor from named argument list

 fullPdf -- Set of 'regular' PDFS that are normalized over all their observables
 ConditionalPdf(pdfSet,depSet) -- Add PDF to product with condition that it
                                  only be normalized over specified observables
                                  any remaining observables will be conditional
                                  observables


 For example, given a PDF F(x,y) and G(y)

 RooProdPdf("P","P",G,Partial(F,x)) will construct a 2-dimensional PDF as follows:

   P(x,y) = G(y)/Int[y]G(y) * F(x,y)/Int[x]G(x,y)

 which is a well normalized and properly defined PDF, but different from the

  P'(x,y) = F(x,y)*G(y) / Int[x,y] F(x,y)*G(y)

 In the former case the y distribution of P is identical to that of G, while
 F only is used to determine the correlation between X and Y. In the latter
 case the Y distribution is defined by the product of F and G.

 This P(x,y) construction is analoguous to generating events from F(x,y) with
 a prototype dataset sampled from G(y)

   cout << "RooProdPdf::ctor" << endl ;
   cmdArgList.Print("v") ;

 Initialize RooProdPdf from a list of RooCmdArg configuration arguments

 Destructor

 Calculate current unnormalized value of object

 Calculate running product of pdfs, skipping factorized components

 Factorize product in irreducible terms for given choice of integration/normalization

 Check if this configuration was created before

{
 Start out with each term in its own group
TIterator* tIter = terms.MakeIterator() ;
RooArgSet* term ;
while((term=(RooArgSet*)tIter->Next())) {
RooLinkedList* group = new RooLinkedList ;
group->Add(term) ;
groupedTerms.Add(group) ;
}
delete tIter ;

 Make list of imported dependents that occur in any term
RooArgSet allImpDeps ;
TIterator* iIter = imps.MakeIterator() ;
RooArgSet *impDeps ;
while((impDeps=(RooArgSet*)iIter->Next())) {
allImpDeps.add(*impDeps,kFALSE) ;
}
delete iIter ;

 Make list of integrated dependents that occur in any term
RooArgSet allIntDeps ;
iIter = ints.MakeIterator() ;
RooArgSet *intDeps ;
while((intDeps=(RooArgSet*)iIter->Next())) {
allIntDeps.add(*intDeps,kFALSE) ;
}
delete iIter ;

   cout << "Complete lists of imported dependens" ; allImpDeps.Print("1") ;
   cout << "Complete lists of integrated dependens" ; allIntDeps.Print("1") ;

 CASE I: factorizing term: term is integrated over all normalizing observables
 -----------------------------------------------------------------------------
 Check if all observbales of this term are integrated. If so the term cancels

 Make an appropriate name for a RooGenProdProj object in getPartIntList()

 Determine which part (if any) of given integral can be performed analytically.
 If any analytical integration is possible, return integration scenario code.

 RooProdPdf implements two strategies in implementing analytical integrals

 First, PDF components whose entire set of dependents are requested to be integrated
 can be dropped from the product, as they will integrate out to 1 by construction
:
 Second, RooProdPdf queries each remaining component PDF for its analytical integration
 capability of the requested set ('allVars'). It finds the largest common set of variables
 that can be integrated by all remaining components. If such a set exists, it reconfirms that
 each component is capable of analytically integrating the common set, and combines the components
 individual integration codes into a single integration code valid for RooProdPdf.

 Return analytical integral defined by given scenario code

   cout << "RooProdPdf::clearCache(" << GetName() << ") sterilizing cache content" << endl ;

 Only override base class behaviour if default generator method is enabled

 Look up user specified normalization set for given input PDF component