/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id$
 * 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)             *
 *****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
// 
// RooAddPdf is an efficient implementation of a sum of PDFs of the form 
//
//  c_1*PDF_1 + c_2*PDF_2 + ... c_n*PDF_n 
//
// or 
//
//  c_1*PDF_1 + c_2*PDF_2 + ... (1-sum(c_1...c_n-1))*PDF_n 
//
// The first form is for extended likelihood fits, where the
// expected number of events is Sum(i) c_i. The coefficients c_i
// can either be explicitly provided, or, if all components support
// extended likelihood fits, they can be calculated the contribution
// of each PDF to the total number of expected events.
//
// In the second form, the sum of the coefficients is enforced to be one,
// and the coefficient of the last PDF is calculated from that condition.
//
// It is also possible to parameterize the coefficients recursively
// 
// c1*PDF_1 + (1-c1)(c2*PDF_2 + (1-c2)*(c3*PDF_3 + ....))
//
// In this form the sum of the coefficients is always less than 1.0
// for all possible values of the individual coefficients between 0 and 1.
// 
// RooAddPdf relies on each component PDF to be normalized and will perform 
// no normalization other than calculating the proper last coefficient c_n, if requested.
// An (enforced) condition for this assuption is that each PDF_i is independent
// of each coefficient_i.
//
// 

#include "RooFit.h"
#include "RooMsgService.h"

#include "TIterator.h"
#include "TIterator.h"
#include "TList.h"
#include "RooAddPdf.h"
#include "RooDataSet.h"
#include "RooRealProxy.h"
#include "RooPlot.h"
#include "RooRealVar.h"
#include "RooAddGenContext.h"
#include "RooRealConstant.h"
#include "RooNameReg.h"
#include "RooMsgService.h"
#include "RooRecursiveFraction.h"
#include "RooGlobalFunc.h"
#include "RooRealIntegral.h"
#include "RooTrace.h"

#include "Riostream.h"
#include <algorithm>


using namespace std;

ClassImp(RooAddPdf)
;


//_____________________________________________________________________________
RooAddPdf::RooAddPdf() :
  _refCoefNorm("!refCoefNorm","Reference coefficient normalization set",this,kFALSE,kFALSE),
  _refCoefRangeName(0),
  _codeReg(10),
  _snormList(0),
  _recursive(kFALSE)
{
  // Default constructor used for persistence

  _pdfIter   = _pdfList.createIterator() ;
  _coefIter  = _coefList.createIterator() ;

  _coefCache = new Double_t[100] ;
  _coefErrCount = _errorCount ;
  TRACE_CREATE 
}



//_____________________________________________________________________________
RooAddPdf::RooAddPdf(const char *name, const char *title) :
  RooAbsPdf(name,title), 
  _refCoefNorm("!refCoefNorm","Reference coefficient normalization set",this,kFALSE,kFALSE),
  _refCoefRangeName(0),
  _projectCoefs(kFALSE),
  _projCacheMgr(this,10),
  _codeReg(10),
  _pdfList("!pdfs","List of PDFs",this),
  _coefList("!coefficients","List of coefficients",this),
  _snormList(0),
  _haveLastCoef(kFALSE),
  _allExtendable(kFALSE),
  _recursive(kFALSE)
{
  // Dummy constructor 
  _pdfIter   = _pdfList.createIterator() ;
  _coefIter  = _coefList.createIterator() ;

  _coefCache = new Double_t[100] ;
  _coefErrCount = _errorCount ;
  TRACE_CREATE 
}



//_____________________________________________________________________________
RooAddPdf::RooAddPdf(const char *name, const char *title,
		     RooAbsPdf& pdf1, RooAbsPdf& pdf2, RooAbsReal& coef1) : 
  RooAbsPdf(name,title),
  _refCoefNorm("!refCoefNorm","Reference coefficient normalization set",this,kFALSE,kFALSE),
  _refCoefRangeName(0),
  _projectCoefs(kFALSE),
  _projCacheMgr(this,10),
  _codeReg(10),
  _pdfList("!pdfs","List of PDFs",this),
  _coefList("!coefficients","List of coefficients",this),
  _haveLastCoef(kFALSE),
  _allExtendable(kFALSE),
  _recursive(kFALSE)
{
  // Constructor with two PDFs and one coefficient

  _pdfIter  = _pdfList.createIterator() ;
  _coefIter = _coefList.createIterator() ;

  _pdfList.add(pdf1) ;  
  _pdfList.add(pdf2) ;
  _coefList.add(coef1) ;

  _coefCache = new Double_t[_pdfList.getSize()] ;
  _coefErrCount = _errorCount ;
  TRACE_CREATE 
}



