library: libRooFit
#include "RooAbsRealLValue.h"

RooAbsRealLValue


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

class RooAbsRealLValue: public RooAbsReal, public RooAbsLValue

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~RooAbsRealLValue()
voidTObject::AbstractMethod(const char* method) const
virtual Double_tRooAbsReal::analyticalIntegral(Int_t code, const char* rangeName = "0") const
virtual Double_tRooAbsReal::analyticalIntegralWN(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*RooAbsReal::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*RooAbsReal::createFundamental(const char* newname = "0") const
TH1*createHistogram(const char* name, const RooLinkedList& cmdList) const
TH1F*createHistogram(const char* name, const char* yAxisLabel) const
TH1F*createHistogram(const char* name, const char* yAxisLabel, const RooAbsBinning& bins) const
TH2F*createHistogram(const char* name, const RooAbsRealLValue& yvar, const char* zAxisLabel, const RooAbsBinning** bins) const
static TH1*createHistogram(const char* name, RooArgList& vars, const char* tAxisLabel, const RooAbsBinning** bins)
TH1F*createHistogram(const char* name, const char* yAxisLabel, Double_t xlo, Double_t xhi, Int_t nBins) const
TH3F*createHistogram(const char* name, const RooAbsRealLValue& yvar, const RooAbsRealLValue& zvar, const char* tAxisLabel, const RooAbsBinning** bins) const
TH2F*createHistogram(const char* name, const RooAbsRealLValue& yvar, const char* zAxisLabel = "0", Double_t* xlo = 0, Double_t* xhi = 0, Int_t* nBins = 0) const
static TH1*createHistogram(const char* name, RooArgList& vars, const char* tAxisLabel, Double_t* xlo, Double_t* xhi, Int_t* nBins)
TH3F*createHistogram(const char* name, const RooAbsRealLValue& yvar, const RooAbsRealLValue& zvar, const char* tAxisLabel, Double_t* xlo = 0, Double_t* xhi = 0, Int_t* nBins = 0) const
TH1*createHistogram(const char* name, 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
const RooAbsReal*RooAbsReal::createProjection(const RooArgSet& depVars, const RooArgSet& projVars) const
const RooAbsReal*RooAbsReal::createProjection(const RooArgSet& depVars, const RooArgSet& projVars, RooArgSet*& cloneSet) const
virtual Double_tRooAbsReal::defaultErrorLevel() const
static RooNumIntConfig*RooAbsReal::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*RooAbsReal::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_tRooAbsReal::forceAnalyticalInt(const RooAbsArg&) const
virtual voidRooAbsReal::forceNumInt(Bool_t flag = kTRUE)
RooPlot*frame() const
RooPlot*frame(const RooLinkedList& cmdList) const
RooPlot*frame(Int_t nbins) const
RooPlot*frame(Double_t lo, Double_t hi) const
RooPlot*frame(Double_t lo, Double_t hi, Int_t nbins) const
RooPlot*frame(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
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
virtual Int_tgetBin() const
virtual const RooAbsBinning&getBinning(const char* name = "0", Bool_t verbose = kTRUE, Bool_t createOnTheFly = kFALSE) const
virtual RooAbsBinning&getBinning(const char* name = "0", Bool_t verbose = kTRUE, Bool_t createOnTheFly = kFALSE)
virtual Int_tgetBins(const char* name = "0") const
virtual Double_tgetBinWidth(Int_t i) 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()
Int_tgetFitBins() const
Double_tgetFitMax() const
Double_tgetFitMin() const
virtual const char*TObject::GetIconName() const
const RooNumIntConfig*RooAbsReal::getIntegratorConfig() const
virtual Double_tgetMax(const char* name = "0") const
virtual Int_tRooAbsReal::getMaxVal(const RooArgSet& vars) const
virtual Double_tgetMin(const char* name = "0") 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_tRooAbsReal::getPlotBins() const
const char*RooAbsReal::getPlotLabel() const
Double_tRooAbsReal::getPlotMax() const
Double_tRooAbsReal::getPlotMin() const
virtual const char*TNamed::GetTitle() const
TStringRooAbsReal::getTitle(Bool_t appendUnit = kFALSE) const
virtual UInt_tTObject::GetUniqueID() const
const Text_t*RooAbsReal::getUnit() const
virtual Double_tRooAbsReal::getVal(const RooArgSet* set = 0) const
Double_tRooAbsReal::getVal(const RooArgSet& set) const
RooArgSet*RooAbsArg::getVariables() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual Bool_thasBinning(const char* name) const
Bool_thasFitMax() const
Bool_thasFitMin() const
virtual ULong_tTNamed::Hash() const
Bool_thasMax(const char* name = "0") const
Bool_thasMin(const char* name = "0") const
virtual Bool_thasRange(const char* name) 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_tRooAbsReal::inPlotRange(Double_t value) const
virtual Bool_tinRange(const char* name) const
Bool_tinRange(Double_t value, Double_t* clippedValue = 0) 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_tisJacobianOK(const RooArgSet& depList) const
virtual Bool_tisLValue() const
Bool_tTObject::IsOnHeap() const
Bool_tRooAbsArg::isShapeServer(const RooAbsArg& arg) const
Bool_tRooAbsArg::isShapeServer(const char* name) const
virtual Bool_tRooAbsArg::IsSortable() const
virtual Bool_tisValidReal(Double_t value, Bool_t printError = kFALSE) const
Bool_tRooAbsArg::isValueServer(const RooAbsArg& arg) const
Bool_tRooAbsArg::isValueServer(const char* name) const
Bool_tTObject::IsZombie() const
virtual Double_tjacobian() 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_tRooAbsReal::maxVal(Int_t code)
voidTObject::MayNotUse(const char* method) const
static voidRooAbsArg::nameFieldLength(Int_t newLen)
virtual Bool_tTObject::Notify()
virtual Int_tnumBins() const
Int_tnumFitBins() const
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)
virtual RooAbsArg&operator=(const RooAbsReal& other)
virtual RooAbsArg&operator=(Double_t newValue)
virtual RooAbsArg&operator=(Int_t ival)
Bool_tRooAbsReal::operator==(Double_t value) const
virtual Bool_tRooAbsReal::operator==(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*RooAbsReal::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*RooAbsReal::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 voidrandomize()
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)
virtual voidsetBin(Int_t ibin)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
static voidRooAbsReal::setCacheCheck(Bool_t flag)
voidsetConstant(Bool_t value = kTRUE)
voidRooAbsArg::setDeleteWatch(Bool_t flag = kTRUE)
static voidRooAbsArg::setDirtyInhibit(Bool_t flag)
virtual voidTObject::SetDrawOption(Option_t* option = "")
static voidTObject::SetDtorOnly(void* obj)
voidRooAbsReal::setIntegratorConfig()
voidRooAbsReal::setIntegratorConfig(const RooNumIntConfig& config)
virtual voidTNamed::SetName(const char* name)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
voidRooAbsReal::setPlotBins(Int_t value)
voidRooAbsReal::setPlotLabel(const char* label)
voidRooAbsReal::setPlotMax(Double_t value)
voidRooAbsReal::setPlotMin(Double_t value)
voidRooAbsReal::setPlotRange(Double_t min, Double_t max)
virtual voidTNamed::SetTitle(const char* title = "")
virtual voidTObject::SetUniqueID(UInt_t uid)
voidRooAbsReal::setUnit(const char* unit)
virtual voidsetVal(Double_t value)
TIterator*RooAbsArg::shapeClientIterator() const
virtual voidShowMembers(TMemberInspector& insp, char* parent)
virtual Int_tTNamed::Sizeof() const
RooNumIntConfig*RooAbsReal::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_tRooAbsReal::allClientsCached(RooAbsArg* var, RooArgSet& cacheList)
virtual voidRooAbsReal::attachToTree(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*RooAbsReal::createProjection(const RooArgSet& dependentVars, const RooArgSet* projectedVars, RooArgSet*& cloneSet, const char* rangeName = "0") const
voidRooAbsReal::doConstOpt(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_tRooAbsReal::evaluate() const
virtual voidRooAbsReal::fillTreeBranch(TTree& t)
Bool_tRooAbsReal::findCacheableBranches(RooAbsArg* arg, RooAbsData* dset, RooArgSet& cacheList, const RooArgSet* normSet, Bool_t verbose)
RooAbsArg*RooAbsArg::findNewServer(const RooAbsCollection& newSet, Bool_t nameChange) const
voidRooAbsReal::findRedundantCacheServers(RooAbsData* dset, RooArgSet& cacheList, RooArgSet& pruneList, Bool_t verbose)
voidRooAbsReal::findUnusedDataVariables(RooAbsData* dset, RooArgSet& pruneList, Bool_t verbose)
Bool_tfitRangeOKForPlotting() const
virtual voidRooAbsArg::getObservablesHook(const RooArgSet*, RooArgSet*) const
virtual voidRooAbsArg::getParametersHook(const RooArgSet*, RooArgSet*) const
RooAbsProxy*RooAbsArg::getProxy(Int_t index) const
TStringRooAbsReal::integralNameSuffix(const RooArgSet& iset, const RooArgSet* nset = 0, const char* rangeName = "0") const
Bool_tRooAbsArg::isShapeDirty() const
virtual Bool_tRooAbsReal::isValid() const
Bool_tRooAbsArg::isValueDirty() 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
RooAbsArg::OperModeRooAbsArg::operMode() const
virtual voidRooAbsArg::operModeHook()
voidRooAbsReal::optimizeDirty(RooAbsData& dataset, const RooArgSet* normSet, Bool_t verbose)
virtual RooPlot*RooAbsReal::plotAsymOn(RooPlot* frame, const RooAbsCategoryLValue& asymCat, RooAbsReal::PlotOpt o) const
virtual RooPlot*RooAbsReal::plotOn(RooPlot* frame, RooLinkedList& cmdList) const
virtual RooPlot*RooAbsReal::plotOn(RooPlot* frame, RooAbsReal::PlotOpt o) const
Bool_tRooAbsReal::plotSanityChecks(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 voidRooAbsReal::selectNormalization(const RooArgSet* depSet = 0, Bool_t force = kFALSE)
virtual voidRooAbsReal::selectNormalizationRange(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 voidRooAbsReal::setTreeBranchStatus(TTree& t, Bool_t active)
voidRooAbsArg::setValueDirty() const
virtual voidRooAbsReal::syncCache(const RooArgSet* set = 0)
Double_tRooAbsReal::traceEval(const RooArgSet* set) const
virtual Bool_tRooAbsReal::traceEvalHook(Double_t) const
voidRooAbsReal::undoConstOpt(RooAbsData& dataset, const RooArgSet* normSet, Bool_t verbose)
voidRooAbsArg::unRegisterProxy(RooArgProxy& proxy)
voidRooAbsArg::unRegisterProxy(RooSetProxy& proxy)
voidRooAbsArg::unRegisterProxy(RooListProxy& proxy)

Data Members

public:
enum RooAbsReal::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_tRooAbsReal::_plotMinMinimum of plot range
Double_tRooAbsReal::_plotMaxMaximum of plot range
Int_tRooAbsReal::_plotBinsNumber of plot bins
Double_tRooAbsReal::_valueCache for current value of object
TStringRooAbsReal::_unitUnit for objects value
TStringRooAbsReal::_labelPlot label for objects value
Bool_tRooAbsReal::_forceNumIntForce numerical integration if flag set
RooNumIntConfig*RooAbsReal::_specIntegratorConfig! Numeric integrator configuration specific for this object
static Bool_tRooAbsReal::_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

~RooAbsRealLValue()
 Destructor
Bool_t inRange(Double_t value, Double_t* clippedValPtr)
 Return kTRUE if the input value is within our fit range. Otherwise, return
 kFALSE and write a clipped value into clippedValPtr if it is non-zero.
Bool_t isValidReal(Double_t value, Bool_t verbose)
 Check if given value is valid
Bool_t readFromStream(istream& /*is*/, Bool_t /*compact*/, Bool_t /*verbose*/)
 Read object contents from given stream
void writeToStream(ostream& /*os*/, Bool_t /*compact*/)
 Write object contents to given stream
RooAbsArg& operator=(Double_t newValue)
 Assignment operator from a Double_t
RooAbsArg& operator=(const RooAbsReal& arg)
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)
 Create a new RooPlot on the heap with a drawing frame initialized for this
 object, but no plot contents. Use x.frame() as the first argument to a
 y.plotOn(...) method, for example. The caller is responsible for deleting
 the returned object.

 This function takes the following named arguments

 Range(double lo, double hi)          -- Make plot frame for the specified range
 Range(const char* name)              -- Make plot frame for range with the specified name
 Bins(Int_t nbins)                    -- Set default binning for datasets to specified number of bins
 AutoRange(const RooAbsData& data,    -- Specifies range so that all points in given data set fit 
                    double margin)       inside the range with given margin.
 AutoSymRange(const RooAbsData& data, -- Specifies range so that all points in given data set fit 
                    double margin)       inside the range and center of range coincides with mean
                                         of distribution in given dataset. 
 Name(const char* name)               -- Give specified name to RooPlot object 
 Title(const char* title)             -- Give specified title to RooPlot object
  
RooPlot* frame(const RooLinkedList& cmdList)
 Define configuration for this method
RooPlot * frame(Double_t xlo, Double_t xhi, Int_t nbins)
 Create a new RooPlot on the heap with a drawing frame initialized for this
 object, but no plot contents. Use x.frame() as the first argument to a
 y.plotOn(...) method, for example. The caller is responsible for deleting
 the returned object.
RooPlot * frame(Double_t xlo, Double_t xhi)
 Create a new RooPlot on the heap with a drawing frame initialized for this
 object, but no plot contents. Use x.frame() as the first argument to a
 y.plotOn(...) method, for example. The caller is responsible for deleting
 the returned object.
RooPlot * frame(Int_t nbins)
 Create a new RooPlot on the heap with a drawing frame initialized for this
 object, but no plot contents. Use x.frame() as the first argument to a
 y.plotOn(...) method, for example. The caller is responsible for deleting
 the returned object.

 The current fit range may not be open ended or empty.
RooPlot * frame()
 Create a new RooPlot on the heap with a drawing frame initialized for this
 object, but no plot contents. Use x.frame() as the first argument to a
 y.plotOn(...) method, for example. The caller is responsible for deleting
 the returned object.

 The current fit range may not be open ended or empty.
void copyCache(const RooAbsArg* source)
 Copy cache of another RooAbsArg to our cache
void printToStream(ostream& os, PrintOption opt, TString indent)
 Print info about this object to the specified stream. In addition to the info
 from RooAbsReal::printToStream() we add:

   Verbose : fit range and error
void randomize()
 Set a new value sampled from a uniform distribution over the fit range.
 Prints a warning and does nothing if the fit range is not finite.
void setBin(Int_t ibin)
 Check range of plot bin index
Bool_t fitRangeOKForPlotting()
 Check if fit range is usable as plot range, i.e. it is neither
 open ended, nor empty
Bool_t inRange(const char* name)
 Check if current value is inside range with given name
TH1* createHistogram(const char *name, 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 empty ROOT histogram TH1,TH2 or TH3 suitabe to store information represent by the RooAbsRealLValue

 This function accepts the following arguments

 name -- Name of the 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
TH1* createHistogram(const char *name, const RooLinkedList& cmdList)
 Create empty 1,2 or 3D histogram
 Arguments recognized

 YVar() -- RooRealVar defining Y dimension with optional range/binning
 ZVar() -- RooRealVar defining Z dimension with optional range/binning
 AxisLabel() -- Vertical axis label
 Binning() -- Range/Binning specification of X axis
TH1F * createHistogram(const char *name, const char *yAxisLabel)
 Create an empty 1D-histogram with appropriate scale and labels for this variable.
 This method uses the default plot range which can be changed using the
 setPlotMin(),setPlotMax() methods, and the default binning which can be
 changed with setPlotBins(). The caller takes ownership of the returned
 object and is responsible for deleting it.
TH1F * createHistogram(const char *name, const char *yAxisLabel, Double_t xlo, Double_t xhi, Int_t nBins)
 Create an empty 1D-histogram with appropriate scale and labels for this variable.
 This method uses the default plot range which can be changed using the
 setPlotMin(),setPlotMax() methods, and the default binning which can be
 changed with setPlotBins(). The caller takes ownership of the returned
 object and is responsible for deleting it.
TH1F * createHistogram(const char *name, const char *yAxisLabel, const RooAbsBinning& bins)
 Create an empty 1D-histogram with appropriate scale and labels for this variable.
TH2F * createHistogram(const char *name, const RooAbsRealLValue &yvar, const char *zAxisLabel, Double_t* xlo, Double_t* xhi, Int_t* nBins)
 Create an empty 2D-histogram with appropriate scale and labels for this variable (x)
 and the specified y variable. This method uses the default plot ranges for x and y which
 can be changed using the setPlotMin(),setPlotMax() methods, and the default binning which
 can be changed with setPlotBins(). The caller takes ownership of the returned object
 and is responsible for deleting it.
TH2F * createHistogram(const char *name, const RooAbsRealLValue &yvar, const char *zAxisLabel, const RooAbsBinning** bins)
 Create an empty 2D-histogram with appropriate scale and labels for this variable (x)
 and the specified y variable. 
TH3F * createHistogram(const char *name, const RooAbsRealLValue &yvar, const RooAbsRealLValue &zvar, const char *tAxisLabel, Double_t* xlo, Double_t* xhi, Int_t* nBins)
 Create an empty 3D-histogram with appropriate scale and labels for this variable (x)
 and the specified y,z variables. This method uses the default plot ranges for x,y,z which
 can be changed using the setPlotMin(),setPlotMax() methods, and the default binning which
 can be changed with setPlotBins(). The caller takes ownership of the returned object
 and is responsible for deleting it.
TH3F * createHistogram(const char *name, const RooAbsRealLValue &yvar, const RooAbsRealLValue &zvar, const char* tAxisLabel, const RooAbsBinning** bins)
 Create an empty 3D-histogram with appropriate scale and labels for this variable (x)
 and the specified y,z variables. 
TH1 * createHistogram(const char *name, RooArgList &vars, const char *tAxisLabel, Double_t* xlo, Double_t* xhi, Int_t* nBins)
TH1 * createHistogram(const char *name, RooArgList &vars, const char *tAxisLabel, const RooAbsBinning** bins)
 Create a 1,2, or 3D-histogram with appropriate scale and labels.
 Binning and ranges are taken from the variables themselves and can be changed by
 calling their setPlotMin/Max() and setPlotBins() methods. A histogram can be filled
 using RooAbsReal::fillHistogram() or RooTreeData::fillHistogram().
 The caller takes ownership of the returned object and is responsible for deleting it.
Double_t getFitMin()
Double_t getFitMax()
Bool_t hasFitMin()
Bool_t hasFitMax()
Int_t getFitBins()
Int_t numFitBins()
Bool_t isJacobianOK(const RooArgSet&)
void setVal(Double_t value)
 Parameter value and error accessors
RooAbsArg& operator=(const RooAbsReal& other)
Int_t getBin()
{ return getBinning().binNumber(getVal()) ; }
Int_t numBins()
{ return getBins() ; }
Double_t getBinWidth(Int_t i)
{ return getBinning().binWidth(i) ; }
const RooAbsBinning& getBinning(const char* name=0, Bool_t verbose=kTRUE, Bool_t createOnTheFly=kFALSE)
 Get fit range limits
RooAbsBinning& getBinning(const char* name=0, Bool_t verbose=kTRUE, Bool_t createOnTheFly=kFALSE)
Bool_t hasBinning(const char* name)
Double_t getMin(const char* name=0)
{ return getBinning(name).lowBound() ; }
Double_t getMax(const char* name=0)
{ return getBinning(name).highBound() ; }
Int_t getBins(const char* name=0)
{ return getBinning(name).numBins() ; }
Bool_t hasMin(const char* name=0)
{ return !RooNumber::isInfinite(getMin(name)); }
Bool_t hasMax(const char* name=0)
{ return !RooNumber::isInfinite(getMax(name)); }
Bool_t hasRange(const char* name)
{ return hasBinning(name) ; }
Double_t jacobian()
{ return 1 ; }
Bool_t isLValue()
{ return kTRUE; }
void setConstant(Bool_t value= kTRUE)
 Constant and Projected flags 
{ setAttribute("Constant",value); }

Last update: Sat Dec 9 09:56:26 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.