RooAbsReal

 Equality operator comparing to a Double_t

 Return this variable's title string. If appendUnit is true and
 this variable has units, also append a string " (<unit>)".

 Return value of object. Calculated if dirty, otherwise cached value is returned.

 And update cache (so that we see the difference)
Double_t RooAbsReal::traceEval(const RooArgSet* /*nset*/) const
 Calculate current value of object, with error tracing wrapper

{
 Default implementation of getAnalyticalIntegralWN for real valued objects defers to
 normalization invariant getAnalyticalIntegral()
return _forceNumInt ? 0 : getAnalyticalIntegral(allDeps,analDeps,rangeName) ;
}


Int_t RooAbsReal::getAnalyticalIntegral(RooArgSet& /*allDeps*/, RooArgSet& /*analDeps*/, const char* /*rangeName*/) const

 Default implementation of analyticalIntegralWN handles only the pass-through
 scenario (code =0). All other codes are deferred to to the normalization
 invariant analyticalIntegral()

 Get the label associated with the variable

 Set the label associated with this variable

 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

 Set minimum value of output associated with this object

 Set maximum value of output associated with this object

 Set a new plot range

 Check if given value is in the min-max range for this object

 Check if current value is valid

 Create an object that represents the integral of the function over one or more observables listed in iset
 The actual integration calculation is only performed when the return object is evaluated. The name
 of the integral object is automatically constructed from the name of the input function, the variables
 it integrates and the range integrates over

 The following named arguments are accepted

 NormSet(const RooArgSet&)            -- Specify normalization set, mostly useful when working with PDFS
 NumIntConfig(const RooNumIntConfig&) -- Use given configuration for any numeric integration, if necessary
 Range(const char* name)              -- Integrate only over given range. Multiple ranges may be specified
                                         by passing multiple Range() arguments

 Create a new object G that represents the normalized projection:

             Integral [ F[x,y,p] , { y } ]
  G[x,p] = ---------------------------------
            Integral [ F[x,y,p] , { x,y } ]

 where F[x,y,p] is the function we represent, "x" are the
 specified dependentVars, "y" are the specified projectedVars, and
 "p" are our remaining variables ("parameters"). Return a
 pointer to the newly created object, or else zero in case of an
 error.  The caller is responsible for deleting the contents of
 cloneSet (which includes the returned projection object) whatever
 the return value. Note that you should normally call getVal()
 on the returned object, without providing any set of normalization
 variables. Otherwise you are requesting an additional normalization
 beyond what is already specified in the equation above.

 Loop over the bins of the input histogram and add an amount equal to our value evaluated
 at the bin center to each one. Our value is calculated by first integrating out any variables
 in projectedVars and then scaling the result by scaleFactor. Returns a pointer to the
 input histogram, or zero in case of an error. The input histogram can be any TH1 subclass, and
 therefore of arbitrary dimension. Variables are matched with the (x,y,...) dimensions of the input
 histogram according to the order in which they appear in the input plotVars list.

 Create and fill a ROOT histogram TH1,TH2 or TH3 with the values of this function.

 This function accepts the following arguments

 name -- Name of the ROOT histogram
 xvar -- Observable to be mapped on x axis of ROOT histogram

 Binning(const char* name)                    -- Apply binning with given name to x axis of histogram
 Binning(RooAbsBinning& binning)              -- Apply specified binning to x axis of histogram
 Binning(double lo, double hi, int nbins)     -- Apply specified binning to x axis of histogram
 ConditionalObservables(const RooArgSet& set) -- Do not normalized PDF over following observables when projecting PDF into histogram

 YVar(const RooAbsRealLValue& var,...)    -- Observable to be mapped on y axis of ROOT histogram
 ZVar(const RooAbsRealLValue& var,...)    -- Observable to be mapped on z axis of ROOT histogram

 The YVar() and ZVar() arguments can be supplied with optional Binning() arguments to control the binning of the Y and Z axes, e.g.
 createHistogram("histo",x,Binning(-1,1,20), YVar(y,Binning(-1,1,30)), ZVar(z,Binning("zbinning")))

 The caller takes ownership of the returned histogram

 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
 ----------------
 DrawOption(const char* opt)     -- Select ROOT draw option for resulting TGraph object
 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()

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

 Plot asymmetry of ourselves, defined as

   asym = f(asymCat=-1) - f(asymCat=+1) / ( f(asymCat=-1) + f(asymCat=+1) )

 on frame. If frame contains a histogram, all dimensions of the plotted
 asymmetry function that occur in the previously plotted dataset are projected via partial integration.
 Otherwise no projections are performed,

 The asymmetry function can be multiplied with an optional scale factor. The default projection
 behaviour can be overriden by supplying an optional set of dependents to project.

 Perform general sanity check on frame to ensure safe plotting operations

 Construct the set of dependents to project when plotting ourselves as function
 of 'plotVar'. 'allVars' is the list of variables that must be projected, but
 may contain variables that we do not depend on. If 'silent' is cleared,
 warnings about inconsistent input parameters will be printed.

 Create an interface adaptor f(vars) that binds us to the specified variables
 (in arbitrary order). For example, calling bindVars({x1,x3}) on an object
 F(x1,x2,x3,x4) returns an object f(x1,x3) that is evaluated using the
 current values of x2 and x4. The caller takes ownership of the returned adaptor.

 Copy the cached value of another RooAbsArg to our cache

 Attach object to a branch of given TTree

 Attach object to a branch of given TTree

 (De)Activate associate tree branch

 Create a RooRealVar fundamental object with our properties. The new
 object will be created without any fit limits.

 Wrapper function for matchArgsByName()

 Wrapper function for matchArgsByName()

 Wrapper function for matchArgsByName()

 Wrapper function for matchArgsByName()

 Wrapper function for matchArgsByName()

 Check if allArgs contains matching elements for each name in nameList. If it does,
 add the corresponding args from allArgs to matchedArgs and return kTRUE. Otherwise
 return kFALSE and do not change matchedArgs.

 optimizeDirty must have been run first!

 Delete the cache

 Find branch PDFs with all-constant parameters, and add them
 to the dataset cache list

 Optimized accept/reject generator support

 Plotting options

 I/O streaming interface (machine readable)

 Function evaluation and error tracing

 Dirty-state and constant term optimization used
 in RooAbsOptGoodnessOfFit and RooDataProjBinding