/*****************************************************************************
 * 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)             *
 *****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
// 
//  RooAbsAnaConvPdf is the base class of for PDFs that represents a
//  physics model that can be analytically convolved with a resolution model
//  
//  To achieve factorization between the physics model and the resolution
//  model, each physics model must be able to be written in the form
//           _ _                 _              _ 
//    Phys(x,a,b) = Sum_k coef_k(a) * basis_k(x,b)
//  
//  where basis_k are a limited number of functions in terms of the variable
//  to be convoluted and coef_k are coefficients independent of the convolution
//  variable.
//  
//  Classes derived from RooResolutionModel implement 
//         _ _                        _                  _
//   R_k(x,b,c) = Int(dx') basis_k(x',b) * resModel(x-x',c)
// 
//  which RooAbsAnaConvPdf uses to construct the pdf for [ Phys (x) R ] :
//          _ _ _                 _          _ _
//    PDF(x,a,b,c) = Sum_k coef_k(a) * R_k(x,b,c)
//
//  A minimal implementation of a RooAbsAnaConvPdf physics model consists of
//  
//  - A constructor that declares the required basis functions using the declareBasis() method.
//    The declareBasis() function assigns a unique identifier code to each declare basis
//
//  - An implementation of coefficient(Int_t code) returning the coefficient value for each
//    declared basis function
//
//  Optionally, analytical integrals can be provided for the coefficient functions. The
//  interface for this is quite similar to that for integrals of regular PDFs. Two functions,
//
//   Int_t getCoefAnalyticalIntegral(Int_t coef, RooArgSet& allVars, RooArgSet& analVars, const char* rangeName) const 
//   Double_t coefAnalyticalIntegral(Int_t coef, Int_t code, const char* rangeName) const 
//
//  advertise the coefficient integration capabilities and implement them respectively.
//  Please see RooAbsPdf for additional details. Advertised analytical integrals must be
//  valid for all coefficients.


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

#include "Riostream.h"
#include "Riostream.h"
#include "RooAbsAnaConvPdf.h"
#include "RooResolutionModel.h"
#include "RooRealVar.h"
#include "RooFormulaVar.h"
#include "RooConvGenContext.h"
#include "RooGenContext.h"
#include "RooTruthModel.h"
#include "RooConvCoefVar.h"
#include "RooNameReg.h"

using namespace std;

ClassImp(RooAbsAnaConvPdf) 
;


//_____________________________________________________________________________
RooAbsAnaConvPdf::RooAbsAnaConvPdf() :
  _isCopy(kFALSE),
  _convNormSet(0),
  _convSetIter(_convSet.createIterator())
{
  // Default constructor, required for persistence
}



//_____________________________________________________________________________
RooAbsAnaConvPdf::RooAbsAnaConvPdf(const char *name, const char *title, 
				   const RooResolutionModel& model, RooRealVar& cVar) :
  RooAbsPdf(name,title), _isCopy(kFALSE),
  _model("!model","Original resolution model",this,(RooResolutionModel&)model,kFALSE,kFALSE),
  _convVar("!convVar","Convolution variable",this,cVar,kFALSE,kFALSE),
  _convSet("!convSet","Set of resModel X basisFunc convolutions",this),
  _convNormSet(0), _convSetIter(_convSet.createIterator()),
  _coefNormMgr(this,10),
  _codeReg(10)
{
  // Constructor. The supplied resolution model must be constructed with the same
  // convoluted variable as this physics model ('convVar')

  _convNormSet = new RooArgSet(cVar,"convNormSet") ;
  _model.absArg()->setAttribute("NOCacheAndTrack") ;
}



//_____________________________________________________________________________
RooAbsAnaConvPdf::RooAbsAnaConvPdf(const RooAbsAnaConvPdf& other, const char* name) : 
  RooAbsPdf(other,name), _isCopy(kTRUE),
  _model("!model",this,other._model),
  _convVar("!convVar",this,other._convVar),
  _convSet("!convSet",this,other._convSet),
  // _basisList(other._basisList),
  _convNormSet(other._convNormSet? new RooArgSet(*other._convNormSet) : new RooArgSet() ),
  _convSetIter(_convSet.createIterator()),
  _coefNormMgr(other._coefNormMgr,this),
  _codeReg(other._codeReg)
{
  // Copy constructor
  if (_model.absArg()) {
    _model.absArg()->setAttribute("NOCacheAndTrack") ;
  }
  other._basisList.snapshot(_basisList);
}



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

  if (_convNormSet) {
    delete _convNormSet ;
  }
    
  delete _convSetIter ;

  if (!_isCopy) {
    TIterator* iter = _convSet.createIterator() ;
    RooAbsArg* arg ;
    while (((arg = (RooAbsArg*)iter->Next()))) {
      _convSet.remove(*arg) ;
      delete arg ;
    }
    delete iter ;
  }

}


//_____________________________________________________________________________
Int_t RooAbsAnaConvPdf::declareBasis(const char* expression, const RooArgList& params) 
{
  // Declare a basis function for use in this physics model. The string expression 
  // must be a valid RooFormulVar expression representing the basis function, referring
  // to the convolution variable as '@0', and any additional parameters (supplied in
  // 'params' as '@1','@2' etc.
  //
  // The return value is a unique identifier code, that will be passed to coefficient()
  // to identify the basis function for which the coefficient is requested. If the
  // resolution model used does not support the declared basis function, code -1 is
  // returned. 
  //

  // Sanity check
  if (_isCopy) {
    coutE(InputArguments) << "RooAbsAnaConvPdf::declareBasis(" << GetName() << "): ERROR attempt to "
			  << " declare basis functions in a copied RooAbsAnaConvPdf" << endl ;
    return -1 ;
  }

  // Resolution model must support declared basis
  if (!((RooResolutionModel*)_model.absArg())->isBasisSupported(expression)) {
    coutE(InputArguments) << "RooAbsAnaConvPdf::declareBasis(" << GetName() << "): resolution model " 
			  << _model.absArg()->GetName() 
			  << " doesn't support basis function " << expression << endl ;
    return -1 ;
  }

  // Instantiate basis function
  RooArgList basisArgs(_convVar.arg()) ;
  basisArgs.add(params) ;

  TString basisName(expression) ;
  TIterator* iter = basisArgs.createIterator() ;
  RooAbsArg* arg  ;
  while(((arg=(RooAbsArg*)iter->Next()))) {
    basisName.Append("_") ;
    basisName.Append(arg->GetName()) ;
  }
  delete iter ;  

  RooFormulaVar* basisFunc = new RooFormulaVar(basisName,expression,basisArgs) ;
  basisFunc->setAttribute("RooWorkspace::Recycle") ;
  basisFunc->setAttribute("NOCacheAndTrack") ;
  basisFunc->setOperMode(operMode()) ;
  _basisList.addOwned(*basisFunc) ;

  // Instantiate resModel x basisFunc convolution
  RooAbsReal* conv = ((RooResolutionModel*)_model.absArg())->convolution(basisFunc,this) ;
  if (!conv) {
    coutE(InputArguments) << "RooAbsAnaConvPdf::declareBasis(" << GetName() << "): unable to construct convolution with basis function '" 
			  << expression << "'" << endl ;
    return -1 ;
  }
  _convSet.add(*conv) ;

  return _convSet.index(conv) ;
}



//_____________________________________________________________________________
Bool_t RooAbsAnaConvPdf::changeModel(const RooResolutionModel& newModel) 
{
  // Change the current resolution model to newModel

  TIterator* cIter = _convSet.createIterator() ;
  RooResolutionModel* conv ;
  RooArgList newConvSet ;
  Bool_t allOK(kTRUE) ;
  while(((conv=(RooResolutionModel*)cIter->Next()))) {

    // Build new resolution model
    RooResolutionModel* newConv = newModel.convolution((RooFormulaVar*)&conv->basis(),this) ;
    if (!newConvSet.add(*newConv)) {
      allOK = kFALSE ;
      break ;
    }
  }
  delete cIter ;

  // Check if all convolutions were successfully built
  if (!allOK) {
    // Delete new basis functions created sofar
    TIterator* iter = newConvSet.createIterator() ;
    while(((conv=(RooResolutionModel*)iter->Next()))) delete conv ;
    delete iter ;

    return kTRUE ;
  }
  
  // Replace old convolutions with new set
  _convSet.removeAll() ;
  _convSet.addOwned(newConvSet) ;

  _model.setArg((RooResolutionModel&)newModel) ;
  return kFALSE ;
}




//_____________________________________________________________________________
RooAbsGenContext* RooAbsAnaConvPdf::genContext(const RooArgSet &vars, const RooDataSet *prototype, 
					       const RooArgSet* auxProto, Bool_t verbose) const 
{
  // Create a generator context for this p.d.f. If both the p.d.f and the resolution model
  // support internal generation of the convolution observable on an infinite domain,
  // deploy a specialized convolution generator context, which generates the physics distribution
  // and the smearing separately, adding them a posteriori. If this is not possible return
  // a (slower) generic generation context that uses accept/reject sampling

  // Check if the resolution model specifies a special context to be used.
  RooResolutionModel* conv = dynamic_cast<RooResolutionModel*>(_model.absArg());
  assert(conv);

  RooArgSet* modelDep = _model.absArg()->getObservables(&vars) ;
  modelDep->remove(*convVar(),kTRUE,kTRUE) ;
  Int_t numAddDep = modelDep->getSize() ;
  delete modelDep ;

  // Check if physics PDF and resolution model can both directly generate the convolution variable
  RooArgSet dummy ;
  Bool_t pdfCanDir = (getGenerator(*convVar(),dummy) != 0) ;
  Bool_t resCanDir = conv && (conv->getGenerator(*convVar(),dummy)!=0) && conv->isDirectGenSafe(*convVar()) ;

  if (numAddDep>0 || !pdfCanDir || !resCanDir) {
    // Any resolution model with more dependents than the convolution variable
    // or pdf or resmodel do not support direct generation
    string reason ;
    if (numAddDep>0) reason += "Resolution model has more onservables that the convolution variable. " ;
    if (!pdfCanDir) reason += "PDF does not support internal generation of convolution observable. " ;
    if (!resCanDir) reason += "Resolution model does not support internal generation of convolution observable. " ;

    coutI(Generation) << "RooAbsAnaConvPdf::genContext(" << GetName() << ") Using regular accept/reject generator for convolution p.d.f because: " << reason.c_str() << endl ;    
    return new RooGenContext(*this,vars,prototype,auxProto,verbose) ;
  } 

  RooAbsGenContext* context = conv->modelGenContext(*this, vars, prototype, auxProto, verbose);
  if (context) return context;
  
  // Any other resolution model: use specialized generator context
  return new RooConvGenContext(*this,vars,prototype,auxProto,verbose) ;
}



//_____________________________________________________________________________
Bool_t RooAbsAnaConvPdf::isDirectGenSafe(const RooAbsArg& arg) const 
{
  // Return true if it is safe to generate the convolution observable 
  // from the internal generator (this is the case if the chosen resolution
  // model is the truth model)


  // All direct generation of convolution arg if model is truth model
  if (!TString(_convVar.absArg()->GetName()).CompareTo(arg.GetName()) && 
      dynamic_cast<RooTruthModel*>(_model.absArg())) {
    return kTRUE ;
  }

  return RooAbsPdf::isDirectGenSafe(arg) ;
}



//_____________________________________________________________________________
const RooRealVar* RooAbsAnaConvPdf::convVar() const
{
  // Return a pointer to the convolution variable instance used in the resolution model

  RooResolutionModel* conv = (RooResolutionModel*) _convSet.at(0) ;
  if (!conv) return 0 ;  
  return &conv->convVar() ;
}



//_____________________________________________________________________________
Double_t RooAbsAnaConvPdf::evaluate() const
{
  // Calculate the current unnormalized value of the PDF
  //
  // PDF = sum_k coef_k * [ basis_k (x) ResModel ]
  //
  Double_t result(0) ;

  _convSetIter->Reset() ;
  RooAbsPdf* conv ;
  Int_t index(0) ;
  while(((conv=(RooAbsPdf*)_convSetIter->Next()))) {
    Double_t coef = coefficient(index++) ;
    if (coef!=0.) {
      Double_t c = conv->getVal(0) ;
      Double_t r = coef ;
      cxcoutD(Eval) << "RooAbsAnaConvPdf::evaluate(" << GetName() << ") val += coef*conv [" << index-1 << "/" 
		    << _convSet.getSize() << "] coef = " << r << " conv = " << c << endl ;
      result += conv->getVal(0)*coef ;
    } else {
      cxcoutD(Eval) << "RooAbsAnaConvPdf::evaluate(" << GetName() << ") [" << index-1 << "/" << _convSet.getSize() << "] coef = 0" << endl ;
    }
  }
  
  return result ;
}



//_____________________________________________________________________________
Int_t RooAbsAnaConvPdf::getAnalyticalIntegralWN(RooArgSet& allVars, 
	  				        RooArgSet& analVars, const RooArgSet* normSet2, const char* /*rangeName*/) const 
{
  // Advertise capability to perform (analytical) integrals
  // internally. For a given integration request over allVars while
  // normalized over normSet2 and in range 'rangeName', returns
  // largest subset that can be performed internally in analVars
  // Return code is unique integer code identifying integration scenario
  // to be passed to analyticalIntegralWN() to calculate requeste integral
  //
  // Class RooAbsAnaConv defers analytical integration request to
  // resolution model and/or coefficient implementations and
  // aggregates results into composite configuration with a unique
  // code assigned by RooAICRegistry

  // Handle trivial no-integration scenario
  if (allVars.getSize()==0) return 0 ;
  
  if (_forceNumInt) return 0 ;

  // Select subset of allVars that are actual dependents
  RooArgSet* allDeps = getObservables(allVars) ;
  RooArgSet* normSet = normSet2 ? getObservables(normSet2) : 0 ;

  RooAbsArg *arg ;
  RooResolutionModel *conv ;

  RooArgSet* intSetAll = new RooArgSet(*allDeps,"intSetAll") ;

  // Split intSetAll in coef/conv parts
  RooArgSet* intCoefSet = new RooArgSet("intCoefSet") ; 
  RooArgSet* intConvSet = new RooArgSet("intConvSet") ;
  TIterator* varIter  = intSetAll->createIterator() ;
  TIterator* convIter = _convSet.createIterator() ;

  while(((arg=(RooAbsArg*) varIter->Next()))) {
    Bool_t ok(kTRUE) ;
    convIter->Reset() ;
    while(((conv=(RooResolutionModel*) convIter->Next()))) {
      if (conv->dependsOn(*arg)) ok=kFALSE ;
    }
    
    if (ok) {
      intCoefSet->add(*arg) ;
    } else {
      intConvSet->add(*arg) ;
    }
    
  }
  delete varIter ;


  // Split normSetAll in coef/conv parts
  RooArgSet* normCoefSet = new RooArgSet("normCoefSet") ;  
  RooArgSet* normConvSet = new RooArgSet("normConvSet") ;
  RooArgSet* normSetAll = normSet ? (new RooArgSet(*normSet,"normSetAll")) : 0 ;
  if (normSetAll) {
    varIter  =  normSetAll->createIterator() ;
    while(((arg=(RooAbsArg*) varIter->Next()))) {
      Bool_t ok(kTRUE) ;
      convIter->Reset() ;
      while(((conv=(RooResolutionModel*) convIter->Next()))) {
	if (conv->dependsOn(*arg)) ok=kFALSE ;
      }
      
      if (ok) {
	normCoefSet->add(*arg) ;
      } else {
	normConvSet->add(*arg) ;
      }
      
    }
    delete varIter ;
  }
  delete convIter ;

  if (intCoefSet->getSize()==0) {
    delete intCoefSet ; intCoefSet=0 ;
  }
  if (intConvSet->getSize()==0) {
    delete intConvSet ; intConvSet=0 ;
  }
  if (normCoefSet->getSize()==0) {
    delete normCoefSet ; normCoefSet=0 ;
  }
  if (normConvSet->getSize()==0) {
    delete normConvSet ; normConvSet=0 ;
  }



  // Store integration configuration in registry
  Int_t masterCode(0) ;
  std::vector<Int_t> tmp(1, 0) ;

  masterCode = _codeReg.store(tmp, intCoefSet, intConvSet, normCoefSet, normConvSet) + 1 ; // takes ownership of all sets

  analVars.add(*allDeps) ;
  delete allDeps ;
  if (normSet) delete normSet ;
  if (normSetAll) delete normSetAll ;
  delete intSetAll ;

//   cout << this << "---> masterCode = " << masterCode << endl ;
  
  return masterCode  ;
}




