ROOT » ROOFIT » ROOFIT » RooLognormal

class RooLognormal: public RooAbsPdf
RooFit Lognormal PDF. The two parameters are: - m0: the median of the distribution - k=exp(sigma): sigma is called the shape parameter in the TMath parametrization Lognormal(x,m0,k) = 1/(sqrt(2*pi)*ln(k)*x)*exp(-ln^2(x/m0)/(2*ln^2(k))) The parametrization here is physics driven and differs from the ROOT::Math::lognormal_pdf(x,m,s,x0) with: - m = log(m0) - s = log(k) - x0 = 0 







Function Members (Methods)


public:



 virtual~RooLognormal()


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_tanalyticalIntegral(Int_t code, const char* rangeName = 0) const


virtual Double_tRooAbsPdf::analyticalIntegralWN(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 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


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_tRooAbsPdf::canBeExtended() 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*RooAbsPdf::chi2FitTo(RooDataHist& data, const RooLinkedList& cmdList)


static TClass*Class()


virtual const char*TObject::ClassName() const


virtual voidTNamed::Clear(Option_t* option = "")


static voidRooAbsPdf::clearEvalError()


static voidRooAbsReal::clearEvalErrorLog()


voidRooAbsArg::clearShapeDirty() const


voidRooAbsArg::clearValueAndShapeDirty() const


voidRooAbsArg::clearValueDirty() const


TIterator*RooAbsArg::clientIterator() const


virtual TObject*clone(const char* newname) 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*RooAbsPdf::createCdf(const RooArgSet& iset, const RooArgSet& nset = RooArgSet())


RooAbsReal*RooAbsPdf::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*RooAbsPdf::createChi2(RooDataSet& data, const RooLinkedList& cmdList)


virtual RooAbsReal*RooAbsPdf::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*RooAbsPdf::createNLL(RooAbsData& data, const RooLinkedList& cmdList)


virtual RooAbsReal*RooAbsPdf::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*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*RooAbsPdf::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*RooAbsPdf::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_tRooAbsPdf::evalError()


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_tRooAbsPdf::expectedEvents(const RooArgSet* nset) const


virtual Double_tRooAbsPdf::expectedEvents(const RooArgSet& nset) const


RooExpensiveObjectCache&RooAbsArg::expensiveObjectCache() const


virtual Double_tRooAbsPdf::extendedTerm(Double_t observedEvents, const RooArgSet* nset = 0) const


virtual RooAbsPdf::ExtendModeRooAbsPdf::extendMode() 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*RooAbsPdf::fitTo(RooAbsData& data, const RooLinkedList& cmdList)


virtual RooFitResult*RooAbsPdf::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


RooDataSet*RooAbsPdf::generate(RooAbsPdf::GenSpec&) const


RooDataSet*RooAbsPdf::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*RooAbsPdf::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*RooAbsPdf::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*RooAbsPdf::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*RooAbsPdf::generateBinned(const RooArgSet& whatVars, Double_t nEvents, Bool_t expectedData = kFALSE, Bool_t extended = kFALSE) const


virtual RooDataHist*RooAbsPdf::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*RooAbsPdf::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*RooAbsPdf::generateSimGlobal(const RooArgSet& whatVars, Int_t nEvents)


virtual RooArgSet*RooAbsPdf::getAllConstraints(const RooArgSet& observables, RooArgSet& constrainedParams, Bool_t stripDisconnected = kTRUE) const


virtual Int_tgetAnalyticalIntegral(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*RooAbsPdf::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*RooAbsPdf::getGeneratorConfig() const


virtual const char*TObject::GetIconName() const


const RooNumIntConfig*RooAbsReal::getIntegratorConfig() const


RooNumIntConfig*RooAbsReal::getIntegratorConfig()


virtual Double_tRooAbsPdf::getLogVal(const RooArgSet* set = 0) const


virtual Int_tRooAbsReal::getMaxVal(const RooArgSet& vars) const


virtual const char*TNamed::GetName() const


Double_tRooAbsPdf::getNorm(const RooArgSet& nset) const


virtual Double_tRooAbsPdf::getNorm(const RooArgSet* set = 0) const


const RooAbsReal*RooAbsPdf::getNormIntegral(const RooArgSet& nset) const


virtual const RooAbsReal*RooAbsPdf::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_tRooAbsPdf::getValV(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 voidRooAbsPdf::initGenerator(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_tRooAbsPdf::isDirectGenSafe(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_tRooAbsPdf::mustBeExtended() const


static voidRooPrintable::nameFieldLength(Int_t newLen)


const TNamed*RooAbsArg::namePtr() const


const char*RooAbsPdf::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)


RooLognormal&operator=(const RooLognormal&)


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*RooAbsPdf::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*RooAbsPdf::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*RooAbsPdf::plotOn(RooPlot* frame, RooLinkedList& cmdList) const


virtual RooPlot*RooAbsPdf::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*RooAbsPdf::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 voidRooAbsPdf::printMultiline(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 voidRooAbsPdf::printValue(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 voidRooAbsPdf::resetErrorCounters(Int_t resetValue = 10)


RooLognormal()


RooLognormal(const RooLognormal& other, const char* name = 0)


RooLognormal(const char* name, const char* title, RooAbsReal& _x, RooAbsReal& _m0, RooAbsReal& _k)


virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU 


virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")


virtual Bool_tRooAbsPdf::selfNormalized() 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)


voidRooAbsPdf::setGeneratorConfig()


voidRooAbsPdf::setGeneratorConfig(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)


voidRooAbsPdf::setNormRange(const char* rangeName)


voidRooAbsPdf::setNormRangeOverride(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 


voidRooAbsPdf::setTraceCounter(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*RooAbsPdf::specialGeneratorConfig() const


RooNumGenConfig*RooAbsPdf::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_tRooAbsPdf::traceEvalHook(Double_t value) const


Bool_tRooAbsPdf::traceEvalPdf(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 intRooAbsPdf::verboseEval()


static voidRooAbsPdf::verboseEval(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)


virtual RooAbsGenContext*RooAbsPdf::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 RooAbsGenContext*RooAbsPdf::binnedGenContext(const RooArgSet& vars, Bool_t verbose = kFALSE) const


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


virtual voidRooAbsReal::fillTreeBranch(TTree& t)


voidRooAbsReal::findInnerMostIntegration(const RooArgSet& allObs, RooArgSet& innerObs, const char* rangeName) const


virtual RooAbsGenContext*RooAbsPdf::genContext(const RooArgSet& vars, const RooDataSet* prototype = 0, const RooArgSet* auxProto = 0, Bool_t verbose = kFALSE) const


RooDataSet*RooAbsPdf::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*RooAbsPdf::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*RooAbsPdf::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 voidRooAbsPdf::raiseEvalError()


Int_t*RooAbsPdf::randomizeProtoOrder(Int_t nProto, Int_t nGen, Bool_t resample = kFALSE) const


virtual Bool_tRooAbsPdf::redirectServersHook(const RooAbsCollection&, Bool_t, Bool_t, Bool_t)


voidRooAbsArg::registerProxy(RooArgProxy& proxy)


voidRooAbsArg::registerProxy(RooSetProxy& proxy)


voidRooAbsArg::registerProxy(RooListProxy& proxy)


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_tRooAbsPdf::syncNormalization(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::ExtendModeRooAbsPdf::CanBeExtended


static RooAbsPdf::ExtendModeRooAbsPdf::CanNotBeExtended


static RooAbsReal::ErrorLoggingModeRooAbsReal::CollectErrors


static RooAbsArg::ConstOpCodeRooAbsArg::ConfigChange


static RooAbsReal::ErrorLoggingModeRooAbsReal::CountErrors


static RooAbsArg::ConstOpCodeRooAbsArg::DeActivate


static RooAbsReal::ErrorLoggingModeRooAbsReal::Ignore


static RooAbsPdf::ExtendModeRooAbsPdf::MustBeExtended


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_tRooAbsPdf::_errorCountNumber of errors remaining to print


static Bool_tRooAbsPdf::_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_tRooAbsPdf::_negCountNumber of negative probablities remaining to print


RooAbsReal*RooAbsPdf::_norm! Normalization integral (owned by _normMgr)


RooObjCacheManagerRooAbsPdf::_normMgrThe cache manager


TStringRooAbsPdf::_normRangeNormalization range


static TStringRooAbsPdf::_normRangeOverride


RooArgSet*RooAbsPdf::_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_tRooAbsPdf::_rawValue


Char_tRooAbsReal::_sbyteValue! Transient cache for signed byte values from tree branches


Bool_tRooAbsPdf::_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*RooAbsPdf::_specGeneratorConfig! MC generator configuration specific for this object


RooNumIntConfig*RooAbsReal::_specIntegratorConfigNumeric integrator configuration specific for this object


map<string,string>RooAbsArg::_stringAttribString attributes


Int_tRooAbsPdf::_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_tRooAbsPdf::_verboseEval


TStringTNamed::fNameobject identifier


TStringTNamed::fTitleobject title


RooRealProxyk


RooRealProxym0


RooRealProxyx







Class Charts





























































Inheritance
Inherited Members
Includes
Libraries



Class Charts


Function documentation


 RooLognormal(const char* name, const char* title, RooAbsReal& _x, RooAbsReal& _m0, RooAbsReal& _k)




 RooLognormal(const RooLognormal& other, const char* name = 0)




Double_t evaluate() const


 ln(k)<1 would correspond to sigma < 0 in the parametrization
 resulting by transforming a normal random variable in its
 standard parametrization to a lognormal random variable
 => treat ln(k) as -ln(k) for k<1





Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName = 0) const




Double_t analyticalIntegral(Int_t code, const char* rangeName = 0) const




Int_t getGenerator(const RooArgSet& directVars, RooArgSet& generateVars, Bool_t staticInitOK = kTRUE) const




void generateEvent(Int_t code)




 RooLognormal()



{}






TObject* clone(const char* newname) const



{ return new RooLognormal(*this,newname); }






virtual ~RooLognormal()



{ }