RooAbsPdf

class RooAbsPdf : public RooAbsReal

    protected:

      virtual RooAbsGenContext* genContext(const RooArgSet& vars, const RooDataSet* prototype = 0, const RooArgSet* auxProto = 0, Bool_t verbose = kFALSE) const
      virtual const RooAbsReal* getNormObj(const RooArgSet* set, const TNamed* rangeName = 0) const
                    static void globalSelectComp(Bool_t flag)
                   virtual void operModeHook()
               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* plotCompOnEngine(RooPlot* frame, RooArgSet* selNodes, Option_t* drawOptions = "L", Double_t scaleFactor = 1.0, RooAbsReal::ScaleType stype = Relative, const RooAbsData* projData = 0, const RooArgSet* projSet = 0) const
               virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const
               virtual RooPlot* plotOn(RooPlot* frame, RooAbsReal::PlotOpt o) const
                           void plotOnCompSelect(RooArgSet* selNodes) const
                    static void raiseEvalError()
                         Int_t* randomizeProtoOrder(Int_t nProto, Int_t nGen) const
                 virtual Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive)
                           void selectComp(Bool_t flag)
                 virtual Bool_t syncNormalization(const RooArgSet* dset, Bool_t adjustProxies = kTRUE) const
                   virtual void syncNormalizationPostHook(RooAbsReal* norm, const RooArgSet* dset) const
                 virtual Bool_t syncNormalizationPreHook(RooAbsReal* norm, const RooArgSet* dset) const

    public:

                            virtual ~RooAbsPdf()
                   virtual Double_t analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName = "0") const
                             Bool_t canBeExtended() const
                     static TClass* Class()
                        static void clearEvalError()
                      static Bool_t evalError()
                   virtual Double_t expectedEvents(const RooArgSet* nset = 0) const
                   virtual Double_t extendedTerm(UInt_t observedEvents, const RooArgSet* nset = 0) const
      virtual RooAbsPdf::ExtendMode extendMode() const
              virtual RooFitResult* fitTo(RooAbsData& data, RooCmdArg arg1, RooCmdArg arg2 = RooCmdArg::none, RooCmdArg arg3 = RooCmdArg::none, RooCmdArg arg4 = RooCmdArg::none, RooCmdArg arg5 = RooCmdArg::none, RooCmdArg arg6 = RooCmdArg::none, RooCmdArg arg7 = RooCmdArg::none, RooCmdArg arg8 = RooCmdArg::none)
              virtual RooFitResult* fitTo(RooAbsData& data, const RooLinkedList& cmdList)
              virtual RooFitResult* fitTo(RooAbsData& data, const RooArgSet& projDeps, Option_t* fitOpt = "", Option_t* optOpt = "c", const char* fitRange = "0")
              virtual RooFitResult* fitTo(RooAbsData& data, Option_t* fitOpt = "", Option_t* optOpt = "c", const char* fitRange = "0")
                       virtual void fixAddCoefNormalization(const RooArgSet& addNormSet = RooArgSet())
                       virtual void fixAddCoefRange(const char* rangeName = "0")
                        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, Int_t nEvents = 0, Bool_t verbose = kFALSE) const
                        RooDataSet* generate(const RooArgSet& whatVars, const RooDataSet& prototype, Int_t nEvents = 0, Bool_t verbose = kFALSE, Bool_t randProtoOrder = kFALSE) const
                       virtual void generateEvent(Int_t code)
                      virtual Int_t getGenerator(const RooArgSet& directVars, RooArgSet& generateVars, Bool_t staticInitOK = kTRUE) const
                           Double_t getLogVal(const RooArgSet* set = 0) const
                           Double_t getNorm(const RooArgSet& nset) const
                   virtual Double_t getNorm(const RooArgSet* set = 0) const
                   virtual Double_t getVal(const RooArgSet* set = 0) const
                       virtual void initGenerator(Int_t code)
                    virtual TClass* IsA() const
                     virtual Bool_t isDirectGenSafe(const RooAbsArg& arg) const
                             Bool_t isSelectedComp() const
                             Bool_t mustBeExtended() 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.65, Double_t xmax = 0.99, Double_t ymax = 0.95)
                   virtual RooPlot* plotCompOn(RooPlot* frame, const char* compNameList, Option_t* drawOptions = "L", Double_t scaleFactor = 1.0, RooAbsReal::ScaleType stype = Relative, const RooAbsData* projData = 0, const RooArgSet* projSet = 0) const
                   virtual RooPlot* plotCompOn(RooPlot* frame, const RooArgSet& compSet, Option_t* drawOptions = "L", Double_t scaleFactor = 1.0, RooAbsReal::ScaleType stype = Relative, const RooAbsData* projData = 0, const RooArgSet* projSet = 0) const
                   virtual RooPlot* plotCompSliceOn(RooPlot* frame, const char* compNameList, const RooArgSet& sliceSet, Option_t* drawOptions = "L", Double_t scaleFactor = 1.0, RooAbsReal::ScaleType stype = Relative, const RooAbsData* projData = 0) const
                   virtual RooPlot* plotCompSliceOn(RooPlot* frame, const RooArgSet& compSet, const RooArgSet& sliceSet, Option_t* drawOptions = "L", Double_t scaleFactor = 1.0, RooAbsReal::ScaleType stype = Relative, const RooAbsData* projData = 0) const
                           RooPlot* plotNLLOn(RooPlot* frame, RooDataSet* data, Option_t* drawOptions = "L", Double_t prec = 1e-2, Bool_t fixMinToZero = kTRUE)
                   virtual RooPlot* plotNLLOn(RooPlot* frame, RooDataSet* data, Bool_t extended, Option_t* drawOptions = "L", Double_t prec = 1e-2, Bool_t fixMinToZero = kTRUE)
                   virtual RooPlot* plotNLLOn(RooPlot* frame, RooDataSet* data, Bool_t extended, const RooArgSet& projDeps, Option_t* drawOptions = "L", Double_t prec = 1e-2, Bool_t fixMinToZero = kTRUE)
                   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
                       virtual void printToStream(ostream& stream, RooPrintable::PrintOption opt = Standard, TString indent = ) const
                       virtual void resetErrorCounters(Int_t resetValue = 10)
                     virtual Bool_t selfNormalized() const
                               void setTraceCounter(Int_t value, Bool_t allNodes = kFALSE)
                       virtual void ShowMembers(TMemberInspector& insp, char* parent)
                       virtual void Streamer(TBuffer& b)
                               void StreamerNVirtual(TBuffer& b)
                     virtual Bool_t traceEvalHook(Double_t value) const
                             Bool_t traceEvalPdf(Double_t value) const
                        static void verboseEval(Int_t stat)