//_____________________________________________________________________________
Double_t RooAbsAnaConvPdf::analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName) const 
{
  // Return analytical integral defined by given code, which is returned
  // by getAnalyticalIntegralWN()
  //
  // For unnormalized integrals the returned value is
  //                    _                _     
  //   PDF = sum_k Int(dx) coef_k * Int(dy) [ basis_k (x) ResModel ].
  //       _
  // where x is the set of coefficient dependents to be integrated
  // and y the set of basis function dependents to be integrated. 
  //
  // For normalized integrals this becomes
  //
  //         sum_k Int(dx) coef_k * Int(dy) [ basis_k (x) ResModel ].
  //  PDF =  --------------------------------------------------------
  //         sum_k Int(dv) coef_k * Int(dw) [ basis_k (x) ResModel ].
  //
  // where x is the set of coefficient dependents to be integrated,
  // y the set of basis function dependents to be integrated,
  // v is the set of coefficient dependents over which is normalized and
  // w is the set of basis function dependents over which is normalized.
  //
  // Set x must be contained in v and set y must be contained in w.
  //

  // WVE needs adaptation to handle new rangeName feature

  // Handle trivial passthrough scenario
  if (code==0) return getVal(normSet) ;

  // Unpack master code
  RooArgSet *intCoefSet, *intConvSet, *normCoefSet, *normConvSet ;
  _codeReg.retrieve(code-1,intCoefSet,intConvSet,normCoefSet,normConvSet) ;

  RooResolutionModel* conv ;
  Int_t index(0) ;
  Double_t answer(0) ;
  _convSetIter->Reset() ;

  if (normCoefSet==0&&normConvSet==0) {

    // Integral over unnormalized function
    Double_t integral(0) ;
    const TNamed *_rangeName = RooNameReg::ptr(rangeName);
    while(((conv=(RooResolutionModel*)_convSetIter->Next()))) {
      Double_t coef = getCoefNorm(index++,intCoefSet,_rangeName) ; 
      //cout << "coefInt[" << index << "] = " << coef << " " ; intCoefSet->Print("1") ; 
      if (coef!=0) {
	integral += coef*(_rangeName ? conv->getNormObj(0,intConvSet,_rangeName)->getVal() :  conv->getNorm(intConvSet) ) ;       
	cxcoutD(Eval) << "RooAbsAnaConv::aiWN(" << GetName() << ") [" << index-1 << "] integral += " << conv->getNorm(intConvSet) << endl ;
      }

    }
    answer = integral ;
    
  } else {

    // Integral over normalized function
    Double_t integral(0) ;
    Double_t norm(0) ;
    const TNamed *_rangeName = RooNameReg::ptr(rangeName);
    while(((conv=(RooResolutionModel*)_convSetIter->Next()))) {

      Double_t coefInt = getCoefNorm(index,intCoefSet,_rangeName) ;
      //cout << "coefInt[" << index << "] = " << coefInt << "*" << term << " " << (intCoefSet?*intCoefSet:RooArgSet()) << endl ;
      if (coefInt!=0) {
	Double_t term = (_rangeName ? conv->getNormObj(0,intConvSet,_rangeName)->getVal() : conv->getNorm(intConvSet) ) ;
	integral += coefInt*term ;
      }

      Double_t coefNorm = getCoefNorm(index,normCoefSet) ;
      //cout << "coefNorm[" << index << "] = " << coefNorm << "*" << term << " " << (normCoefSet?*normCoefSet:RooArgSet()) << endl ;
      if (coefNorm!=0) {
	Double_t term = conv->getNorm(normConvSet) ;
	norm += coefNorm*term ;
      }

      index++ ;
    }
    answer = integral/norm ;    
  }

  return answer ;
}



