ROOT » ROOFIT » ROOFITCORE » RooAbsPdf

class RooAbsPdf: public RooAbsReal


 RooAbsPdf 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 variables. 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 observables]

 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 observables, 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 observables that can be generated,
 similar to the way analytical integrals are advertised. The second
 function implements the generator for the advertised observables

 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

Function Members (Methods)

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

public:
virtual~RooAbsPdf()
voidTObject::AbstractMethod(const char* method) const
Bool_tRooAbsArg::addOwnedComponents(const RooArgSet& comps)
voidRooAbsArg::addParameters(RooArgSet& params, const RooArgSet* nset = 0, Bool_t stripDisconnected = kTRUE) const
voidRooAbsArg::addServer(RooAbsArg& server, Bool_t valueProp = kTRUE, Bool_t shapeProp = kFALSE)
voidRooAbsArg::addServerList(RooAbsCollection& serverList, Bool_t valueProp = kTRUE, Bool_t shapeProp = kFALSE)
const char*RooAbsArg::aggregateCacheUniqueSuffix() const
virtual Double_tRooAbsReal::analyticalIntegral(Int_t code, const char* rangeName = 0) const
virtual Double_tanalyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName = 0) const
virtual voidTObject::AppendPad(Option_t* option = "")
TF1*RooAbsReal::asTF(const RooArgList& obs, const RooArgList& pars = RooArgList(), const RooArgSet& nset = RooArgSet()) const
voidRooAbsArg::attachDataSet(const RooAbsData& set)
voidRooAbsArg::attachDataStore(const RooAbsDataStore& set)
const set<string>&RooAbsArg::attributes() const
virtual RooAbsGenContext*autoGenContext(const RooArgSet& vars, const RooDataSet* prototype = 0, const RooArgSet* auxProto = 0, Bool_t verbose = kFALSE, Bool_t autoBinned = kTRUE, const char* binnedTag = "") const
virtual list<Double_t>*RooAbsReal::binBoundaries(RooAbsRealLValue&, Double_t, Double_t) const
RooAbsFunc*RooAbsReal::bindVars(const RooArgSet& vars, const RooArgSet* nset = 0, Bool_t clipInvalid = kFALSE) const
virtual RooAbsGenContext*binnedGenContext(const RooArgSet& vars, Bool_t verbose = kFALSE) const
voidRooAbsArg::branchNodeServerList(RooAbsCollection* list, const RooAbsArg* arg = 0, Bool_t recurseNonDerived = kFALSE) const
virtual voidTObject::Browse(TBrowser* b)
virtual const char*RooAbsArg::cacheUniqueSuffix() const
Bool_tcanBeExtended() const
virtual RooAbsArg::CacheModeRooAbsArg::canNodeBeCached() const
voidRooAbsArg::changeServer(RooAbsArg& server, Bool_t valueProp, Bool_t shapeProp)
Bool_tRooAbsArg::checkDependents(const RooArgSet* nset) const
virtual Bool_tRooAbsArg::checkObservables(const RooArgSet* nset) const
virtual RooFitResult*chi2FitTo(RooDataHist& data, const RooLinkedList& cmdList)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTNamed::Clear(Option_t* option = "")
static voidclearEvalError()
static voidRooAbsReal::clearEvalErrorLog()
voidRooAbsArg::clearShapeDirty() const
voidRooAbsArg::clearValueAndShapeDirty() const
voidRooAbsArg::clearValueDirty() const
TIterator*RooAbsArg::clientIterator() const
virtual TObject*RooAbsArg::clone(const char* newname = 0) const
virtual TObject*RooAbsArg::Clone(const char* newname = 0) const
virtual RooAbsArg*RooAbsArg::cloneTree(const char* newname = 0) const
virtual Int_tRooAbsArg::Compare(const TObject* other) const
virtual voidRooAbsArg::constOptimizeTestStatistic(RooAbsArg::ConstOpCode opcode, Bool_t doAlsoTrackingOpt = kTRUE)
virtual voidTNamed::Copy(TObject& named) const
static UInt_tRooAbsArg::crc32(const char* data)
static UInt_tRooAbsArg::crc32(const char* data, ULong_t sz, UInt_t crc = 0)
RooAbsReal*createCdf(const RooArgSet& iset, const RooArgSet& nset = RooArgSet())
RooAbsReal*createCdf(const RooArgSet& iset, const RooCmdArg& arg1, const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none())
virtual RooAbsReal*createChi2(RooDataSet& data, const RooLinkedList& cmdList)
virtual RooAbsReal*createChi2(RooDataHist& data, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none())
virtual RooAbsArg*RooAbsReal::createFundamental(const char* newname = 0) const
TH1*RooAbsReal::createHistogram(const char* name, const RooAbsRealLValue& xvar, RooLinkedList& argList) const
TH1*RooAbsReal::createHistogram(const char* varNameList, Int_t xbins = 0, Int_t ybins = 0, Int_t zbins = 0) const
TH1*RooAbsReal::createHistogram(const char* name, const RooAbsRealLValue& xvar, 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
RooAbsReal*RooAbsReal::createIntegral(const RooArgSet& iset, const char* rangeName) const
RooAbsReal*RooAbsReal::createIntegral(const RooArgSet& iset, const RooArgSet& nset, const char* rangeName = 0) const
RooAbsReal*RooAbsReal::createIntegral(const RooArgSet& iset, const RooNumIntConfig& cfg, const char* rangeName = 0) const
RooAbsReal*RooAbsReal::createIntegral(const RooArgSet& iset, const RooArgSet& nset, const RooNumIntConfig& cfg, const char* rangeName = 0) const
virtual RooAbsReal*RooAbsReal::createIntegral(const RooArgSet& iset, const RooArgSet* nset = 0, const RooNumIntConfig* cfg = 0, const char* rangeName = 0) const
RooAbsReal*RooAbsReal::createIntegral(const RooArgSet& iset, const RooCmdArg& arg1, const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none()) const
RooAbsReal*RooAbsReal::createIntRI(const RooArgSet& iset, const RooArgSet& nset = RooArgSet())
virtual RooAbsReal*createNLL(RooAbsData& data, const RooLinkedList& cmdList)
virtual RooAbsReal*createNLL(RooAbsData& data, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none())
const RooAbsReal*RooAbsReal::createPlotProjection(const RooArgSet& depVars, const RooArgSet& projVars) const
const RooAbsReal*RooAbsReal::createPlotProjection(const RooArgSet& depVars, const RooArgSet& projVars, RooArgSet*& cloneSet) const
const RooAbsReal*RooAbsReal::createPlotProjection(const RooArgSet& dependentVars, const RooArgSet* projectedVars, RooArgSet*& cloneSet, const char* rangeName = 0, const RooArgSet* condObs = 0) const
virtual RooAbsReal*RooAbsReal::createProfile(const RooArgSet& paramsOfInterest)
virtual RooAbsPdf*createProjection(const RooArgSet& iset)
RooAbsReal*RooAbsReal::createRunningIntegral(const RooArgSet& iset, const RooArgSet& nset = RooArgSet())
RooAbsReal*RooAbsReal::createRunningIntegral(const RooArgSet& iset, const RooCmdArg& arg1, const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none())
RooAbsReal*createScanCdf(const RooArgSet& iset, const RooArgSet& nset, Int_t numScanBins, Int_t intOrder)
RooAbsReal*RooAbsReal::createScanRI(const RooArgSet& iset, const RooArgSet& nset, Int_t numScanBins, Int_t intOrder)
virtual Double_tRooAbsReal::defaultErrorLevel() const
static RooNumGenConfig*defaultGeneratorConfig()
static RooNumIntConfig*RooAbsReal::defaultIntegratorConfig()
virtual Int_tRooAbsArg::defaultPrintContents(Option_t* opt) const
static ostream&RooPrintable::defaultPrintStream(ostream* os = 0)
virtual RooPrintable::StyleOptionRooPrintable::defaultPrintStyle(Option_t* opt) const
virtual voidTObject::Delete(Option_t* option = "")MENU
Bool_tRooAbsArg::dependentOverlaps(const RooAbsData* dset, const RooAbsArg& testArg) const
Bool_tRooAbsArg::dependentOverlaps(const RooArgSet* depList, const RooAbsArg& testArg) const
Bool_tRooAbsArg::dependsOn(const RooAbsCollection& serverList, const RooAbsArg* ignoreArg = 0, Bool_t valueOnly = kFALSE) const
Bool_tRooAbsArg::dependsOn(const RooAbsArg& server, const RooAbsArg* ignoreArg = 0, Bool_t valueOnly = kFALSE) const
Bool_tRooAbsArg::dependsOnValue(const RooAbsCollection& serverList, const RooAbsArg* ignoreArg = 0) const
Bool_tRooAbsArg::dependsOnValue(const RooAbsArg& server, const RooAbsArg* ignoreArg = 0) const
RooDerivative*RooAbsReal::derivative(RooRealVar& obs, Int_t order = 1, Double_t eps = 0.001)
RooDerivative*RooAbsReal::derivative(RooRealVar& obs, const RooArgSet& normSet, Int_t order, Double_t eps = 0.001)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidRooAbsReal::enableOffsetting(Bool_t)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
static Bool_tevalError()
static RooAbsReal::EvalErrorIterRooAbsReal::evalErrorIter()
static RooAbsReal::ErrorLoggingModeRooAbsReal::evalErrorLoggingMode()
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual Double_texpectedEvents(const RooArgSet* nset) const
virtual Double_texpectedEvents(const RooArgSet& nset) const
RooExpensiveObjectCache&RooAbsArg::expensiveObjectCache() const
virtual Double_textendedTerm(Double_t observedEvents, const RooArgSet* nset = 0) const
virtual RooAbsPdf::ExtendModeextendMode() const
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
RooDataHist*RooAbsReal::fillDataHist(RooDataHist* hist, const RooArgSet* nset, Double_t scaleFactor, Bool_t correctForBinVolume = kFALSE, Bool_t showProgress = kFALSE) const
TH1*RooAbsReal::fillHistogram(TH1* hist, const RooArgList& plotVars, Double_t scaleFactor = 1, const RooArgSet* projectedVars = 0, Bool_t scaling = kTRUE, const RooArgSet* condObs = 0, Bool_t setError = kTRUE) const
Bool_tRooAbsArg::findConstantNodes(const RooArgSet& observables, RooArgSet& cacheList)
Bool_tRooAbsArg::findConstantNodes(const RooArgSet& observables, RooArgSet& cacheList, RooLinkedList& processedNodes)
RooAbsArg*RooAbsArg::findNewServer(const RooAbsCollection& newSet, Bool_t nameChange) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Double_tRooAbsReal::findRoot(RooRealVar& x, Double_t xmin, Double_t xmax, Double_t yval)
RooAbsArg*RooAbsArg::findServer(const char* name) const
RooAbsArg*RooAbsArg::findServer(const RooAbsArg& arg) const
RooAbsArg*RooAbsArg::findServer(Int_t index) const
virtual RooFitResult*fitTo(RooAbsData& data, const RooLinkedList& cmdList)
virtual RooFitResult*fitTo(RooAbsData& data, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none())
virtual voidRooAbsReal::fixAddCoefNormalization(const RooArgSet& addNormSet = RooArgSet(), Bool_t force = kTRUE)
virtual voidRooAbsReal::fixAddCoefRange(const char* rangeName = 0, Bool_t force = kTRUE)
static UInt_tRooAbsArg::fnv1a32(const char* data)
static UInt_tRooAbsArg::fnv1a32(const char* data, ULong_t sz, UInt_t hash = fnv1a32start)
static ULong64_tRooAbsArg::fnv1a64(const char* data)
static ULong64_tRooAbsArg::fnv1a64(const char* data, ULong_t sz, ULong64_t hash = fnv1a64start)
virtual Bool_tRooAbsReal::forceAnalyticalInt(const RooAbsArg&) const
virtual voidRooAbsReal::forceNumInt(Bool_t flag = kTRUE)
RooFunctor*RooAbsReal::functor(const RooArgList& obs, const RooArgList& pars = RooArgList(), const RooArgSet& nset = RooArgSet()) const
virtual RooAbsGenContext*genContext(const RooArgSet& vars, const RooDataSet* prototype = 0, const RooArgSet* auxProto = 0, Bool_t verbose = kFALSE) const
RooDataSet*generate(RooAbsPdf::GenSpec&) const
RooDataSet*generate(const RooArgSet& whatVars, const RooDataSet& prototype, Int_t nEvents = 0, Bool_t verbose = kFALSE, Bool_t randProtoOrder = kFALSE, Bool_t resampleProto = kFALSE) const
RooDataSet*generate(const RooArgSet& whatVars, Int_t nEvents, const RooCmdArg& arg1, const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none())
RooDataSet*generate(const RooArgSet& whatVars, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none())
RooDataSet*generate(const RooArgSet& whatVars, Double_t nEvents = 0, Bool_t verbose = kFALSE, Bool_t autoBinned = kTRUE, const char* binnedTag = "", Bool_t expectedData = kFALSE, Bool_t extended = kFALSE) const
virtual RooDataHist*generateBinned(const RooArgSet& whatVars, Double_t nEvents, Bool_t expectedData = kFALSE, Bool_t extended = kFALSE) const
virtual RooDataHist*generateBinned(const RooArgSet& whatVars, Double_t nEvents, const RooCmdArg& arg1, const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none())
virtual RooDataHist*generateBinned(const RooArgSet& whatVars, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none())
virtual voidgenerateEvent(Int_t code)
virtual RooDataSet*generateSimGlobal(const RooArgSet& whatVars, Int_t nEvents)
virtual RooArgSet*getAllConstraints(const RooArgSet& observables, RooArgSet& constrainedParams, Bool_t stripDisconnected = kTRUE) const
virtual Int_tRooAbsReal::getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName = 0) const
virtual Int_tRooAbsReal::getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, const RooArgSet* normSet, const char* rangeName = 0) const
Bool_tRooAbsArg::getAttribute(const Text_t* name) const
RooAbsCache*RooAbsArg::getCache(Int_t index) const
RooLinkedListRooAbsArg::getCloningAncestors() const
RooArgSet*RooAbsArg::getComponents() const
virtual RooArgSet*getConstraints(const RooArgSet&, RooArgSet&, Bool_t) const
RooArgSet*RooAbsArg::getDependents(const RooArgSet& set) const
RooArgSet*RooAbsArg::getDependents(const RooAbsData* set) const
RooArgSet*RooAbsArg::getDependents(const RooArgSet* depList) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
Bool_tRooAbsReal::getForceNumInt() const
virtual Int_tgetGenerator(const RooArgSet& directVars, RooArgSet& generateVars, Bool_t staticInitOK = kTRUE) const
const RooNumGenConfig*getGeneratorConfig() const
virtual const char*TObject::GetIconName() const
const RooNumIntConfig*RooAbsReal::getIntegratorConfig() const
RooNumIntConfig*RooAbsReal::getIntegratorConfig()
virtual Double_tgetLogVal(const RooArgSet* set = 0) const
virtual Int_tRooAbsReal::getMaxVal(const RooArgSet& vars) const
virtual const char*TNamed::GetName() const
Double_tgetNorm(const RooArgSet& nset) const
virtual Double_tgetNorm(const RooArgSet* set = 0) const
const RooAbsReal*getNormIntegral(const RooArgSet& nset) const
virtual const RooAbsReal*getNormObj(const RooArgSet* set, const RooArgSet* iset, const TNamed* rangeName = 0) const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
RooArgSet*RooAbsArg::getObservables(const RooAbsData* data) const
RooArgSet*RooAbsArg::getObservables(const RooAbsData& data) const
RooArgSet*RooAbsArg::getObservables(const RooArgSet& set, Bool_t valueOnly = kTRUE) const
RooArgSet*RooAbsArg::getObservables(const RooArgSet* depList, Bool_t valueOnly = kTRUE) const
virtual Option_t*TObject::GetOption() const
RooArgSet*RooAbsArg::getParameters(const RooAbsData* data, Bool_t stripDisconnected = kTRUE) const
RooArgSet*RooAbsArg::getParameters(const RooAbsData& data, Bool_t stripDisconnected = kTRUE) const
RooArgSet*RooAbsArg::getParameters(const RooArgSet& set, Bool_t stripDisconnected = kTRUE) const
virtual RooArgSet*RooAbsArg::getParameters(const RooArgSet* depList, Bool_t stripDisconnected = kTRUE) const
const char*RooAbsReal::getPlotLabel() const
Double_tRooAbsReal::getPropagatedError(const RooFitResult& fr)
const Text_t*RooAbsArg::getStringAttribute(const Text_t* key) const
virtual const char*TNamed::GetTitle() const
TStringRooAbsReal::getTitle(Bool_t appendUnit = kFALSE) const
Bool_tRooAbsArg::getTransientAttribute(const Text_t* name) const
virtual UInt_tTObject::GetUniqueID() const
const Text_t*RooAbsReal::getUnit() const
Double_tRooAbsReal::getVal(const RooArgSet* set = 0) const
Double_tRooAbsReal::getVal(const RooArgSet& set) const
virtual Double_tgetValV(const RooArgSet* set = 0) const
RooArgSet*RooAbsArg::getVariables(Bool_t stripDisconnected = kTRUE) const
voidRooAbsArg::graphVizTree(const char* fileName, const char* delimiter = "\n", bool useTitle = false, bool useLatex = false)
voidRooAbsArg::graphVizTree(ostream& os, const char* delimiter = "\n", bool useTitle = false, bool useLatex = false)
virtual Bool_tTObject::HandleTimer(TTimer* timer)
Bool_tRooAbsArg::hasClients() const
virtual ULong_tTNamed::Hash() const
virtual Bool_tRooAbsArg::hasRange(const char*) const
static Bool_tRooAbsReal::hideOffset()
RooGenFunction*RooAbsReal::iGenFunction(RooRealVar& x, const RooArgSet& nset = RooArgSet())
RooMultiGenFunction*RooAbsReal::iGenFunction(const RooArgSet& observables, const RooArgSet& nset = RooArgSet())
virtual Bool_tRooAbsArg::importWorkspaceHook(RooWorkspace&)
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidinitGenerator(Int_t code)
virtual Bool_tRooAbsArg::inRange(const char*) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual voidRooAbsArg::ioStreamerPass2()
static voidRooAbsArg::ioStreamerPass2Finalize()
virtual TClass*IsA() const
virtual Bool_tRooAbsReal::isBinnedDistribution(const RooArgSet&) const
Bool_tRooAbsArg::isCloneOf(const RooAbsArg& other) const
Bool_tRooAbsArg::isConstant() const
virtual Bool_tRooAbsArg::isDerived() const
virtual Bool_tisDirectGenSafe(const RooAbsArg& arg) const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
virtual Bool_tRooAbsArg::isFundamental() const
virtual Bool_tRooAbsReal::isIdentical(const RooAbsArg& other, Bool_t assumeSameType = kFALSE)
virtual Bool_tRooAbsArg::isLValue() const
virtual Bool_tRooAbsReal::isOffsetting() const
Bool_tTObject::IsOnHeap() const
Bool_tRooAbsArg::isShapeDirty() const
Bool_tRooAbsArg::isShapeServer(const RooAbsArg& arg) const
Bool_tRooAbsArg::isShapeServer(const char* name) const
virtual Bool_tRooAbsArg::IsSortable() const
Bool_tRooAbsArg::isValueDirty() const
Bool_tRooAbsArg::isValueDirtyAndClear() const
Bool_tRooAbsArg::isValueOrShapeDirtyAndClear() const
Bool_tRooAbsArg::isValueServer(const RooAbsArg& arg) const
Bool_tRooAbsArg::isValueServer(const char* name) const
Bool_tTObject::IsZombie() const
voidRooAbsArg::leafNodeServerList(RooAbsCollection* list, const RooAbsArg* arg = 0, Bool_t recurseNonDerived = kFALSE) const
Bool_tRooAbsArg::localNoDirtyInhibit() const
voidRooAbsReal::logEvalError(const char* message, const char* serverValueString = 0) const
static voidRooAbsReal::logEvalError(const RooAbsReal* originator, const char* origName, const char* message, const char* serverValueString = 0)
virtual voidTNamed::ls(Option_t* option = "") const
virtual Double_tRooAbsReal::maxVal(Int_t code) const
voidTObject::MayNotUse(const char* method) const
RooAbsMoment*RooAbsReal::mean(RooRealVar& obs)
RooAbsMoment*RooAbsReal::mean(RooRealVar& obs, const RooArgSet& nset)
virtual Int_tRooAbsReal::minTrialSamples(const RooArgSet&) const
RooAbsMoment*RooAbsReal::moment(RooRealVar& obs, Int_t order, Bool_t central, Bool_t takeRoot)
RooAbsMoment*RooAbsReal::moment(RooRealVar& obs, const RooArgSet& normObs, Int_t order, Bool_t central, Bool_t takeRoot, Bool_t intNormObs)
Bool_tmustBeExtended() const
static voidRooPrintable::nameFieldLength(Int_t newLen)
const TNamed*RooAbsArg::namePtr() const
const char*normRange() const
virtual Bool_tTObject::Notify()
Int_tRooAbsArg::numCaches() const
static Int_tRooAbsReal::numEvalErrorItems()
static Int_tRooAbsReal::numEvalErrors()
Bool_tRooAbsArg::observableOverlaps(const RooAbsData* dset, const RooAbsArg& testArg) const
Bool_tRooAbsArg::observableOverlaps(const RooArgSet* depList, const RooAbsArg& testArg) const
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
virtual Double_tRooAbsReal::offset() const
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
RooAbsPdf&operator=(const RooAbsPdf&)
Bool_tRooAbsReal::operator==(Double_t value) const
virtual Bool_tRooAbsReal::operator==(const RooAbsArg& other)
RooAbsArg::OperModeRooAbsArg::operMode() const
virtual voidRooAbsArg::optimizeCacheMode(const RooArgSet& observables)
virtual voidRooAbsArg::optimizeCacheMode(const RooArgSet& observables, RooArgSet& optNodes, RooLinkedList& processedNodes)
Bool_tRooAbsArg::overlaps(const RooAbsArg& testArg, Bool_t valueOnly = kFALSE) const
const RooArgSet*RooAbsArg::ownedComponents() const
virtual voidTObject::Paint(Option_t* option = "")
virtual RooPlot*paramOn(RooPlot* frame, const RooAbsData* data, const char* label = "", Int_t sigDigits = 2, Option_t* options = "NELU", Double_t xmin = 0.5, Double_t xmax = 0.98999999999999999, Double_t ymax = 0.94999999999999996)
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*plotOn(RooPlot* frame, RooLinkedList& cmdList) const
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 list<Double_t>*RooAbsReal::plotSamplingHint(RooAbsRealLValue&, Double_t, Double_t) const
virtual RooPlot*RooAbsReal::plotSliceOn(RooPlot* frame, const RooArgSet& sliceSet, Option_t* drawOptions = "L", Double_t scaleFactor = 1., RooAbsReal::ScaleType stype = Relative, const RooAbsData* projData = 0) const
virtual voidTObject::Pop()
virtual voidRooAbsReal::preferredObservableScanOrder(const RooArgSet& obs, RooArgSet& orderedObs) const
RooAbsPdf::GenSpec*prepareMultiGen(const RooArgSet& whatVars, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none())
virtual voidRooAbsArg::Print(Option_t* options = 0) const
virtual voidRooAbsArg::printAddress(ostream& os) const
virtual voidRooAbsArg::printArgs(ostream& os) const
virtual voidRooAbsArg::printClassName(ostream& os) const
voidRooAbsArg::printCompactTree(const char* indent = "", const char* fileName = 0, const char* namePat = 0, RooAbsArg* client = 0)
voidRooAbsArg::printCompactTree(ostream& os, const char* indent = "", const char* namePat = 0, RooAbsArg* client = 0)
virtual voidRooAbsArg::printCompactTreeHook(ostream& os, const char* ind = "")
voidRooAbsArg::printComponentTree(const char* indent = "", const char* namePat = 0, Int_t nLevel = 999)
voidRooAbsArg::printDirty(Bool_t depth = kTRUE) const
static voidRooAbsReal::printEvalErrors(ostream& os = std::cout, Int_t maxPerNode = 10000000)
virtual voidRooPrintable::printExtras(ostream& os) const
virtual voidRooAbsArg::printMetaArgs(ostream&) const
virtual voidprintMultiline(ostream& os, Int_t contents, Bool_t verbose = kFALSE, TString indent = "") const
virtual voidRooAbsArg::printName(ostream& os) const
virtual voidRooPrintable::printStream(ostream& os, Int_t contents, RooPrintable::StyleOption style, TString indent = "") const
virtual voidRooAbsArg::printTitle(ostream& os) const
virtual voidRooAbsArg::printTree(ostream& os, TString indent = "") const
virtual voidprintValue(ostream& os) const
virtual Int_tTObject::Read(const char* name)
virtual Bool_tRooAbsReal::readFromStream(istream& is, Bool_t compact, Bool_t verbose = kFALSE)
Bool_tRooAbsArg::recursiveCheckDependents(const RooArgSet* nset) const
Bool_tRooAbsArg::recursiveCheckObservables(const RooArgSet* nset) const
Bool_tRooAbsArg::recursiveRedirectServers(const RooAbsCollection& newServerList, Bool_t mustReplaceAll = kFALSE, Bool_t nameChange = kFALSE, Bool_t recurseInNewSet = kTRUE)
virtual voidTObject::RecursiveRemove(TObject* obj)
Bool_tRooAbsArg::redirectServers(const RooAbsCollection& newServerList, Bool_t mustReplaceAll = kFALSE, Bool_t nameChange = kFALSE, Bool_t isRecursionStep = kFALSE)
voidRooAbsArg::registerCache(RooAbsCache& cache)
voidRooAbsArg::removeServer(RooAbsArg& server, Bool_t force = kFALSE)
voidRooAbsArg::replaceServer(RooAbsArg& oldServer, RooAbsArg& newServer, Bool_t valueProp, Bool_t shapeProp)
voidTObject::ResetBit(UInt_t f)
virtual voidresetErrorCounters(Int_t resetValue = 10)
RooAbsPdf()
RooAbsPdf(const char* name, const char* title = 0)
RooAbsPdf(const char* name, const char* title, Double_t minVal, Double_t maxVal)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
virtual Bool_tselfNormalized() const
TIterator*RooAbsArg::serverIterator() const
RooFIterRooAbsArg::serverMIterator() const
virtual voidRooAbsArg::serverNameChangeHook(const RooAbsArg*, const RooAbsArg*)
voidRooAbsArg::setAttribute(const Text_t* name, Bool_t value = kTRUE)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidRooAbsArg::setCacheAndTrackHints(RooArgSet&)
static voidRooAbsReal::setCacheCheck(Bool_t flag)
virtual Bool_tRooAbsReal::setData(RooAbsData&, Bool_t = kTRUE)
static voidRooAbsArg::setDirtyInhibit(Bool_t flag)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
static voidRooAbsReal::setEvalErrorLoggingMode(RooAbsReal::ErrorLoggingMode m)
virtual voidRooAbsArg::setExpensiveObjectCache(RooExpensiveObjectCache& cache)
voidsetGeneratorConfig()
voidsetGeneratorConfig(const RooNumGenConfig& config)
static voidRooAbsReal::setHideOffset(Bool_t flag)
voidRooAbsReal::setIntegratorConfig()
voidRooAbsReal::setIntegratorConfig(const RooNumIntConfig& config)
voidRooAbsArg::setLocalNoDirtyInhibit(Bool_t flag) const
virtual voidRooAbsArg::SetName(const char* name)
virtual voidRooAbsArg::SetNameTitle(const char* name, const char* title)
voidsetNormRange(const char* rangeName)
voidsetNormRangeOverride(const char* rangeName)
static voidTObject::SetObjectStat(Bool_t stat)
voidRooAbsArg::setOperMode(RooAbsArg::OperMode mode, Bool_t recurseADirty = kTRUE)
voidRooAbsReal::setParameterizeIntegral(const RooArgSet& paramVars)
voidRooAbsReal::setPlotLabel(const char* label)
voidRooAbsArg::setProhibitServerRedirect(Bool_t flag)
voidRooAbsArg::setShapeDirty() const
voidRooAbsArg::setStringAttribute(const Text_t* key, const Text_t* value)
virtual voidTNamed::SetTitle(const char* title = "")MENU
voidsetTraceCounter(Int_t value, Bool_t allNodes = kFALSE)
voidRooAbsArg::setTransientAttribute(const Text_t* name, Bool_t value = kTRUE)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidRooAbsReal::setUnit(const char* unit)
voidRooAbsArg::setValueDirty() const
TIterator*RooAbsArg::shapeClientIterator() const
RooFIterRooAbsArg::shapeClientMIterator() const
virtual voidShowMembers(TMemberInspector& insp) const
RooAbsMoment*RooAbsReal::sigma(RooRealVar& obs)
RooAbsMoment*RooAbsReal::sigma(RooRealVar& obs, const RooArgSet& nset)
virtual Int_tTNamed::Sizeof() const
RooNumGenConfig*specialGeneratorConfig() const
RooNumGenConfig*specialGeneratorConfig(Bool_t createOnTheFly)
RooNumIntConfig*RooAbsReal::specialIntegratorConfig() const
RooNumIntConfig*RooAbsReal::specialIntegratorConfig(Bool_t createOnTheFly)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
const map<string,string>&RooAbsArg::stringAttributes() const
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual Bool_ttraceEvalHook(Double_t value) const
Bool_ttraceEvalPdf(Double_t value) const
const set<string>&RooAbsArg::transientAttributes() const
voidRooAbsArg::treeNodeServerList(RooAbsCollection* list, const RooAbsArg* arg = 0, Bool_t doBranch = kTRUE, Bool_t doLeaf = kTRUE, Bool_t valueOnly = kFALSE, Bool_t recurseNonDerived = kFALSE) const
voidRooAbsArg::unRegisterCache(RooAbsCache& cache)
virtual voidTObject::UseCurrentStyle()
TIterator*RooAbsArg::valueClientIterator() const
RooFIterRooAbsArg::valueClientMIterator() const
static voidRooAbsArg::verboseDirty(Bool_t flag)
static intverboseEval()
static voidverboseEval(Int_t stat)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
voidRooAbsArg::wireAllCaches()
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
virtual voidRooAbsReal::writeToStream(ostream& os, Bool_t compact) const
protected:
voidRooAbsArg::attachToStore(RooAbsDataStore& store)
virtual voidRooAbsReal::attachToTree(TTree& t, Int_t bufSize = 32000)
virtual voidRooAbsReal::attachToVStore(RooVectorDataStore& vstore)
RooFitResult*RooAbsReal::chi2FitDriver(RooAbsReal& fcn, RooLinkedList& cmdList)
TStringRooAbsArg::cleanBranchName() const
virtual voidRooAbsReal::copyCache(const RooAbsArg* source, Bool_t valueOnly = kFALSE, Bool_t setValDirty = kTRUE)
RooAbsReal*RooAbsReal::createIntObj(const RooArgSet& iset, const RooArgSet* nset, const RooNumIntConfig* cfg, const char* rangeName) const
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual Double_tRooAbsReal::evaluate() const
virtual voidRooAbsReal::fillTreeBranch(TTree& t)
voidRooAbsReal::findInnerMostIntegration(const RooArgSet& allObs, RooArgSet& innerObs, const char* rangeName) const
RooDataSet*generate(RooAbsGenContext& context, const RooArgSet& whatVars, const RooDataSet* prototype, Double_t nEvents, Bool_t verbose, Bool_t randProtoOrder, Bool_t resampleProto, Bool_t skipInit = kFALSE, Bool_t extended = kFALSE) const
virtual voidRooAbsArg::getObservablesHook(const RooArgSet*, RooArgSet*) const
virtual voidRooAbsArg::getParametersHook(const RooArgSet*, RooArgSet*, Bool_t) const
RooAbsProxy*RooAbsArg::getProxy(Int_t index) const
static voidRooAbsReal::globalSelectComp(Bool_t flag)
voidRooAbsArg::graphVizAddConnections(set<pair<RooAbsArg*,RooAbsArg*> >&)
Bool_tRooAbsArg::inhibitDirty() const
TStringRooAbsReal::integralNameSuffix(const RooArgSet& iset, const RooArgSet* nset = 0, const char* rangeName = 0, Bool_t omitEmpty = kFALSE) const
Bool_tRooAbsReal::isSelectedComp() const
virtual Bool_tRooAbsReal::isValid() const
virtual Bool_tRooAbsReal::isValidReal(Double_t value, Bool_t printError = kFALSE) const
voidRooAbsReal::makeProjectionSet(const RooAbsArg* plotVar, const RooArgSet* allVars, RooArgSet& projectedVars, Bool_t silent) const
voidTObject::MakeZombie()
Bool_tRooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgProxy& a) const
Bool_tRooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgSet& set) const
Bool_tRooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgProxy& a, const RooArgProxy& b) const
Bool_tRooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgProxy& a, const RooArgProxy& b, const RooArgProxy& c) const
Bool_tRooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgProxy& a, const RooArgProxy& b, const RooArgProxy& c, const RooArgProxy& d) const
Int_tRooAbsArg::numProxies() const
virtual voidRooAbsArg::operModeHook()
virtual voidRooAbsArg::optimizeDirtyHook(const RooArgSet*)
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.65000000000000002, Double_t xmax = 0.98999999999999999, Double_t ymax = 0.94999999999999996, const RooCmdArg* formatCmd = 0)
virtual RooPlot*RooAbsReal::plotAsymOn(RooPlot* frame, const RooAbsCategoryLValue& asymCat, RooAbsReal::PlotOpt o) const
virtual RooPlot*plotOn(RooPlot* frame, RooAbsReal::PlotOpt o) const
voidRooAbsReal::plotOnCompSelect(RooArgSet* selNodes) const
RooPlot*RooAbsReal::plotOnWithErrorBand(RooPlot* frame, const RooFitResult& fr, Double_t Z, const RooArgSet* params, const RooLinkedList& argList, Bool_t method1) const
Bool_tRooAbsReal::plotSanityChecks(RooPlot* frame) const
voidRooAbsArg::printAttribList(ostream& os) const
static voidraiseEvalError()
Int_t*randomizeProtoOrder(Int_t nProto, Int_t nGen, Bool_t resample = kFALSE) const
virtual Bool_tredirectServersHook(const RooAbsCollection&, Bool_t, Bool_t, Bool_t)
voidRooAbsArg::registerProxy(RooArgProxy& proxy)
voidRooAbsArg::registerProxy(RooSetProxy& proxy)
voidRooAbsArg::registerProxy(RooListProxy& proxy)
RooAbsPdf(const RooAbsPdf& other, const char* name = 0)
voidRooAbsReal::selectComp(Bool_t flag)
virtual voidRooAbsReal::selectNormalization(const RooArgSet* depSet = 0, Bool_t force = kFALSE)
virtual voidRooAbsReal::selectNormalizationRange(const char* rangeName = 0, Bool_t force = kFALSE)
voidRooAbsArg::setProxyNormSet(const RooArgSet* nset)
voidRooAbsArg::setShapeDirty(const RooAbsArg* source) const
virtual voidRooAbsReal::setTreeBranchStatus(TTree& t, Bool_t active)
voidRooAbsArg::setValueDirty(const RooAbsArg* source) const
virtual voidRooAbsReal::syncCache(const RooArgSet* set = 0)
virtual Bool_tsyncNormalization(const RooArgSet* dset, Bool_t adjustProxies = kTRUE) const
Double_tRooAbsReal::traceEval(const RooArgSet* set) const
voidRooAbsArg::unRegisterProxy(RooArgProxy& proxy)
voidRooAbsArg::unRegisterProxy(RooSetProxy& proxy)
voidRooAbsArg::unRegisterProxy(RooListProxy& proxy)

