ROOT logo
/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 *    File: $Id: RooAbsPdf.h,v 1.90 2007/07/21 21:32:52 wouter Exp $
 * 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)             *
 *****************************************************************************/
#ifndef ROO_ABS_PDF
#define ROO_ABS_PDF

#include "RooAbsReal.h"
//#include "RooRealIntegral.h"
#include "RooNameSet.h"
#include "RooObjCacheManager.h"
#include "RooCmdArg.h"

class RooDataSet;
class RooDataHist ;
class RooArgSet ;
class RooRealProxy ;
class RooAbsGenContext ;
class RooFitResult ;
class RooExtendPdf ;
class RooCategory ;
class TPaveText;
class TH1F;
class TH2F;
class TList ;
class RooLinkedList ;
class RooNumGenConfig ;
class RooRealIntegral ;

class RooAbsPdf : public RooAbsReal {
public:

  // Constructors, assignment etc
  RooAbsPdf() ;
  RooAbsPdf(const char *name, const char *title=0) ;
  RooAbsPdf(const char *name, const char *title, Double_t minVal, Double_t maxVal) ;
  // RooAbsPdf(const RooAbsPdf& other, const char* name=0);
  virtual ~RooAbsPdf();

  // Toy MC generation
  RooDataSet *generate(const RooArgSet &whatVars, Int_t nEvents, const RooCmdArg& arg1,
                       const RooCmdArg& arg2=RooCmdArg::none(), const RooCmdArg& arg3=RooCmdArg::none(),
                       const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none()) ;
  RooDataSet *generate(const RooArgSet &whatVars,  
                       const RooCmdArg& arg1=RooCmdArg::none(),const RooCmdArg& arg2=RooCmdArg::none(),
                       const RooCmdArg& arg3=RooCmdArg::none(),const RooCmdArg& arg4=RooCmdArg::none(),
                       const RooCmdArg& arg5=RooCmdArg::none(),const RooCmdArg& arg6=RooCmdArg::none()) ;
  RooDataSet *generate(const RooArgSet &whatVars, Double_t nEvents = 0, Bool_t verbose=kFALSE, Bool_t autoBinned=kTRUE, 
		       const char* binnedTag="", Bool_t expectedData=kFALSE, Bool_t extended = kFALSE) const;
  RooDataSet *generate(const RooArgSet &whatVars, const RooDataSet &prototype, Int_t nEvents= 0,
		       Bool_t verbose=kFALSE, Bool_t randProtoOrder=kFALSE, Bool_t resampleProto=kFALSE) const;


  class GenSpec {
  public:
    virtual ~GenSpec() ;
    GenSpec() { _genContext = 0 ; _protoData = 0 ; _init = kFALSE ; _extended=kFALSE, _nGen=0 ; _randProto = kFALSE ; _resampleProto=kFALSE ; }
  private:
    GenSpec(RooAbsGenContext* context, const RooArgSet& whatVars, RooDataSet* protoData, Int_t nGen, Bool_t extended, 
	    Bool_t randProto, Bool_t resampleProto, TString dsetName, Bool_t init=kFALSE) ;
    GenSpec(const GenSpec& other) ;

    friend class RooAbsPdf ;
    RooAbsGenContext* _genContext ;
    RooArgSet _whatVars ;
    RooDataSet* _protoData ;
    Int_t _nGen ;
    Bool_t _extended ;
    Bool_t _randProto ;
    Bool_t _resampleProto ;
    TString _dsetName ;    
    Bool_t _init ;
    ClassDef(GenSpec,0) // Generation specification
  } ;

  GenSpec* prepareMultiGen(const RooArgSet &whatVars,  
			   const RooCmdArg& arg1=RooCmdArg::none(),const RooCmdArg& arg2=RooCmdArg::none(),
			   const RooCmdArg& arg3=RooCmdArg::none(),const RooCmdArg& arg4=RooCmdArg::none(),
			   const RooCmdArg& arg5=RooCmdArg::none(),const RooCmdArg& arg6=RooCmdArg::none()) ;
  RooDataSet* generate(GenSpec&) const ;
  