//_____________________________________________________________________________
RooAddPdf::RooAddPdf(const char *name, const char *title, const RooArgList& inPdfList, const RooArgList& inCoefList, Bool_t recursiveFractions) :
  RooAbsPdf(name,title),
  _refCoefNorm("!refCoefNorm","Reference coefficient normalization set",this,kFALSE,kFALSE),
  _refCoefRangeName(0),
  _projectCoefs(kFALSE),
  _projCacheMgr(this,10),
  _codeReg(10),
  _pdfList("!pdfs","List of PDFs",this),
  _coefList("!coefficients","List of coefficients",this),
  _haveLastCoef(kFALSE),
  _allExtendable(kFALSE),
  _recursive(kFALSE)
{ 
  // Generic constructor from list of PDFs and list of coefficients.
  // Each pdf list element (i) is paired with coefficient list element (i).
  // The number of coefficients must be either equal to the number of PDFs,
  // in which case extended MLL fitting is enabled, or be one less.
  //
  // All PDFs must inherit from RooAbsPdf. All coefficients must inherit from RooAbsReal
  //
  // If the recursiveFraction flag is true, the coefficients are interpreted as recursive
  // coefficients as explained in the class description.

  if (inPdfList.getSize()>inCoefList.getSize()+1 || inPdfList.getSize()<inCoefList.getSize()) {
    coutE(InputArguments) << "RooAddPdf::RooAddPdf(" << GetName() 
			  << ") number of pdfs and coefficients inconsistent, must have Npdf=Ncoef or Npdf=Ncoef+1" << endl ;
    assert(0) ;
  }

  if (recursiveFractions && inPdfList.getSize()!=inCoefList.getSize()+1) {
    coutW(InputArguments) << "RooAddPdf::RooAddPdf(" << GetName() 
			  << ") WARNING inconsistent input: recursive fractions options can only be used if Npdf=Ncoef+1, ignoring recursive fraction setting" << endl ;
  }


  _pdfIter  = _pdfList.createIterator() ;
  _coefIter = _coefList.createIterator() ;
 
  // Constructor with N PDFs and N or N-1 coefs
  TIterator* pdfIter = inPdfList.createIterator() ;
  TIterator* coefIter = inCoefList.createIterator() ;
  RooAbsPdf* pdf ;
  RooAbsReal* coef ;

  RooArgList partinCoefList ;

  Bool_t first(kTRUE) ;

  while((coef = (RooAbsPdf*)coefIter->Next())) {
    pdf = (RooAbsPdf*) pdfIter->Next() ;
    if (!pdf) {
      coutE(InputArguments) << "RooAddPdf::RooAddPdf(" << GetName() 
			    << ") number of pdfs and coefficients inconsistent, must have Npdf=Ncoef or Npdf=Ncoef+1" << endl ;
      assert(0) ;
    }
    if (!dynamic_cast<RooAbsReal*>(coef)) {
      coutE(InputArguments) << "RooAddPdf::RooAddPdf(" << GetName() << ") coefficient " << coef->GetName() << " is not of type RooAbsReal, ignored" << endl ;
      continue ;
    }
    if (!dynamic_cast<RooAbsReal*>(pdf)) {
      coutE(InputArguments) << "RooAddPdf::RooAddPdf(" << GetName() << ") pdf " << pdf->GetName() << " is not of type RooAbsPdf, ignored" << endl ;
      continue ;
    }
    _pdfList.add(*pdf) ;

    // Process recursive fraction mode separately
    if (recursiveFractions) {
      partinCoefList.add(*coef) ;
      if (first) {	

	// The first fraction is the first plain fraction
	first = kFALSE ;
	_coefList.add(*coef) ;

      } else {

	// The i-th recursive fraction = (1-f1)*(1-f2)*...(fi) and is calculated from the list (f1,...,fi) by RooRecursiveFraction)
	RooAbsReal* rfrac = new RooRecursiveFraction(Form("%s_recursive_fraction_%s",GetName(),pdf->GetName()),"Recursive Fraction",partinCoefList) ;
	addOwnedComponents(*rfrac) ;
	_coefList.add(*rfrac) ;      	

      }

    } else {
      _coefList.add(*coef) ;    
    }
  }

  pdf = (RooAbsPdf*) pdfIter->Next() ;
  if (pdf) {
    if (!dynamic_cast<RooAbsReal*>(pdf)) {
      coutE(InputArguments) << "RooAddPdf::RooAddPdf(" << GetName() << ") last pdf " << coef->GetName() << " is not of type RooAbsPdf, fatal error" << endl ;
      assert(0) ;
    }
    _pdfList.add(*pdf) ;  

    // Process recursive fractions mode
    if (recursiveFractions) {

      // The last recursive fraction = (1-f1)*(1-f2)*...(1-fN) and is calculated from the list (f1,...,fN,1) by RooRecursiveFraction)
      partinCoefList.add(RooFit::RooConst(1)) ;
      RooAbsReal* rfrac = new RooRecursiveFraction(Form("%s_recursive_fraction_%s",GetName(),pdf->GetName()),"Recursive Fraction",partinCoefList) ;
      addOwnedComponents(*rfrac) ;
      _coefList.add(*rfrac) ;      	

      // In recursive mode we always have Ncoef=Npdf
      _haveLastCoef=kTRUE ;
    }

  } else {
    _haveLastCoef=kTRUE ;
  }

  delete pdfIter ;
  delete coefIter  ;

  _coefCache = new Double_t[_pdfList.getSize()] ;
  _coefErrCount = _errorCount ;
  _recursive = recursiveFractions ;

  TRACE_CREATE 
}



//_____________________________________________________________________________
RooAddPdf::RooAddPdf(const char *name, const char *title, const RooArgList& inPdfList) :
  RooAbsPdf(name,title),
  _refCoefNorm("!refCoefNorm","Reference coefficient normalization set",this,kFALSE,kFALSE),
  _refCoefRangeName(0),
  _projectCoefs(kFALSE),
  _projCacheMgr(this,10),
  _pdfList("!pdfs","List of PDFs",this),
  _coefList("!coefficients","List of coefficients",this),
  _haveLastCoef(kFALSE),
  _allExtendable(kTRUE),
  _recursive(kFALSE)
{ 
  // Generic constructor from list of extended PDFs. There are no coefficients as the expected
  // number of events from each components determine the relative weight of the PDFs.
  // 
  // All PDFs must inherit from RooAbsPdf. 

  _pdfIter  = _pdfList.createIterator() ;
  _coefIter = _coefList.createIterator() ;
 
  // Constructor with N PDFs 
  TIterator* pdfIter = inPdfList.createIterator() ;
  RooAbsPdf* pdf ;
  while((pdf = (RooAbsPdf*) pdfIter->Next())) {
    
    if (!dynamic_cast<RooAbsReal*>(pdf)) {
      coutE(InputArguments) << "RooAddPdf::RooAddPdf(" << GetName() << ") pdf " << pdf->GetName() << " is not of type RooAbsPdf, ignored" << endl ;
      continue ;
    }
    if (!pdf->canBeExtended()) {
      coutE(InputArguments) << "RooAddPdf::RooAddPdf(" << GetName() << ") pdf " << pdf->GetName() << " is not extendable, ignored" << endl ;
      continue ;
    }
    _pdfList.add(*pdf) ;    
  }

  delete pdfIter ;

  _coefCache = new Double_t[_pdfList.getSize()] ;
  _coefErrCount = _errorCount ;
  TRACE_CREATE 
}