Data Members

public:
static RooAbsArg::OperModeRooAbsArg::AClean
static RooAbsArg::OperModeRooAbsArg::ADirty
static RooAbsArg::ConstOpCodeRooAbsArg::Activate
static RooAbsArg::CacheModeRooAbsArg::Always
static RooAbsArg::OperModeRooAbsArg::Auto
static RooAbsPdf::ExtendModeCanBeExtended
static RooAbsPdf::ExtendModeCanNotBeExtended
static RooAbsReal::ErrorLoggingModeRooAbsReal::CollectErrors
static RooAbsArg::ConstOpCodeRooAbsArg::ConfigChange
static RooAbsReal::ErrorLoggingModeRooAbsReal::CountErrors
static RooAbsArg::ConstOpCodeRooAbsArg::DeActivate
static RooAbsReal::ErrorLoggingModeRooAbsReal::Ignore
static RooAbsPdf::ExtendModeMustBeExtended
static RooAbsArg::CacheModeRooAbsArg::Never
static RooAbsArg::CacheModeRooAbsArg::NotAdvised
static RooAbsReal::ScaleTypeRooAbsReal::NumEvent
static RooAbsReal::ErrorLoggingModeRooAbsReal::PrintErrors
static RooAbsReal::ScaleTypeRooAbsReal::Raw
static RooAbsReal::ScaleTypeRooAbsReal::Relative
static RooAbsReal::ScaleTypeRooAbsReal::RelativeExpected
static RooAbsArg::ConstOpCodeRooAbsArg::ValueChange
static map<RooAbsArg*,TRefArray*>RooAbsArg::_ioEvoListtemporary holding list for proxies needed in schema evolution
static stack<RooAbsArg*>RooAbsArg::_ioReadStackreading stack
static const UInt_tRooAbsArg::fnv1a32start
static const ULong64_tRooAbsArg::fnv1a64start
static RooPrintable::ContentsOptionRooPrintable::kAddress
static RooPrintable::ContentsOptionRooPrintable::kArgs
static TObject::(anonymous)TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TObject::EStatusBitsTObject::kCannotPick
static RooPrintable::ContentsOptionRooPrintable::kClassName
static RooPrintable::ContentsOptionRooPrintable::kCollectionHeader
static RooPrintable::ContentsOptionRooPrintable::kExtras
static TObject::EStatusBitsTObject::kHasUUID
static RooPrintable::StyleOptionRooPrintable::kInline
static TObject::EStatusBitsTObject::kInvalidObject
static TObject::(anonymous)TObject::kIsOnHeap
static TObject::EStatusBitsTObject::kIsReferenced
static TObject::EStatusBitsTObject::kMustCleanup
static RooPrintable::ContentsOptionRooPrintable::kName
static TObject::EStatusBitsTObject::kNoContextMenu
static TObject::(anonymous)TObject::kNotDeleted
static TObject::EStatusBitsTObject::kObjInCanvas
static TObject::(anonymous)TObject::kOverwrite
static TObject::(anonymous)TObject::kSingleKey
static RooPrintable::StyleOptionRooPrintable::kSingleLine
static RooPrintable::StyleOptionRooPrintable::kStandard
static RooPrintable::ContentsOptionRooPrintable::kTitle
static RooPrintable::StyleOptionRooPrintable::kTreeStructure
static RooPrintable::ContentsOptionRooPrintable::kValue
static RooPrintable::StyleOptionRooPrintable::kVerbose
static TObject::(anonymous)TObject::kWriteDelete
static TObject::(anonymous)TObject::kZombie
protected:
set<string>RooAbsArg::_boolAttribBoolean attributes
set<string>RooAbsArg::_boolAttribTransient! Transient boolean attributes (not copied in ctor)
Bool_tRooAbsReal::_boolValue! Transient cache for bool values from tree branches
UChar_tRooAbsReal::_byteValue! Transient cache for byte values from tree branches
static Bool_tRooAbsReal::_cacheCheckIf true, always validate contents of clean which outcome of evaluate()
deque<RooAbsCache*>RooAbsArg::_cacheListlist of caches
RooRefCountListRooAbsArg::_clientListlist of client objects
RooRefCountListRooAbsArg::_clientListShapesubset of clients that requested shape dirty flag propagation
RooRefCountListRooAbsArg::_clientListValuesubset of clients that requested value dirty flag propagation
TIterator*RooAbsArg::_clientShapeIter! Iterator over _clientListShape
TIterator*RooAbsArg::_clientValueIter! Iterator over _clientListValue
Bool_tRooAbsArg::_deleteWatch! Delete watch flag
RooExpensiveObjectCache*RooAbsArg::_eocachePointer to global cache manager for any expensive components created by this object
Int_t_errorCountNumber of errors remaining to print
static Bool_t_evalError
Bool_tRooAbsArg::_fastAllow fast access mode in getVal() and proxies
Float_tRooAbsReal::_floatValue! Transient cache for floating point values from tree branches
Bool_tRooAbsReal::_forceNumIntForce numerical integration if flag set
static Bool_tRooAbsReal::_globalSelectCompGlobal activation switch for component selection
static Bool_tRooAbsReal::_hideOffsetOffset hiding flag
static Bool_tRooAbsArg::_inhibitDirtyStatic flag controlling global inhibit of dirty state propagation
Int_tRooAbsReal::_intValue! Transient cache for integer values from tree branches
Bool_tRooAbsArg::_isConstant! Cached isConstant status
TStringRooAbsReal::_labelPlot label for objects value
RooArgSet*RooAbsReal::_lastNSet!
Bool_tRooAbsArg::_localNoInhibitDirty! Prevent 'AlwaysDirty' mode for this node
static Int_tRooPrintable::_nameLength
TNamed*RooAbsArg::_namePtr! Do not persist. Pointer to global instance of string that matches object named
Int_t_negCountNumber of negative probablities remaining to print
RooAbsReal*_norm! Normalization integral (owned by _normMgr)
RooObjCacheManager_normMgrThe cache manager
TString_normRangeNormalization range
static TString_normRangeOverride
RooArgSet*_normSet! Normalization set with for above integral
RooAbsArg::OperModeRooAbsArg::_operModeDirty state propagation mode
RooArgSet*RooAbsArg::_ownedComponents! Set of owned component
Int_tRooAbsReal::_plotBinsNumber of plot bins
Double_tRooAbsReal::_plotMaxMaximum of plot range
Double_tRooAbsReal::_plotMinMinimum of plot range
Bool_tRooAbsArg::_prohibitServerRedirect! Prohibit server redirects -- Debugging tool
RooRefArrayRooAbsArg::_proxyListlist of proxies
Double_t_rawValue
Char_tRooAbsReal::_sbyteValue! Transient cache for signed byte values from tree branches
Bool_t_selectCompComponent selection flag for RooAbsPdf::plotCompOn
Bool_tRooAbsReal::_selectComp! Component selection flag for RooAbsPdf::plotCompOn
RooRefCountListRooAbsArg::_serverListlist of server objects
Bool_tRooAbsArg::_shapeDirtyFlag set if value needs recalculating because input shapes modified
RooNumGenConfig*_specGeneratorConfig! MC generator configuration specific for this object
RooNumIntConfig*RooAbsReal::_specIntegratorConfigNumeric integrator configuration specific for this object
map<string,string>RooAbsArg::_stringAttribString attributes
Int_t_traceCountNumber of traces remaining to print
Bool_tRooAbsReal::_treeVar!do not persist
UInt_tRooAbsReal::_uintValue! Transient cache for unsigned integer values from tree branches
TStringRooAbsReal::_unitUnit for objects value
Double_tRooAbsReal::_valueCache for current value of object
Bool_tRooAbsArg::_valueDirtyFlag set if value needs recalculating because input values modified
static Bool_tRooAbsArg::_verboseDirtyStatic flag controlling verbose messaging for dirty state changes
static Int_t_verboseEval
TStringTNamed::fNameobject identifier
TStringTNamed::fTitleobject title

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

