library: libRooFit
#include "RooAbsReal.h"

RooAbsReal


class description - header file - source file
viewCVS header - viewCVS source

class RooAbsReal: public RooAbsArg

Inheritance Inherited Members Includes Libraries
Class Charts

Function Members (Methods)

Display options:
Show inherited
Show non-public
 
    This is an abstract class, constructors will not be documented.
    Look at the header to check for available constructors.

public:
virtual~RooAbsReal()
voidTObject::AbstractMethod(const char* method) const
virtual Double_tanalyticalIntegral(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 = "")
voidRooAbsArg::attachDataSet(const RooAbsData& set)
TIterator*RooAbsArg::attribIterator() const
RooAbsFunc*bindVars(const RooArgSet& vars, const RooArgSet* nset = 0, Bool_t clipInvalid = kFALSE) const
voidRooAbsArg::branchNodeServerList(RooAbsCollection* list, const RooAbsArg* arg = 0) const
virtual voidTObject::Browse(TBrowser* b)
Bool_tRooAbsArg::checkDependents(const RooArgSet* nset) const
virtual Bool_tRooAbsArg::checkObservables(const RooArgSet* nset) const
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTNamed::Clear(Option_t* option = "")
TIterator*RooAbsArg::clientIterator() const
virtual TObject*RooAbsArg::clone(const char* newname) const
virtual TObject*RooAbsArg::Clone(const char* newname = "0") const
virtual Int_tRooAbsArg::Compare(const TObject* other) const
virtual voidRooAbsArg::constOptimize(RooAbsArg::ConstOpCode opcode)
virtual voidTNamed::Copy(TObject& named) const
static voidRooAbsArg::copyList(TList& dest, const TList& source)
virtual RooAbsArg*createFundamental(const char* newname = "0") const
TH1*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*createIntegral(const RooArgSet& iset, const char* rangeName) const
RooAbsReal*createIntegral(const RooArgSet& iset, const RooArgSet& nset, const char* rangeName = "0") const
RooAbsReal*createIntegral(const RooArgSet& iset, const RooNumIntConfig& cfg, const char* rangeName = "0") const
RooAbsReal*createIntegral(const RooArgSet& iset, const RooArgSet& nset, const RooNumIntConfig& cfg, const char* rangeName = "0") const
virtual RooAbsReal*createIntegral(const RooArgSet& iset, const RooArgSet* nset = 0, const RooNumIntConfig* cfg = 0, const char* rangeName = "0") const
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
const RooAbsReal*createProjection(const RooArgSet& depVars, const RooArgSet& projVars) const
const RooAbsReal*createProjection(const RooArgSet& depVars, const RooArgSet& projVars, RooArgSet*& cloneSet) const
virtual Double_tdefaultErrorLevel() const
static RooNumIntConfig*defaultIntegratorConfig()
static ostream&RooPrintable::defaultStream(ostream* os = 0)
virtual voidTObject::Delete(Option_t* option = "")
Bool_tRooAbsArg::deleteWatch() const
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) const
Bool_tRooAbsArg::dependsOn(const RooAbsArg& server, const RooAbsArg* ignoreArg = 0) const
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() const
virtual TObject*TObject::DrawClone(Option_t* option = "") const
virtual voidTObject::Dump() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
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 voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
TH1*fillHistogram(TH1* hist, const RooArgList& plotVars, Double_t scaleFactor = 1, const RooArgSet* projectedVars = 0) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
RooAbsArg*RooAbsArg::findServer(const char* name) const
RooAbsArg*RooAbsArg::findServer(const RooAbsArg& arg) const
RooAbsArg*RooAbsArg::findServer(Int_t index) const
virtual Bool_tforceAnalyticalInt(const RooAbsArg&) const
virtual voidforceNumInt(Bool_t flag = kTRUE)
virtual Int_tgetAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, const char* rangeName = "0") const
virtual Int_tgetAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, const RooArgSet* normSet, const char* rangeName = "0") const
Bool_tRooAbsArg::getAttribute(const Text_t* name) const
RooLinkedListRooAbsArg::getCloningAncestors() const
RooArgSet*RooAbsArg::getComponents() 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()
virtual const char*TObject::GetIconName() const
const RooNumIntConfig*getIntegratorConfig() const
virtual Int_tgetMaxVal(const RooArgSet& vars) const
virtual const char*TNamed::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
RooArgSet*RooAbsArg::getObservables(const RooArgSet& set) const
RooArgSet*RooAbsArg::getObservables(const RooAbsData* data) const
RooArgSet*RooAbsArg::getObservables(const RooAbsData& data) const
virtual RooArgSet*RooAbsArg::getObservables(const RooArgSet* depList) const
virtual Option_t*TObject::GetOption() const
RooArgSet*RooAbsArg::getParameters(const RooAbsData* data) const
RooArgSet*RooAbsArg::getParameters(const RooAbsData& data) const
RooArgSet*RooAbsArg::getParameters(const RooArgSet& set) const
virtual RooArgSet*RooAbsArg::getParameters(const RooArgSet* depList) const
virtual Int_tgetPlotBins() const
const char*getPlotLabel() const
Double_tgetPlotMax() const
Double_tgetPlotMin() const
virtual const char*TNamed::GetTitle() const
TStringgetTitle(Bool_t appendUnit = kFALSE) const
virtual UInt_tTObject::GetUniqueID() const
const Text_t*getUnit() const
virtual Double_tgetVal(const RooArgSet* set = 0) const
Double_tgetVal(const RooArgSet& set) const
RooArgSet*RooAbsArg::getVariables() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
virtual Bool_tRooAbsArg::hasRange(const char*) const
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
static voidRooPrintable::inLinePrint(ostream& os, const TNamed& named)
virtual Bool_tinPlotRange(Double_t value) const
virtual Bool_tRooAbsArg::inRange(const char*) const
virtual voidTObject::Inspect() const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tRooAbsArg::isCloneOf(const RooAbsArg& other) const
Bool_tRooAbsArg::isConstant() const
virtual Bool_tRooAbsArg::isDerived() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
virtual Bool_tRooAbsArg::isFundamental() const
virtual Bool_tRooAbsArg::isLValue() const
Bool_tTObject::IsOnHeap() const
Bool_tRooAbsArg::isShapeServer(const RooAbsArg& arg) const
Bool_tRooAbsArg::isShapeServer(const char* name) const
virtual Bool_tRooAbsArg::IsSortable() 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) const
RooPrintable::PrintOptionRooPrintable::lessVerbose(RooPrintable::PrintOption opt) const
virtual voidTNamed::ls(Option_t* option = "") const
virtual Double_tmaxVal(Int_t code)
voidTObject::MayNotUse(const char* method) const
static voidRooAbsArg::nameFieldLength(Int_t newLen)
virtual Bool_tTObject::Notify()
Bool_tRooAbsArg::observableOverlaps(const RooAbsData* dset, const RooAbsArg& testArg) const
Bool_tRooAbsArg::observableOverlaps(const RooArgSet* depList, const RooAbsArg& testArg) const
static voidRooPrintable::oneLinePrint(ostream& os, const TNamed& named)
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static 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)
TNamed&TNamed::operator=(const TNamed& rhs)
Bool_toperator==(Double_t value) const
virtual Bool_toperator==(const RooAbsArg& other)
Bool_tRooAbsArg::overlaps(const RooAbsArg& testArg) const
virtual voidTObject::Paint(Option_t* option = "")
RooPrintable::PrintOptionRooPrintable::parseOptions(Option_t* options) const
virtual RooPlot*plotOn(RooPlot* frame, const RooCmdArg& arg1 = RooCmdArg(), const RooCmdArg& arg2 = RooCmdArg(), const RooCmdArg& arg3 = RooCmdArg(), const RooCmdArg& arg4 = RooCmdArg(), const RooCmdArg& arg5 = RooCmdArg(), const RooCmdArg& arg6 = RooCmdArg(), const RooCmdArg& arg7 = RooCmdArg(), const RooCmdArg& arg8 = RooCmdArg(), const RooCmdArg& arg9 = RooCmdArg(), const RooCmdArg& arg10 = RooCmdArg()) const
virtual RooPlot*plotSliceOn(RooPlot* frame, const RooArgSet& sliceSet, Option_t* drawOptions = "L", Double_t scaleFactor = 1.0, RooAbsReal::ScaleType stype = Relative, const RooAbsData* projData = 0) const
virtual voidTObject::Pop()
virtual voidRooAbsArg::Print(Option_t* options = "0") const
voidRooAbsArg::printCompactTree(const char* indent = "", const char* fileName = "0", const char* namePat = "0")
voidRooAbsArg::printCompactTree(ostream& os, const char* indent = "", const char* namePat = "0")
virtual voidRooAbsArg::printCompactTreeHook(ostream& os, const char* ind = "")
voidRooAbsArg::printDirty(Bool_t depth = kTRUE) const
virtual voidprintToStream(ostream& stream, RooPrintable::PrintOption opt = Standard, TString indent = ) const
virtual Int_tTObject::Read(const char* name)
virtual Bool_treadFromStream(istream& is, Bool_t compact, Bool_t verbose = kFALSE)
Bool_tRooAbsArg::recursiveCheckDependents(const RooArgSet* nset) const
Bool_tRooAbsArg::recursiveCheckObservables(const RooArgSet* nset) const
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") const
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
TIterator*RooAbsArg::serverIterator() const
voidRooAbsArg::setAttribute(const Text_t* name, Bool_t value = kTRUE)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
static voidsetCacheCheck(Bool_t flag)
voidRooAbsArg::setDeleteWatch(Bool_t flag = kTRUE)
static voidRooAbsArg::setDirtyInhibit(Bool_t flag)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
voidsetIntegratorConfig()
voidsetIntegratorConfig(const RooNumIntConfig& config)
virtual voidTNamed::SetName(const char* name)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
voidsetPlotBins(Int_t value)
voidsetPlotLabel(const char* label)
voidsetPlotMax(Double_t value)
voidsetPlotMin(Double_t value)
voidsetPlotRange(Double_t min, Double_t max)
virtual voidTNamed::SetTitle(const char* title = "")
virtual voidTObject::SetUniqueID(UInt_t uid)
voidsetUnit(const char* unit)
TIterator*RooAbsArg::shapeClientIterator() const
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual Int_tTNamed::Sizeof() const
RooNumIntConfig*specialIntegratorConfig() const
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidRooAbsArg::treeNodeServerList(RooAbsCollection* list, const RooAbsArg* arg = 0, Bool_t doBranch = kTRUE, Bool_t doLeaf = kTRUE, Bool_t valueOnly = kFALSE) const
virtual voidTObject::UseCurrentStyle()
TIterator*RooAbsArg::valueClientIterator() const
static voidRooAbsArg::verboseDirty(Bool_t flag)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
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 voidwriteToStream(ostream& os, Bool_t compact) const
protected:
voidRooAbsArg::addServer(RooAbsArg& server, Bool_t valueProp = kTRUE, Bool_t shapeProp = kFALSE)
voidRooAbsArg::addServerList(RooAbsCollection& serverList, Bool_t valueProp = kTRUE, Bool_t shapeProp = kFALSE)
Bool_tallClientsCached(RooAbsArg* var, RooArgSet& cacheList)
virtual voidattachToTree(TTree& t, Int_t bufSize = 32000)
voidRooAbsArg::changeServer(RooAbsArg& server, Bool_t valueProp, Bool_t shapeProp)
TStringRooAbsArg::cleanBranchName() const
voidRooAbsArg::clearShapeDirty() const
voidRooAbsArg::clearValueDirty() const
virtual voidcopyCache(const RooAbsArg* source)
UInt_tRooAbsArg::crc32(const char* data) const
const RooAbsReal*createProjection(const RooArgSet& dependentVars, const RooArgSet* projectedVars, RooArgSet*& cloneSet, const char* rangeName = "0") const
voiddoConstOpt(RooAbsData& dataset, const RooArgSet* normSet, Bool_t verbose)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual Double_tevaluate() const
virtual voidfillTreeBranch(TTree& t)
Bool_tfindCacheableBranches(RooAbsArg* arg, RooAbsData* dset, RooArgSet& cacheList, const RooArgSet* normSet, Bool_t verbose)
RooAbsArg*RooAbsArg::findNewServer(const RooAbsCollection& newSet, Bool_t nameChange) const
voidfindRedundantCacheServers(RooAbsData* dset, RooArgSet& cacheList, RooArgSet& pruneList, Bool_t verbose)
voidfindUnusedDataVariables(RooAbsData* dset, RooArgSet& pruneList, Bool_t verbose)
virtual voidRooAbsArg::getObservablesHook(const RooArgSet*, RooArgSet*) const
virtual voidRooAbsArg::getParametersHook(const RooArgSet*, RooArgSet*) const
RooAbsProxy*RooAbsArg::getProxy(Int_t index) const
TStringintegralNameSuffix(const RooArgSet& iset, const RooArgSet* nset = 0, const char* rangeName = "0") const
Bool_tRooAbsArg::isShapeDirty() const
virtual Bool_tisValid() const
virtual Bool_tisValidReal(Double_t value, Bool_t printError = kFALSE) const
Bool_tRooAbsArg::isValueDirty() const
voidmakeProjectionSet(const RooAbsArg* plotVar, const RooArgSet* allVars, RooArgSet& projectedVars, Bool_t silent) const
voidTObject::MakeZombie()
Bool_tmatchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgProxy& a) const
Bool_tmatchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgSet& set) const
Bool_tmatchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgProxy& a, const RooArgProxy& b) const
Bool_tmatchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgProxy& a, const RooArgProxy& b, const RooArgProxy& c) const
Bool_tmatchArgs(const RooArgSet& allDeps, RooArgSet& numDeps, const RooArgProxy& a, const RooArgProxy& b, const RooArgProxy& c, const RooArgProxy& d) const
Int_tRooAbsArg::numProxies() const
RooAbsArg::OperModeRooAbsArg::operMode() const
virtual voidRooAbsArg::operModeHook()
voidoptimizeDirty(RooAbsData& dataset, const RooArgSet* normSet, Bool_t verbose)
virtual RooPlot*plotAsymOn(RooPlot* frame, const RooAbsCategoryLValue& asymCat, RooAbsReal::PlotOpt o) const
virtual RooPlot*plotOn(RooPlot* frame, RooLinkedList& cmdList) const
virtual RooPlot*plotOn(RooPlot* frame, RooAbsReal::PlotOpt o) const
Bool_tplotSanityChecks(RooPlot* frame) const
voidRooAbsArg::printAttribList(ostream& os) const
Bool_tRooAbsArg::recursiveRedirectServers(const RooAbsCollection& newServerList, Bool_t mustReplaceAll = kFALSE, Bool_t nameChange = kFALSE)
Bool_tRooAbsArg::redirectServers(const RooAbsCollection& newServerList, Bool_t mustReplaceAll = kFALSE, Bool_t nameChange = kFALSE, Bool_t isRecursionStep = kFALSE)
virtual Bool_tRooAbsArg::redirectServersHook(const RooAbsCollection&, Bool_t, Bool_t, Bool_t)
voidRooAbsArg::registerProxy(RooArgProxy& proxy)
voidRooAbsArg::registerProxy(RooSetProxy& proxy)
voidRooAbsArg::registerProxy(RooListProxy& proxy)
voidRooAbsArg::removeServer(RooAbsArg& server, Bool_t force = kFALSE)
voidRooAbsArg::replaceServer(RooAbsArg& oldServer, RooAbsArg& newServer, Bool_t valueProp, Bool_t shapeProp)
virtual voidselectNormalization(const RooArgSet* depSet = 0, Bool_t force = kFALSE)
virtual voidselectNormalizationRange(const char* rangeName = "0", Bool_t force = kFALSE)
virtual voidRooAbsArg::serverNameChangeHook(const RooAbsArg*, const RooAbsArg*)
voidRooAbsArg::setOperMode(RooAbsArg::OperMode mode, Bool_t recurseADirty = kTRUE)
voidRooAbsArg::setProxyNormSet(const RooArgSet* nset)
voidRooAbsArg::setShapeDirty() const
virtual voidsetTreeBranchStatus(TTree& t, Bool_t active)
voidRooAbsArg::setValueDirty() const
virtual voidsyncCache(const RooArgSet* set = 0)
Double_ttraceEval(const RooArgSet* set) const
virtual Bool_ttraceEvalHook(Double_t) const
voidundoConstOpt(RooAbsData& dataset, const RooArgSet* normSet, Bool_t verbose)
voidRooAbsArg::unRegisterProxy(RooArgProxy& proxy)
voidRooAbsArg::unRegisterProxy(RooSetProxy& proxy)
voidRooAbsArg::unRegisterProxy(RooListProxy& proxy)
private:
Bool_tmatchArgsByName(const RooArgSet& allArgs, RooArgSet& matchedArgs, const TList& nameList) const