//_____________________________________________________________________________
RooAddPdf::RooAddPdf(const RooAddPdf& other, const char* name) :
  RooAbsPdf(other,name),
  _refCoefNorm("!refCoefNorm",this,other._refCoefNorm),
  _refCoefRangeName((TNamed*)other._refCoefRangeName),
  _projectCoefs(other._projectCoefs),
  _projCacheMgr(other._projCacheMgr,this),
  _codeReg(other._codeReg),
  _pdfList("!pdfs",this,other._pdfList),
  _coefList("!coefficients",this,other._coefList),
  _haveLastCoef(other._haveLastCoef),
  _allExtendable(other._allExtendable),
  _recursive(other._recursive)
{
  // Copy constructor

  _pdfIter  = _pdfList.createIterator() ;
  _coefIter = _coefList.createIterator() ;
  _coefCache = new Double_t[_pdfList.getSize()] ;
  _coefErrCount = _errorCount ;
  TRACE_CREATE 
}



//_____________________________________________________________________________
RooAddPdf::~RooAddPdf()
{
  // Destructor

  delete _pdfIter ;
  delete _coefIter ;

  if (_coefCache) delete[] _coefCache ;
  TRACE_DESTROY
}



//_____________________________________________________________________________
void RooAddPdf::fixCoefNormalization(const RooArgSet& refCoefNorm) 
{
  // By default the interpretation of the fraction coefficients is
  // performed in the contextual choice of observables. This makes the
  // shape of the p.d.f explicitly dependent on the choice of
  // observables. This method instructs RooAddPdf to freeze the
  // interpretation of the coefficients to be done in the given set of
  // observables. If frozen, fractions are automatically transformed
  // from the reference normalization set to the contextual normalization
  // set by ratios of integrals

  if (refCoefNorm.getSize()==0) {
    _projectCoefs = kFALSE ;
    return ;
  }
  _projectCoefs = kTRUE ;  

  _refCoefNorm.removeAll() ;
  _refCoefNorm.add(refCoefNorm) ;

  _projCacheMgr.reset() ;
}



//_____________________________________________________________________________
void RooAddPdf::fixCoefRange(const char* rangeName)
{
  // By default the interpretation of the fraction coefficients is
  // performed in the default range. This make the shape of a RooAddPdf
  // explicitly dependent on the range of the observables. To allow
  // a range independent definition of the fraction this function
  // instructs RooAddPdf to freeze its interpretation in the given
  // named range. If the current normalization range is different
  // from the reference range, the appropriate fraction coefficients
  // are automically calculation from the reference fractions using
  // ratios if integrals

  _refCoefRangeName = (TNamed*)RooNameReg::ptr(rangeName) ;
  if (_refCoefRangeName) _projectCoefs = kTRUE ;
}