RooAbsPdf()
 Default constructor
RooAbsPdf(const char* name, const char* title = 0)
 Constructor with name and title only
RooAbsPdf(const char* name, const char* title, Double_t minVal, Double_t maxVal)
 Constructor with name, title, and plot range
RooAbsPdf(const RooAbsPdf& other, const char* name = 0)
 Copy constructor
~RooAbsPdf()
 Destructor
Double_t getValV(const RooArgSet* set = 0) const
 Return current value, normalizated by integrating over
 the observables in 'nset'. If 'nset' is 0, the unnormalized value.
 is returned. All elements of 'nset' must be lvalues

 Unnormalized values are not cached
 Doing so would be complicated as _norm->getVal() could
 spoil the cache and interfere with returning the cached
 return value. Since unnormalized calls are typically
 done in integration calls, there is no performance hit.
Double_t analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName = 0) 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* set = 0) const
 Return the integral of this PDF over all observables listed in 'nset'.
const RooAbsReal* getNormObj(const RooArgSet* set, const RooArgSet* iset, const TNamed* rangeName = 0) const
 Return pointer to RooAbsReal object that implements calculation of integral over observables iset in range
 rangeName, optionally taking the integrand normalized over observables nset
Bool_t syncNormalization(const RooArgSet* dset, Bool_t adjustProxies = kTRUE) const
 Verify that the normalization integral cached with this PDF
 is valid for given set of normalization observables

 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

 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 = 10)
 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 = kFALSE)
 Reset trace counter to given value, limiting the
 number of future trace messages for this pdf to 'value'