  virtual RooDataHist *generateBinned(const RooArgSet &whatVars, Double_t nEvents, const RooCmdArg& arg1,
			      const RooCmdArg& arg2=RooCmdArg::none(), const RooCmdArg& arg3=RooCmdArg::none(),
			      const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none()) ;
  virtual RooDataHist *generateBinned(const RooArgSet &whatVars,  
			      const RooCmdArg& arg1=RooCmdArg::none(),const RooCmdArg& arg2=RooCmdArg::none(),
			      const RooCmdArg& arg3=RooCmdArg::none(),const RooCmdArg& arg4=RooCmdArg::none(),
			      const RooCmdArg& arg5=RooCmdArg::none(),const RooCmdArg& arg6=RooCmdArg::none()) ;
  virtual RooDataHist *generateBinned(const RooArgSet &whatVars, Double_t nEvents, Bool_t expectedData=kFALSE, Bool_t extended=kFALSE) const;

  virtual RooDataSet* generateSimGlobal(const RooArgSet& whatVars, Int_t nEvents) ;

  virtual RooPlot* plotOn(RooPlot* frame, 
			  const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(),
			  const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(),
			  const RooCmdArg& arg5=RooCmdArg::none(), const RooCmdArg& arg6=RooCmdArg::none(),
			  const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none(),
			  const RooCmdArg& arg9=RooCmdArg::none(), const RooCmdArg& arg10=RooCmdArg::none()
              ) const {
    return RooAbsReal::plotOn(frame,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10) ;
  }
  virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;