//_____________________________________________________________________________
Int_t RooAbsAnaConvPdf::getCoefAnalyticalIntegral(Int_t /* coef*/, RooArgSet& /*allVars*/, RooArgSet& /*analVars*/, const char* /*rangeName*/) const 
{
  // Default implementation of function advertising integration capabilities. The interface is
  // similar to that of getAnalyticalIntegral except that an integer code is added that 
  // designates the coefficient number for which the integration capabilities are requested
  //
  // This default implementation advertises that no internal integrals are supported.

  return 0 ;
}



//_____________________________________________________________________________
Double_t RooAbsAnaConvPdf::coefAnalyticalIntegral(Int_t coef, Int_t code, const char* /*rangeName*/) const 
{
  // Default implementation of function implementing advertised integrals. Only
  // the pass-through scenario (no integration) is implemented.

  if (code==0) return coefficient(coef) ;
  coutE(InputArguments) << "RooAbsAnaConvPdf::coefAnalyticalIntegral(" << GetName() << ") ERROR: unrecognized integration code: " << code << endl ;
  assert(0) ;
  return 1 ;
}



//_____________________________________________________________________________
Bool_t RooAbsAnaConvPdf::forceAnalyticalInt(const RooAbsArg& /*dep*/) const
{
  // This function forces RooRealIntegral to offer all integration dependents
  // to RooAbsAnaConvPdf::getAnalyticalIntegralWN() for consideration for
  // internal integration, if RooRealIntegral considers this to be unsafe (e.g. due
  // to hidden Jacobian terms).
  //
  // RooAbsAnaConvPdf will not attempt to actually integrate all these dependents
  // but feed them to the resolution models integration interface, which will
  // make the final determination on how to integrate these dependents.

  return kTRUE ;
}                                                                                                                         
               


//_____________________________________________________________________________
Double_t RooAbsAnaConvPdf::getCoefNorm(Int_t coefIdx, const RooArgSet* nset, const TNamed* rangeName) const 
{
  // Returns the normalization integral value of the coefficient with number coefIdx over normalization
  // set nset in range rangeName

  if (nset==0) return coefficient(coefIdx) ;

  CacheElem* cache = (CacheElem*) _coefNormMgr.getObj(nset,0,0,rangeName) ;
  if (!cache) {

    cache = new CacheElem ;

    // Make list of coefficient normalizations
    Int_t i ;
    makeCoefVarList(cache->_coefVarList) ;  

    for (i=0 ; i<cache->_coefVarList.getSize() ; i++) {
      RooAbsReal* coefInt = static_cast<RooAbsReal&>(*cache->_coefVarList.at(i)).createIntegral(*nset,RooNameReg::str(rangeName)) ;
      cache->_normList.addOwned(*coefInt) ;      
    }  

    _coefNormMgr.setObj(nset,0,cache,rangeName) ;
  }

  return ((RooAbsReal*)cache->_normList.at(coefIdx))->getVal() ;
}