Data Members

    protected:

        static Int_t _verboseEval       
            Double_t _rawValue          
         RooAbsReal* _norm              Normalization integral (owned by _normMgr)
          RooArgSet* _normSet           Normalization set with for above integral
      RooNormManager _normMgr           Normalization manager
               Int_t _errorCount        Number of errors remaining to print
               Int_t _traceCount        Number of traces remaining to print
               Int_t _negCount          Number of negative probablities remaining to print
              Bool_t _selectComp        Component selection flag for RooAbsPdf::plotCompOn
       static Bool_t _globalSelectComp  Global activation switch for component selection
       static Bool_t _evalError         

    public:

      static const RooAbsPdf::ExtendMode CanNotBeExtended  
      static const RooAbsPdf::ExtendMode CanBeExtended     
      static const RooAbsPdf::ExtendMode MustBeExtended    

Class Description

 advertises the analytical integrals that are supported. 'integSet'
 is the set of dependents for which integration is requested. The
 function should copy the subset of dependents it can analytically
 integrate to anaIntSet and return a unique identification code for
 this integration configuration.  If no integration can be
 performed, zero should be returned.  Second,

 Double_t analyticalIntegral(Int_t code)

 Implements the actual analytical integral(s) advertised by
 getAnalyticalIntegral.  This functions will only be called with
 codes returned by getAnalyticalIntegral, except code zero.

 The integration range for real each dependent to be integrated can
 be obtained from the dependents' proxy functions min() and
 max(). Never call these proxy functions for any proxy not known to
 be a dependent via the integration code.  Doing so may be
 ill-defined, e.g. in case the proxy holds a function, and will
 trigger an assert. Integrated category dependents should always be
 summed over all of their states.



 [Direct generation of dependents]

 Any PDF dependent can be generated with the accept/reject method,
 but for certain PDFs more efficient methods may be implemented. To
 implement direct generation of one or more dependents, two
 functions need to be implemented, similar to those for analytical
 integrals:

 Int_t getGenerator(const RooArgSet& generateVars, RooArgSet& directVars) and
 void generateEvent(Int_t code)

 The first function advertises dependents that can be generated,
 similar to the way analytical integrals are advertised. The second
 function implements the generator for the advertised dependents

 The generated dependent values should be store in the proxy
 objects. For this the assignment operator can be used (i.e. xProxy
 = 3.0 ). Never call assign to any proxy not known to be a dependent
 via the generation code.  Doing so may be ill-defined, e.g. in case
 the proxy holds a function, and will trigger an assert

 Destructor