Data Members

public:
enum ScaleType { Raw
Relative
NumEvent
RelativeExpected
};
enum RooAbsArg::ConstOpCode { Activate
DeActivate
ConfigChange
ValueChange
};
enum RooAbsArg::OperMode { Auto
AClean
ADirty
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
enum RooPrintable::PrintOption { InLine
OneLine
Standard
Shape
Verbose
};
protected:
Double_t_plotMinMinimum of plot range
Double_t_plotMaxMaximum of plot range
Int_t_plotBinsNumber of plot bins
Double_t_valueCache for current value of object
TString_unitUnit for objects value
TString_labelPlot label for objects value
Bool_t_forceNumIntForce numerical integration if flag set
RooNumIntConfig*_specIntegratorConfig! Numeric integrator configuration specific for this object
static Bool_t_cacheCheck
RooRefCountListRooAbsArg::_serverList! list of server objects
RooRefCountListRooAbsArg::_clientList! list of client objects
RooRefCountListRooAbsArg::_clientListShape! subset of clients that requested shape dirty flag propagation
RooRefCountListRooAbsArg::_clientListValue! subset of clients that requested value dirty flag propagation
TListRooAbsArg::_proxyList! list of proxies
TIterator*RooAbsArg::_clientShapeIter! Iterator over _clientListShape
TIterator*RooAbsArg::_clientValueIter! Iterator over _clientListValue
THashListRooAbsArg::_attribListList of string attributes
static Bool_tRooAbsArg::_verboseDirtyStatic flag controlling verbose messaging for dirty state changes
static Bool_tRooAbsArg::_inhibitDirtyStatic flag controlling global inhibit of dirty state propagation
Bool_tRooAbsArg::_deleteWatch! Delete watch flag
static Int_tRooAbsArg::_nameLength
TStringTNamed::fNameobject identifier
TStringTNamed::fTitleobject title

Class Description

~RooAbsReal()
Bool_t operator==(Double_t value)
 Equality operator comparing to a Double_t
Bool_t operator==(const RooAbsArg& other)
TString getTitle(Bool_t appendUnit)
 Return this variable's title string. If appendUnit is true and
 this variable has units, also append a string " (<unit>)".
Double_t getVal(const RooArgSet* set)
 Return value of object. Calculated if dirty, otherwise cached value is returned.
cout << " getVal(" << GetName() << ")
Double_t traceEval(const RooArgSet* /*nset*/)
 Calculate current value of object, with error tracing wrapper
Int_t getAnalyticalIntegralWN(RooArgSet& allDeps, RooArgSet& analDeps, const RooArgSet* /*normSet*/, const char* rangeName)
 Default implementation of getAnalyticalIntegralWN for real valued objects defers to
 normalization invariant getAnalyticalIntegral()
Int_t getAnalyticalIntegral(RooArgSet& /*allDeps*/, RooArgSet& /*analDeps*/, const char* /*rangeName*/)
 By default we do not supply any analytical integrals
Double_t analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName)
 Default implementation of analyticalIntegralWN handles only the pass-through
 scenario (code =0). All other codes are deferred to to the normalization
 invariant analyticalIntegral() 