//_____________________________________________________________________________
void RooAbsAnaConvPdf::makeCoefVarList(RooArgList& varList) const
{
  // Build complete list of coefficient variables

  // Instantate a coefficient variables
  for (Int_t i=0 ; i<_convSet.getSize() ; i++) {
    RooArgSet* cvars = coefVars(i) ;
    RooAbsReal* coefVar = new RooConvCoefVar(Form("%s_coefVar_%d",GetName(),i),"coefVar",*this,i,cvars) ;
    varList.addOwned(*coefVar) ;
    delete cvars ;
  }
  
}


//_____________________________________________________________________________
RooArgSet* RooAbsAnaConvPdf::coefVars(Int_t /*coefIdx*/) const 
{
  // Return set of parameters with are used exclusively by the coefficient functions

  RooArgSet* cVars = getParameters((RooArgSet*)0) ;
  TIterator* iter = cVars->createIterator() ;
  RooAbsArg* arg ;
  Int_t i ;
  while(((arg=(RooAbsArg*)iter->Next()))) {
    for (i=0 ; i<_convSet.getSize() ; i++) {
      if (_convSet.at(i)->dependsOn(*arg)) {
	cVars->remove(*arg,kTRUE) ;
      }
    }
  }
  delete iter ;  
  return cVars ;
}