//_____________________________________________________________________________
RooAddPdf::CacheElem* RooAddPdf::getProjCache(const RooArgSet* nset, const RooArgSet* iset, const char* rangeName) const
{
  // Retrieve cache element with for calculation of p.d.f value with normalization set nset and integrated over iset
  // in range 'rangeName'. If cache element does not exist, create and fill it on the fly. The cache contains
  // suplemental normalization terms (in case not all added p.d.f.s have the same observables), projection
  // integrals to calculated transformed fraction coefficients when a frozen reference frame is provided
  // and projection integrals for similar transformations when a frozen reference range is provided.


  // Check if cache already exists 
  CacheElem* cache = (CacheElem*) _projCacheMgr.getObj(nset,iset,0,rangeName) ;
  if (cache) {
    return cache ;
  }

  //Create new cache 
  cache = new CacheElem ;

  // *** PART 1 : Create supplemental normalization list ***

  // Retrieve the combined set of dependents of this PDF ;
  RooArgSet *fullDepList = getObservables(nset) ;
  if (iset) {
    fullDepList->remove(*iset,kTRUE,kTRUE) ;
  }    

  // Fill with dummy unit RRVs for now
  _pdfIter->Reset() ;
  _coefIter->Reset() ;
  RooAbsPdf* pdf ;
  RooAbsReal* coef ;
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {    
    coef=(RooAbsPdf*)_coefIter->Next() ;

    // Start with full list of dependents
    RooArgSet supNSet(*fullDepList) ;

    // Remove PDF dependents
    RooArgSet* pdfDeps = pdf->getObservables(nset) ;
    if (pdfDeps) {
      supNSet.remove(*pdfDeps,kTRUE,kTRUE) ;
      delete pdfDeps ; 
    }

    // Remove coef dependents
    RooArgSet* coefDeps = coef ? coef->getObservables(nset) : 0 ;
    if (coefDeps) {
      supNSet.remove(*coefDeps,kTRUE,kTRUE) ;
      delete coefDeps ;
    }
    
    RooAbsReal* snorm ;
    TString name(GetName()) ;
    name.Append("_") ;
    name.Append(pdf->GetName()) ;
    name.Append("_SupNorm") ;
    cache->_needSupNorm = kFALSE ;
    if (supNSet.getSize()>0) {
      snorm = new RooRealIntegral(name,"Supplemental normalization integral",RooRealConstant::value(1.0),supNSet) ;
      cxcoutD(Caching) << "RooAddPdf " << GetName() << " making supplemental normalization set " << supNSet << " for pdf component " << pdf->GetName() << endl ;
      cache->_needSupNorm = kTRUE ;
    } else {
      snorm = new RooRealVar(name,"Unit Supplemental normalization integral",1.0) ;
    }
    cache->_suppNormList.addOwned(*snorm) ;
  }

  delete fullDepList ;
    
  if (_verboseEval>1) {
    cxcoutD(Caching) << "RooAddPdf::syncSuppNormList(" << GetName() << ") synching supplemental normalization list for norm" << (nset?*nset:RooArgSet()) << endl ;
    if dologD(Caching) {
      cache->_suppNormList.Print("v") ;
    }
  }


  // *** PART 2 : Create projection coefficients ***

//   cout << " this = " << this << " (" << GetName() << ")" << endl ;
//   cout << "projectCoefs = " << (_projectCoefs?"T":"F") << endl ;
//   cout << "_normRange.Length() = " << _normRange.Length() << endl ;

  // If no projections required stop here
  if (!_projectCoefs && !rangeName) {
    _projCacheMgr.setObj(nset,iset,cache,RooNameReg::ptr(rangeName)) ;
//     cout << " no projection required" << endl ;
    return cache ;
  }


//   cout << "calculating projection" << endl ;

  // Reduce iset/nset to actual dependents of this PDF
  RooArgSet* nset2 = nset ? getObservables(nset) : new RooArgSet() ;
  cxcoutD(Caching) << "RooAddPdf(" << GetName() << ")::getPC nset = " << (nset?*nset:RooArgSet()) << " nset2 = " << *nset2 << endl ;

  if (nset2->getSize()==0 && _refCoefNorm.getSize()!=0) {
    //cout << "WVE: evaluating RooAddPdf without normalization, but have reference normalization for coefficient definition" << endl ;
    
    nset2->add(_refCoefNorm) ;
    if (_refCoefRangeName) {
      rangeName = RooNameReg::str(_refCoefRangeName) ;
    }
  }


  // Check if requested transformation is not identity 
  if (!nset2->equals(_refCoefNorm) || _refCoefRangeName !=0 || rangeName !=0 || _normRange.Length()>0) {
   
    cxcoutD(Caching) << "ALEX:     RooAddPdf::syncCoefProjList(" << GetName() << ") projecting coefficients from "
		   << *nset2 << (rangeName?":":"") << (rangeName?rangeName:"") 
		   << " to "  << ((_refCoefNorm.getSize()>0)?_refCoefNorm:*nset2) << (_refCoefRangeName?":":"") << (_refCoefRangeName?RooNameReg::str(_refCoefRangeName):"") << endl ;
    
    // Recalculate projection integrals of PDFs 
    _pdfIter->Reset() ;
    RooAbsPdf* thePdf ;

    while((thePdf=(RooAbsPdf*)_pdfIter->Next())) {

      // Calculate projection integral
      RooAbsReal* pdfProj ;
      if (!nset2->equals(_refCoefNorm)) {
	pdfProj = thePdf->createIntegral(*nset2,_refCoefNorm,_normRange.Length()>0?_normRange.Data():0) ;
	pdfProj->setOperMode(operMode()) ;
	cxcoutD(Caching) << "RooAddPdf(" << GetName() << ")::getPC nset2(" << *nset2 << ")!=_refCoefNorm(" << _refCoefNorm << ") --> pdfProj = " << pdfProj->GetName() << endl ;
      } else {
	TString name(GetName()) ;
	name.Append("_") ;
	name.Append(thePdf->GetName()) ;
	name.Append("_ProjectNorm") ;
	pdfProj = new RooRealVar(name,"Unit Projection normalization integral",1.0) ;
	cxcoutD(Caching) << "RooAddPdf(" << GetName() << ")::getPC nset2(" << *nset2 << ")==_refCoefNorm(" << _refCoefNorm << ") --> pdfProj = " << pdfProj->GetName() << endl ;
      }

      cache->_projList.addOwned(*pdfProj) ;
      cxcoutD(Caching) << " RooAddPdf::syncCoefProjList(" << GetName() << ") PP = " << pdfProj->GetName() << endl ;

      // Calculation optional supplemental normalization term
      RooArgSet supNormSet(_refCoefNorm) ;
      RooArgSet* deps = thePdf->getParameters(RooArgSet()) ;
      supNormSet.remove(*deps,kTRUE,kTRUE) ;
      delete deps ;

      RooAbsReal* snorm ;
      TString name(GetName()) ;
      name.Append("_") ;
      name.Append(thePdf->GetName()) ;
      name.Append("_ProjSupNorm") ;
      if (supNormSet.getSize()>0 && !nset2->equals(_refCoefNorm) ) {
	snorm = new RooRealIntegral(name,"Projection Supplemental normalization integral",
				    RooRealConstant::value(1.0),supNormSet) ;
      } else {
	snorm = new RooRealVar(name,"Unit Projection Supplemental normalization integral",1.0) ;
      }
      cxcoutD(Caching) << " RooAddPdf::syncCoefProjList(" << GetName() << ") SN = " << snorm->GetName() << endl ;
      cache->_suppProjList.addOwned(*snorm) ;

      // Calculate reference range adjusted projection integral
      RooAbsReal* rangeProj1 ;

   //    cout << "ALEX >>>> RooAddPdf(" << GetName() << ")::getPC _refCoefRangeName WVE = " 	   
// 	   <<(_refCoefRangeName?":":"") << (_refCoefRangeName?RooNameReg::str(_refCoefRangeName):"")
// 	   <<" _refCoefRangeName AK = "  << (_refCoefRangeName?_refCoefRangeName->GetName():"")  	   
// 	   << " && _refCoefNorm" << _refCoefNorm << " with size = _refCoefNorm.getSize() " << _refCoefNorm.getSize() << endl ;

      // Check if _refCoefRangeName is identical to default range for all observables, 
      // If so, substitute by unit integral 

      // ----------
      RooArgSet* tmpObs = thePdf->getObservables(_refCoefNorm) ;
      RooAbsArg* obsArg ;
      TIterator* iter = tmpObs->createIterator() ;
      Bool_t allIdent = kTRUE ;
      while((obsArg=(RooAbsArg*)iter->Next())) {
	RooRealVar* rvarg = dynamic_cast<RooRealVar*>(obsArg) ;
	if (rvarg) {
	  if (rvarg->getMin(RooNameReg::str(_refCoefRangeName))!=rvarg->getMin() ||
	      rvarg->getMax(RooNameReg::str(_refCoefRangeName))!=rvarg->getMax()) {
	    allIdent=kFALSE ;
	  }
	}
      }
      delete iter ;
      delete tmpObs ;
      // -------------

      if (_refCoefRangeName && _refCoefNorm.getSize()>0 && !allIdent) {
	

	RooArgSet* tmp = thePdf->getObservables(_refCoefNorm) ;
	rangeProj1 = thePdf->createIntegral(*tmp,*tmp,RooNameReg::str(_refCoefRangeName)) ;
	
	//rangeProj1->setOperMode(operMode()) ;

	delete tmp ;
      } else {

	TString theName(GetName()) ;
	theName.Append("_") ;
	theName.Append(thePdf->GetName()) ;
	theName.Append("_RangeNorm1") ;
	rangeProj1 = new RooRealVar(theName,"Unit range normalization integral",1.0) ;

      }
      cxcoutD(Caching) << " RooAddPdf::syncCoefProjList(" << GetName() << ") R1 = " << rangeProj1->GetName() << endl ;
      cache->_refRangeProjList.addOwned(*rangeProj1) ;
      

      // Calculate range adjusted projection integral
      RooAbsReal* rangeProj2 ;
      cxcoutD(Caching) << "RooAddPdf::syncCoefProjList(" << GetName() << ") rangename = " << (rangeName?rangeName:"<null>") 
		       << " nset = " << (nset?*nset:RooArgSet()) << endl ;
      if (rangeName && _refCoefNorm.getSize()>0) {

	rangeProj2 = thePdf->createIntegral(_refCoefNorm,_refCoefNorm,rangeName) ;
	//rangeProj2->setOperMode(operMode()) ;

      } else if (_normRange.Length()>0) {

	RooArgSet* tmp = thePdf->getObservables(_refCoefNorm) ;
	rangeProj2 = thePdf->createIntegral(*tmp,*tmp,_normRange.Data()) ;
	delete tmp ;

      } else {

	TString theName(GetName()) ;
	theName.Append("_") ;
	theName.Append(thePdf->GetName()) ;
	theName.Append("_RangeNorm2") ;
	rangeProj2 = new RooRealVar(theName,"Unit range normalization integral",1.0) ;

      }
      cxcoutD(Caching) << " RooAddPdf::syncCoefProjList(" << GetName() << ") R2 = " << rangeProj2->GetName() << endl ;
      cache->_rangeProjList.addOwned(*rangeProj2) ;

    }               

  }

  delete nset2 ;

  _projCacheMgr.setObj(nset,iset,cache,RooNameReg::ptr(rangeName)) ;

  return cache ;
}


