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
27class RooAbsReal ;
28class RooAbsRealLValue ;
29class RooAbsPdf ;
30class RooWorkspace ;
31class RooRealVar ;
32class RooCategory ;
33class RooAddPdf ;
34class RooProdPdf ;
35class RooSimultaneous ;
36class RooDataHist ;
37class RooDataSet ;
38class RooAbsData ;
39class RooFactoryWSToolSpec ;
41class RooAbsCategory ;
43class RooAddition ;
44class RooProduct ;
45class RooRealSumPdf ;
46
47class RooFactoryWSTool : public TNamed, public RooPrintable {
48
49public:
50
51 // Constructors, assignment etc
53 ~RooFactoryWSTool() override ;
54
55 // --- low level factory interface ---
56
57 // Create variables
58 RooRealVar* createVariable(const char* name, double xmin, double xmax) ;
59 RooCategory* createCategory(const char* name, const char* stateNameList=nullptr) ;
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 recursiveCoefs=false) ;
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 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 as_DOUBLE(UInt_t idx, double 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 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 ~SpecialsIFace() override {} ;
148 std::string create(RooFactoryWSTool& ft, const char* typeName, const char* instanceName, std::vector<std::string> args) override ;
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
158protected:
159
160 bool 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 ; }
194
195 Int_t _errorCount ; // Error counter for a given expression processing
196
197 std::string _autoClassPostFix ;
198
200
201 ClassDefOverride(RooFactoryWSTool,0) // RooFit class code and instance factory
202
203} ;
204
205
206
207#endif
#define ClassDefOverride(name, id)
Definition: Rtypes.h:339
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
char name[80]
Definition: TGX11.cxx:110
float xmin
Definition: THbookFile.cxx:95
float xmax
Definition: THbookFile.cxx:95
RooAbsArg is the common abstract base class for objects that represent a value and a "shape" in RooFi...
Definition: RooAbsArg.h:71
RooAbsCategoryLValue is the common abstract base class for objects that represent a discrete value th...
A space to attach TBranches.
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:62
RooAbsRealLValue is the common abstract base class for objects that represent a real value that may a...
RooAbsReal is the common abstract base class for objects that represent a real value and implements f...
Definition: RooAbsReal.h:62
RooAddPdf is an efficient implementation of a sum of PDFs of the form.
Definition: RooAddPdf.h:34
RooAddition calculates the sum of a set of RooAbsReal terms, or when constructed with two sets,...
Definition: RooAddition.h:27
RooArgList is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgList.h:22
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition: RooArgSet.h:56
RooCategory is an object to represent discrete states.
Definition: RooCategory.h:28
The RooDataHist is a container class to hold N-dimensional binned data.
Definition: RooDataHist.h:45
RooDataSet is a container class to hold unbinned data.
Definition: RooDataSet.h:55
virtual std::string create(RooFactoryWSTool &ft, const char *typeName, const char *instanceName, std::vector< std::string > args)=0
std::string create(RooFactoryWSTool &ft, const char *typeName, const char *instanceName, std::vector< std::string > args) override
Concatenate list of args into comma separated string.
RooFactoryWSTool is a class similar to TTree::MakeClass() that generates skeleton code for RooAbsPdf ...
RooWorkspace & ws()
const char * autoClassNamePostFix() const
void setAutoClassNamePostFix(const char *pfix)
static RooAbsReal & as_FUNC(UInt_t idx)
RooWorkspace * _ws
RooAddPdf * add(const char *objName, const char *specList, bool recursiveCoefs=false)
RooAbsArg & asARG(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsArg reference found in w...
RooFactoryWSTool(const RooFactoryWSTool &)
std::string _autoClassPostFix
RooAbsArg * process(const char *expr)
Create a RooFit object from the given expression.
RooCategory & asCAT(const char *)
CINT constructor interface, return constructor string argument #idx as RooCategory reference found in...
static void checkIndex(UInt_t index)
static RooFactoryWSTool * of()
static RooAbsArg & as_ARG(UInt_t idx)
static RooAbsRealLValue & as_VARLV(UInt_t idx)
RooAbsPdf & asPDF(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsPdf reference found in w...
RooDataSet & asDSET(const char *)
CINT constructor interface, return constructor string argument #idx as RooDataSet object found in wor...
std::string processListExpression(const char *arg)
Process a list of high-level expression.
RooRealVar & asVAR(const char *)
CINT constructor interface, return constructor string argument #idx as RooRealVar reference found in ...
static void registerSpecial(const char *typeName, RooFactoryWSTool::IFace *iface)
Register foreign special objects in factory.
std::string processExpression(const char *expr)
Process a single high-level expression or list of expressions.
static Int_t as_INT(UInt_t idx, Int_t defVal)
static RooFactoryWSTool * _of
static TObject & as_OBJ(UInt_t idx)
std::string processAliasExpression(const char *arg)
Parse token.
RooAbsRealLValue & asVARLV(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsRealLValue reference fou...
static RooAbsCategoryLValue & as_CATLV(UInt_t idx)
Int_t asINT(const char *)
CINT constructor interface, return constructor string argument #idx as Int_t.
RooAddition * addfunc(const char *objName, const char *specList)
static double as_DOUBLE(UInt_t idx, double defVal)
~RooFactoryWSTool() override
Destructor.
static RooDataHist & as_DHIST(UInt_t idx)
RooAbsData & asDATA(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsData object found in wor...
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...
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...
static RooResolutionModel & as_RMODEL(UInt_t idx)
static const char * as_STRING(UInt_t idx)
RooFactoryWSTool(RooWorkspace &ws)
static RooAbsData & as_DATA(UInt_t idx)
static std::map< std::string, IFace * > & hooks()
void clearError()
Associated workspace.
std::string varTag(std::string &func, std::vector< std::string > &args)
static RooArgList as_LIST(UInt_t idx)
RooCategory * createCategory(const char *name, const char *stateNameList=nullptr)
Low-level factory interface for creating a RooCategory with a given list of state names.
static RooDataSet & as_DSET(UInt_t idx)
RooRealVar * createVariable(const char *name, double xmin, double xmax)
Low-level factory interface for creating a RooRealVar with a given range and initial value.
RooResolutionModel & asRMODEL(const char *)
CINT constructor interface, return constructor string argument #idx as RooResolutionModel reference f...
std::string processMetaArg(std::string &func, std::vector< std::string > &args)
Concatenate list of args into comma separated string.
static std::map< std::string, IFace * > * _hooks
TObject & asOBJ(const char *)
RooArgList asLIST(const char *)
CINT constructor interface, return constructor string argument #idx as RooArgList of objects found in...
RooSimultaneous * simul(const char *objName, const char *indexCat, const char *pdfMap)
static RooArgSet as_SET(UInt_t idx)
static RooAbsCategory & as_CATFUNC(UInt_t idx)
std::string processCompositeExpression(const char *arg)
Process a single composite expression.
TClass * resolveClassName(const char *className)
RooAbsCategory & asCATFUNC(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsCategory reference found...
static double as_DOUBLE(UInt_t idx)
const char * asSTRING(const char *)
CINT constructor interface, return constructor string argument #idx as const char*.
static RooAbsPdf & as_PDF(UInt_t idx)
RooProdPdf * prod(const char *objName, const char *pdfList)
std::vector< std::string > _args
RooRealSumPdf * amplAdd(const char *objName, const char *specList)
std::stack< std::string > _autoNamePrefix
RooDataHist & asDHIST(const char *)
CINT constructor interface, return constructor string argument #idx as RooDataHist object found in wo...
RooProduct * prodfunc(const char *objName, const char *pdfList)
RooAbsReal & asFUNC(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsReal reference found in ...
RooAbsCategoryLValue & asCATLV(const char *)
CINT constructor interface, return constructor string argument #idx as RooAbsCategoryLValue reference...
static RooCategory & as_CAT(UInt_t idx)
static Int_t as_INT(UInt_t idx)
std::string processSingleExpression(const char *arg)
Process a single high-level expression.
std::vector< std::string > splitFunctionArgs(const char *funcExpr)
Allocate and fill work buffer.
static RooRealVar & as_VAR(UInt_t idx)
double asDOUBLE(const char *)
CINT constructor interface, return constructor string argument #idx as double.
std::map< std::string, std::string > _typeAliases
RooArgSet asSET(const char *)
CINT constructor interface, return constructor string argument #idx as RooArgSet of objects found in ...
bool checkSyntax(const char *arg)
Perform basic syntax on given factory expression.
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...
RooPlotable is a 'mix-in' base class that define the standard RooFit plotting and printing methods.
Definition: RooPrintable.h:25
RooProdPdf is an efficient implementation of a product of PDFs of the form.
Definition: RooProdPdf.h:33
A RooProduct represents the product of a given set of RooAbsReal objects.
Definition: RooProduct.h:29
The class RooRealSumPdf implements a PDF constructed from a sum of functions:
Definition: RooRealSumPdf.h:24
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:40
RooResolutionModel is the base class for PDFs that represent a resolution model that can be convolute...
RooSimultaneous facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset.
The RooWorkspace is a persistable container for RooFit projects.
Definition: RooWorkspace.h:43
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:81
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
Mother of all ROOT objects.
Definition: TObject.h:37