Double_t getLogVal(const RooArgSet* set = 0) 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(Double_t observedEvents, const RooArgSet* nset = 0) 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.
RooAbsReal* createNLL(RooAbsData& data, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none())
 Construct representation of -log(L) of PDFwith given dataset. If dataset is unbinned, an unbinned likelihood is constructed. If the dataset
 is binned, a binned likelihood is constructed.

 The following named arguments are supported

 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.
                                    Multiple comma separated range names can be specified.
 SumCoefRange(const char* name)  -- Set the range in which to interpret the coefficients of RooAddPdf components
 NumCPU(int num, int strat)      -- Parallelize NLL calculation on num CPUs

                                    Strategy 0 = RooFit::BulkPartition (Default) --> Divide events in N equal chunks
                                    Strategy 1 = RooFit::Interleave --> Process event i%N in process N. Recommended for binned data with
                                                 a substantial number of zero-bins, which will be distributed across processes more equitably in this strategy
                                    Strategy 2 = RooFit::SimComponents --> Process each component likelihood of a RooSimultaneous fully in a single process
                                                 and distribute components over processes. This approach can be benificial if normalization calculation time
                                                 dominates the total computation time of a component (since the normalization calculation must be performed
                                                 in each process in strategies 0 and 1. However beware that if the RooSimultaneous components do not share many
                                                 parameters this strategy is inefficient: as most minuit-induced likelihood calculations involve changing
                                                 a single parameter, only 1 of the N processes will be active most of the time if RooSimultaneous components
                                                 do not share many parameters
                                    Strategy 3 = RooFit::Hybrid --> Follow strategy 0 for all RooSimultaneous components, except those with less than
                                                 30 dataset entries, for which strategy 2 is followed.

 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
 Constrain(const RooArgSet&pars) -- For p.d.f.s that contain internal parameter constraint terms, only apply constraints to given subset of parameters
 ExternalConstraints(const RooArgSet& ) -- Include given external constraints to likelihood
 GlobalObservables(const RooArgSet&) -- Define the set of normalization observables to be used for the constraint terms.
                                        If none are specified the constrained parameters are used
 GlobalObservablesTag(const char* tagName) -- Define the set of normalization observables to be used for the constraint terms by a string attribute
                                              associated with pdf observables that match the given tagName
 Verbose(Bool_t flag)           -- Constrols RooFit informational messages in likelihood construction
 CloneData(Bool flag)           -- Use clone of dataset in NLL (default is true)
 Offset(Bool_t)                  -- Offset likelihood by initial value (so that starting value of FCN in minuit is zero). This
                                    can improve numeric stability in simultaneously fits with components with large likelihood values


RooAbsReal* createNLL(RooAbsData& data, const RooLinkedList& cmdList)
 Construct representation of -log(L) of PDFwith given dataset. If dataset is unbinned, an unbinned likelihood is constructed. If the dataset
 is binned, a binned likelihood is constructed.

 See RooAbsPdf::createNLL(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, 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())
 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 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.
                                    Multiple comma separated range names can be specified.
 SumCoefRange(const char* name)  -- Set the range in which to interpret the coefficients of RooAddPdf components
 NumCPU(int num, int strat)      -- Parallelize NLL calculation on num CPUs

                                    Strategy 0 = RooFit::BulkPartition (Default) --> Divide events in N equal chunks
                                    Strategy 1 = RooFit::Interleave --> Process event i%N in process N. Recommended for binned data with
                                                 a substantial number of zero-bins, which will be distributed across processes more equitably in this strategy
                                    Strategy 2 = RooFit::SimComponents --> Process each component likelihood of a RooSimultaneous fully in a single process
                                                 and distribute components over processes. This approach can be benificial if normalization calculation time
                                                 dominates the total computation time of a component (since the normalization calculation must be performed
                                                 in each process in strategies 0 and 1. However beware that if the RooSimultaneous components do not share many
                                                 parameters this strategy is inefficient: as most minuit-induced likelihood calculations involve changing
                                                 a single parameter, only 1 of the N processes will be active most of the time if RooSimultaneous components
                                                 do not share many parameters
                                    Strategy 3 = RooFit::Hybrid --> Follow strategy 0 for all RooSimultaneous components, except those with less than
                                                 30 dataset entries, for which strategy 2 is followed.

 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
 Constrained()                   -- Apply all constrained contained in the p.d.f. in the likelihood
 Contrain(const RooArgSet&pars)  -- Apply constraints to listed parameters in likelihood using internal constrains in p.d.f
 GlobalObservables(const RooArgSet&) -- Define the set of normalization observables to be used for the constraint terms.
                                        If none are specified the constrained parameters are used
 ExternalConstraints(const RooArgSet& ) -- Include given external constraints to likelihood
 Offset(Bool_t)                  -- Offset likelihood by initial value (so that starting value of FCN in minuit is zero). This
                                    can improve numeric stability in simultaneously fits with components with large likelihood values

 Options to control flow of fit procedure


 Minimizer(type,algo)           -- Choose minimization package and algorithm to use. Default is MINUIT/MIGRAD through the RooMinimizer
                                   interface, but others can be specified (through RooMinimizer interface). Select OldMinuit to use
                                   MINUIT through the old RooMinuit interface

                                          Type         Algorithm
                                          ------       ---------
                                          OldMinuit    migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
                                          Minuit       migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
                                          Minuit2      migrad, simplex, minimize, scan
                                          GSLMultiMin  conjugatefr, conjugatepr, bfgs, bfgs2, steepestdescent
                                          GSLSimAn     -


 InitialHesse(Bool_t flag)      -- Flag controls if HESSE before MIGRAD as well, off by default
 Optimize(Bool_t flag)          -- Activate constant term optimization of test statistic during minimization (on 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, off 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.

 SumW2Error(Bool_t flag)        -- Apply correaction to errors and covariance matrix using sum-of-weights covariance matrix
                                   to obtain correct error for weighted likelihood fits. If this option is activated the
                                   corrected covariance matrix is calculated as Vcorr = V C-1 V, where V is the original
                                   covariance matrix and C is the inverse of the covariance matrix calculated using the
                                   weights squared

 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
 Warnings(Bool_t flag)          -- Enable or disable MINUIT warnings (enabled by default)
 PrintEvalErrors(Int_t numErr)  -- Control number of p.d.f evaluation errors printed per likelihood evaluation. A negative
                                   value suppress output completely, a zero value will only print the error count per p.d.f component,
                                   a positive value is will print details of each error up to numErr messages per p.d.f component.


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* chi2FitTo(RooDataHist& data, const RooLinkedList& cmdList)
 Internal back-end function to steer chi2 fits
RooAbsReal* createChi2(RooDataHist& data, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none())
 Create a chi-2 from a histogram and this function.

 The following named arguments are supported

  Options to control construction of the chi^2

  Extended()   -- Use expected number of events of an extended p.d.f as normalization
  DataError()  -- Choose between Expected error [RooAbsData::Expected] , or Observed error (e.g. Sum-of-weights [RooAbsData:SumW2] or Poisson interval [RooAbsData::Poisson] )
                  Default is AUTO : Expected error for unweighted data, Sum-of-weights for weighted data
  NumCPU()     -- Activate parallel processing feature
  Range()      -- Fit only selected region
  SumCoefRange() -- Set the range in which to interpret the coefficients of RooAddPdf components
  SplitRange() -- Fit range is split by index catory of simultaneous PDF
  ConditionalObservables() -- Define projected observables
RooAbsReal* createChi2(RooDataSet& data, const RooLinkedList& cmdList)
 Internal back-end function to create a chi^2 from a p.d.f. and a dataset
void printValue(ostream& os) const
 Print value of p.d.f, also print normalization integral that was last used, if any
void printMultiline(ostream& os, Int_t contents, Bool_t verbose = kFALSE, TString indent = "") const
 Print multi line detailed information of this RooAbsPdf
RooAbsGenContext* binnedGenContext(const RooArgSet& vars, Bool_t verbose = kFALSE) const
 Return a binned generator context
RooAbsGenContext* genContext(const RooArgSet& vars, const RooDataSet* prototype = 0, const RooArgSet* auxProto = 0, Bool_t verbose = kFALSE) const
 Interface function to create a generator context from a p.d.f. This default
 implementation returns a 'standard' context that works for any p.d.f
RooAbsGenContext* autoGenContext(const RooArgSet& vars, const RooDataSet* prototype = 0, const RooArgSet* auxProto = 0, Bool_t verbose = kFALSE, Bool_t autoBinned = kTRUE, const char* binnedTag = "") const
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())
 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

 Name(const char* name)             -- Name of the output dataset
 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
 AutoBinned(Bool_t flag)            -- Automatically deploy binned generation for binned distributions (e.g. RooHistPdf, sums and products of RooHistPdfs etc)
                                       NB: Datasets that are generated in binned mode are returned as weighted unbinned datasets

 GenBinned(const char* tag)         -- Use binned generation for all component pdfs that have 'setAttribute(tag)' set
 AllBinned()                        -- As above, but for all components.

                                       Note that the notion of components is only meaningful for simultaneous pdf
                                       as binned generation is always executed at the top-level node for a regular
                                       pdf, so for those it only mattes that the top-level node is tagged.

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

 Name(const char* name)             -- Name of the output dataset
 Verbose(Bool_t flag)               -- Print informational messages during event generation
 NumEvent(int nevt)                 -- Generate specified number of events

 AutoBinned(Bool_t flag)            -- Automatically deploy binned generation for binned distributions (e.g. RooHistPdf, sums and products of RooHistPdfs etc)
                                       NB: Datasets that are generated in binned mode are returned as weighted unbinned datasets

 GenBinned(const char* tag)         -- Use binned generation for all component pdfs that have 'setAttribute(tag)' set
 AllBinned()                        -- As above, but for all components.

                                       Note that the notion of components is only meaningful for simultaneous pdf
                                       as binned generation is always executed at the top-level node for a regular
                                       pdf, so for those it only mattes that the top-level node is tagged.

                                       Binned generation cannot be used when prototype data is supplied
 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
                 Bool_t resample)      if the requested number of events to be generated does not match the
                                       number of events in the prototype dataset. If resample is also set to
                                       true, the prototype dataset will be resampled rather than be strictly
                                       reshuffled. In this mode events of the protodata may be used more than
                                       once.

 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(RooAbsPdf::GenSpec& ) const
 Generate data according to a pre-configured specification created by
 RooAbsPdf::prepareMultiGen(). If many identical generation requests
 are needed, e.g. in toy MC studies, it is more efficient to use the prepareMultiGen()/generate()
 combination than calling the standard generate() multiple times as
 initialization overhead is only incurred once.
RooDataSet * generate(const RooArgSet& whatVars, Double_t nEvents = 0, Bool_t verbose = kFALSE, Bool_t autoBinned = kTRUE, const char* binnedTag = "", Bool_t expectedData = kFALSE, Bool_t extended = kFALSE) const
 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(RooAbsGenContext& context, const RooArgSet& whatVars, const RooDataSet* prototype, Double_t nEvents, Bool_t verbose, Bool_t randProtoOrder, Bool_t resampleProto, Bool_t skipInit = kFALSE, Bool_t extended = kFALSE) const
 Internal method
RooDataSet * generate(const RooArgSet& whatVars, const RooDataSet& prototype, Int_t nEvents = 0, Bool_t verbose = kFALSE, Bool_t randProtoOrder = kFALSE, Bool_t resampleProto = kFALSE) const
 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 nGen, Bool_t resample = kFALSE) 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& generateVars, Bool_t staticInitOK = kTRUE) 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)
 Interface for one-time initialization to setup the generator for the specified code.