//_____________________________________________________________________________
void RooAddPdf::updateCoefficients(CacheElem& cache, const RooArgSet* nset) const 
{
  // Update the coefficient values in the given cache element: calculate new remainder
  // fraction, normalize fractions obtained from extended ML terms to unity and
  // multiply these the various range and dimensional corrections needed in the
  // current use context

  // cxcoutD(ChangeTracking) << "RooAddPdf::updateCoefficients(" << GetName() << ") update coefficients" << endl ;
  
  Int_t i ;

  // Straight coefficients
  if (_allExtendable) {
    
    // coef[i] = expectedEvents[i] / SUM(expectedEvents)
    Double_t coefSum(0) ;
    RooFIter it=_pdfList.fwdIterator() ; i=0 ;
    RooAbsPdf* pdf ;
    while((pdf=(RooAbsPdf*)it.next())) {      
      _coefCache[i] = pdf->expectedEvents(_refCoefNorm.getSize()>0?&_refCoefNorm:nset) ;
      coefSum += _coefCache[i] ;
      i++ ;
    }

    if (coefSum==0.) {
      coutW(Eval) << "RooAddPdf::updateCoefCache(" << GetName() << ") WARNING: total number of expected events is 0" << endl ;
    } else {
      Int_t siz = _pdfList.getSize() ;
      for (i=0 ; i<siz ; i++) {
	_coefCache[i] /= coefSum ;
      }			            
    }
    
  } else {
    if (_haveLastCoef) {
      
      // coef[i] = coef[i] / SUM(coef)
      Double_t coefSum(0) ;
      RooFIter it=_coefList.fwdIterator() ; i=0 ;      
      RooAbsReal* coef ;
      while((coef=(RooAbsReal*)it.next())) {
	_coefCache[i] = coef->getVal(nset) ;
	coefSum += _coefCache[i] ;
	i++ ;
      }		
      if (coefSum==0.) {
	coutW(Eval) << "RooAddPdf::updateCoefCache(" << GetName() << ") WARNING: sum of coefficients is zero 0" << endl ;
      } else {	
	Int_t siz = _coefList.getSize() ;
	for (i=0 ; i<siz ; i++) {
	  _coefCache[i] /= coefSum ;
	}			
      }
    } else {
      
      // coef[i] = coef[i] ; coef[n] = 1-SUM(coef[0...n-1])
      Double_t lastCoef(1) ;
      RooFIter it=_coefList.fwdIterator() ; i=0 ;      
      RooAbsReal* coef ;
      while((coef=(RooAbsReal*)it.next())) {
	_coefCache[i] = coef->getVal(nset) ;
 	//cxcoutD(Caching) << "SYNC: orig coef[" << i << "] = " << _coefCache[i] << endl ;
	lastCoef -= _coefCache[i] ;
	i++ ;
      }			
      _coefCache[_coefList.getSize()] = lastCoef ;
      //cxcoutD(Caching) << "SYNC: orig coef[" << _coefList.getSize() << "] = " << _coefCache[_coefList.getSize()] << endl ;
      
      
      // Warn about coefficient degeneration
      if ((lastCoef<-1e-05 || (lastCoef-1)>1e-5) && _coefErrCount-->0) {
	coutW(Eval) << "RooAddPdf::updateCoefCache(" << GetName() 
		    << " WARNING: sum of PDF coefficients not in range [0-1], value=" 
		    << 1-lastCoef ; 
	if (_coefErrCount==0) {
	  coutW(Eval) << " (no more will be printed)"  ;
	}
	coutW(Eval) << endl ;
      } 
    }
  }

  

//    cout << "XXXX" << GetName() << "updateCoefs _projectCoefs = " << (_projectCoefs?"T":"F") << " cache._projList.getSize()= " << cache._projList.getSize() << endl ;

  // Stop here if not projection is required or needed
  if ((!_projectCoefs && _normRange.Length()==0) || cache._projList.getSize()==0) {
    //if (cache._projList.getSize()==0) {
//     cout << GetName() << " SYNC no projection required rangeName = " << (_normRange.Length()>0?_normRange.Data():"<none>") << endl ;
    return ;
  }

//    cout << "XXXX" << GetName() << " updateCoefs, applying correction" << endl ;
//    cout << "PROJLIST = " << endl ;
//    cache._projList.Print("v") ;
   
   
  // Adjust coefficients for given projection
  Double_t coefSum(0) ;
  for (i=0 ; i<_pdfList.getSize() ; i++) {
    Bool_t _tmp = _globalSelectComp ;
    RooAbsPdf::globalSelectComp(kTRUE) ;    

    RooAbsReal* pp = ((RooAbsReal*)cache._projList.at(i)) ; 
    RooAbsReal* sn = ((RooAbsReal*)cache._suppProjList.at(i)) ; 
    RooAbsReal* r1 = ((RooAbsReal*)cache._refRangeProjList.at(i)) ;
    RooAbsReal* r2 = ((RooAbsReal*)cache._rangeProjList.at(i)) ;

    Double_t proj = pp->getVal()/sn->getVal()*(r2->getVal()/r1->getVal()) ;  
    
//     cxcoutD(Caching) << "ALEX:    RooAddPdf::updateCoef(" << GetName() << ") with nset = " << (nset?*nset:RooArgSet()) << "for pdf component #" << i << " = " << _pdfList.at(i)->GetName() << endl
// 	 << "ALEX:   pp = " << pp->GetName() << " = " << pp->getVal() << endl 
// 	 << "ALEX:   sn = " << sn->GetName() << " = " << sn->getVal() <<  endl 
// 	 << "ALEX:   r1 = " << r1->GetName() << " = " << r1->getVal() <<  endl 
// 	 << "ALEX:   r2 = " << r2->GetName() << " = " << r2->getVal() <<  endl 
// 	 << "ALEX: proj = (" << pp->getVal() << "/" << sn->getVal() << ")*(" << r2->getVal() << "/" << r1->getVal() << ") = " << proj << endl ;
    
    RooAbsPdf::globalSelectComp(_tmp) ;

    _coefCache[i] *= proj ;
    coefSum += _coefCache[i] ;
  }

  for (i=0 ; i<_pdfList.getSize() ; i++) {
    _coefCache[i] /= coefSum ;
    //    _coefCache[i] *= rfrac ;
//     cout << "POST-SYNC coef[" << i << "] = " << _coefCache[i] << endl ;
     cxcoutD(Caching) << " ALEX:   POST-SYNC coef[" << i << "] = " << _coefCache[i]  
 	 << " ( _coefCache[i]/coefSum = " << _coefCache[i]*coefSum << "/" << coefSum << " ) "<< endl ;
  }
   

  
}