Double_t analyticalIntegral(Int_t code, const char* /*rangeName*/)
 By default no analytical integrals are implemented
const char * getPlotLabel()
 Get the label associated with the variable
void setPlotLabel(const char *label)
 Set the label associated with this variable
Bool_t readFromStream(istream& /*is*/, Bool_t /*compact*/, Bool_t /*verbose*/)
Read object contents from stream (dummy for now)
void writeToStream(ostream& /*os*/, Bool_t /*compact*/)
Write object contents to stream (dummy for now)
void printToStream(ostream& os, PrintOption opt, TString indent)
 Print info about this object to the specified stream. In addition to the info
 from RooAbsArg::printToStream() we add:

     Shape : value, units, plot range
   Verbose : default binning and print label
void setPlotMin(Double_t value)
 Set minimum value of output associated with this object
void setPlotMax(Double_t value)
 Set maximum value of output associated with this object
void setPlotRange(Double_t, Double_t)
 Set a new plot range
void setPlotBins(Int_t /*value*/)
 Set number of histogram bins 
Bool_t inPlotRange(Double_t value)
 Check if given value is in the min-max range for this object
Bool_t isValid()
 Check if current value is valid
Bool_t isValidReal(Double_t /*value*/, Bool_t /*printError*/)
 Check if given value is valid