void generateEvent(Int_t code)
 Interface for generation of anan 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 given observable can be safely generated using the
 pdfs internal generator mechanism (if that existsP). Observables
 on which a PDF depends via more than route are not safe
 for use with internal generators because they introduce
 correlations not known to the internal generator
RooDataHist * generateBinned(const RooArgSet& whatVars, Double_t nEvents, const RooCmdArg& arg1, const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none())
 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

 Name(const char* name)             -- Name of the output dataset
 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
 ExpectedData()                     -- Return a binned dataset _without_ statistical fluctuations (also aliased as Asimov())
RooDataHist * generateBinned(const RooArgSet& whatVars, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none())
 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

 Name(const char* name)             -- Name of the output dataset
 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
 ExpectedData()                     -- Return a binned dataset _without_ statistical fluctuations (also aliased as Asimov())
RooDataHist * generateBinned(const RooArgSet& whatVars, Double_t nEvents, Bool_t expectedData = kFALSE, Bool_t extended = kFALSE) 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.

 If expectedData is kTRUE (it is kFALSE by default), the returned histogram returns the 'expected'
 data sample, i.e. no statistical fluctuations are present.

 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* generateSimGlobal(const RooArgSet& whatVars, Int_t nEvents)
 Special generator interface for generation of 'global observables' -- for RooStats tools
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
 NormRange(const char* name)     -- Calculate curve normalization w.r.t. only in specified ranges. NB: A Range() by default implies a NormRange()
                                    on the same range, but this option allows to override the default, or specify a normalization ranges
                                    when the full curve is to be drawn

 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
                                    A negative precision value will disable adaptive point spacing and restrict sampling to
                                    the grid point of points defined by the binning of the plotted observabled (recommended for
                                    expensive functions such as profile likelihoods)
 Invisble(Bool_t flag)           -- Add curve to frame, but do not display. Useful in combination AddTo()