//_____________________________________________________________________________
Double_t RooAddPdf::evaluate() const 
{
  // Calculate and return the current value

  const RooArgSet* nset = _normSet ; 
  //cxcoutD(Caching) << "RooAddPdf::evaluate(" << GetName() << ") calling getProjCache with nset = " << nset << " = " << (nset?*nset:RooArgSet()) << endl ;

  if (nset==0 || nset->getSize()==0) {
    if (_refCoefNorm.getSize()!=0) {
      nset = &_refCoefNorm ;
    }
  }

  CacheElem* cache = getProjCache(nset) ;
  updateCoefficients(*cache,nset) ;
  
  // Do running sum of coef/pdf pairs, calculate lastCoef.
  RooAbsPdf* pdf ;
  Double_t value(0) ;
  Int_t i(0) ;
  RooFIter pi = _pdfList.fwdIterator() ;

  if (cache->_needSupNorm) {

    Double_t snormVal ;
    while((pdf = (RooAbsPdf*)pi.next())) {
      snormVal = ((RooAbsReal*)cache->_suppNormList.at(i))->getVal() ;
      Double_t pdfVal = pdf->getVal(nset) ;
      if (pdf->isSelectedComp()) {
	value += pdfVal*_coefCache[i]/snormVal ;
      }
      i++ ;
    }
  } else {
    
    while((pdf = (RooAbsPdf*)pi.next())) {
      Double_t pdfVal = pdf->getVal(nset) ;

      if (pdf->isSelectedComp()) {
	value += pdfVal*_coefCache[i] ;
      }
      i++ ;
    }
        
  }

  return value ;
}


//_____________________________________________________________________________
void RooAddPdf::resetErrorCounters(Int_t resetValue)
{
  // Reset error counter to given value, limiting the number
  // of future error messages for this pdf to 'resetValue'

  RooAbsPdf::resetErrorCounters(resetValue) ;
  _coefErrCount = resetValue ;
}



//_____________________________________________________________________________
Bool_t RooAddPdf::checkObservables(const RooArgSet* nset) const 
{
  // Check if PDF is valid for given normalization set.
  // Coeffient and PDF must be non-overlapping, but pdf-coefficient 
  // pairs may overlap each other

  Bool_t ret(kFALSE) ;

  _pdfIter->Reset() ;
  _coefIter->Reset() ;
  RooAbsReal* coef ;
  RooAbsReal* pdf ;
  while((coef=(RooAbsReal*)_coefIter->Next())) {
    pdf = (RooAbsReal*)_pdfIter->Next() ;
    if (pdf->observableOverlaps(nset,*coef)) {
      coutE(InputArguments) << "RooAddPdf::checkObservables(" << GetName() << "): ERROR: coefficient " << coef->GetName() 
			    << " and PDF " << pdf->GetName() << " have one or more dependents in common" << endl ;
      ret = kTRUE ;
    }
  }
  
  return ret ;
}


//_____________________________________________________________________________
Int_t RooAddPdf::getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, 
					 const RooArgSet* normSet, const char* rangeName) const 
{
  // Determine which part (if any) of given integral can be performed analytically.
  // If any analytical integration is possible, return integration scenario code
  //
  // RooAddPdf queries each 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 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 RooAddPdf.


  RooArgSet* allDepVars = getObservables(allVars) ;
  RooArgSet allAnalVars(*allDepVars) ;
  delete allDepVars ;

  TIterator* avIter = allVars.createIterator() ;

  Int_t n(0) ;

  // First iteration, determine what each component can integrate analytically
  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {
    RooArgSet subAnalVars ;
    pdf->getAnalyticalIntegralWN(allVars,subAnalVars,normSet,rangeName) ;

    // Observables that cannot be integrated analytically by this component are dropped from the common list
    avIter->Reset() ;
    RooAbsArg* arg ;
    while((arg=(RooAbsArg*)avIter->Next())) {
      if (!subAnalVars.find(arg->GetName()) && pdf->dependsOn(*arg)) {
	allAnalVars.remove(*arg,kTRUE,kTRUE) ;
      }	
    }
    n++ ;
  }

  // If no observables can be integrated analytically, return code 0 here
  if (allAnalVars.getSize()==0) {
    delete avIter ;
    return 0 ;
  }


  // Now retrieve codes for integration over common set of analytically integrable observables for each component
  _pdfIter->Reset() ;
  n=0 ;
  std::vector<Int_t> subCode(_pdfList.getSize());
  Bool_t allOK(kTRUE) ;
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {
    RooArgSet subAnalVars ;
    RooArgSet* allAnalVars2 = pdf->getObservables(allAnalVars) ;
    subCode[n] = pdf->getAnalyticalIntegralWN(*allAnalVars2,subAnalVars,normSet,rangeName) ;
    if (subCode[n]==0 && allAnalVars2->getSize()>0) {
      coutE(InputArguments) << "RooAddPdf::getAnalyticalIntegral(" << GetName() << ") WARNING: component PDF " << pdf->GetName() 
			    << "   advertises inconsistent set of integrals (e.g. (X,Y) but not X or Y individually."
			    << "   Distributed analytical integration disabled. Please fix PDF" << endl ;
      allOK = kFALSE ;
    }
    delete allAnalVars2 ; 
    n++ ;
  }  
  if (!allOK) {
    delete avIter ;
    return 0 ;
  }

  // Mare all analytically integrated observables as such
  analVars.add(allAnalVars) ;

  // Store set of variables analytically integrated
  RooArgSet* intSet = new RooArgSet(allAnalVars) ;
  Int_t masterCode = _codeReg.store(subCode,intSet)+1 ;

  delete avIter ;

  return masterCode ;
}



