Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RooWorkspace.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Project: RooFit *
3 * Package: RooFitCore *
4 * File: $Id: RooWorkspace.h,v 1.3 2007/07/16 21:04:28 wouter Exp $
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#ifndef ROO_WORKSPACE
17#define ROO_WORKSPACE
18
19#include "RooPrintable.h"
20#include "RooArgSet.h"
21#include "RooLinkedList.h"
22#include "RooCmdArg.h"
24#include "TUUID.h"
25#include <map>
26#include <list>
27#include <memory>
28#include <string>
29
30class TClass ;
31class RooAbsPdf ;
32class RooAbsData ;
33class RooRealVar ;
34class RooCategory ;
35class RooAbsReal ;
36class RooAbsCategory ;
37class RooFactoryWSTool ;
38class RooAbsStudy ;
39
40#include "TNamed.h"
41#include "TDirectoryFile.h"
42
43class RooWorkspace : public TNamed {
44public:
45
46 RooWorkspace() ;
47 RooWorkspace(const char* name, bool doCINTExport)
48 R__SUGGEST_ALTERNATIVE("The \"doCINTExport\" argument has no effect anymore since ROOT 6."
49 "Consider using RooWorkspace(const char* name, const char* title=nullptr).");
50 RooWorkspace(const char* name, const char* title=nullptr) ;
51 RooWorkspace(const RooWorkspace& other) ;
52 ~RooWorkspace() override ;
53
54 TObject *Clone(const char *newname="") const override;
55
56 bool importClassCode(const char* pat="*", bool doReplace=false) ;
57 bool importClassCode(TClass* theClass, bool doReplace=false) ;
58
59 // Import functions for dataset, functions, generic objects
60 bool import(const RooAbsArg& arg,
61 const RooCmdArg& arg1={},const RooCmdArg& arg2={},const RooCmdArg& arg3={},
62 const RooCmdArg& arg4={},const RooCmdArg& arg5={},const RooCmdArg& arg6={},
63 const RooCmdArg& arg7={},const RooCmdArg& arg8={},const RooCmdArg& arg9={}) ;
64 bool import(const RooArgSet& args,
65 const RooCmdArg& arg1={},const RooCmdArg& arg2={},const RooCmdArg& arg3={},
66 const RooCmdArg& arg4={},const RooCmdArg& arg5={},const RooCmdArg& arg6={},
67 const RooCmdArg& arg7={},const RooCmdArg& arg8={},const RooCmdArg& arg9={}) ;
68 bool import(RooAbsData const& data,
69 const RooCmdArg& arg1={},const RooCmdArg& arg2={},const RooCmdArg& arg3={},
70 const RooCmdArg& arg4={},const RooCmdArg& arg5={},const RooCmdArg& arg6={},
71 const RooCmdArg& arg7={},const RooCmdArg& arg8={},const RooCmdArg& arg9={}) ;
72 bool import(const char *fileSpec,
73 const RooCmdArg& arg1={},const RooCmdArg& arg2={},const RooCmdArg& arg3={},
74 const RooCmdArg& arg4={},const RooCmdArg& arg5={},const RooCmdArg& arg6={},
75 const RooCmdArg& arg7={},const RooCmdArg& arg8={},const RooCmdArg& arg9={}) ;
76 bool import(TObject const& object, bool replaceExisting=false) ;
77 bool import(TObject const& object, const char* aliasName, bool replaceExisting=false) ;
78
79 // Transaction management interface for multi-step import operations
80 bool startTransaction() ;
81 bool cancelTransaction() ;
82 bool commitTransaction() ;
83
84 // Named set management
85 bool defineSet(const char* name, const RooArgSet& aset, bool importMissing=false) ;
86 bool defineSet(const char* name, const char* contentList) ;
87 bool extendSet(const char* name, const char* newContents) ;
88 bool renameSet(const char* name, const char* newName) ;
89 bool removeSet(const char* name) ;
91 inline const std::map<std::string,RooArgSet>& sets() const { return _namedSets; }
92
93 // Import, load and save parameter value snapshots
94 bool saveSnapshot(RooStringView, const char* paramNames) ;
95 bool saveSnapshot(RooStringView, const RooArgSet& params, bool importValues=false) ;
96 bool loadSnapshot(const char* name) ;
97 const RooArgSet* getSnapshot(const char* name) const ;
98
99 // Retrieve list of parameter snapshots
100 RooLinkedList const& getSnapshots() const { return _snapshots; }
101
102 void merge(const RooWorkspace& /*other*/) {} ;
103
104 // Accessor functions
114 RooArgSet argSet(RooStringView nameList) const ;
116 R__DEPRECATED(6,34, "Better iterate over RooWorkspace::components() with range-based loop instead of using RooWorkspace::componentIterator().");
117 const RooArgSet& components() const { return _allOwnedNodes ; }
118 TObject* genobj(RooStringView name) const ;
119 TObject* obj(RooStringView name) const ;
120
121 // Group accessors
122 RooArgSet allVars() const;
123 RooArgSet allCats() const ;
124 RooArgSet allFunctions() const ;
125 RooArgSet allCatFunctions() const ;
126 RooArgSet allPdfs() const ;
127 RooArgSet allResolutionModels() const ;
128 std::list<RooAbsData*> allData() const ;
129 std::list<RooAbsData*> allEmbeddedData() const ;
130 std::list<TObject*> allGenericObjects() const ;
131
132 bool makeDir() ;
133 bool cd(const char* path = nullptr) ;
134
135 bool writeToFile(const char* fileName, bool recreate=true) ;
136
137 /// Make internal collection use an unordered_map for
138 /// faster searching. Important when large trees are
139 /// imported / or modified in the workspace.
140 /// Note that RooAbsCollection may eventually switch
141 /// this on by itself.
142 void useFindsWithHashLookup(bool flag) {
143 _allOwnedNodes.useHashMapForFind(flag);
144 }
145
146 void RecursiveRemove(TObject *obj) override;
147
148 // Tools management
149 RooFactoryWSTool& factory() ;
150 RooAbsArg* factory(RooStringView expr) ;
151
152 // RooStudyManager modules
153 bool addStudy(RooAbsStudy& study) ;
154 TIterator* studyIterator() { return _studyMods.MakeIterator() ; }
155 void clearStudies() ;
156
157 // Print function
158 void Print(Option_t* opts=nullptr) const override ;
159
160 static void autoImportClassCode(bool flag) ;
161
162 static void addClassDeclImportDir(const char* dir) ;
163 static void addClassImplImportDir(const char* dir) ;
164 static void setClassFileExportDir(const char* dir=nullptr) ;
165
166 const TUUID& uuid() const { return _uuid ; }
167
168 RooExpensiveObjectCache& expensiveObjectCache() { return _eocache ; }
169
170 class CodeRepo : public TObject {
171 public:
172 CodeRepo(RooWorkspace* wspace=nullptr) : _wspace(wspace), _compiledOK(true) {} ;
173
174 CodeRepo(const CodeRepo& other, RooWorkspace* wspace=nullptr) : TObject(other) ,
175 _wspace(wspace?wspace:other._wspace),
176 _c2fmap(other._c2fmap),
177 _fmap(other._fmap),
178 _ehmap(other._ehmap),
179 _compiledOK(other._compiledOK) {} ;
180
181 bool autoImportClass(TClass* tc, bool doReplace=false) ;
182 bool compileClasses() ;
183
184 bool compiledOK() const { return _compiledOK ; }
185
186 std::string listOfClassNames() const ;
187
188
189
190 class ClassRelInfo {
191 public:
192 TString _baseName;
193 TString _fileBase ;
194 } ;
195
196 class ClassFiles {
197 public:
198 ClassFiles() : _extracted(false) {}
199 TString _hext ;
200 TString _hfile ;
201 TString _cxxfile ;
202 bool _extracted ;
203 } ;
204
205
206 class ExtraHeader {
207 public:
208 TString _hname ;
209 TString _hfile ;
210 } ;
211
212 protected:
213 RooWorkspace* _wspace ; // owning workspace
214 std::map<TString,ClassRelInfo> _c2fmap ; // List of contained classes
215 std::map<TString,ClassFiles> _fmap ; // List of contained files
216 std::map<TString,ExtraHeader> _ehmap ; // List of extra header files
217 bool _compiledOK ; //! Flag indicating that classes compiled OK
218
219 ClassDefOverride(CodeRepo,2) ; // Code repository for RooWorkspace
220 } ;
221
222
223 class WSDir : public TDirectoryFile {
224 public:
225 WSDir(const char* name, const char* title, RooWorkspace* wspace) :
226 TDirectoryFile(name,title,"RooWorkspace::WSDir",nullptr),
227 _wspace(wspace)
228 {
229 }
230
231 ~WSDir() override { Clear("nodelete") ; }
232
233
234 void Add(TObject*,bool) override ;
235 void Append(TObject*,bool) override ;
236
237 protected:
238 friend class RooWorkspace ;
239 void InternalAppend(TObject* obj) ;
240 RooWorkspace* _wspace ; //! do not persist
241
242 ClassDefOverride(WSDir,1) ; // TDirectory representation of RooWorkspace
243 } ;
244
245
246 private:
247 friend class RooAbsArg;
248 friend class RooAbsPdf;
249 friend class RooConstraintSum;
250 bool defineSetInternal(const char *name, const RooArgSet &aset);
251
252 friend class CodeRepo;
253 static std::list<std::string> _classDeclDirList;
254 static std::list<std::string> _classImplDirList;
255 static std::string _classFileExportDir;
256
257 TUUID _uuid; // Unique workspace ID
258
259 static bool _autoClass; // Automatic import of non-distribution class code
260
261 CodeRepo _classes; // Repository of embedded class code. This data member _must_ be first
262
263 RooArgSet _allOwnedNodes; ///< List of owned pdfs and components
264 RooLinkedList _dataList; ///< List of owned datasets
265 RooLinkedList _embeddedDataList; ///< List of owned datasets that are embedded in pdfs
266 RooLinkedList _views; ///< List of model views
267 RooLinkedList _snapshots; ///< List of parameter snapshots
268 RooLinkedList _genObjects; ///< List of generic objects
269 RooLinkedList _studyMods; ///< List if StudyManager modules
270 std::map<std::string, RooArgSet> _namedSets; ///< Map of named RooArgSets
271
272 WSDir *_dir = nullptr; ///<! Transient ROOT directory representation of workspace
273
274 RooExpensiveObjectCache _eocache; ///< Cache for expensive objects
275
276 std::unique_ptr<RooFactoryWSTool> _factory; ///<! Factory tool associated with workspace
277
278 bool _doExport; ///<! Export contents of workspace to CINT?
279 std::string _exportNSName; ///<! Name of CINT namespace to which contents are exported
280
281 bool _openTrans = false; ///<! Is there a transaction open?
282 RooArgSet _sandboxNodes; ///<! Sandbox for incoming objects in a transaction
283
284 ClassDefOverride(RooWorkspace, 8) // Persistable project container for (composite) pdfs, functions, variables and datasets
285} ;
286
287#endif
#define R__SUGGEST_ALTERNATIVE(ALTERNATIVE)
Definition RConfig.hxx:537
#define R__DEPRECATED(MAJOR, MINOR, REASON)
Definition RConfig.hxx:529
const char Option_t
Definition RtypesCore.h:66
#define ClassDefOverride(name, id)
Definition Rtypes.h:341
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
char name[80]
Definition TGX11.cxx:110
Common abstract base class for objects that represent a value and a "shape" in RooFit.
Definition RooAbsArg.h:79
A space to attach TBranches.
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:57
Abstract interface for all probability density functions.
Definition RooAbsPdf.h:40
Abstract base class for objects that represent a real value and implements functionality common to al...
Definition RooAbsReal.h:59
Abstract base class for RooStudyManager modules.
Definition RooAbsStudy.h:33
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:55
Object to represent discrete states.
Definition RooCategory.h:28
Named container for two doubles, two integers two object points and three string pointers that can be...
Definition RooCmdArg.h:26
Calculates the sum of the -(log) likelihoods of a set of RooAbsPfs that represent constraint function...
RooExpensiveObjectCache is a singleton class that serves as repository for objects that are expensive...
RooFactoryWSTool is a class similar to TTree::MakeClass() that generates skeleton code for RooAbsPdf ...
RooLinkedList is an collection class for internal use, storing a collection of RooAbsArg pointers in ...
Variable that can be changed from the outside.
Definition RooRealVar.h:37
The RooStringView is a wrapper around a C-style string that can also be constructed from a std::strin...
Persistable container for RooFit projects.
const RooArgSet * getSnapshot(const char *name) const
Return the RooArgSet containing a snapshot of variables contained in the workspace.
RooAbsCategory * catfunc(RooStringView name) const
Retrieve discrete function (RooAbsCategory) with given name. A null pointer is returned if not found.
RooAbsPdf * pdf(RooStringView name) const
Retrieve p.d.f (RooAbsPdf) with given name. A null pointer is returned if not found.
RooAbsData * embeddedData(RooStringView name) const
Retrieve dataset (binned or unbinned) with given name. A null pointer is returned if not found.
RooCategory * cat(RooStringView name) const
Retrieve discrete variable (RooCategory) with given name. A null pointer is returned if not found.
bool renameSet(const char *name, const char *newName)
Rename set to a new name.
TIterator * componentIterator() const R__DEPRECATED(6
RooArgSet argSet(RooStringView nameList) const
Return set of RooAbsArgs matching to given list of names.
const RooArgSet * set(RooStringView name)
Return pointer to previously defined named set with given nmame If no such set is found a null pointe...
RooAbsArg * fundArg(RooStringView name) const
Return fundamental (i.e.
bool commitTransaction()
~RooWorkspace() override
Workspace destructor.
const std::map< std::string, RooArgSet > & sets() const
bool cancelTransaction()
Cancel an ongoing import transaction.
bool startTransaction()
Open an import transaction operations.
TObject * Clone(const char *newname="") const override
TObject::Clone() needs to be overridden.
bool saveSnapshot(RooStringView, const char *paramNames)
Save snapshot of values and attributes (including "Constant") of given parameters.
void merge(const RooWorkspace &)
RooLinkedList const & getSnapshots() const
bool importClassCode(const char *pat="*", bool doReplace=false)
Import code of all classes in the workspace that have a class name that matches pattern 'pat' and whi...
RooAbsReal * function(RooStringView name) const
Retrieve function (RooAbsReal) with given name. Note that all RooAbsPdfs are also RooAbsReals....
RooAbsArg * arg(RooStringView name) const
Return RooAbsArg with given name. A null pointer is returned if none is found.
RooWorkspace()
Default constructor.
bool removeSet(const char *name)
Remove a named set from the workspace.
bool extendSet(const char *name, const char *newContents)
Define a named set in the work space through a comma separated list of names of objects already in th...
RooRealVar * var(RooStringView name) const
Retrieve real-valued variable (RooRealVar) with given name. A null pointer is returned if not found.
bool loadSnapshot(const char *name)
Load the values and attributes of the parameters in the snapshot saved with the given name.
bool defineSet(const char *name, const RooArgSet &aset, bool importMissing=false)
Define a named RooArgSet with given constituents.
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
A ROOT file is structured in Directories (like a file system).
Iterator abstract base class.
Definition TIterator.h:30
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
void Print(Option_t *option="") const override
Print TNamed name and title.
Definition TNamed.cxx:128
Mother of all ROOT objects.
Definition TObject.h:41
virtual void RecursiveRemove(TObject *obj)
Recursively remove this object from a list.
Definition TObject.cxx:659
Basic string class.
Definition TString.h:139
This class defines a UUID (Universally Unique IDentifier), also known as GUIDs (Globally Unique IDent...
Definition TUUID.h:42
int iterate(rng_state_t *X)
Definition mixmax.icc:34
TMatrixT< Element > & Add(TMatrixT< Element > &target, Element scalar, const TMatrixT< Element > &source)
Modify addition: target += scalar * source.