RooPlot* plotOn(RooPlot* frame, RooAbsReal::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* 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())
 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
   ShowConstants(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 = 2, Option_t* options = "NELU", Double_t xmin = 0.5, Double_t xmax = 0.98999999999999999, Double_t ymax = 0.94999999999999996)
 OBSOLETE FUNCTION PROVIDED FOR BACKWARD COMPATIBILITY
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.65000000000000002, Double_t xmax = 0.98999999999999999, Double_t ymax = 0.94999999999999996, const RooCmdArg* formatCmd = 0)
 Add a text box with the current parameter values and their errors to the frame.
 Observables 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
Double_t expectedEvents(const RooArgSet* nset) const
 Return expected number of events from this p.d.f for use in extended
 likelihood calculations. This default implementation returns zero
void verboseEval(Int_t stat)
 Change global level of verbosity for p.d.f. evaluations
Int_t verboseEval()
 Return global level of verbosity for p.d.f. evaluations
RooAbsPdf* createProjection(const RooArgSet& iset)
 Return a p.d.f that represent a projection of this p.d.f integrated over given observables
RooAbsReal* createCdf(const RooArgSet& iset, const RooArgSet& nset = RooArgSet())
 Create a cumulative distribution function of this p.d.f in terms
 of the observables listed in iset. If no nset argument is given
 the c.d.f normalization is constructed over the integrated
 observables, so that its maximum value is precisely 1. It is also
 possible to choose a different normalization for
 multi-dimensional p.d.f.s: eg. for a pdf f(x,y,z) one can
 construct a partial cdf c(x,y) that only when integrated itself
 over z results in a maximum value of 1. To construct such a cdf pass
 z as argument to the optional nset argument