//_____________________________________________________________________________
Double_t RooAddPdf::analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName) const 
{
  // Return analytical integral defined by given scenario code

  // WVE needs adaptation to handle new rangeName feature
  if (code==0) {
    return getVal(normSet) ;
  }

  // Retrieve analytical integration subCodes and set of observabels integrated over
  RooArgSet* intSet ;
  const std::vector<Int_t>& subCode = _codeReg.retrieve(code-1,intSet) ;
  if (subCode.empty()) {
    coutE(InputArguments) << "RooAddPdf::analyticalIntegral(" << GetName() << "): ERROR unrecognized integration code, " << code << endl ;
    assert(0) ;    
  }

  cxcoutD(Caching) << "RooAddPdf::aiWN(" << GetName() << ") calling getProjCache with nset = " << (normSet?*normSet:RooArgSet()) << endl ;

  if ((normSet==0 || normSet->getSize()==0) && _refCoefNorm.getSize()>0) {
//     cout << "WVE integration of RooAddPdf without normalization, but have reference set, using ref set for normalization" << endl ;
    normSet = &_refCoefNorm ;
  }

  CacheElem* cache = getProjCache(normSet,intSet,0) ; // WVE rangename here?
  updateCoefficients(*cache,normSet) ;

  // Calculate the current value of this object  
  Double_t value(0) ;

  // Do running sum of coef/pdf pairs, calculate lastCoef.
  _pdfIter->Reset() ;
  _coefIter->Reset() ;
  RooAbsPdf* pdf ;
  Double_t snormVal ;
  Int_t i(0) ;

  //cout << "ROP::aIWN updateCoefCache with rangeName = " << (rangeName?rangeName:"<null>") << endl ;
  RooArgList* snormSet = (cache->_suppNormList.getSize()>0) ? &cache->_suppNormList : 0 ;
  while((pdf = (RooAbsPdf*)_pdfIter->Next())) {
    if (_coefCache[i]) {
      snormVal = snormSet ? ((RooAbsReal*) cache->_suppNormList.at(i))->getVal() : 1.0 ;
      
      // WVE swap this?
      Double_t val = pdf->analyticalIntegralWN(subCode[i],normSet,rangeName) ;
      if (pdf->isSelectedComp()) {
	
	value += val*_coefCache[i]/snormVal ;
      }
    }    
    i++ ;
  }

  return value ;
}



//_____________________________________________________________________________
Double_t RooAddPdf::expectedEvents(const RooArgSet* nset) const 
{  
  // Return the number of expected events, which is either the sum of all coefficients
  // or the sum of the components extended terms, multiplied with the fraction that
  // is in the current range w.r.t the reference range

  Double_t expectedTotal(0.0);

  cxcoutD(Caching) << "RooAddPdf::expectedEvents(" << GetName() << ") calling getProjCache with nset = " << (nset?*nset:RooArgSet()) << endl ;
  CacheElem* cache = getProjCache(nset) ;
  updateCoefficients(*cache,nset) ;

  if (cache->_rangeProjList.getSize()>0) {

    RooFIter iter1 = cache->_refRangeProjList.fwdIterator() ;
    RooFIter iter2 = cache->_rangeProjList.fwdIterator() ;
    RooFIter iter3 = _pdfList.fwdIterator() ;

    if (_allExtendable) {
      
      RooAbsPdf* pdf ;
      while ((pdf=(RooAbsPdf*)iter3.next())) {      
	RooAbsReal* r1 = (RooAbsReal*)iter1.next() ;
	RooAbsReal* r2 = (RooAbsReal*)iter2.next() ;
	expectedTotal += (r2->getVal()/r1->getVal()) * pdf->expectedEvents(nset) ; 
      }    

    } else {

      RooFIter citer = _coefList.fwdIterator() ;
      RooAbsReal* coef ;
      while((coef=(RooAbsReal*)citer.next())) {
	Double_t ncomp = coef->getVal(nset) ;
	RooAbsReal* r1 = (RooAbsReal*)iter1.next() ;
	RooAbsReal* r2 = (RooAbsReal*)iter2.next() ;
	expectedTotal += (r2->getVal()/r1->getVal()) * ncomp ; 
      }

    }



  } else {

    if (_allExtendable) {

      RooFIter iter = _pdfList.fwdIterator() ;
      RooAbsPdf* pdf ;
      while((pdf=(RooAbsPdf*)iter.next())) {
	expectedTotal += pdf->expectedEvents(nset) ; 
      }

    } else {

      RooFIter citer = _coefList.fwdIterator() ;
      RooAbsReal* coef ;
      while((coef=(RooAbsReal*)citer.next())) {
	Double_t ncomp = coef->getVal(nset) ;
	expectedTotal += ncomp ;      
      }

    }

  }
  return expectedTotal ;  
}