RooAbsReal* createIntegral(const RooArgSet& iset, const RooCmdArg arg1, const RooCmdArg arg2, const RooCmdArg arg3, const RooCmdArg arg4, const RooCmdArg arg5, const RooCmdArg arg6, const RooCmdArg arg7, const RooCmdArg arg8)
 Create an object that represents the integral of the function over one or more observables listed in iset
 The actual integration calculation is only performed when the return object is evaluated. The name
 of the integral object is automatically constructed from the name of the input function, the variables
 it integrates and the range integrates over

 The following named arguments are accepted

 NormSet(const RooArgSet&)            -- Specify normalization set, mostly useful when working with PDFS
 NumIntConfig(const RooNumIntConfig&) -- Use given configuration for any numeric integration, if necessary
 Range(const char* name)              -- Integrate only over given range. Multiple ranges may be specified
                                         by passing multiple Range() arguments  
RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet* nset, const RooNumIntConfig* cfg, const char* rangeName)
TString integralNameSuffix(const RooArgSet& iset, const RooArgSet* nset, const char* rangeName)
const RooAbsReal* createProjection(const RooArgSet& depVars, const RooArgSet& projVars, RooArgSet*& cloneSet)
const RooAbsReal* createProjection(const RooArgSet& depVars, const RooArgSet& projVars)
const RooAbsReal * createProjection(const RooArgSet &dependentVars, const RooArgSet *projectedVars, RooArgSet *&cloneSet, const char* rangeName)
 Create a new object G that represents the normalized projection:

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

 where F[x,y,p] is the function we represent, "x" are the
 specified dependentVars, "y" are the specified projectedVars, and
 "p" are our remaining variables ("parameters"). Return a
 pointer to the newly created object, or else zero in case of an
 error.  The caller is responsible for deleting the contents of
 cloneSet (which includes the returned projection object) whatever
 the return value. Note that you should normally call getVal()
 on the returned object, without providing any set of normalization
 variables. Otherwise you are requesting an additional normalization
 beyond what is already specified in the equation above.
 Get the set of our leaf nodes