RooAbsReal* createCdf(const RooArgSet& iset, const RooCmdArg& arg1, const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none(), const RooCmdArg& arg7 = RooCmdArg::none(), const RooCmdArg& arg8 = RooCmdArg::none())
 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

 SupNormSet(const RooArgSet&)         -- Observables over which should be normalized _in_addition_ to the
                                         integration observables
 ScanNumCdf()                         -- Apply scanning technique if cdf integral involves numeric integration [ default ]
 ScanAllCdf()                         -- Always apply scanning technique
 ScanNoCdf()                          -- Never apply scanning technique
 ScanParameters(Int_t nbins,          -- Parameters for scanning technique of making CDF: number
                Int_t intOrder)          of sampled bins and order of interpolation applied on numeric cdf
RooAbsReal* createScanCdf(const RooArgSet& iset, const RooArgSet& nset, Int_t numScanBins, Int_t intOrder)
RooArgSet* getAllConstraints(const RooArgSet& observables, RooArgSet& constrainedParams, Bool_t stripDisconnected = kTRUE) const
 This helper function finds and collects all constraints terms of all coponent p.d.f.s
 and returns a RooArgSet with all those terms
void clearEvalError()
 Clear the evaluation error flag
Bool_t evalError()
 Return the evaluation error flag
void raiseEvalError()
 Raise the evaluation error flag