if (_norm) delete _norm ;

 Return current value, normalizated by integrating over
 the dependents in 'nset'. If 'nset' is 0, the unnormalized value.
 is returned. All elements of 'nset' must be lvalues

 Analytical integral with normalization (see RooAbsReal::analyticalIntegralWN() for further information)

 This function applies the normalization specified by 'normSet' to the integral returned
 by RooAbsReal::analyticalIntegral(). The passthrough scenario (code=0) is also changed
 to return a normalized answer

 Check that passed value is positive and not 'not-a-number'.
 If not, print an error, until the error counter reaches
 its set maximum.

 Return the integral of this PDF over all elements of 'nset'.

 Check normalization is already stored

 Verify that the normalization integral cached with this PDF
 is valid for given set of normalization dependents

 If not, the cached normalization integral (if any) is deleted
 and a new integral is constructed for use with 'nset'
 Elements in 'nset' can be discrete and real, but must be lvalues

 By default, only actual dependents of the PDF listed in 'nset'
 are integration. This behaviour can be modified in subclasses
 by overloading the syncNormalizationPreHook() function.

 For functions that declare to be self-normalized by overloading the
 selfNormalized() function, a unit normalization is always constructed

 WVE 08/21/01 Probably obsolete now.

 Reset error counter to given value, limiting the number
 of future error messages for this pdf to 'resetValue'

 Reset trace counter to given value, limiting the
 number of future trace messages for this pdf to 'value'

 WVE 08/21/01 Probably obsolete now

 Return the log of the current value with given normalization
 An error message is printed if the argument of the log is negative.

 Returned the extended likelihood term (Nexpect - Nobserved*log(NExpected)
 of this PDF for the given number of observed events

 For successfull operation the PDF implementation must indicate
 it is extendable by overloading canBeExtended() and must
 implemented the expectedEvents() function.

 Fit PDF to given dataset. If dataset is unbinned, an unbinned maximum likelihood is performed. If the dataset
 is binned, a binned maximum likelihood is performed. By default the fit is executed through the MINUIT
 commands MIGRAD, HESSE and MINOS in succession.

 The following named arguments are supported

 Options to control construction of -log(L)
 ------------------------------------------
 ConditionalObservables(const RooArgSet& set) -- Do not normalize PDF over listed observables
 Extended(Bool_t flag)           -- Add extended likelihood term, off by default
 Range(const char* name)         -- Fit only data inside range with given name
 Range(Double_t lo, Double_t hi) -- Fit only data inside given range. A range named "fit" is created on the fly on all observables.
 NumCPU(int num)                 -- Parallelize NLL calculation on num CPUs
 Optimize(Bool_t flag)           -- Activate constant term optimization (on by default)
 SplitRange(Bool_t flag)         -- Use separate fit ranges in a simultaneous fit. Actual range name for each
                                    subsample is assumed to by rangeName_{indexState} where indexState
                                    is the state of the master index category of the simultaneous fit

 Options to control flow of fit procedure
 ----------------------------------------
 InitialHesse(Bool_t flag)      -- Flag controls if HESSE before MIGRAD as well, off by default
 Hesse(Bool_t flag)             -- Flag controls if HESSE is run after MIGRAD, on by default
 Minos(Bool_t flag)             -- Flag controls if MINOS is run after HESSE, on by default
 Minos(const RooArgSet& set)    -- Only run MINOS on given subset of arguments
 Save(Bool_t flag)              -- Flac controls if RooFitResult object is produced and returned, off by default
 Strategy(Int_t flag)           -- Set Minuit strategy (0 through 2, default is 1)
 FitOptions(const char* optStr) -- Steer fit with classic options string (for backward compatibility). Use of this option
                                   excludes use of any of the new style steering options.

 Options to control informational output
 ---------------------------------------
 Verbose(Bool_t flag)           -- Flag controls if verbose output is printed (NLL, parameter changes during fit
 Timer(Bool_t flag)             -- Time CPU and wall clock consumption of fit steps, off by default
 PrintLevel(Int_t level)        -- Set Minuit print level (-1 through 3, default is 1). At -1 all RooFit informational
                                   messages are suppressed as well

 Fit PDF to given dataset. If dataset is unbinned, an unbinned maximum likelihood is performed. If the dataset
 is binned, a binned maximum likelihood is performed. By default the fit is executed through the MINUIT
 commands MIGRAD, HESSE and MINOS in succession.

 See RooAbsPdf::fitTo(RooAbsData& data, RooCmdArg arg1, RooCmdArg arg2, RooCmdArg arg3, RooCmdArg arg4,
                                         RooCmdArg arg5, RooCmdArg arg6, RooCmdArg arg7, RooCmdArg arg8)

 for documentation of options

 Fit this PDF to given data set

 OLD STYLE INTERFACE, PLEASE USE NEW INTERFACE fitTo(RooAbsData& data, RooCmdArg arg1,...,RooCmdArg arg8)

 The dataset can be either binned, in which case a binned maximum likelihood fit
 is performed, or unbinned, in which case an unbinned maximum likelihood fit is performed

 Available fit options:

  "m" = MIGRAD only, i.e. no MINOS
  "s" = estimate step size with HESSE before starting MIGRAD
  "h" = run HESSE after MIGRAD
  "e" = Perform extended MLL fit
  "0" = Run MIGRAD with strategy MINUIT 0 (no correlation matrix calculation at end)
        Does not apply to HESSE or MINOS, if run afterwards.

  "q" = Switch off verbose mode
  "l" = Save log file with parameter values at each MINUIT step
  "v" = Show changed parameters at each MINUIT step
  "t" = Time fit
  "r" = Save fit output in RooFitResult object (return value is object RFR pointer)

 Available optimizer options

  "c" = Cache and precalculate components of PDF that exclusively depend on constant parameters
  "2" = Do NLL calculation in multi-processor mode on 2 processors
  "3" = Do NLL calculation in multi-processor mode on 3 processors
  "4" = Do NLL calculation in multi-processor mode on 4 processors

 The actual fit is performed to a temporary copy of both PDF and data set. Several optimization
 algorithm are run to increase the efficiency of the likelihood calculation and may increase
 the speed of complex fits up to an order of magnitude. All optimizations are exact, i.e the fit result
 of any fit should _exactly_ the same with and without optimization. We strongly encourage
 to stick to the default optimizer setting (all on). If for any reason you see a difference in the result
 with and without optimizer, please file a bug report.

 The function always return null unless the "r" fit option is specified. In that case a pointer to a RooFitResult
 is returned. The RooFitResult object contains the full fit output, including the correlation matrix.

 Print info about this object to the specified stream. In addition to the info
 from RooAbsArg::printToStream() we add:

     Shape : value, units, plot range
   Verbose : default binning and print label

 Generate a new dataset containing the specified variables with events sampled from our distribution.
 Generate the specified number of events or expectedEvents() if not specified.

 Any variables of this PDF that are not in whatVars will use their
 current values and be treated as fixed parameters. Returns zero
 in case of an error. The caller takes ownership of the returned
 dataset.

 The following named arguments are supported

 Verbose(Bool_t flag)               -- Print informational messages during event generation
 Extended()                         -- The actual number of events generated will be sampled from a Poisson distribution
                                       with mu=nevt. For use with extended maximum likelihood fits
 ProtoData(const RooDataSet& data,  -- Use specified dataset as prototype dataset. If randOrder is set to true
                 Bool_t randOrder)     the order of the events in the dataset will be read in a random order
                                       if the requested number of events to be generated does not match the
                                       number of events in the prototype dataset

 If ProtoData() is used, the specified existing dataset as a prototype: the new dataset will contain
 the same number of events as the prototype (unless otherwise specified), and any prototype variables not in
 whatVars will be copied into the new dataset for each generated event and also used to set our PDF parameters.
 The user can specify a  number of events to generate that will override the default. The result is a
 copy of the prototype dataset with only variables in whatVars randomized. Variables in whatVars that
 are not in the prototype will be added as new columns to the generated dataset.

 Generate a new dataset containing the specified variables with events sampled from our distribution.
 Generate the specified number of events or expectedEvents() if not specified.

 Any variables of this PDF that are not in whatVars will use their
 current values and be treated as fixed parameters. Returns zero
 in case of an error. The caller takes ownership of the returned
 dataset.

 The following named arguments are supported

 Verbose(Bool_t flag)               -- Print informational messages during event generation
 NumEvent(int nevt)                 -- Generate specified number of events
 Extended()                         -- The actual number of events generated will be sampled from a Poisson distribution
                                       with mu=nevt. For use with extended maximum likelihood fits
 ProtoData(const RooDataSet& data,  -- Use specified dataset as prototype dataset. If randOrder is set to true
                 Bool_t randOrder)     the order of the events in the dataset will be read in a random order
                                       if the requested number of events to be generated does not match the
                                       number of events in the prototype dataset

 If ProtoData() is used, the specified existing dataset as a prototype: the new dataset will contain
 the same number of events as the prototype (unless otherwise specified), and any prototype variables not in
 whatVars will be copied into the new dataset for each generated event and also used to set our PDF parameters.
 The user can specify a  number of events to generate that will override the default. The result is a
 copy of the prototype dataset with only variables in whatVars randomized. Variables in whatVars that
 are not in the prototype will be added as new columns to the generated dataset.

 Generate a new dataset containing the specified variables with
 events sampled from our distribution. Generate the specified
 number of events or else try to use expectedEvents() if nEvents <= 0.
 Any variables of this PDF that are not in whatVars will use their
 current values and be treated as fixed parameters. Returns zero
 in case of an error. The caller takes ownership of the returned
 dataset.

 Generate a new dataset with values of the whatVars variables
 sampled from our distribution. Use the specified existing dataset
 as a prototype: the new dataset will contain the same number of
 events as the prototype (by default), and any prototype variables not in
 whatVars will be copied into the new dataset for each generated
 event and also used to set our PDF parameters. The user can specify a
 number of events to generate that will override the default. The result is a
 copy of the prototype dataset with only variables in whatVars
 randomized. Variables in whatVars that are not in the prototype
 will be added as new columns to the generated dataset.  Returns
 zero in case of an error. The caller takes ownership of the
 returned dataset.

 Return lookup table with randomized access order for prototype events,
 given nProto prototype data events and nGen events that will actually
 be accessed

 Load generatedVars with the subset of directVars that we can generate events for,
 and return a code that specifies the generator algorithm we will use. A code of
 zero indicates that we cannot generate any of the directVars (in this case, nothing
 should be added to generatedVars). Any non-zero codes will be passed to our generateEvent()
 implementation, but otherwise its value is arbitrary. The default implemetation of
 this method returns zero. Subclasses will usually implement this method using the
 matchArgs() methods to advertise the algorithms they provide.

 One-time initialization to setup the generator for the specified code.

 Generate an event using the algorithm corresponding to the specified code. The
 meaning of each code is defined by the getGenerator() implementation. The default
 implementation does nothing.

 Check if PDF depends via more than route on given arg

 Plot (project) PDF on specified frame. If a PDF is plotted in an empty frame, it
 will show a unit normalized curve in the frame variable, taken at the present value
 of other observables defined for this PDF

 If a PDF is plotted in a frame in which a dataset has already been plotted, it will
 show a projected curve integrated over all variables that were present in the shown
 dataset except for the one on the x-axis. The normalization of the curve will also
 be adjusted to the event count of the plotted dataset. An informational message
 will be printed for each projection step that is performed

 This function takes the following named arguments

 Projection control
 ------------------
 Slice(const RooArgSet& set)     -- Override default projection behaviour by omittting observables listed
                                    in set from the projection, resulting a 'slice' plot. Slicing is usually
                                    only sensible in discrete observables
 Project(const RooArgSet& set)   -- Override default projection behaviour by projecting over observables
                                    given in set and complete ignoring the default projection behavior. Advanced use only.
 ProjWData(const RooAbsData& d)  -- Override default projection _technique_ (integration). For observables present in given dataset
                                    projection of PDF is achieved by constructing an average over all observable values in given set.
                                    Consult RooFit plotting tutorial for further explanation of meaning & use of this technique
 ProjWData(const RooArgSet& s,   -- As above but only consider subset 's' of observables in dataset 'd' for projection through data averaging
           const RooAbsData& d)
 ProjectionRange(const char* rn) -- Override default range of projection integrals to a different range speficied by given range name.
                                    This technique allows you to project a finite width slice in a real-valued observable

 Misc content control
 --------------------
 Normalization(Double_t scale,   -- Adjust normalization by given scale factor. Interpretation of number depends on code: Relative:
                ScaleType code)     relative adjustment factor, NumEvent: scale to match given number of events.
 Name(const chat* name)          -- Give curve specified name in frame. Useful if curve is to be referenced later
 Asymmetry(const RooCategory& c) -- Show the asymmetry of the PDF in given two-state category [F(+)-F(-)] / [F(+)+F(-)] rather than
                                    the PDF projection. Category must have two states with indices -1 and +1 or three states with
                                    indeces -1,0 and +1.
 ShiftToZero(Bool_t flag)        -- Shift entire curve such that lowest visible point is at exactly zero. Mostly useful when
                                    plotting -log(L) or chi^2 distributions
 AddTo(const char* name,         -- Add constructed projection to already existing curve with given name and relative weight factors
       double_t wgtSelf, double_t wgtOther)

 Plotting control
 ----------------
 LineStyle(Int_t style)          -- Select line style by ROOT line style code, default is solid
 LineColor(Int_t color)          -- Select line color by ROOT color code, default is blue
 LineWidth(Int_t width)          -- Select line with in pixels, default is 3
 FillStyle(Int_t style)          -- Select fill style, default is not filled. If a filled style is selected, also use VLines()
                                    to add vertical downward lines at end of curve to ensure proper closure
 FillColor(Int_t color)          -- Select fill color by ROOT color code
 Range(const char* name)         -- Only draw curve in range defined by given name
 Range(double lo, double hi)     -- Only draw curve in specified range
 VLines()                        -- Add vertical lines to y=0 at end points of curve
 Precision(Double_t eps)         -- Control precision of drawn curve w.r.t to scale of plot, default is 1e-3. Higher precision
                                    will result in more and more densely spaced curve points
 Invisble(Bool_t flag)           -- Add curve to frame, but do not display. Useful in combination AddTo()

 Get complete set of tree branch nodes

 Plot oneself on 'frame'. In addition to features detailed in  RooAbsReal::plotOn(),
 the scale factor for a PDF can be interpreted in three different ways. The interpretation
 is controlled by ScaleType

  Relative  -  Scale factor is applied on top of PDF normalization scale factor
  NumEvent  -  Scale factor is interpreted as a number of events. The surface area
               under the PDF curve will match that of a histogram containing the specified
               number of event
  Raw       -  Scale factor is applied to the raw (projected) probability density.
               Not too useful, option provided for completeness.

 THIS FUNCTION IS OBSOLETE AND ONLY RETAINED FOR BACKWARD COMPATIBILITY.
 PLEASE USE plotOn(frame,Componenents(...),...)

 Plot only the PDF components listed in 'compSet' of this PDF on 'frame'.
 See RooAbsReal::plotOn() for a description of the remaining arguments and other features

 THIS FUNCTION IS OBSOLETE AND ONLY RETAINED FOR BACKWARD COMPATIBILITY.
 PLEASE USE plotOn(frame,Componenents(...),...)

 Plot only the PDF components listed in 'compSet' of this PDF on 'frame'.
 See RooAbsReal::plotOn() for a description of the remaining arguments and other features

 Get complete set of tree branch nodes

 THIS FUNCTION IS OBSOLETE AND ONLY RETAINED FOR BACKWARD COMPATIBILITY.
 PLEASE USE plotOn(frame,Componenents(...),Slice(...),...)

 Plot ourselves on given frame, as done in plotOn(), except that the variables
 listed in 'sliceSet' are taken out from the default list of projected dimensions created
 by plotOn().

 THIS FUNCTION IS OBSOLETE AND ONLY RETAINED FOR BACKWARD COMPATIBILITY.
 PLEASE USE plotOn(frame,Componenents(...),Slice(...),...)

 Plot ourselves on given frame, as done in plotOn(), except that the variables
 listed in 'sliceSet' are taken out from the default list of projected dimensions created
 by plotOn().

 Add a box with parameter values (and errors) to the specified frame

 The following named arguments are supported

   Parameters(const RooArgSet& param) -- Only the specified subset of parameters will be shown.
                                         By default all non-contant parameters are shown
   ShowConstant(Bool_t flag)          -- Also display constant parameters
   Format(const char* optStr)         -- Classing [arameter formatting options, provided for backward compatibility
   Format(const char* what,...)       -- Parameter formatting options, details given below
   Label(const chat* label)           -- Add header label to parameter box
   Layout(Double_t xmin,              -- Specify relative position of left,right side of box and top of box. Position of
       Double_t xmax, Double_t ymax)     bottom of box is calculated automatically from number lines in box


 The Format(const char* what,...) has the following structure

   const char* what      -- Controls what is shown. "N" adds name, "E" adds error,
                            "A" shows asymmetric error, "U" shows unit, "H" hides the value
   FixedPrecision(int n) -- Controls precision, set fixed number of digits
   AutoPrecision(int n)  -- Controls precision. Number of shown digits is calculated from error
                            + n specified additional digits (1 is sensible default)

 Example use: pdf.paramOn(frame, Label("fit result"), Format("NEU",AutoPrecision(1)) ) ;

 OBSOLETE FUNCTION PROVIDED FOR BACKWARD COMPATIBILITY

 Add a text box with the current parameter values and their errors to the frame.
 Dependents of this PDF appearing in the 'data' dataset will be omitted.

 Optional label will be inserted as first line of the text box. Use 'sigDigits'
 to modify the default number of significant digits printed. The 'xmin,xmax,ymax'
 values specify the inital relative position of the text box in the plot frame

Inline Functions

                     RooPlot* plotNLLOn(RooPlot* frame, RooDataSet* data, Bool_t extended, Option_t* drawOptions = "L", Double_t prec = 1e-2, Bool_t fixMinToZero = kTRUE)
                     RooPlot* plotNLLOn(RooPlot* frame, RooDataSet* data, Bool_t extended, const RooArgSet& projDeps, Option_t* drawOptions = "L", Double_t prec = 1e-2, Bool_t fixMinToZero = kTRUE)
                     Double_t getNorm(const RooArgSet* set = 0) const
                       Bool_t selfNormalized() const
        RooAbsPdf::ExtendMode extendMode() const
                       Bool_t canBeExtended() const
                       Bool_t mustBeExtended() const
                         void verboseEval(Int_t stat)
                       Bool_t isSelectedComp() const
                         void clearEvalError()
                       Bool_t evalError()
                     RooPlot* plotOn(RooPlot* frame, RooAbsReal::PlotOpt o) const
                         void selectComp(Bool_t flag)
                         void globalSelectComp(Bool_t flag)
                         void raiseEvalError()
                      TClass* Class()
                      TClass* IsA() const
                         void ShowMembers(TMemberInspector& insp, char* parent)
                         void Streamer(TBuffer& b)
                         void StreamerNVirtual(TBuffer& b)