TH1 * fillHistogram(TH1 *hist, const RooArgList &plotVars, Double_t scaleFactor, const RooArgSet *projectedVars)
 Loop over the bins of the input histogram and add an amount equal to our value evaluated
 at the bin center to each one. Our value is calculated by first integrating out any variables
 in projectedVars and then scaling the result by scaleFactor. Returns a pointer to the
 input histogram, or zero in case of an error. The input histogram can be any TH1 subclass, and
 therefore of arbitrary dimension. Variables are matched with the (x,y,...) dimensions of the input
 histogram according to the order in which they appear in the input plotVars list.
 Do we have a valid histogram to use?
TH1 * createHistogram(const char *name, const RooAbsRealLValue& xvar, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
 Create and fill a ROOT histogram TH1,TH2 or TH3 with the values of this function. 

 This function accepts the following arguments

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

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

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

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

 The caller takes ownership of the returned histogram
RooPlot* plotOn(RooPlot* frame, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8, const RooCmdArg& arg9, const RooCmdArg& arg10)
 Plot (project) PDF on specified frame. If a PDF is plotted in an empty frame, it
 will show a unit normalized curve in the frame variable, taken at the present value 
 of other observables defined for this PDF

 If a PDF is plotted in a frame in which a dataset has already been plotted, it will
 show a projected curve integrated over all variables that were present in the shown
 dataset except for the one on the x-axis. The normalization of the curve will also
 be adjusted to the event count of the plotted dataset. An informational message
 will be printed for each projection step that is performed

 This function takes the following named arguments

 Projection control

 Slice(const RooArgSet& set)     -- Override default projection behaviour by omittting observables listed 
                                    in set from the projection, resulting a 'slice' plot. Slicing is usually
                                    only sensible in discrete observables
 Project(const RooArgSet& set)   -- Override default projection behaviour by projecting over observables
                                    given in set and complete ignoring the default projection behavior. Advanced use only.
 ProjWData(const RooAbsData& d)  -- Override default projection _technique_ (integration). For observables present in given dataset
                                    projection of PDF is achieved by constructing an average over all observable values in given set.
                                    Consult RooFit plotting tutorial for further explanation of meaning & use of this technique
 ProjWData(const RooArgSet& s,   -- As above but only consider subset 's' of observables in dataset 'd' for projection through data averaging
           const RooAbsData& d)
 ProjectionRange(const char* rn) -- Override default range of projection integrals to a different range speficied by given range name.
                                    This technique allows you to project a finite width slice in a real-valued observable
 
 Misc content control

 Normalization(Double_t scale,   -- Adjust normalization by given scale factor. Interpretation of number depends on code: Relative:
                ScaleType code)     relative adjustment factor, NumEvent: scale to match given number of events.
 Name(const chat* name)          -- Give curve specified name in frame. Useful if curve is to be referenced later
 Asymmetry(const RooCategory& c) -- Show the asymmetry of the PDF in given two-state category [F(+)-F(-)] / [F(+)+F(-)] rather than
                                    the PDF projection. Category must have two states with indices -1 and +1 or three states with
                                    indeces -1,0 and +1.
 ShiftToZero(Bool_t flag)        -- Shift entire curve such that lowest visible point is at exactly zero. Mostly useful when
                                    plotting -log(L) or chi^2 distributions
 AddTo(const char* name,         -- Add constructed projection to already existing curve with given name and relative weight factors
       double_t wgtSelf, double_t wgtOther)

 Plotting control 

 DrawOption(const char* opt)     -- Select ROOT draw option for resulting TGraph object
 LineStyle(Int_t style)          -- Select line style by ROOT line style code, default is solid
 LineColor(Int_t color)          -- Select line color by ROOT color code, default is blue
 LineWidth(Int_t width)          -- Select line with in pixels, default is 3
 FillStyle(Int_t style)          -- Select fill style, default is not filled. If a filled style is selected, also use VLines()
                                    to add vertical downward lines at end of curve to ensure proper closure
 FillColor(Int_t color)          -- Select fill color by ROOT color code
 Range(const char* name)         -- Only draw curve in range defined by given name
 Range(double lo, double hi)     -- Only draw curve in specified range
 VLines()                        -- Add vertical lines to y=0 at end points of curve
 Precision(Double_t eps)         -- Control precision of drawn curve w.r.t to scale of plot, default is 1e-3. Higher precision
                                    will result in more and more densely spaced curve points
 Invisble(Bool_t flag)           -- Add curve to frame, but do not display. Useful in combination AddTo()
RooPlot* plotOn(RooPlot* frame, RooLinkedList& argList)
cout << " plotOn(" << GetName() << ")
RooPlot* plotSliceOn(RooPlot *frame, const RooArgSet& sliceSet, Option_t* drawOptions, Double_t scaleFactor, ScaleType stype, const RooAbsData* projData)
 Plot ourselves on given frame, as done in plotOn(), except that the variables 
 listed in 'sliceSet' are taken out from the default list of projected dimensions created
 by plotOn().
RooPlot* plotAsymOn(RooPlot *frame, const RooAbsCategoryLValue& asymCat, PlotOpt o)
 Plot asymmetry of ourselves, defined as

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

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

 The asymmetry function can be multiplied with an optional scale factor. The default projection 
 behaviour can be overriden by supplying an optional set of dependents to project. 
Bool_t plotSanityChecks(RooPlot* frame)
 Perform general sanity check on frame to ensure safe plotting operations
void makeProjectionSet(const RooAbsArg* plotVar, const RooArgSet* allVars, RooArgSet& projectedVars, Bool_t silent)
 Construct the set of dependents to project when plotting ourselves as function
 of 'plotVar'. 'allVars' is the list of variables that must be projected, but
 may contain variables that we do not depend on. If 'silent' is cleared,
 warnings about inconsistent input parameters will be printed.
RooAbsFunc * bindVars(const RooArgSet &vars, const RooArgSet* nset, Bool_t clipInvalid)
 Create an interface adaptor f(vars) that binds us to the specified variables
 (in arbitrary order). For example, calling bindVars({x1,x3}) on an object
 F(x1,x2,x3,x4) returns an object f(x1,x3) that is evaluated using the
 current values of x2 and x4. The caller takes ownership of the returned adaptor.
void copyCache(const RooAbsArg* source)
 Copy the cached value of another RooAbsArg to our cache
void attachToTree(TTree& t, Int_t bufSize)
 Attach object to a branch of given TTree
void fillTreeBranch(TTree& t)
 Attach object to a branch of given TTree
void setTreeBranchStatus(TTree& t, Bool_t active)
 (De)Activate associate tree branch
RooAbsArg * createFundamental(const char* newname)
 Create a RooRealVar fundamental object with our properties. The new
 object will be created without any fit limits.
Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, const RooArgProxy& a)
 Wrapper function for matchArgsByName()
Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, const RooArgProxy& a, const RooArgProxy& b)
 Wrapper function for matchArgsByName()
Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, const RooArgProxy& a, const RooArgProxy& b, const RooArgProxy& c)
 Wrapper function for matchArgsByName()
Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, const RooArgProxy& a, const RooArgProxy& b, const RooArgProxy& c, const RooArgProxy& d)
 Wrapper function for matchArgsByName()