RooNumGenConfig* defaultGeneratorConfig()
 Returns the default numeric MC generator configuration for all RooAbsReals
RooNumGenConfig* specialGeneratorConfig() const
 Returns the specialized integrator configuration for _this_ RooAbsReal.
 If this object has no specialized configuration, a null pointer is returned
RooNumGenConfig* specialGeneratorConfig(Bool_t createOnTheFly)
 Returns the specialized integrator configuration for _this_ RooAbsReal.
 If this object has no specialized configuration, a null pointer is returned,
 unless createOnTheFly is kTRUE in which case a clone of the default integrator
 configuration is created, installed as specialized configuration, and returned
const RooNumGenConfig* getGeneratorConfig() const
 Return the numeric MC generator configuration used for this object. If
 a specialized configuration was associated with this object, that configuration
 is returned, otherwise the default configuration for all RooAbsReals is returned
void setGeneratorConfig(const RooNumGenConfig& config)
 Set the given configuration as default numeric MC generator
 configuration for this object
void setGeneratorConfig()
 Remove the specialized numeric MC generator configuration associated
 with this object
void setNormRange(const char* rangeName)
void setNormRangeOverride(const char* rangeName)
GenSpec* prepareMultiGen(const RooArgSet& whatVars, const RooCmdArg& arg1 = RooCmdArg::none(), const RooCmdArg& arg2 = RooCmdArg::none(), const RooCmdArg& arg3 = RooCmdArg::none(), const RooCmdArg& arg4 = RooCmdArg::none(), const RooCmdArg& arg5 = RooCmdArg::none(), const RooCmdArg& arg6 = RooCmdArg::none())
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
RooArgSet* getConstraints(const RooArgSet& , RooArgSet& , Bool_t ) const
 Constraint management
Double_t getNorm(const RooArgSet& nset) const
 Get p.d.f normalization term needed for observables 'nset'
Bool_t selfNormalized() const
 If true, p.d.f is taken as self-normalized and no attempt is made to add a normalization term
 This default implementation return false
ExtendMode extendMode() const
 Returns ability of p.d.f to provided extended likelihood terms. Possible
 answers are CanNotBeExtended, CanBeExtended or MustBeExtended. This
 default implementation always return CanNotBeExtended
Bool_t canBeExtended() const
 If true p.d.f can provide extended likelihood term
Bool_t mustBeExtended() const
 If true p.d.f must extended likelihood term
Double_t expectedEvents(const RooArgSet* nset) const
const char* normRange() const
const RooAbsReal* getNormIntegral(const RooArgSet& nset) const
{ return getNormObj(0,&nset,0) ; }
Bool_t redirectServersHook(const RooAbsCollection& , Bool_t , Bool_t , Bool_t )
 Hook function intercepting redirectServer calls. Discard current normalization
 object if any server is redirected