  virtual RooPlot* paramOn(RooPlot* frame, 
                           const RooCmdArg& arg1=RooCmdArg::none(), const RooCmdArg& arg2=RooCmdArg::none(), 
                           const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(), 
                           const RooCmdArg& arg5=RooCmdArg::none(), const RooCmdArg& arg6=RooCmdArg::none(), 
                           const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;

  virtual RooPlot* paramOn(RooPlot* frame, const RooAbsData* data, const char *label= "", Int_t sigDigits = 2,
			   Option_t *options = "NELU", Double_t xmin=0.50,
			   Double_t xmax= 0.99,Double_t ymax=0.95) ;

  // Built-in generator support
  virtual Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const;
  virtual void initGenerator(Int_t code) ;
  virtual void generateEvent(Int_t code);  
  virtual Bool_t isDirectGenSafe(const RooAbsArg& arg) const ; 

  // Configuration of MC generators used for this pdf
  const RooNumGenConfig* getGeneratorConfig() const ;
  static RooNumGenConfig* defaultGeneratorConfig()  ;
  RooNumGenConfig* specialGeneratorConfig() const ;
  RooNumGenConfig* specialGeneratorConfig(Bool_t createOnTheFly) ;
  void setGeneratorConfig() ;
  void setGeneratorConfig(const RooNumGenConfig& config) ;

  // -log(L) fits to binned and unbinned data
  virtual RooFitResult* fitTo(RooAbsData& data, const RooCmdArg& arg1=RooCmdArg::none(),  const RooCmdArg& arg2=RooCmdArg::none(),  
                              const RooCmdArg& arg3=RooCmdArg::none(),  const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none(),  
                              const RooCmdArg& arg6=RooCmdArg::none(),  const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;
  virtual RooFitResult* fitTo(RooAbsData& data, const RooLinkedList& cmdList) ;

  virtual RooAbsReal* createNLL(RooAbsData& data, const RooLinkedList& cmdList) ;
  virtual RooAbsReal* createNLL(RooAbsData& data, const RooCmdArg& arg1=RooCmdArg::none(),  const RooCmdArg& arg2=RooCmdArg::none(),  
				const RooCmdArg& arg3=RooCmdArg::none(),  const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none(),  
				const RooCmdArg& arg6=RooCmdArg::none(),  const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;

  // Chi^2 fits to histograms
  using RooAbsReal::chi2FitTo ;
  using RooAbsReal::createChi2 ;
  virtual RooFitResult* chi2FitTo(RooDataHist& data, const RooLinkedList& cmdList) ;
  virtual RooAbsReal* createChi2(RooDataHist& data, const RooCmdArg& arg1=RooCmdArg::none(),  const RooCmdArg& arg2=RooCmdArg::none(),  
				 const RooCmdArg& arg3=RooCmdArg::none(),  const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none(),  
				 const RooCmdArg& arg6=RooCmdArg::none(),  const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;

  // Chi^2 fits to X-Y datasets
  virtual RooAbsReal* createChi2(RooDataSet& data, const RooLinkedList& cmdList) ;
  




  // Constraint management
  virtual RooArgSet* getConstraints(const RooArgSet& /*observables*/, RooArgSet& /*constrainedParams*/, Bool_t /*stripDisconnected*/) const { 
    // Interface to retrieve constraint terms on this pdf. Default implementation returns null
    return 0 ; 
  }
  virtual RooArgSet* getAllConstraints(const RooArgSet& observables, RooArgSet& constrainedParams, Bool_t stripDisconnected=kTRUE) const ;
  
  // Project p.d.f into lower dimensional p.d.f
  virtual RooAbsPdf* createProjection(const RooArgSet& iset) ;  

  // Create cumulative density function from p.d.f
  RooAbsReal* createCdf(const RooArgSet& iset, const RooArgSet& nset=RooArgSet()) ;
  RooAbsReal* createCdf(const RooArgSet& iset, const RooCmdArg& arg1, const RooCmdArg& arg2=RooCmdArg::none(),
			const RooCmdArg& arg3=RooCmdArg::none(), const RooCmdArg& arg4=RooCmdArg::none(), 
			const RooCmdArg& arg5=RooCmdArg::none(), const RooCmdArg& arg6=RooCmdArg::none(), 
			const RooCmdArg& arg7=RooCmdArg::none(), const RooCmdArg& arg8=RooCmdArg::none()) ;
  RooAbsReal* createScanCdf(const RooArgSet& iset, const RooArgSet& nset, Int_t numScanBins, Int_t intOrder) ;

  // Function evaluation support
  virtual Bool_t traceEvalHook(Double_t value) const ;  
  virtual Double_t getValV(const RooArgSet* set=0) const ;
  virtual Double_t getLogVal(const RooArgSet* set=0) const ;

  Double_t getNorm(const RooArgSet& nset) const { 
    // Get p.d.f normalization term needed for observables 'nset'
    return getNorm(&nset) ; 
  }
  virtual Double_t getNorm(const RooArgSet* set=0) const ;

  virtual void resetErrorCounters(Int_t resetValue=10) ;
  void setTraceCounter(Int_t value, Bool_t allNodes=kFALSE) ;
  Bool_t traceEvalPdf(Double_t value) const ;

  Double_t analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName=0) const ;

  virtual Bool_t selfNormalized() const { 
    // If true, p.d.f is taken as self-normalized and no attempt is made to add a normalization term
    // This default implementation return false
    return kFALSE ; 
  }

  // Support for extended maximum likelihood, switched off by default
  enum ExtendMode { CanNotBeExtended, CanBeExtended, MustBeExtended } ;
  virtual ExtendMode extendMode() const { 
    // Returns ability of p.d.f to provided extended likelihood terms. Possible
    // answers are CanNotBeExtended, CanBeExtended or MustBeExtended. This
    // default implementation always return CanNotBeExtended
    return CanNotBeExtended ; 
  } 
  inline Bool_t canBeExtended() const { 
    // If true p.d.f can provide extended likelihood term
    return (extendMode() != CanNotBeExtended) ; 
  }
  inline Bool_t mustBeExtended() const { 
    // If true p.d.f must extended likelihood term
    return (extendMode() == MustBeExtended) ; 
  }
  virtual Double_t expectedEvents(const RooArgSet* nset) const ; 
  virtual Double_t expectedEvents(const RooArgSet& nset) const { 
    // Return expecteded number of p.d.fs to be used in calculated of extended likelihood
    return expectedEvents(&nset) ; 
  }

  // Printing interface (human readable)
  virtual void printValue(std::ostream& os) const ;
  virtual void printMultiline(std::ostream& os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const ;

  static void verboseEval(Int_t stat) ;
  static int verboseEval() ;

  virtual Double_t extendedTerm(Double_t observedEvents, const RooArgSet* nset=0) const ;

  static void clearEvalError() ;
  static Bool_t evalError() ;

  void setNormRange(const char* rangeName) ;
  const char* normRange() const { 
    return _normRange.Length()>0 ? _normRange.Data() : 0 ; 
  }
  void setNormRangeOverride(const char* rangeName) ;

  const RooAbsReal* getNormIntegral(const RooArgSet& nset) const { return getNormObj(0,&nset,0) ; }
  
protected:   

public:
  virtual const RooAbsReal* getNormObj(const RooArgSet* set, const RooArgSet* iset, const TNamed* rangeName=0) const ;

  virtual RooAbsGenContext* binnedGenContext(const RooArgSet &vars, Bool_t verbose= kFALSE) const ;

  virtual RooAbsGenContext* genContext(const RooArgSet &vars, const RooDataSet *prototype=0, 
	                               const RooArgSet* auxProto=0, Bool_t verbose= kFALSE) const ;

  virtual RooAbsGenContext* autoGenContext(const RooArgSet &vars, const RooDataSet* prototype=0, const RooArgSet* auxProto=0, 
					   Bool_t verbose=kFALSE, Bool_t autoBinned=kTRUE, const char* binnedTag="") const ;

protected:

  RooDataSet *generate(RooAbsGenContext& context, const RooArgSet& whatVars, const RooDataSet* prototype,
		       Double_t nEvents, Bool_t verbose, Bool_t randProtoOrder, Bool_t resampleProto, Bool_t skipInit=kFALSE, 
		       Bool_t extended=kFALSE) const ;

  // Implementation version
  virtual RooPlot* paramOn(RooPlot* frame, const RooArgSet& params, Bool_t showConstants=kFALSE,
                           const char *label= "", Int_t sigDigits = 2, Option_t *options = "NELU", Double_t xmin=0.65,
			   Double_t xmax= 0.99,Double_t ymax=0.95, const RooCmdArg* formatCmd=0) ;


  virtual RooPlot *plotOn(RooPlot *frame, PlotOpt o) const;  

  friend class RooEffGenContext ;
  friend class RooAddGenContext ;
  friend class RooProdGenContext ;
  friend class RooSimGenContext ;
  friend class RooSimSplitGenContext ;
  friend class RooConvGenContext ;
  friend class RooSimultaneous ;
  friend class RooAddGenContextOrig ;
  friend class RooProdPdf ;
  friend class RooMCStudy ;

  Int_t* randomizeProtoOrder(Int_t nProto,Int_t nGen,Bool_t resample=kFALSE) const ;

  friend class RooExtendPdf ;
  // This also forces the definition of a copy ctor in derived classes 
  RooAbsPdf(const RooAbsPdf& other, const char* name = 0);

  friend class RooRealIntegral ;
  static Int_t _verboseEval ;

  virtual Bool_t syncNormalization(const RooArgSet* dset, Bool_t adjustProxies=kTRUE) const ;

  friend class RooAbsAnaConvPdf ;
  mutable Double_t _rawValue ;
  mutable RooAbsReal* _norm   ;      //! Normalization integral (owned by _normMgr)
  mutable RooArgSet* _normSet ;      //! Normalization set with for above integral

  class CacheElem : public RooAbsCacheElement {
  public:
    CacheElem(RooAbsReal& norm) : _norm(&norm) {} ;
    void operModeHook(RooAbsArg::OperMode) ;
    virtual ~CacheElem() ; 
    virtual RooArgList containedArgs(Action) { return RooArgList(*_norm) ; }
    RooAbsReal* _norm ;
  } ;
  mutable RooObjCacheManager _normMgr ; // The cache manager

  friend class CacheElem ; // Cache needs to be able to clear _norm pointer
  
  virtual Bool_t redirectServersHook(const RooAbsCollection&, Bool_t, Bool_t, Bool_t) { 
    // Hook function intercepting redirectServer calls. Discard current normalization
    // object if any server is redirected

    // Object is own by _normCacheManager that will delete object as soon as cache
    // is sterilized by server redirect
    _norm = 0 ;
    return kFALSE ; 
  } ;

  
  mutable Int_t _errorCount ;        // Number of errors remaining to print
  mutable Int_t _traceCount ;        // Number of traces remaining to print
  mutable Int_t _negCount ;          // Number of negative probablities remaining to print

  Bool_t _selectComp ;               // Component selection flag for RooAbsPdf::plotCompOn

  static void raiseEvalError() ;

  static Bool_t _evalError ;

  RooNumGenConfig* _specGeneratorConfig ; //! MC generator configuration specific for this object
  
  TString _normRange ; // Normalization range
  static TString _normRangeOverride ; 
  
  ClassDef(RooAbsPdf,4) // Abstract PDF with normalization support
};


#endif
 RooAbsPdf.h:1
 RooAbsPdf.h:2
 RooAbsPdf.h:3
 RooAbsPdf.h:4
 RooAbsPdf.h:5
 RooAbsPdf.h:6
 RooAbsPdf.h:7
 RooAbsPdf.h:8
 RooAbsPdf.h:9
 RooAbsPdf.h:10
 RooAbsPdf.h:11
 RooAbsPdf.h:12
 RooAbsPdf.h:13
 RooAbsPdf.h:14
 RooAbsPdf.h:15
 RooAbsPdf.h:16
 RooAbsPdf.h:17
 RooAbsPdf.h:18
 RooAbsPdf.h:19
 RooAbsPdf.h:20
 RooAbsPdf.h:21
 RooAbsPdf.h:22
 RooAbsPdf.h:23
 RooAbsPdf.h:24
 RooAbsPdf.h:25
 RooAbsPdf.h:26
 RooAbsPdf.h:27
 RooAbsPdf.h:28
 RooAbsPdf.h:29
 RooAbsPdf.h:30
 RooAbsPdf.h:31
 RooAbsPdf.h:32
 RooAbsPdf.h:33
 RooAbsPdf.h:34
 RooAbsPdf.h:35
 RooAbsPdf.h:36
 RooAbsPdf.h:37
 RooAbsPdf.h:38
 RooAbsPdf.h:39
 RooAbsPdf.h:40
 RooAbsPdf.h:41
 RooAbsPdf.h:42
 RooAbsPdf.h:43
 RooAbsPdf.h:44
 RooAbsPdf.h:45
 RooAbsPdf.h:46
 RooAbsPdf.h:47
 RooAbsPdf.h:48
 RooAbsPdf.h:49
 RooAbsPdf.h:50
 RooAbsPdf.h:51
 RooAbsPdf.h:52
 RooAbsPdf.h:53
 RooAbsPdf.h:54
 RooAbsPdf.h:55
 RooAbsPdf.h:56
 RooAbsPdf.h:57
 RooAbsPdf.h:58
 RooAbsPdf.h:59
 RooAbsPdf.h:60
 RooAbsPdf.h:61
 RooAbsPdf.h:62
 RooAbsPdf.h:63
 RooAbsPdf.h:64
 RooAbsPdf.h:65
 RooAbsPdf.h:66
 RooAbsPdf.h:67
 RooAbsPdf.h:68
 RooAbsPdf.h:69
 RooAbsPdf.h:70
 RooAbsPdf.h:71
 RooAbsPdf.h:72
 RooAbsPdf.h:73
 RooAbsPdf.h:74
 RooAbsPdf.h:75
 RooAbsPdf.h:76
 RooAbsPdf.h:77
 RooAbsPdf.h:78
 RooAbsPdf.h:79
 RooAbsPdf.h:80
 RooAbsPdf.h:81
 RooAbsPdf.h:82
 RooAbsPdf.h:83
 RooAbsPdf.h:84
 RooAbsPdf.h:85
 RooAbsPdf.h:86
 RooAbsPdf.h:87
 RooAbsPdf.h:88
 RooAbsPdf.h:89
 RooAbsPdf.h:90
 RooAbsPdf.h:91
 RooAbsPdf.h:92
 RooAbsPdf.h:93
 RooAbsPdf.h:94
 RooAbsPdf.h:95
 RooAbsPdf.h:96
 RooAbsPdf.h:97
 RooAbsPdf.h:98
 RooAbsPdf.h:99
 RooAbsPdf.h:100
 RooAbsPdf.h:101
 RooAbsPdf.h:102
 RooAbsPdf.h:103
 RooAbsPdf.h:104
 RooAbsPdf.h:105
 RooAbsPdf.h:106
 RooAbsPdf.h:107
 RooAbsPdf.h:108
 RooAbsPdf.h:109
 RooAbsPdf.h:110
 RooAbsPdf.h:111
 RooAbsPdf.h:112
 RooAbsPdf.h:113
 RooAbsPdf.h:114
 RooAbsPdf.h:115
 RooAbsPdf.h:116
 RooAbsPdf.h:117
 RooAbsPdf.h:118
 RooAbsPdf.h:119
 RooAbsPdf.h:120
 RooAbsPdf.h:121
 RooAbsPdf.h:122
 RooAbsPdf.h:123
 RooAbsPdf.h:124
 RooAbsPdf.h:125
 RooAbsPdf.h:126
 RooAbsPdf.h:127
 RooAbsPdf.h:128
 RooAbsPdf.h:129
 RooAbsPdf.h:130
 RooAbsPdf.h:131
 RooAbsPdf.h:132
 RooAbsPdf.h:133
 RooAbsPdf.h:134
 RooAbsPdf.h:135
 RooAbsPdf.h:136
 RooAbsPdf.h:137
 RooAbsPdf.h:138
 RooAbsPdf.h:139
 RooAbsPdf.h:140
 RooAbsPdf.h:141
 RooAbsPdf.h:142
 RooAbsPdf.h:143
 RooAbsPdf.h:144
 RooAbsPdf.h:145
 RooAbsPdf.h:146
 RooAbsPdf.h:147
 RooAbsPdf.h:148
 RooAbsPdf.h:149
 RooAbsPdf.h:150
 RooAbsPdf.h:151
 RooAbsPdf.h:152
 RooAbsPdf.h:153
 RooAbsPdf.h:154
 RooAbsPdf.h:155
 RooAbsPdf.h:156
 RooAbsPdf.h:157
 RooAbsPdf.h:158
 RooAbsPdf.h:159
 RooAbsPdf.h:160
 RooAbsPdf.h:161
 RooAbsPdf.h:162
 RooAbsPdf.h:163
 RooAbsPdf.h:164
 RooAbsPdf.h:165
 RooAbsPdf.h:166
 RooAbsPdf.h:167
 RooAbsPdf.h:168
 RooAbsPdf.h:169
 RooAbsPdf.h:170
 RooAbsPdf.h:171
 RooAbsPdf.h:172
 RooAbsPdf.h:173
 RooAbsPdf.h:174
 RooAbsPdf.h:175
 RooAbsPdf.h:176
 RooAbsPdf.h:177
 RooAbsPdf.h:178
 RooAbsPdf.h:179
 RooAbsPdf.h:180
 RooAbsPdf.h:181
 RooAbsPdf.h:182
 RooAbsPdf.h:183
 RooAbsPdf.h:184
 RooAbsPdf.h:185
 RooAbsPdf.h:186
 RooAbsPdf.h:187
 RooAbsPdf.h:188
 RooAbsPdf.h:189
 RooAbsPdf.h:190
 RooAbsPdf.h:191
 RooAbsPdf.h:192
 RooAbsPdf.h:193
 RooAbsPdf.h:194
 RooAbsPdf.h:195
 RooAbsPdf.h:196
 RooAbsPdf.h:197
 RooAbsPdf.h:198
 RooAbsPdf.h:199
 RooAbsPdf.h:200
 RooAbsPdf.h:201
 RooAbsPdf.h:202
 RooAbsPdf.h:203
 RooAbsPdf.h:204
 RooAbsPdf.h:205
 RooAbsPdf.h:206
 RooAbsPdf.h:207
 RooAbsPdf.h:208
 RooAbsPdf.h:209
 RooAbsPdf.h:210
 RooAbsPdf.h:211
 RooAbsPdf.h:212
 RooAbsPdf.h:213
 RooAbsPdf.h:214
 RooAbsPdf.h:215
 RooAbsPdf.h:216
 RooAbsPdf.h:217
 RooAbsPdf.h:218
 RooAbsPdf.h:219
 RooAbsPdf.h:220
 RooAbsPdf.h:221
 RooAbsPdf.h:222
 RooAbsPdf.h:223
 RooAbsPdf.h:224
 RooAbsPdf.h:225
 RooAbsPdf.h:226
 RooAbsPdf.h:227
 RooAbsPdf.h:228
 RooAbsPdf.h:229
 RooAbsPdf.h:230
 RooAbsPdf.h:231
 RooAbsPdf.h:232
 RooAbsPdf.h:233
 RooAbsPdf.h:234
 RooAbsPdf.h:235
 RooAbsPdf.h:236
 RooAbsPdf.h:237
 RooAbsPdf.h:238
 RooAbsPdf.h:239
 RooAbsPdf.h:240
 RooAbsPdf.h:241
 RooAbsPdf.h:242
 RooAbsPdf.h:243
 RooAbsPdf.h:244
 RooAbsPdf.h:245
 RooAbsPdf.h:246
 RooAbsPdf.h:247
 RooAbsPdf.h:248
 RooAbsPdf.h:249
 RooAbsPdf.h:250
 RooAbsPdf.h:251
 RooAbsPdf.h:252
 RooAbsPdf.h:253
 RooAbsPdf.h:254
 RooAbsPdf.h:255
 RooAbsPdf.h:256
 RooAbsPdf.h:257
 RooAbsPdf.h:258
 RooAbsPdf.h:259
 RooAbsPdf.h:260
 RooAbsPdf.h:261
 RooAbsPdf.h:262
 RooAbsPdf.h:263
 RooAbsPdf.h:264
 RooAbsPdf.h:265
 RooAbsPdf.h:266
 RooAbsPdf.h:267
 RooAbsPdf.h:268
 RooAbsPdf.h:269
 RooAbsPdf.h:270
 RooAbsPdf.h:271
 RooAbsPdf.h:272
 RooAbsPdf.h:273
 RooAbsPdf.h:274
 RooAbsPdf.h:275
 RooAbsPdf.h:276
 RooAbsPdf.h:277
 RooAbsPdf.h:278
 RooAbsPdf.h:279
 RooAbsPdf.h:280
 RooAbsPdf.h:281
 RooAbsPdf.h:282
 RooAbsPdf.h:283
 RooAbsPdf.h:284
 RooAbsPdf.h:285
 RooAbsPdf.h:286
 RooAbsPdf.h:287
 RooAbsPdf.h:288
 RooAbsPdf.h:289
 RooAbsPdf.h:290
 RooAbsPdf.h:291
 RooAbsPdf.h:292
 RooAbsPdf.h:293
 RooAbsPdf.h:294
 RooAbsPdf.h:295
 RooAbsPdf.h:296
 RooAbsPdf.h:297
 RooAbsPdf.h:298
 RooAbsPdf.h:299
 RooAbsPdf.h:300
 RooAbsPdf.h:301
 RooAbsPdf.h:302
 RooAbsPdf.h:303
 RooAbsPdf.h:304
 RooAbsPdf.h:305
 RooAbsPdf.h:306
 RooAbsPdf.h:307
 RooAbsPdf.h:308
 RooAbsPdf.h:309
 RooAbsPdf.h:310
 RooAbsPdf.h:311
 RooAbsPdf.h:312
 RooAbsPdf.h:313
 RooAbsPdf.h:314
 RooAbsPdf.h:315
 RooAbsPdf.h:316
 RooAbsPdf.h:317
 RooAbsPdf.h:318
 RooAbsPdf.h:319
 RooAbsPdf.h:320
 RooAbsPdf.h:321
 RooAbsPdf.h:322
 RooAbsPdf.h:323
 RooAbsPdf.h:324
 RooAbsPdf.h:325
 RooAbsPdf.h:326
 RooAbsPdf.h:327
 RooAbsPdf.h:328
 RooAbsPdf.h:329
 RooAbsPdf.h:330
 RooAbsPdf.h:331
 RooAbsPdf.h:332
 RooAbsPdf.h:333
 RooAbsPdf.h:334
 RooAbsPdf.h:335
 RooAbsPdf.h:336
 RooAbsPdf.h:337
 RooAbsPdf.h:338
 RooAbsPdf.h:339
 RooAbsPdf.h:340
 RooAbsPdf.h:341
 RooAbsPdf.h:342
 RooAbsPdf.h:343
 RooAbsPdf.h:344
 RooAbsPdf.h:345
 RooAbsPdf.h:346