Bool_t matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, const RooArgSet& set)
 Wrapper function for matchArgsByName()
Bool_t matchArgsByName(const RooArgSet &allArgs, RooArgSet &matchedArgs, const TList &nameList)
 Check if allArgs contains matching elements for each name in nameList. If it does,
 add the corresponding args from allArgs to matchedArgs and return kTRUE. Otherwise
 return kFALSE and do not change matchedArgs.
RooNumIntConfig* defaultIntegratorConfig()
RooNumIntConfig* specialIntegratorConfig()
const RooNumIntConfig* getIntegratorConfig()
void setIntegratorConfig(const RooNumIntConfig& config)
void setIntegratorConfig()
void optimizeDirty(RooAbsData& dataset, const RooArgSet* normSet, Bool_t /*verbose*/)
void doConstOpt(RooAbsData& dataset, const RooArgSet* normSet, Bool_t verbose)
 optimizeDirty must have been run first!
void undoConstOpt(RooAbsData& dataset, const RooArgSet* normSet, Bool_t verbose)
 Delete the cache
Bool_t findCacheableBranches(RooAbsArg* arg, RooAbsData* dset, RooArgSet& cacheList, const RooArgSet* normSet, Bool_t verbose)
 Find branch PDFs with all-constant parameters, and add them
 to the dataset cache list