//_____________________________________________________________________________
void RooAbsAnaConvPdf::printMultiline(ostream& os, Int_t contents, Bool_t verbose, TString indent) const 
{
  // Print info about this object to the specified stream. In addition to the info
  // from RooAbsPdf::printStream() we add:
  //
  //   Verbose : detailed information on convolution integrals

  RooAbsPdf::printMultiline(os,contents,verbose,indent);

  os << indent << "--- RooAbsAnaConvPdf ---" << endl;
  TIterator* iter = _convSet.createIterator() ;
  RooResolutionModel* conv ;
  while (((conv=(RooResolutionModel*)iter->Next()))) {
    conv->printMultiline(os,contents,verbose,indent) ;
  }
}


 RooAbsAnaConvPdf.cxx:1
 RooAbsAnaConvPdf.cxx:2
 RooAbsAnaConvPdf.cxx:3
 RooAbsAnaConvPdf.cxx:4
 RooAbsAnaConvPdf.cxx:5
 RooAbsAnaConvPdf.cxx:6
 RooAbsAnaConvPdf.cxx:7
 RooAbsAnaConvPdf.cxx:8
 RooAbsAnaConvPdf.cxx:9
 RooAbsAnaConvPdf.cxx:10
 RooAbsAnaConvPdf.cxx:11
 RooAbsAnaConvPdf.cxx:12
 RooAbsAnaConvPdf.cxx:13
 RooAbsAnaConvPdf.cxx:14
 RooAbsAnaConvPdf.cxx:15
 RooAbsAnaConvPdf.cxx:16
 RooAbsAnaConvPdf.cxx:17
 RooAbsAnaConvPdf.cxx:18
 RooAbsAnaConvPdf.cxx:19
 RooAbsAnaConvPdf.cxx:20
 RooAbsAnaConvPdf.cxx:21
 RooAbsAnaConvPdf.cxx:22
 RooAbsAnaConvPdf.cxx:23
 RooAbsAnaConvPdf.cxx:24
 RooAbsAnaConvPdf.cxx:25
 RooAbsAnaConvPdf.cxx:26
 RooAbsAnaConvPdf.cxx:27
 RooAbsAnaConvPdf.cxx:28
 RooAbsAnaConvPdf.cxx:29
 RooAbsAnaConvPdf.cxx:30
 RooAbsAnaConvPdf.cxx:31
 RooAbsAnaConvPdf.cxx:32
 RooAbsAnaConvPdf.cxx:33
 RooAbsAnaConvPdf.cxx:34
 RooAbsAnaConvPdf.cxx:35
 RooAbsAnaConvPdf.cxx:36
 RooAbsAnaConvPdf.cxx:37
 RooAbsAnaConvPdf.cxx:38
 RooAbsAnaConvPdf.cxx:39
 RooAbsAnaConvPdf.cxx:40
 RooAbsAnaConvPdf.cxx:41
 RooAbsAnaConvPdf.cxx:42
 RooAbsAnaConvPdf.cxx:43
 RooAbsAnaConvPdf.cxx:44
 RooAbsAnaConvPdf.cxx:45
 RooAbsAnaConvPdf.cxx:46
 RooAbsAnaConvPdf.cxx:47
 RooAbsAnaConvPdf.cxx:48
 RooAbsAnaConvPdf.cxx:49
 RooAbsAnaConvPdf.cxx:50
 RooAbsAnaConvPdf.cxx:51
 RooAbsAnaConvPdf.cxx:52
 RooAbsAnaConvPdf.cxx:53
 RooAbsAnaConvPdf.cxx:54
 RooAbsAnaConvPdf.cxx:55
 RooAbsAnaConvPdf.cxx:56
 RooAbsAnaConvPdf.cxx:57
 RooAbsAnaConvPdf.cxx:58
 RooAbsAnaConvPdf.cxx:59
 RooAbsAnaConvPdf.cxx:60
 RooAbsAnaConvPdf.cxx:61
 RooAbsAnaConvPdf.cxx:62
 RooAbsAnaConvPdf.cxx:63
 RooAbsAnaConvPdf.cxx:64
 RooAbsAnaConvPdf.cxx:65
 RooAbsAnaConvPdf.cxx:66
 RooAbsAnaConvPdf.cxx:67
 RooAbsAnaConvPdf.cxx:68
 RooAbsAnaConvPdf.cxx:69
 RooAbsAnaConvPdf.cxx:70
 RooAbsAnaConvPdf.cxx:71
 RooAbsAnaConvPdf.cxx:72
 RooAbsAnaConvPdf.cxx:73
 RooAbsAnaConvPdf.cxx:74
 RooAbsAnaConvPdf.cxx:75
 RooAbsAnaConvPdf.cxx:76
 RooAbsAnaConvPdf.cxx:77
 RooAbsAnaConvPdf.cxx:78
 RooAbsAnaConvPdf.cxx:79
 RooAbsAnaConvPdf.cxx:80
 RooAbsAnaConvPdf.cxx:81
 RooAbsAnaConvPdf.cxx:82
 RooAbsAnaConvPdf.cxx:83
 RooAbsAnaConvPdf.cxx:84
 RooAbsAnaConvPdf.cxx:85
 RooAbsAnaConvPdf.cxx:86
 RooAbsAnaConvPdf.cxx:87
 RooAbsAnaConvPdf.cxx:88
 RooAbsAnaConvPdf.cxx:89
 RooAbsAnaConvPdf.cxx:90
 RooAbsAnaConvPdf.cxx:91
 RooAbsAnaConvPdf.cxx:92
 RooAbsAnaConvPdf.cxx:93
 RooAbsAnaConvPdf.cxx:94
 RooAbsAnaConvPdf.cxx:95
 RooAbsAnaConvPdf.cxx:96
 RooAbsAnaConvPdf.cxx:97
 RooAbsAnaConvPdf.cxx:98
 RooAbsAnaConvPdf.cxx:99
 RooAbsAnaConvPdf.cxx:100
 RooAbsAnaConvPdf.cxx:101
 RooAbsAnaConvPdf.cxx:102
 RooAbsAnaConvPdf.cxx:103
 RooAbsAnaConvPdf.cxx:104
 RooAbsAnaConvPdf.cxx:105
 RooAbsAnaConvPdf.cxx:106
 RooAbsAnaConvPdf.cxx:107
 RooAbsAnaConvPdf.cxx:108
 RooAbsAnaConvPdf.cxx:109
 RooAbsAnaConvPdf.cxx:110
 RooAbsAnaConvPdf.cxx:111
 RooAbsAnaConvPdf.cxx:112
 RooAbsAnaConvPdf.cxx:113
 RooAbsAnaConvPdf.cxx:114
 RooAbsAnaConvPdf.cxx:115
 RooAbsAnaConvPdf.cxx:116
 RooAbsAnaConvPdf.cxx:117
 RooAbsAnaConvPdf.cxx:118
 RooAbsAnaConvPdf.cxx:119
 RooAbsAnaConvPdf.cxx:120
 RooAbsAnaConvPdf.cxx:121
 RooAbsAnaConvPdf.cxx:122
 RooAbsAnaConvPdf.cxx:123
 RooAbsAnaConvPdf.cxx:124
 RooAbsAnaConvPdf.cxx:125
 RooAbsAnaConvPdf.cxx:126
 RooAbsAnaConvPdf.cxx:127
 RooAbsAnaConvPdf.cxx:128
 RooAbsAnaConvPdf.cxx:129
 RooAbsAnaConvPdf.cxx:130
 RooAbsAnaConvPdf.cxx:131
 RooAbsAnaConvPdf.cxx:132
 RooAbsAnaConvPdf.cxx:133
 RooAbsAnaConvPdf.cxx:134
 RooAbsAnaConvPdf.cxx:135
 RooAbsAnaConvPdf.cxx:136
 RooAbsAnaConvPdf.cxx:137
 RooAbsAnaConvPdf.cxx:138
 RooAbsAnaConvPdf.cxx:139
 RooAbsAnaConvPdf.cxx:140
 RooAbsAnaConvPdf.cxx:141
 RooAbsAnaConvPdf.cxx:142
 RooAbsAnaConvPdf.cxx:143
 RooAbsAnaConvPdf.cxx:144
 RooAbsAnaConvPdf.cxx:145
 RooAbsAnaConvPdf.cxx:146
 RooAbsAnaConvPdf.cxx:147
 RooAbsAnaConvPdf.cxx:148
 RooAbsAnaConvPdf.cxx:149
 RooAbsAnaConvPdf.cxx:150
 RooAbsAnaConvPdf.cxx:151
 RooAbsAnaConvPdf.cxx:152
 RooAbsAnaConvPdf.cxx:153
 RooAbsAnaConvPdf.cxx:154
 RooAbsAnaConvPdf.cxx:155
 RooAbsAnaConvPdf.cxx:156
 RooAbsAnaConvPdf.cxx:157
 RooAbsAnaConvPdf.cxx:158
 RooAbsAnaConvPdf.cxx:159
 RooAbsAnaConvPdf.cxx:160
 RooAbsAnaConvPdf.cxx:161
 RooAbsAnaConvPdf.cxx:162
 RooAbsAnaConvPdf.cxx:163
 RooAbsAnaConvPdf.cxx:164
 RooAbsAnaConvPdf.cxx:165
 RooAbsAnaConvPdf.cxx:166
 RooAbsAnaConvPdf.cxx:167
 RooAbsAnaConvPdf.cxx:168
 RooAbsAnaConvPdf.cxx:169
 RooAbsAnaConvPdf.cxx:170
 RooAbsAnaConvPdf.cxx:171
 RooAbsAnaConvPdf.cxx:172
 RooAbsAnaConvPdf.cxx:173
 RooAbsAnaConvPdf.cxx:174
 RooAbsAnaConvPdf.cxx:175
 RooAbsAnaConvPdf.cxx:176
 RooAbsAnaConvPdf.cxx:177
 RooAbsAnaConvPdf.cxx:178
 RooAbsAnaConvPdf.cxx:179
 RooAbsAnaConvPdf.cxx:180
 RooAbsAnaConvPdf.cxx:181
 RooAbsAnaConvPdf.cxx:182
 RooAbsAnaConvPdf.cxx:183
 RooAbsAnaConvPdf.cxx:184
 RooAbsAnaConvPdf.cxx:185
 RooAbsAnaConvPdf.cxx:186
 RooAbsAnaConvPdf.cxx:187
 RooAbsAnaConvPdf.cxx:188
 RooAbsAnaConvPdf.cxx:189
 RooAbsAnaConvPdf.cxx:190
 RooAbsAnaConvPdf.cxx:191
 RooAbsAnaConvPdf.cxx:192
 RooAbsAnaConvPdf.cxx:193
 RooAbsAnaConvPdf.cxx:194
 RooAbsAnaConvPdf.cxx:195
 RooAbsAnaConvPdf.cxx:196
 RooAbsAnaConvPdf.cxx:197
 RooAbsAnaConvPdf.cxx:198
 RooAbsAnaConvPdf.cxx:199
 RooAbsAnaConvPdf.cxx:200
 RooAbsAnaConvPdf.cxx:201
 RooAbsAnaConvPdf.cxx:202
 RooAbsAnaConvPdf.cxx:203
 RooAbsAnaConvPdf.cxx:204
 RooAbsAnaConvPdf.cxx:205
 RooAbsAnaConvPdf.cxx:206
 RooAbsAnaConvPdf.cxx:207
 RooAbsAnaConvPdf.cxx:208
 RooAbsAnaConvPdf.cxx:209
 RooAbsAnaConvPdf.cxx:210
 RooAbsAnaConvPdf.cxx:211
 RooAbsAnaConvPdf.cxx:212
 RooAbsAnaConvPdf.cxx:213
 RooAbsAnaConvPdf.cxx:214
 RooAbsAnaConvPdf.cxx:215
 RooAbsAnaConvPdf.cxx:216
 RooAbsAnaConvPdf.cxx:217
 RooAbsAnaConvPdf.cxx:218
 RooAbsAnaConvPdf.cxx:219
 RooAbsAnaConvPdf.cxx:220
 RooAbsAnaConvPdf.cxx:221
 RooAbsAnaConvPdf.cxx:222
 RooAbsAnaConvPdf.cxx:223
 RooAbsAnaConvPdf.cxx:224
 RooAbsAnaConvPdf.cxx:225
 RooAbsAnaConvPdf.cxx:226
 RooAbsAnaConvPdf.cxx:227
 RooAbsAnaConvPdf.cxx:228
 RooAbsAnaConvPdf.cxx:229
 RooAbsAnaConvPdf.cxx:230
 RooAbsAnaConvPdf.cxx:231
 RooAbsAnaConvPdf.cxx:232
 RooAbsAnaConvPdf.cxx:233
 RooAbsAnaConvPdf.cxx:234
 RooAbsAnaConvPdf.cxx:235
 RooAbsAnaConvPdf.cxx:236
 RooAbsAnaConvPdf.cxx:237
 RooAbsAnaConvPdf.cxx:238
 RooAbsAnaConvPdf.cxx:239
 RooAbsAnaConvPdf.cxx:240
 RooAbsAnaConvPdf.cxx:241
 RooAbsAnaConvPdf.cxx:242
 RooAbsAnaConvPdf.cxx:243
 RooAbsAnaConvPdf.cxx:244
 RooAbsAnaConvPdf.cxx:245
 RooAbsAnaConvPdf.cxx:246
 RooAbsAnaConvPdf.cxx:247
 RooAbsAnaConvPdf.cxx:248
 RooAbsAnaConvPdf.cxx:249
 RooAbsAnaConvPdf.cxx:250
 RooAbsAnaConvPdf.cxx:251
 RooAbsAnaConvPdf.cxx:252
 RooAbsAnaConvPdf.cxx:253
 RooAbsAnaConvPdf.cxx:254
 RooAbsAnaConvPdf.cxx:255
 RooAbsAnaConvPdf.cxx:256
 RooAbsAnaConvPdf.cxx:257
 RooAbsAnaConvPdf.cxx:258
 RooAbsAnaConvPdf.cxx:259
 RooAbsAnaConvPdf.cxx:260
 RooAbsAnaConvPdf.cxx:261
 RooAbsAnaConvPdf.cxx:262
 RooAbsAnaConvPdf.cxx:263
 RooAbsAnaConvPdf.cxx:264
 RooAbsAnaConvPdf.cxx:265
 RooAbsAnaConvPdf.cxx:266
 RooAbsAnaConvPdf.cxx:267
 RooAbsAnaConvPdf.cxx:268
 RooAbsAnaConvPdf.cxx:269
 RooAbsAnaConvPdf.cxx:270
 RooAbsAnaConvPdf.cxx:271
 RooAbsAnaConvPdf.cxx:272
 RooAbsAnaConvPdf.cxx:273
 RooAbsAnaConvPdf.cxx:274
 RooAbsAnaConvPdf.cxx:275
 RooAbsAnaConvPdf.cxx:276
 RooAbsAnaConvPdf.cxx:277
 RooAbsAnaConvPdf.cxx:278
 RooAbsAnaConvPdf.cxx:279
 RooAbsAnaConvPdf.cxx:280
 RooAbsAnaConvPdf.cxx:281
 RooAbsAnaConvPdf.cxx:282
 RooAbsAnaConvPdf.cxx:283
 RooAbsAnaConvPdf.cxx:284
 RooAbsAnaConvPdf.cxx:285
 RooAbsAnaConvPdf.cxx:286
 RooAbsAnaConvPdf.cxx:287
 RooAbsAnaConvPdf.cxx:288
 RooAbsAnaConvPdf.cxx:289
 RooAbsAnaConvPdf.cxx:290
 RooAbsAnaConvPdf.cxx:291
 RooAbsAnaConvPdf.cxx:292
 RooAbsAnaConvPdf.cxx:293
 RooAbsAnaConvPdf.cxx:294
 RooAbsAnaConvPdf.cxx:295
 RooAbsAnaConvPdf.cxx:296
 RooAbsAnaConvPdf.cxx:297
 RooAbsAnaConvPdf.cxx:298
 RooAbsAnaConvPdf.cxx:299
 RooAbsAnaConvPdf.cxx:300
 RooAbsAnaConvPdf.cxx:301
 RooAbsAnaConvPdf.cxx:302
 RooAbsAnaConvPdf.cxx:303
 RooAbsAnaConvPdf.cxx:304
 RooAbsAnaConvPdf.cxx:305
 RooAbsAnaConvPdf.cxx:306
 RooAbsAnaConvPdf.cxx:307
 RooAbsAnaConvPdf.cxx:308
 RooAbsAnaConvPdf.cxx:309
 RooAbsAnaConvPdf.cxx:310
 RooAbsAnaConvPdf.cxx:311
 RooAbsAnaConvPdf.cxx:312
 RooAbsAnaConvPdf.cxx:313
 RooAbsAnaConvPdf.cxx:314
 RooAbsAnaConvPdf.cxx:315
 RooAbsAnaConvPdf.cxx:316
 RooAbsAnaConvPdf.cxx:317
 RooAbsAnaConvPdf.cxx:318
 RooAbsAnaConvPdf.cxx:319
 RooAbsAnaConvPdf.cxx:320
 RooAbsAnaConvPdf.cxx:321
 RooAbsAnaConvPdf.cxx:322
 RooAbsAnaConvPdf.cxx:323
 RooAbsAnaConvPdf.cxx:324
 RooAbsAnaConvPdf.cxx:325
 RooAbsAnaConvPdf.cxx:326
 RooAbsAnaConvPdf.cxx:327
 RooAbsAnaConvPdf.cxx:328
 RooAbsAnaConvPdf.cxx:329
 RooAbsAnaConvPdf.cxx:330
 RooAbsAnaConvPdf.cxx:331
 RooAbsAnaConvPdf.cxx:332
 RooAbsAnaConvPdf.cxx:333
 RooAbsAnaConvPdf.cxx:334
 RooAbsAnaConvPdf.cxx:335
 RooAbsAnaConvPdf.cxx:336
 RooAbsAnaConvPdf.cxx:337
 RooAbsAnaConvPdf.cxx:338
 RooAbsAnaConvPdf.cxx:339
 RooAbsAnaConvPdf.cxx:340
 RooAbsAnaConvPdf.cxx:341
 RooAbsAnaConvPdf.cxx:342
 RooAbsAnaConvPdf.cxx:343
 RooAbsAnaConvPdf.cxx:344
 RooAbsAnaConvPdf.cxx:345
 RooAbsAnaConvPdf.cxx:346
 RooAbsAnaConvPdf.cxx:347
 RooAbsAnaConvPdf.cxx:348
 RooAbsAnaConvPdf.cxx:349
 RooAbsAnaConvPdf.cxx:350
 RooAbsAnaConvPdf.cxx:351
 RooAbsAnaConvPdf.cxx:352
 RooAbsAnaConvPdf.cxx:353
 RooAbsAnaConvPdf.cxx:354
 RooAbsAnaConvPdf.cxx:355
 RooAbsAnaConvPdf.cxx:356
 RooAbsAnaConvPdf.cxx:357
 RooAbsAnaConvPdf.cxx:358
 RooAbsAnaConvPdf.cxx:359
 RooAbsAnaConvPdf.cxx:360
 RooAbsAnaConvPdf.cxx:361
 RooAbsAnaConvPdf.cxx:362
 RooAbsAnaConvPdf.cxx:363
 RooAbsAnaConvPdf.cxx:364
 RooAbsAnaConvPdf.cxx:365
 RooAbsAnaConvPdf.cxx:366
 RooAbsAnaConvPdf.cxx:367
 RooAbsAnaConvPdf.cxx:368
 RooAbsAnaConvPdf.cxx:369
 RooAbsAnaConvPdf.cxx:370
 RooAbsAnaConvPdf.cxx:371
 RooAbsAnaConvPdf.cxx:372
 RooAbsAnaConvPdf.cxx:373
 RooAbsAnaConvPdf.cxx:374
 RooAbsAnaConvPdf.cxx:375
 RooAbsAnaConvPdf.cxx:376
 RooAbsAnaConvPdf.cxx:377
 RooAbsAnaConvPdf.cxx:378
 RooAbsAnaConvPdf.cxx:379
 RooAbsAnaConvPdf.cxx:380
 RooAbsAnaConvPdf.cxx:381
 RooAbsAnaConvPdf.cxx:382
 RooAbsAnaConvPdf.cxx:383
 RooAbsAnaConvPdf.cxx:384
 RooAbsAnaConvPdf.cxx:385
 RooAbsAnaConvPdf.cxx:386
 RooAbsAnaConvPdf.cxx:387
 RooAbsAnaConvPdf.cxx:388
 RooAbsAnaConvPdf.cxx:389
 RooAbsAnaConvPdf.cxx:390
 RooAbsAnaConvPdf.cxx:391
 RooAbsAnaConvPdf.cxx:392
 RooAbsAnaConvPdf.cxx:393
 RooAbsAnaConvPdf.cxx:394
 RooAbsAnaConvPdf.cxx:395
 RooAbsAnaConvPdf.cxx:396
 RooAbsAnaConvPdf.cxx:397
 RooAbsAnaConvPdf.cxx:398
 RooAbsAnaConvPdf.cxx:399
 RooAbsAnaConvPdf.cxx:400
 RooAbsAnaConvPdf.cxx:401
 RooAbsAnaConvPdf.cxx:402
 RooAbsAnaConvPdf.cxx:403
 RooAbsAnaConvPdf.cxx:404
 RooAbsAnaConvPdf.cxx:405
 RooAbsAnaConvPdf.cxx:406
 RooAbsAnaConvPdf.cxx:407
 RooAbsAnaConvPdf.cxx:408
 RooAbsAnaConvPdf.cxx:409
 RooAbsAnaConvPdf.cxx:410
 RooAbsAnaConvPdf.cxx:411
 RooAbsAnaConvPdf.cxx:412
 RooAbsAnaConvPdf.cxx:413
 RooAbsAnaConvPdf.cxx:414
 RooAbsAnaConvPdf.cxx:415
 RooAbsAnaConvPdf.cxx:416
 RooAbsAnaConvPdf.cxx:417
 RooAbsAnaConvPdf.cxx:418
 RooAbsAnaConvPdf.cxx:419
 RooAbsAnaConvPdf.cxx:420
 RooAbsAnaConvPdf.cxx:421
 RooAbsAnaConvPdf.cxx:422
 RooAbsAnaConvPdf.cxx:423
 RooAbsAnaConvPdf.cxx:424
 RooAbsAnaConvPdf.cxx:425
 RooAbsAnaConvPdf.cxx:426
 RooAbsAnaConvPdf.cxx:427
 RooAbsAnaConvPdf.cxx:428
 RooAbsAnaConvPdf.cxx:429
 RooAbsAnaConvPdf.cxx:430
 RooAbsAnaConvPdf.cxx:431
 RooAbsAnaConvPdf.cxx:432
 RooAbsAnaConvPdf.cxx:433
 RooAbsAnaConvPdf.cxx:434
 RooAbsAnaConvPdf.cxx:435
 RooAbsAnaConvPdf.cxx:436
 RooAbsAnaConvPdf.cxx:437
 RooAbsAnaConvPdf.cxx:438
 RooAbsAnaConvPdf.cxx:439
 RooAbsAnaConvPdf.cxx:440
 RooAbsAnaConvPdf.cxx:441
 RooAbsAnaConvPdf.cxx:442
 RooAbsAnaConvPdf.cxx:443
 RooAbsAnaConvPdf.cxx:444
 RooAbsAnaConvPdf.cxx:445
 RooAbsAnaConvPdf.cxx:446
 RooAbsAnaConvPdf.cxx:447
 RooAbsAnaConvPdf.cxx:448
 RooAbsAnaConvPdf.cxx:449
 RooAbsAnaConvPdf.cxx:450
 RooAbsAnaConvPdf.cxx:451
 RooAbsAnaConvPdf.cxx:452
 RooAbsAnaConvPdf.cxx:453
 RooAbsAnaConvPdf.cxx:454
 RooAbsAnaConvPdf.cxx:455
 RooAbsAnaConvPdf.cxx:456
 RooAbsAnaConvPdf.cxx:457
 RooAbsAnaConvPdf.cxx:458
 RooAbsAnaConvPdf.cxx:459
 RooAbsAnaConvPdf.cxx:460
 RooAbsAnaConvPdf.cxx:461
 RooAbsAnaConvPdf.cxx:462
 RooAbsAnaConvPdf.cxx:463
 RooAbsAnaConvPdf.cxx:464
 RooAbsAnaConvPdf.cxx:465
 RooAbsAnaConvPdf.cxx:466
 RooAbsAnaConvPdf.cxx:467
 RooAbsAnaConvPdf.cxx:468
 RooAbsAnaConvPdf.cxx:469
 RooAbsAnaConvPdf.cxx:470
 RooAbsAnaConvPdf.cxx:471
 RooAbsAnaConvPdf.cxx:472
 RooAbsAnaConvPdf.cxx:473
 RooAbsAnaConvPdf.cxx:474
 RooAbsAnaConvPdf.cxx:475
 RooAbsAnaConvPdf.cxx:476
 RooAbsAnaConvPdf.cxx:477
 RooAbsAnaConvPdf.cxx:478
 RooAbsAnaConvPdf.cxx:479
 RooAbsAnaConvPdf.cxx:480
 RooAbsAnaConvPdf.cxx:481
 RooAbsAnaConvPdf.cxx:482
 RooAbsAnaConvPdf.cxx:483
 RooAbsAnaConvPdf.cxx:484
 RooAbsAnaConvPdf.cxx:485
 RooAbsAnaConvPdf.cxx:486
 RooAbsAnaConvPdf.cxx:487
 RooAbsAnaConvPdf.cxx:488
 RooAbsAnaConvPdf.cxx:489
 RooAbsAnaConvPdf.cxx:490
 RooAbsAnaConvPdf.cxx:491
 RooAbsAnaConvPdf.cxx:492
 RooAbsAnaConvPdf.cxx:493
 RooAbsAnaConvPdf.cxx:494
 RooAbsAnaConvPdf.cxx:495
 RooAbsAnaConvPdf.cxx:496
 RooAbsAnaConvPdf.cxx:497
 RooAbsAnaConvPdf.cxx:498
 RooAbsAnaConvPdf.cxx:499
 RooAbsAnaConvPdf.cxx:500
 RooAbsAnaConvPdf.cxx:501
 RooAbsAnaConvPdf.cxx:502
 RooAbsAnaConvPdf.cxx:503
 RooAbsAnaConvPdf.cxx:504
 RooAbsAnaConvPdf.cxx:505
 RooAbsAnaConvPdf.cxx:506
 RooAbsAnaConvPdf.cxx:507
 RooAbsAnaConvPdf.cxx:508
 RooAbsAnaConvPdf.cxx:509
 RooAbsAnaConvPdf.cxx:510
 RooAbsAnaConvPdf.cxx:511
 RooAbsAnaConvPdf.cxx:512
 RooAbsAnaConvPdf.cxx:513
 RooAbsAnaConvPdf.cxx:514
 RooAbsAnaConvPdf.cxx:515
 RooAbsAnaConvPdf.cxx:516
 RooAbsAnaConvPdf.cxx:517
 RooAbsAnaConvPdf.cxx:518
 RooAbsAnaConvPdf.cxx:519
 RooAbsAnaConvPdf.cxx:520
 RooAbsAnaConvPdf.cxx:521
 RooAbsAnaConvPdf.cxx:522
 RooAbsAnaConvPdf.cxx:523
 RooAbsAnaConvPdf.cxx:524
 RooAbsAnaConvPdf.cxx:525
 RooAbsAnaConvPdf.cxx:526
 RooAbsAnaConvPdf.cxx:527
 RooAbsAnaConvPdf.cxx:528
 RooAbsAnaConvPdf.cxx:529
 RooAbsAnaConvPdf.cxx:530
 RooAbsAnaConvPdf.cxx:531
 RooAbsAnaConvPdf.cxx:532
 RooAbsAnaConvPdf.cxx:533
 RooAbsAnaConvPdf.cxx:534
 RooAbsAnaConvPdf.cxx:535
 RooAbsAnaConvPdf.cxx:536
 RooAbsAnaConvPdf.cxx:537
 RooAbsAnaConvPdf.cxx:538
 RooAbsAnaConvPdf.cxx:539
 RooAbsAnaConvPdf.cxx:540
 RooAbsAnaConvPdf.cxx:541
 RooAbsAnaConvPdf.cxx:542
 RooAbsAnaConvPdf.cxx:543
 RooAbsAnaConvPdf.cxx:544
 RooAbsAnaConvPdf.cxx:545
 RooAbsAnaConvPdf.cxx:546
 RooAbsAnaConvPdf.cxx:547
 RooAbsAnaConvPdf.cxx:548
 RooAbsAnaConvPdf.cxx:549
 RooAbsAnaConvPdf.cxx:550
 RooAbsAnaConvPdf.cxx:551
 RooAbsAnaConvPdf.cxx:552
 RooAbsAnaConvPdf.cxx:553
 RooAbsAnaConvPdf.cxx:554
 RooAbsAnaConvPdf.cxx:555
 RooAbsAnaConvPdf.cxx:556
 RooAbsAnaConvPdf.cxx:557
 RooAbsAnaConvPdf.cxx:558
 RooAbsAnaConvPdf.cxx:559
 RooAbsAnaConvPdf.cxx:560
 RooAbsAnaConvPdf.cxx:561
 RooAbsAnaConvPdf.cxx:562
 RooAbsAnaConvPdf.cxx:563
 RooAbsAnaConvPdf.cxx:564
 RooAbsAnaConvPdf.cxx:565
 RooAbsAnaConvPdf.cxx:566
 RooAbsAnaConvPdf.cxx:567
 RooAbsAnaConvPdf.cxx:568
 RooAbsAnaConvPdf.cxx:569
 RooAbsAnaConvPdf.cxx:570
 RooAbsAnaConvPdf.cxx:571
 RooAbsAnaConvPdf.cxx:572
 RooAbsAnaConvPdf.cxx:573
 RooAbsAnaConvPdf.cxx:574
 RooAbsAnaConvPdf.cxx:575
 RooAbsAnaConvPdf.cxx:576
 RooAbsAnaConvPdf.cxx:577
 RooAbsAnaConvPdf.cxx:578
 RooAbsAnaConvPdf.cxx:579
 RooAbsAnaConvPdf.cxx:580
 RooAbsAnaConvPdf.cxx:581
 RooAbsAnaConvPdf.cxx:582
 RooAbsAnaConvPdf.cxx:583
 RooAbsAnaConvPdf.cxx:584
 RooAbsAnaConvPdf.cxx:585
 RooAbsAnaConvPdf.cxx:586
 RooAbsAnaConvPdf.cxx:587
 RooAbsAnaConvPdf.cxx:588
 RooAbsAnaConvPdf.cxx:589
 RooAbsAnaConvPdf.cxx:590
 RooAbsAnaConvPdf.cxx:591
 RooAbsAnaConvPdf.cxx:592
 RooAbsAnaConvPdf.cxx:593
 RooAbsAnaConvPdf.cxx:594
 RooAbsAnaConvPdf.cxx:595
 RooAbsAnaConvPdf.cxx:596
 RooAbsAnaConvPdf.cxx:597
 RooAbsAnaConvPdf.cxx:598
 RooAbsAnaConvPdf.cxx:599
 RooAbsAnaConvPdf.cxx:600
 RooAbsAnaConvPdf.cxx:601
 RooAbsAnaConvPdf.cxx:602
 RooAbsAnaConvPdf.cxx:603
 RooAbsAnaConvPdf.cxx:604
 RooAbsAnaConvPdf.cxx:605
 RooAbsAnaConvPdf.cxx:606
 RooAbsAnaConvPdf.cxx:607
 RooAbsAnaConvPdf.cxx:608
 RooAbsAnaConvPdf.cxx:609
 RooAbsAnaConvPdf.cxx:610
 RooAbsAnaConvPdf.cxx:611
 RooAbsAnaConvPdf.cxx:612
 RooAbsAnaConvPdf.cxx:613
 RooAbsAnaConvPdf.cxx:614
 RooAbsAnaConvPdf.cxx:615
 RooAbsAnaConvPdf.cxx:616
 RooAbsAnaConvPdf.cxx:617
 RooAbsAnaConvPdf.cxx:618
 RooAbsAnaConvPdf.cxx:619
 RooAbsAnaConvPdf.cxx:620
 RooAbsAnaConvPdf.cxx:621
 RooAbsAnaConvPdf.cxx:622
 RooAbsAnaConvPdf.cxx:623
 RooAbsAnaConvPdf.cxx:624
 RooAbsAnaConvPdf.cxx:625
 RooAbsAnaConvPdf.cxx:626
 RooAbsAnaConvPdf.cxx:627
 RooAbsAnaConvPdf.cxx:628
 RooAbsAnaConvPdf.cxx:629
 RooAbsAnaConvPdf.cxx:630
 RooAbsAnaConvPdf.cxx:631
 RooAbsAnaConvPdf.cxx:632
 RooAbsAnaConvPdf.cxx:633
 RooAbsAnaConvPdf.cxx:634
 RooAbsAnaConvPdf.cxx:635
 RooAbsAnaConvPdf.cxx:636
 RooAbsAnaConvPdf.cxx:637
 RooAbsAnaConvPdf.cxx:638
 RooAbsAnaConvPdf.cxx:639
 RooAbsAnaConvPdf.cxx:640
 RooAbsAnaConvPdf.cxx:641
 RooAbsAnaConvPdf.cxx:642
 RooAbsAnaConvPdf.cxx:643
 RooAbsAnaConvPdf.cxx:644
 RooAbsAnaConvPdf.cxx:645
 RooAbsAnaConvPdf.cxx:646
 RooAbsAnaConvPdf.cxx:647
 RooAbsAnaConvPdf.cxx:648
 RooAbsAnaConvPdf.cxx:649
 RooAbsAnaConvPdf.cxx:650
 RooAbsAnaConvPdf.cxx:651
 RooAbsAnaConvPdf.cxx:652
 RooAbsAnaConvPdf.cxx:653
 RooAbsAnaConvPdf.cxx:654
 RooAbsAnaConvPdf.cxx:655
 RooAbsAnaConvPdf.cxx:656
 RooAbsAnaConvPdf.cxx:657
 RooAbsAnaConvPdf.cxx:658
 RooAbsAnaConvPdf.cxx:659
 RooAbsAnaConvPdf.cxx:660
 RooAbsAnaConvPdf.cxx:661
 RooAbsAnaConvPdf.cxx:662
 RooAbsAnaConvPdf.cxx:663
 RooAbsAnaConvPdf.cxx:664
 RooAbsAnaConvPdf.cxx:665
 RooAbsAnaConvPdf.cxx:666
 RooAbsAnaConvPdf.cxx:667
 RooAbsAnaConvPdf.cxx:668
 RooAbsAnaConvPdf.cxx:669
 RooAbsAnaConvPdf.cxx:670
 RooAbsAnaConvPdf.cxx:671
 RooAbsAnaConvPdf.cxx:672
 RooAbsAnaConvPdf.cxx:673
 RooAbsAnaConvPdf.cxx:674
 RooAbsAnaConvPdf.cxx:675
 RooAbsAnaConvPdf.cxx:676
 RooAbsAnaConvPdf.cxx:677
 RooAbsAnaConvPdf.cxx:678
 RooAbsAnaConvPdf.cxx:679
 RooAbsAnaConvPdf.cxx:680
 RooAbsAnaConvPdf.cxx:681
 RooAbsAnaConvPdf.cxx:682
 RooAbsAnaConvPdf.cxx:683
 RooAbsAnaConvPdf.cxx:684
 RooAbsAnaConvPdf.cxx:685
 RooAbsAnaConvPdf.cxx:686
 RooAbsAnaConvPdf.cxx:687
 RooAbsAnaConvPdf.cxx:688
 RooAbsAnaConvPdf.cxx:689
 RooAbsAnaConvPdf.cxx:690
 RooAbsAnaConvPdf.cxx:691
 RooAbsAnaConvPdf.cxx:692
 RooAbsAnaConvPdf.cxx:693
 RooAbsAnaConvPdf.cxx:694
 RooAbsAnaConvPdf.cxx:695
 RooAbsAnaConvPdf.cxx:696
 RooAbsAnaConvPdf.cxx:697