Logo ROOT  
Reference Guide
RooFactoryWSTool.h
Go to the documentation of this file.
1 /*****************************************************************************
2  * Project: RooFit *
3  * Package: RooFitCore *
4  * File: $Id$
5  * Authors: *
6  * WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
7  * DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
8  * *
9  * Copyright (c) 2000-2005, Regents of the University of California *
10  * and Stanford University. All rights reserved. *
11  * *
12  * Redistribution and use in source and binary forms, *
13  * with or without modification, are permitted according to the terms *
14  * listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
15  *****************************************************************************/
16 
17 #ifndef ROO_FACTORY_WS_TOOL
18 #define ROO_FACTORY_WS_TOOL
19 
20 #include "RooArgSet.h"
21 #include "RooArgList.h"
22 #include <string>
23 #include <vector>
24 #include <stack>
25 #include <map>
26 
27 class RooAbsReal ;
28 class RooAbsRealLValue ;
29 class RooAbsPdf ;
30 class RooWorkspace ;
31 class RooRealVar ;
32 class RooCategory ;
33 class RooAddPdf ;
34 class RooProdPdf ;
35 class RooSimultaneous ;
36 class RooDataHist ;
37 class RooDataSet ;
38 class RooAbsData ;
39 class RooFactoryWSToolSpec ;
41 class RooAbsCategory ;
42 class RooResolutionModel ;
43 class RooAddition ;
44 class RooProduct ;
45 class RooRealSumPdf ;
46 
47 class RooFactoryWSTool : public TNamed, public RooPrintable {
48 
49 public:
50 
51  // Constructors, assignment etc
53  virtual ~RooFactoryWSTool() ;
54 
55  // --- low level factory interface ---
56 
57  // Create variables
59  RooCategory* createCategory(const char* name, const char* stateNameList=0) ;
60 
61  // Create functions and p.d.f.s (any RooAbsArg)
62  RooAbsArg* createArg(const char* className, const char* objName, const char* varList) ;
63 
64  // Create operator p.d.f.s
65  RooAddPdf* add(const char *objName, const char* specList, Bool_t recursiveCoefs=kFALSE) ;
66  RooRealSumPdf* amplAdd(const char *objName, const char* specList) ;
67  RooProdPdf* prod(const char *objName, const char* pdfList) ;
68  RooSimultaneous* simul(const char* objName, const char* indexCat, const char* pdfMap) ;
69 
70  // Create operator functions
71  RooAddition* addfunc(const char *objName, const char* specList) ;
72  RooProduct* prodfunc(const char *objName, const char* pdfList) ;
73 
74  RooWorkspace& ws() { return *_ws ; }
75 
76  // --- High level factory interface ---
77 
78  // Composite object construction language parser
79  RooAbsArg* process(const char* expr) ;
80  std::string processExpression(const char* expr) ;
81  std::vector<std::string> splitFunctionArgs(const char* funcExpr) ;
82 
83 
84  // --- Internal stuff that must be public so that CINT can access it ---
85 
86  // CINT constructor interface
87  static RooAbsArg& as_ARG(UInt_t idx) { checkIndex(idx) ; return of()->of()->asARG(of()->_args[idx].c_str()) ; }
88 
89  static RooAbsPdf& as_PDF(UInt_t idx) { checkIndex(idx) ; return of()->asPDF(of()->_args[idx].c_str()) ; }
90  static RooAbsReal& as_FUNC(UInt_t idx) { checkIndex(idx) ; return of()->asFUNC(of()->_args[idx].c_str()) ; }
91  static RooRealVar& as_VAR(UInt_t idx) { checkIndex(idx) ; return of()->asVAR(of()->_args[idx].c_str()) ; }
92  static RooAbsRealLValue& as_VARLV(UInt_t idx) { checkIndex(idx) ; return of()->asVARLV(of()->_args[idx].c_str()) ; }
93  static RooResolutionModel& as_RMODEL(UInt_t idx) { checkIndex(idx) ; return of()->asRMODEL(of()->_args[idx].c_str()) ; }
94 
95  static RooCategory& as_CAT(UInt_t idx) { checkIndex(idx) ; return of()->asCAT(of()->_args[idx].c_str()) ; }
96  static RooAbsCategoryLValue& as_CATLV(UInt_t idx) { checkIndex(idx) ; return of()->asCATLV(of()->_args[idx].c_str()) ; }
97  static RooAbsCategory& as_CATFUNC(UInt_t idx) { checkIndex(idx) ; return of()->asCATFUNC(of()->_args[idx].c_str()) ; }
98 
99  static RooArgSet as_SET(UInt_t idx) { checkIndex(idx) ; return of()->asSET(of()->_args[idx].c_str()) ; }
100  static RooArgList as_LIST(UInt_t idx) { checkIndex(idx) ; return of()->asLIST(of()->_args[idx].c_str()) ; }
101 
102  static RooAbsData& as_DATA(UInt_t idx) { checkIndex(idx) ; return of()->asDATA(of()->_args[idx].c_str()) ; }
103  static RooDataHist& as_DHIST(UInt_t idx) { checkIndex(idx) ; return of()->asDHIST(of()->_args[idx].c_str()) ; }
104  static RooDataSet& as_DSET(UInt_t idx) { checkIndex(idx) ; return of()->asDSET(of()->_args[idx].c_str()) ; }
105 
106  static TObject& as_OBJ(UInt_t idx) { checkIndex(idx) ; return of()->asOBJ(of()->_args[idx].c_str()) ; }
107 
108  static const char* as_STRING(UInt_t idx) { checkIndex(idx) ; return of()->asSTRING(of()->_args[idx].c_str()) ; }
109  static Int_t as_INT(UInt_t idx) { checkIndex(idx) ; return of()->asINT(of()->_args[idx].c_str()) ; }
110  static Double_t as_DOUBLE(UInt_t idx) { checkIndex(idx) ; return of()->asDOUBLE(of()->_args[idx].c_str()) ; }
111  static Int_t as_INT(UInt_t idx, Int_t defVal) { checkIndex(idx) ; if (idx>of()->_args.size()-1) return defVal ; return of()->asINT(of()->_args[idx].c_str()) ; }
112  static Double_t as_DOUBLE(UInt_t idx, Double_t defVal) { checkIndex(idx) ; if (idx>of()->_args.size()-1) return defVal ; return of()->asDOUBLE(of()->_args[idx].c_str()) ; }
113 
114  RooAbsArg& asARG(const char*) ;
115 
116  RooAbsPdf& asPDF(const char*) ;
117  RooAbsReal& asFUNC(const char*) ;
118  RooRealVar& asVAR(const char*) ;
119  RooAbsRealLValue& asVARLV(const char*) ;
120  RooResolutionModel& asRMODEL(const char*) ;
121 
122  RooCategory& asCAT(const char*) ;
123  RooAbsCategoryLValue& asCATLV(const char*) ;
124  RooAbsCategory& asCATFUNC(const char*) ;
125 
126  RooArgSet asSET(const char*) ;
127  RooArgList asLIST(const char*) ;
128 
129  RooAbsData& asDATA(const char*) ;
130  RooDataHist& asDHIST(const char*) ;
131  RooDataSet& asDSET(const char*) ;
132 
133  TObject& asOBJ(const char*) ;
134 
135  const char* asSTRING(const char*) ;
136  Int_t asINT(const char*) ;
137  Double_t asDOUBLE(const char*) ;
138 
139  class IFace {
140  public:
141  virtual ~IFace() {} ;
142  virtual std::string create(RooFactoryWSTool& ft, const char* typeName, const char* instanceName, std::vector<std::string> args) = 0 ;
143  } ;
144 
145  class SpecialsIFace : public IFace {
146  public:
147  virtual ~SpecialsIFace() {} ;
148  std::string create(RooFactoryWSTool& ft, const char* typeName, const char* instanceName, std::vector<std::string> args) ;
149  } ;
150 
151  static void registerSpecial(const char* typeName, RooFactoryWSTool::IFace* iface) ;
152 
153  void logError() { _errorCount++ ; }
154 
155  const char* autoClassNamePostFix() const { return _autoClassPostFix.c_str() ; }
156  void setAutoClassNamePostFix(const char* pfix) { _autoClassPostFix = pfix ; }
157 
158 protected:
159 
160  Bool_t checkSyntax(const char* arg) ;
161 
162  std::string varTag(std::string& func, std::vector<std::string>& args) ;
163 
164  std::stack<std::string> _autoNamePrefix ;
165  std::map<std::string,std::string> _typeAliases ;
166 
167  static void checkIndex(UInt_t index) ;
168 
169 
170  std::string processCompositeExpression(const char* arg) ;
171  std::string processSingleExpression(const char* arg) ;
172  std::string processListExpression(const char* arg) ;
173  std::string processAliasExpression(const char* arg) ;
174 
175  std::string processCreateVar(std::string& func, std::vector<std::string>& args) ;
176  std::string processCreateArg(std::string& func, std::vector<std::string>& args) ;
177  std::string processMetaArg(std::string& func, std::vector<std::string>& args) ;
178 
179  TClass* resolveClassName(const char* className) ;
180 
181  // CINT constructor interface back end
182  static RooFactoryWSTool* of() ;
184  std::vector<std::string> _args ;
185 
186  // Hooks for other tools
187  static std::map<std::string,IFace*>& hooks() ;
188  static std::map<std::string,IFace*>* _hooks ;
189 
190  RooWorkspace* _ws ; //! Associated workspace
191 
192  void clearError() { _errorCount = 0 ; }
193  Int_t errorCount() { return _errorCount ; }
194 
195  Int_t _errorCount ; // Error counter for a given expression processing
196 
197  std::string _autoClassPostFix ;
198 
200 
201  ClassDef(RooFactoryWSTool,0) // RooFit class code and instance factory
202 
203 } ;
204 
205 
206 
207 #endif
RooFactoryWSTool::asRMODEL
RooResolutionModel & asRMODEL(const char *)
CINT constructor interface, return constructor string argument #idx as RooResolutionModel reference f...
Definition: RooFactoryWSTool.cxx:1670
RooFactoryWSTool::processAliasExpression
std::string processAliasExpression(const char *arg)
Parse token.
Definition: RooFactoryWSTool.cxx:1229
RooFactoryWSTool::as_DOUBLE
static Double_t as_DOUBLE(UInt_t idx)
Definition: RooFactoryWSTool.h:110
RooFactoryWSTool::asDATA
RooAbsData & asDATA(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsData object found in wor...
Definition: RooFactoryWSTool.cxx:1827
RooFactoryWSTool::process
RooAbsArg * process(const char *expr)
Create a RooFit object from the given expression.
Definition: RooFactoryWSTool.cxx:853
RooAddPdf
RooAddPdf is an efficient implementation of a sum of PDFs of the form.
Definition: RooAddPdf.h:32
RooAbsData
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:47
RooFactoryWSTool::asDSET
RooDataSet & asDSET(const char *)
CINT constructor interface, return constructor string argument #idx as RooDataSet object found in wor...
Definition: RooFactoryWSTool.cxx:1858
RooFactoryWSTool::asARG
RooAbsArg & asARG(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsArg reference found in w...
Definition: RooFactoryWSTool.cxx:1574
RooFactoryWSTool::_typeAliases
std::map< std::string, std::string > _typeAliases
Definition: RooFactoryWSTool.h:165
RooFactoryWSTool::as_ARG
static RooAbsArg & as_ARG(UInt_t idx)
Definition: RooFactoryWSTool.h:87
RooArgSet.h
RooFactoryWSTool::processCreateVar
std::string processCreateVar(std::string &func, std::vector< std::string > &args)
Glue function between high-level syntax and low-level factory call to createVariable: Process a parse...
Definition: RooFactoryWSTool.cxx:1311
RooFactoryWSTool::_args
std::vector< std::string > _args
Definition: RooFactoryWSTool.h:184
RooFactoryWSTool::as_FUNC
static RooAbsReal & as_FUNC(UInt_t idx)
Definition: RooFactoryWSTool.h:90
RooFactoryWSTool::asFUNC
RooAbsReal & asFUNC(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsReal reference found in ...
Definition: RooFactoryWSTool.cxx:1594
xmax
float xmax
Definition: THbookFile.cxx:95
RooFactoryWSTool::asDHIST
RooDataHist & asDHIST(const char *)
CINT constructor interface, return constructor string argument #idx as RooDataHist object found in wo...
Definition: RooFactoryWSTool.cxx:1841
RooFactoryWSTool::_autoClassPostFix
std::string _autoClassPostFix
Definition: RooFactoryWSTool.h:197
RooFactoryWSTool::asCAT
RooCategory & asCAT(const char *)
CINT constructor interface, return constructor string argument #idx as RooCategory reference found in...
Definition: RooFactoryWSTool.cxx:1726
RooFactoryWSTool::as_RMODEL
static RooResolutionModel & as_RMODEL(UInt_t idx)
Definition: RooFactoryWSTool.h:93
RooArgList
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:21
RooFactoryWSTool::as_LIST
static RooArgList as_LIST(UInt_t idx)
Definition: RooFactoryWSTool.h:100
RooFactoryWSTool::checkSyntax
Bool_t checkSyntax(const char *arg)
Perform basic syntax on given factory expression.
Definition: RooFactoryWSTool.cxx:1529
RooFactoryWSTool::_hooks
static std::map< std::string, IFace * > * _hooks
Definition: RooFactoryWSTool.h:188
RooFactoryWSTool::~RooFactoryWSTool
virtual ~RooFactoryWSTool()
Destructor.
Definition: RooFactoryWSTool.cxx:143
RooFactoryWSTool::as_DHIST
static RooDataHist & as_DHIST(UInt_t idx)
Definition: RooFactoryWSTool.h:103
RooAbsReal
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:62
RooFactoryWSTool::_ws
RooWorkspace * _ws
Definition: RooFactoryWSTool.h:190
RooFactoryWSTool::SpecialsIFace::create
std::string create(RooFactoryWSTool &ft, const char *typeName, const char *instanceName, std::vector< std::string > args)
Concatenate list of args into comma separated string.
Definition: RooFactoryWSTool.cxx:1958
RooFactoryWSTool::ws
RooWorkspace & ws()
Definition: RooFactoryWSTool.h:74
RooFactoryWSTool::as_INT
static Int_t as_INT(UInt_t idx)
Definition: RooFactoryWSTool.h:109
RooFactoryWSTool::RooFactoryWSTool
RooFactoryWSTool(RooWorkspace &ws)
Definition: RooFactoryWSTool.cxx:132
RooFactoryWSTool::errorCount
Int_t errorCount()
Definition: RooFactoryWSTool.h:193
RooPrintable
RooPlotable is a 'mix-in' base class that define the standard RooFit plotting and printing methods.
Definition: RooPrintable.h:25
bool
RooFactoryWSTool::as_CATFUNC
static RooAbsCategory & as_CATFUNC(UInt_t idx)
Definition: RooFactoryWSTool.h:97
RooFactoryWSTool::createCategory
RooCategory * createCategory(const char *name, const char *stateNameList=0)
Low-level factory interface for creating a RooCategory with a given list of state names.
Definition: RooFactoryWSTool.cxx:177
RooFactoryWSTool::RooFactoryWSTool
RooFactoryWSTool(const RooFactoryWSTool &)
RooFactoryWSTool::asPDF
RooAbsPdf & asPDF(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsPdf reference found in w...
Definition: RooFactoryWSTool.cxx:1655
RooFactoryWSTool::as_OBJ
static TObject & as_OBJ(UInt_t idx)
Definition: RooFactoryWSTool.h:106
RooAbsCategory
RooAbsCategory is the base class for objects that represent a discrete value with a finite number of ...
Definition: RooAbsCategory.h:38
RooFactoryWSTool::_errorCount
Int_t _errorCount
Definition: RooFactoryWSTool.h:195
RooFactoryWSTool::of
static RooFactoryWSTool * of()
Definition: RooFactoryWSTool.cxx:2200
RooFactoryWSTool::asVARLV
RooAbsRealLValue & asVARLV(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsRealLValue reference fou...
Definition: RooFactoryWSTool.cxx:1617
RooFactoryWSTool::as_SET
static RooArgSet as_SET(UInt_t idx)
Definition: RooFactoryWSTool.h:99
RooFactoryWSTool::registerSpecial
static void registerSpecial(const char *typeName, RooFactoryWSTool::IFace *iface)
Register foreign special objects in factory.
Definition: RooFactoryWSTool.cxx:1937
RooFactoryWSTool::asSET
RooArgSet asSET(const char *)
CINT constructor interface, return constructor string argument #idx as RooArgSet of objects found in ...
Definition: RooFactoryWSTool.cxx:1742
RooProduct
A RooProduct represents the product of a given set of RooAbsReal objects.
Definition: RooProduct.h:30
RooDataHist
The RooDataHist is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:39
RooFactoryWSTool::splitFunctionArgs
std::vector< std::string > splitFunctionArgs(const char *funcExpr)
Allocate and fill work buffer.
Definition: RooFactoryWSTool.cxx:1453
RooFactoryWSTool
RooFactoryWSTool is a class similar to TTree::MakeClass() that generates skeleton code for RooAbsPdf ...
Definition: RooFactoryWSTool.h:47
RooResolutionModel
RooResolutionModel is the base class for PDFs that represent a resolution model that can be convolute...
Definition: RooResolutionModel.h:26
RooFactoryWSTool::as_INT
static Int_t as_INT(UInt_t idx, Int_t defVal)
Definition: RooFactoryWSTool.h:111
xmin
float xmin
Definition: THbookFile.cxx:95
RooFactoryWSTool::processCompositeExpression
std::string processCompositeExpression(const char *arg)
Process a single composite expression.
Definition: RooFactoryWSTool.cxx:945
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
RooFactoryWSTool::createVariable
RooRealVar * createVariable(const char *name, Double_t xmin, Double_t xmax)
Low-level factory interface for creating a RooRealVar with a given range and initial value.
Definition: RooFactoryWSTool.cxx:153
RooFactoryWSTool::processMetaArg
std::string processMetaArg(std::string &func, std::vector< std::string > &args)
Concatenate list of args into comma separated string.
Definition: RooFactoryWSTool.cxx:1429
RooFactoryWSTool::asLIST
RooArgList asLIST(const char *)
CINT constructor interface, return constructor string argument #idx as RooArgList of objects found in...
Definition: RooFactoryWSTool.cxx:1791
RooAddition
RooAddition calculates the sum of a set of RooAbsReal terms, or when constructed with two sets,...
Definition: RooAddition.h:27
RooFactoryWSTool::as_CAT
static RooCategory & as_CAT(UInt_t idx)
Definition: RooFactoryWSTool.h:95
RooFactoryWSTool::simul
RooSimultaneous * simul(const char *objName, const char *indexCat, const char *pdfMap)
Definition: RooFactoryWSTool.cxx:656
RooFactoryWSTool::processListExpression
std::string processListExpression(const char *arg)
Process a list of high-level expression.
Definition: RooFactoryWSTool.cxx:1159
RooFactoryWSTool::setAutoClassNamePostFix
void setAutoClassNamePostFix(const char *pfix)
Definition: RooFactoryWSTool.h:156
RooFactoryWSTool::resolveClassName
TClass * resolveClassName(const char *className)
Definition: RooFactoryWSTool.cxx:1249
RooFactoryWSTool::clearError
void clearError()
Associated workspace.
Definition: RooFactoryWSTool.h:192
RooFactoryWSTool::checkIndex
static void checkIndex(UInt_t index)
Definition: RooFactoryWSTool.cxx:1562
RooFactoryWSTool::asCATFUNC
RooAbsCategory & asCATFUNC(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsCategory reference found...
Definition: RooFactoryWSTool.cxx:1689
RooFactoryWSTool::createArg
RooAbsArg * createArg(const char *className, const char *objName, const char *varList)
Low-level factory interface for creating a RooAbsPdf of a given class with a given list of input vari...
Definition: RooFactoryWSTool.cxx:307
RooFactoryWSTool::asINT
Int_t asINT(const char *)
CINT constructor interface, return constructor string argument #idx as Int_t.
Definition: RooFactoryWSTool.cxx:1919
unsigned int
RooFactoryWSTool::amplAdd
RooRealSumPdf * amplAdd(const char *objName, const char *specList)
Definition: RooFactoryWSTool.cxx:546
RooFactoryWSTool::IFace
Definition: RooFactoryWSTool.h:139
RooFactoryWSTool::autoClassNamePostFix
const char * autoClassNamePostFix() const
Definition: RooFactoryWSTool.h:155
RooFactoryWSTool::varTag
std::string varTag(std::string &func, std::vector< std::string > &args)
Definition: RooFactoryWSTool.cxx:1282
RooWorkspace
The RooWorkspace is a persistable container for RooFit projects.
Definition: RooWorkspace.h:43
RooFactoryWSTool::IFace::create
virtual std::string create(RooFactoryWSTool &ft, const char *typeName, const char *instanceName, std::vector< std::string > args)=0
Double_t
double Double_t
Definition: RtypesCore.h:59
RooFactoryWSTool::as_DSET
static RooDataSet & as_DSET(UInt_t idx)
Definition: RooFactoryWSTool.h:104
RooCategory
RooCategory is an object to represent discrete states.
Definition: RooCategory.h:27
RooFactoryWSTool::processSingleExpression
std::string processSingleExpression(const char *arg)
Process a single high-level expression.
Definition: RooFactoryWSTool.cxx:1010
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
RooFactoryWSTool::as_VARLV
static RooAbsRealLValue & as_VARLV(UInt_t idx)
Definition: RooFactoryWSTool.h:92
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:325
RooFactoryWSTool::_of
static RooFactoryWSTool * _of
Definition: RooFactoryWSTool.h:183
RooFactoryWSTool::as_PDF
static RooAbsPdf & as_PDF(UInt_t idx)
Definition: RooFactoryWSTool.h:89
RooFactoryWSTool::as_DATA
static RooAbsData & as_DATA(UInt_t idx)
Definition: RooFactoryWSTool.h:102
RooFactoryWSTool::_autoNamePrefix
std::stack< std::string > _autoNamePrefix
Definition: RooFactoryWSTool.h:164
RooFactoryWSTool::SpecialsIFace
Definition: RooFactoryWSTool.h:145
name
char name[80]
Definition: TGX11.cxx:110
RooFactoryWSTool::as_DOUBLE
static Double_t as_DOUBLE(UInt_t idx, Double_t defVal)
Definition: RooFactoryWSTool.h:112
RooFactoryWSTool::prod
RooProdPdf * prod(const char *objName, const char *pdfList)
Definition: RooFactoryWSTool.cxx:588
RooDataSet
RooDataSet is a container class to hold unbinned data.
Definition: RooDataSet.h:33
RooFactoryWSTool::SpecialsIFace::~SpecialsIFace
virtual ~SpecialsIFace()
Definition: RooFactoryWSTool.h:147
RooFactoryWSTool::asCATLV
RooAbsCategoryLValue & asCATLV(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsCategoryLValue reference...
Definition: RooFactoryWSTool.cxx:1707
RooFactoryWSTool::asVAR
RooRealVar & asVAR(const char *)
CINT constructor interface, return constructor string argument #idx as RooRealVar reference found in ...
Definition: RooFactoryWSTool.cxx:1640
RooAbsArg
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:72
RooFactoryWSTool::add
RooAddPdf * add(const char *objName, const char *specList, Bool_t recursiveCoefs=kFALSE)
Definition: RooFactoryWSTool.cxx:504
RooAbsPdf
Definition: RooAbsPdf.h:43
RooFactoryWSTool::addfunc
RooAddition * addfunc(const char *objName, const char *specList)
Definition: RooFactoryWSTool.cxx:705
RooFactoryWSTool::processCreateArg
std::string processCreateArg(std::string &func, std::vector< std::string > &args)
Glue function between high-level syntax and low-level factory call to createArg: Process a parsed cal...
Definition: RooFactoryWSTool.cxx:1381
RooFactoryWSTool::prodfunc
RooProduct * prodfunc(const char *objName, const char *pdfList)
Definition: RooFactoryWSTool.cxx:760
RooSimultaneous
RooSimultaneous facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset.
Definition: RooSimultaneous.h:37
RooAbsCategoryLValue
RooAbsCategoryLValue is the common abstract base class for objects that represent a discrete value th...
Definition: RooAbsCategoryLValue.h:25
RooFactoryWSTool::logError
void logError()
Definition: RooFactoryWSTool.h:153
RooRealVar
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:37
RooFactoryWSTool::hooks
static std::map< std::string, IFace * > & hooks()
Definition: RooFactoryWSTool.cxx:1946
RooAbsRealLValue
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
Definition: RooAbsRealLValue.h:31
RooProdPdf
RooProdPdf is an efficient implementation of a product of PDFs of the form.
Definition: RooProdPdf.h:37
RooFactoryWSTool::asOBJ
TObject & asOBJ(const char *)
Definition: RooFactoryWSTool.cxx:1875
RooArgList.h
RooRealSumPdf
The class RooRealSumPdf implements a PDF constructed from a sum of functions:
Definition: RooRealSumPdf.h:25
RooFactoryWSTool::as_CATLV
static RooAbsCategoryLValue & as_CATLV(UInt_t idx)
Definition: RooFactoryWSTool.h:96
RooFactoryWSTool::as_STRING
static const char * as_STRING(UInt_t idx)
Definition: RooFactoryWSTool.h:108
RooFactoryWSTool::asDOUBLE
Double_t asDOUBLE(const char *)
CINT constructor interface, return constructor string argument #idx as Double_t.
Definition: RooFactoryWSTool.cxx:1928
RooFactoryWSTool::processExpression
std::string processExpression(const char *expr)
Process a single high-level expression or list of expressions.
Definition: RooFactoryWSTool.cxx:918
RooFactoryWSTool::as_VAR
static RooRealVar & as_VAR(UInt_t idx)
Definition: RooFactoryWSTool.h:91
RooArgSet
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:29
RooFactoryWSTool::IFace::~IFace
virtual ~IFace()
Definition: RooFactoryWSTool.h:141
RooFactoryWSTool::asSTRING
const char * asSTRING(const char *)
CINT constructor interface, return constructor string argument #idx as const char*.
Definition: RooFactoryWSTool.cxx:1889
int