void findUnusedDataVariables(RooAbsData* dset,RooArgSet& pruneList, Bool_t /*verbose*/)
void findRedundantCacheServers(RooAbsData* dset,RooArgSet& cacheList, RooArgSet& pruneList, Bool_t /*verbose*/)
Bool_t allClientsCached(RooAbsArg* var, RooArgSet& cacheList)
void selectNormalization(const RooArgSet*, Bool_t)
void selectNormalizationRange(const char*, Bool_t)
Int_t getMaxVal(const RooArgSet& /*vars*/)
 Advertise capability to determine maximum value of function for given set of 
 observables. If no direct generator method is provided, this information
 will assist the accept/reject generator to operate more efficiently as
 it can skip the initial trial sampling phase to empirically find the function
 maximum
Double_t maxVal(Int_t /*code*/)
 Return maximum value for set of observables identified by code assigned
 in getMaxVal
const Text_t * getUnit()
{ return _unit.Data(); }
void setUnit(const char *unit)
{ _unit= unit; }
Bool_t forceAnalyticalInt(const RooAbsArg& /*dep*/)
{ return kFALSE ; }
void forceNumInt(Bool_t flag=kTRUE)
{ _forceNumInt = flag ; }
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)
{ return createIntegral(iset,0,0,rangeName) ; }
RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet& nset, const char* rangeName=0)
{ return createIntegral(iset,&nset,0,rangeName) ; }
RooAbsReal* createIntegral(const RooArgSet& iset, const RooArgSet& nset, const RooNumIntConfig& cfg, const char* rangeName=0)
{ return createIntegral(iset,&nset,&cfg,rangeName) ; }
RooAbsReal* createIntegral(const RooArgSet& iset, const RooNumIntConfig& cfg, const char* rangeName=0)
{ return createIntegral(iset,0,&cfg,rangeName) ; }
Double_t getPlotMin()
 Plotting options
{ return _plotMin; }
Double_t getPlotMax()
{ return _plotMax; }
Int_t getPlotBins()
{ return _plotBins; }
Double_t defaultErrorLevel()
{ return 1.0 ; }
void setCacheCheck(Bool_t flag)
{ _cacheCheck = flag ; }
Bool_t traceEvalHook(Double_t /*value*/)
{ return kFALSE ;}
Double_t evaluate()
void syncCache(const RooArgSet* set=0)
{ getVal(set) ; }

Last update: Sat Dec 9 09:56:23 2006
Copyright (c) 2000-2005, Regents of the University of California *


ROOT page - Class index - Class Hierarchy - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.