//_____________________________________________________________________________
void RooAddPdf::selectNormalization(const RooArgSet* depSet, Bool_t force) 
{
  // Interface function used by test statistics to freeze choice of observables
  // for interpretation of fraction coefficients


  if (!force && _refCoefNorm.getSize()!=0) {
    return ;
  }

  if (!depSet) {
    fixCoefNormalization(RooArgSet()) ;
    return ;
  }

  RooArgSet* myDepSet = getObservables(depSet) ;
  fixCoefNormalization(*myDepSet) ;
  delete myDepSet ;
}



//_____________________________________________________________________________
void RooAddPdf::selectNormalizationRange(const char* rangeName, Bool_t force) 
{
  // Interface function used by test statistics to freeze choice of range
  // for interpretation of fraction coefficients

  if (!force && _refCoefRangeName) {
    return ;
  }

  fixCoefRange(rangeName) ;
}



//_____________________________________________________________________________
RooAbsGenContext* RooAddPdf::genContext(const RooArgSet &vars, const RooDataSet *prototype, 
					const RooArgSet* auxProto, Bool_t verbose) const 
{
  // Return specialized context to efficiently generate toy events from RooAddPdfs
  // return RooAbsPdf::genContext(vars,prototype,auxProto,verbose) ; // WVE DEBUG
  return new RooAddGenContext(*this,vars,prototype,auxProto,verbose) ;
}



//_____________________________________________________________________________
RooArgList RooAddPdf::CacheElem::containedArgs(Action) 
{
  // List all RooAbsArg derived contents in this cache element

  RooArgList allNodes;
  allNodes.add(_projList) ;
  allNodes.add(_suppProjList) ;
  allNodes.add(_refRangeProjList) ;
  allNodes.add(_rangeProjList) ;

  return allNodes ;
}



//_____________________________________________________________________________
std::list<Double_t>* RooAddPdf::plotSamplingHint(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const 
{
  // Loop over components for plot sampling hints and merge them if there are multiple

  list<Double_t>* sumHint = 0 ;

  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;
  Bool_t needClean(kFALSE) ;

  // Loop over components pdf
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {

    list<Double_t>* pdfHint = pdf->plotSamplingHint(obs,xlo,xhi) ;

    // Process hint
    if (pdfHint) {
      if (!sumHint) {

	// If this is the first hint, then just save it
	sumHint = pdfHint ;

      } else {

	list<Double_t>* newSumHint = new list<Double_t>(sumHint->size()+pdfHint->size()) ;

	// Merge hints into temporary array
	merge(pdfHint->begin(),pdfHint->end(),sumHint->begin(),sumHint->end(),newSumHint->begin()) ;

	// Copy merged array without duplicates to new sumHintArrau
	delete sumHint ;
	sumHint = newSumHint ;
	needClean = kTRUE ;
	
      }
    }
  }
  if (needClean) {
    list<Double_t>::iterator new_end = unique(sumHint->begin(),sumHint->end()) ;
    sumHint->erase(new_end,sumHint->end()) ;
  }

  return sumHint ;
}


//_____________________________________________________________________________
std::list<Double_t>* RooAddPdf::binBoundaries(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const 
{
  // Loop over components for plot sampling hints and merge them if there are multiple

  list<Double_t>* sumBinB = 0 ;
  Bool_t needClean(kFALSE) ;
  
  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;
  // Loop over components pdf
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {

    list<Double_t>* pdfBinB = pdf->binBoundaries(obs,xlo,xhi) ;

    // Process hint
    if (pdfBinB) {
      if (!sumBinB) {

	// If this is the first hint, then just save it
	sumBinB = pdfBinB ;

      } else {
	
	list<Double_t>* newSumBinB = new list<Double_t>(sumBinB->size()+pdfBinB->size()) ;

	// Merge hints into temporary array
	merge(pdfBinB->begin(),pdfBinB->end(),sumBinB->begin(),sumBinB->end(),newSumBinB->begin()) ;

	// Copy merged array without duplicates to new sumBinBArrau
	delete sumBinB ;
	delete pdfBinB ;
	sumBinB = newSumBinB ;
	needClean = kTRUE ;	
      }
    }
  }

  // Remove consecutive duplicates
  if (needClean) {    
    list<Double_t>::iterator new_end = unique(sumBinB->begin(),sumBinB->end()) ;
    sumBinB->erase(new_end,sumBinB->end()) ;
  }

  return sumBinB ;
}


//_____________________________________________________________________________
Bool_t RooAddPdf::isBinnedDistribution(const RooArgSet& obs) const 
{
  // If all components that depend on obs are binned that so is the product
  
  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {
    if (pdf->dependsOn(obs) && !pdf->isBinnedDistribution(obs)) {
      return kFALSE ;
    }
  }
  
  return kTRUE  ;  
}


//_____________________________________________________________________________
void RooAddPdf::setCacheAndTrackHints(RooArgSet& trackNodes) 
{
  // Label OK'ed components of a RooAddPdf with cache-and-track
  RooFIter aiter = pdfList().fwdIterator() ;
  RooAbsArg* aarg ;
  while ((aarg=aiter.next())) {
    if (aarg->canNodeBeCached()==Always) {
      trackNodes.add(*aarg) ;
      //cout << "tracking node RooAddPdf component " << aarg->IsA()->GetName() << "::" << aarg->GetName() << endl ;	      
    } 
  }  
}



//_____________________________________________________________________________
void RooAddPdf::printMetaArgs(ostream& os) const 
{
  // Customized printing of arguments of a RooAddPdf to more intuitively reflect the contents of the
  // product operator construction

  _pdfIter->Reset() ;
  _coefIter->Reset() ;

  Bool_t first(kTRUE) ;
    
  RooAbsArg* coef, *pdf ;
  if (_coefList.getSize()!=0) { 
    while((coef=(RooAbsArg*)_coefIter->Next())) {
      if (!first) {
	os << " + " ;
      } else {
	first = kFALSE ;
      }
      pdf=(RooAbsArg*)_pdfIter->Next() ;
      os << coef->GetName() << " * " << pdf->GetName() ;
    }
    pdf = (RooAbsArg*) _pdfIter->Next() ;
    if (pdf) {
      os << " + [%] * " << pdf->GetName() ;
    }
  } else {
    
    while((pdf=(RooAbsArg*)_pdfIter->Next())) {
      if (!first) {
	os << " + " ;
      } else {
	first = kFALSE ;
      }
      os << pdf->GetName() ; 
    }  
  }

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