library: libRooFit #include "RooAbsPdf.h"

# RooAbsPdf

class description - source file - inheritance tree (.pdf)

## class RooAbsPdf : public RooAbsReal

| Inheritance Chart:

`TObject`

<-

`TNamed`

`RooPrintable`

<-

`RooAbsArg`

<-

`RooAbsReal`

<-

`RooAbsPdf`

<-

`Roo2DKeysPdf` |

`RooAbsAnaConvPdf`

<-

`RooBCPEffDecay` |

`RooBCPGenDecay` |

`RooBDecay` |

`RooBMixDecay` |

`RooDecay` |

`RooNonCPEigenDecay` |

`RooAddPdf` |

`RooArgusBG` |

[more...]

This is an abstract class, constructors will not be documented.
Look at the header to check for available constructors.

        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

~RooAbsPdf()

     Destructor
    if (_norm) delete _norm ;

Double_t getVal(const RooArgSet* nset) const

     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

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

     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

Bool_t traceEvalPdf(Double_t value) const

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

Double_t getNorm(const RooArgSet* nset) const

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

const RooAbsReal* getNormObj(const RooArgSet* nset, const TNamed* rangeName) const

     Check normalization is already stored

Bool_t syncNormalizationPreHook(RooAbsReal*,const RooArgSet*) const

void syncNormalizationPostHook(RooAbsReal*,const RooArgSet*) const

Bool_t syncNormalization(const RooArgSet* nset, Bool_t adjustProxies) const

     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

Bool_t traceEvalHook(Double_t value) const

     WVE 08/21/01 Probably obsolete now.

void resetErrorCounters(Int_t resetValue)

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

void setTraceCounter(Int_t value, Bool_t allNodes)

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

void operModeHook()

     WVE 08/21/01 Probably obsolete now

Double_t getLogVal(const RooArgSet* nset) const

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

Double_t extendedTerm(UInt_t observed, const RooArgSet* nset) const

     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.

RooFitResult* fitTo(RooAbsData& data, RooCmdArg arg1, RooCmdArg arg2, RooCmdArg arg3, RooCmdArg arg4, RooCmdArg arg5, RooCmdArg arg6, RooCmdArg arg7, RooCmdArg arg8)

     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

RooFitResult* fitTo(RooAbsData& data, const RooLinkedList& cmdList)

     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

RooFitResult* fitTo(RooAbsData& data, Option_t *fitOpt, Option_t *optOpt, const char* fitRange)

RooFitResult* fitTo(RooAbsData& data, const RooArgSet& projDeps, Option_t *fitOpt, Option_t *optOpt, const char* fitRange)

     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.

void printToStream(ostream& os, PrintOption opt, TString indent) const

     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

RooAbsGenContext* genContext(const RooArgSet &vars, const RooDataSet *prototype, const RooArgSet* auxProto, Bool_t verbose) const

RooDataSet* generate(const RooArgSet& whatVars, Int_t nEvents, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5)

     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.

RooDataSet* generate(const RooArgSet& whatVars, const RooCmdArg& arg1,const RooCmdArg& arg2, const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5,const RooCmdArg& arg6)

     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.

RooDataSet* generate(const RooArgSet &whatVars, Int_t nEvents, Bool_t verbose) const

     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.

RooDataSet* generate(const RooArgSet &whatVars, const RooDataSet &prototype, Int_t nEvents, Bool_t verbose, Bool_t randProtoOrder) const

     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.

Int_t* randomizeProtoOrder(Int_t nProto, Int_t) const

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

Int_t getGenerator(const RooArgSet &/*directVars*/, RooArgSet &/*generatedVars*/, Bool_t /*staticInitOK*/) const

     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.

void initGenerator(Int_t /*code*/)

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

void generateEvent(Int_t /*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.

Bool_t isDirectGenSafe(const RooAbsArg& arg) const

     Check if PDF depends via more than route on given arg

RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const

     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()

void plotOnCompSelect(RooArgSet* selNodes) const

     Get complete set of tree branch nodes

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

     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.

RooPlot* plotCompOn(RooPlot *frame, const RooArgSet& compSet, Option_t* drawOptions, Double_t scaleFactor, ScaleType stype, const RooAbsData* projData, const RooArgSet* projSet) const

     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

RooPlot* plotCompOn(RooPlot *frame, const char* compNameList, Option_t* drawOptions, Double_t scaleFactor, ScaleType stype, const RooAbsData* projData, const RooArgSet* projSet) const

     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

RooPlot* plotCompOnEngine(RooPlot *frame, RooArgSet* selNodes, Option_t* drawOptions, Double_t scaleFactor, ScaleType stype, const RooAbsData* projData, const RooArgSet* projSet) const

     Get complete set of tree branch nodes

RooPlot* plotCompSliceOn(RooPlot *frame, const char* compNameList, const RooArgSet& sliceSet, Option_t* drawOptions, Double_t scaleFactor, ScaleType stype, const RooAbsData* projData) const

     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().

RooPlot* plotCompSliceOn(RooPlot *frame, const RooArgSet& compSet, const RooArgSet& sliceSet, Option_t* drawOptions, Double_t scaleFactor, ScaleType stype, const RooAbsData* projData) const

     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().

RooPlot* paramOn(RooPlot* frame, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)

     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)) ) ;

RooPlot* paramOn(RooPlot* frame, const RooAbsData* data, const char *label, Int_t sigDigits, Option_t *options, Double_t xmin, Double_t xmax ,Double_t ymax)

     OBSOLETE FUNCTION PROVIDED FOR BACKWARD COMPATIBILITY

RooPlot* paramOn(RooPlot* frame, const RooArgSet& params, Bool_t showConstants, const char *label, Int_t sigDigits, Option_t *options, Double_t xmin, Double_t xmax ,Double_t ymax, const RooCmdArg* formatCmd)

     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

void fixAddCoefNormalization(const RooArgSet& addNormSet)

void fixAddCoefRange(const char* rangeName)

RooPlot* plotNLLOn(RooPlot* frame, RooDataSet* data, Bool_t extended, const RooArgSet& /*projDeps*/, Option_t* /*drawOptions*/, Double_t prec, Bool_t fixMinToZero)

Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t /*isRecursive*/)

Double_t expectedEvents(const RooArgSet*) const

### 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)

Last update: Tue Jun 28 18:09:50 2005
Copyright (c) 2000-2005, Regents of the University of California *