 |
|
Docs
RooAbsPdfclass description - source file - inheritance tree (.pdf) class RooAbsPdf : public RooAbsReal
This is an abstract class, constructors will not be documented. Look at the header to check for available constructors.
protected:
Data Members
protected:
Class DescriptionRooAbsPdf is the abstract interface for all probability density functions The class provides hybrid analytical/numerical normalization for its implementations, error tracing and a MC generator interface. A minimal implementation of a PDF class derived from RooAbsPdf should overload the evaluate() function. This functions should return PDFs value. [Normalization/Integration] Although the normalization of a PDF is an integral part of a probability density function, normalization is treated separately in RooAbsPdf. The reason is that a RooAbsPdf object is more than a PDF: it can be a building block for a more complex, composite PDF if any of its variables are functions instead of fundamentals. In such cases the normalization of the composite may not be simply the integral over the dependents of the top level PDF as these are functions with potentially non-trivial Jacobian terms themselves. Therefore --> No explicit attempt should be made to normalize the functions output in evaluate(). In addition, RooAbsPdf objects do not have a static concept of what variables are parameters and what variables are dependents (which need to be integrated over for a correct PDF normalization). Instead the choice of normalization is always specified each time a normalized values is requested from the PDF via the getVal() method. RooAbsPdf manages the entire normalization logic of each PDF with help of a RooRealIntegral object, which coordinates the integration of a given choice of normalization. By default, RooRealIntegral will perform a fully numeric integration of all dependents. However, PDFs can advertise one or more (partial) analytical integrals of their function, and these will be used by RooRealIntegral, if it determines that this is safe (i.e. no hidden Jacobian terms, multiplication with other PDFs that have one or more dependents in commen etc) To implement analytical integrals, two functions must be implemented. First, Int_t getAnalyticalIntegral(const RooArgSet& integSet, RooArgSet& anaIntSet) 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 RooArgSet* iset, 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
Double_t expectedEvents(const RooArgSet& nset) 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)
|
|
Page maintained by Wouter Verkerke and David Kirkby |
|