def __init__(self, width=DEFAULT_WindowW, height=DEFAULT_WindowH):
self._tmpTFile = ROOT.TFile('tmp.root', 'recreate')
self._tmpTFile.cd()
self._canv = MyCanvas()
self._drawables = DrawableMgr()
self._brah = []
self._addfuncMGR = ImportAddFunc()
def __init__(self, width=1000, height=1000):
self._tmpTFile=ROOT.TFile('tmp.root','recreate')
self._tmpTFile.cd()
self._drawObj=[]
self._drawArg=[]
self._cwidth=width
self._cheight=height
self._canvasSetting={}
self._addfuncMGR=ImportAddFunc()
class DrawingWorkflow(object):
def __init__(self, width=DEFAULT_WindowW, height=DEFAULT_WindowH):
self._tmpTFile = ROOT.TFile('tmp.root', 'recreate')
self._tmpTFile.cd()
self._canv = MyCanvas()
self._drawables = DrawableMgr()
self._brah = []
self._addfuncMGR = ImportAddFunc()
def __del__(self):
self._tmpTFile.Close() # write nothing
def grabrootobj(self, obj, opt):
self._drawObj.append(obj)
self._drawArg.append(opt)
return self._drawObj[-1]
def AddPlotContent(self, **kwargs):
if not 'function' in kwargs:
logging.error(
'importing function but no any "function" argument input')
exit(1)
self._addfuncMGR.ImportFunction(**kwargs)
def CallbackExec(self, name, function, **kwargs):
self._addfuncMGR.ImportFunction(function, **kwargs)
#self._drawables.InsertObj( {name:self._addfuncMGR[-1].Exec()} )
## tmp used
for funcMgr in self._addfuncMGR:
funcMgr.ExecuteIteratively()
def KeepIt(self, obj):
self._brah.append(obj)
def ExportFig(self,
outputname='hi',
logScale=False,
transparentCanv=True,
redraw=False):
if not redraw:
self._canv.Export(outputname, 'png')
return
for funcMgr in self._addfuncMGR:
funcMgr.GetExecRes().Draw(funcMgr.GetArg('drawOpt'))
self._canv.Export(self, outputname, 'png')
### to be deleted
@staticmethod
def GeneralSetting():
ROOT.gROOT.SetBatch(True)
def __init__(self, workspace='space', loadFile=''):
logger.debug('init space')
self._loadfile = ROOT.TFile.Open(
loadFile) if '.root' in loadFile else None
self._space = self._loadfile.Get(
workspace) if self._loadfile else ROOT.RooWorkspace(
'space', False)
self._keptItem = []
self._additionalInfo = ImportAddFunc()
self._additionalWriting = []
self._written = False
self._loadinfos = [] # (tfile, {'label':tobject, 'label2':tobject2 }
def __init__(self, inputworkspace):
if not isinstance(inputworkspace, (RooFitSpaceMgr, None)):
logger.error(
'constructing object failed. Input RooFitSpaceMgr object')
self._workspace = inputworkspace
self._observ = None
self._target = None
self._fitpdf = None # pdf
self._pdfcomponents = [] # [ (label,pdf) ]
self._additionalInfo = ImportAddFunc()
self.loadinfos = []
pass
class DrawingMgr(object):
def __init__(self, width=1000, height=1000):
self._tmpTFile=ROOT.TFile('tmp.root','recreate')
self._tmpTFile.cd()
self._drawObj=[]
self._drawArg=[]
self._cwidth=width
self._cheight=height
self._canvasSetting={}
self._addfuncMGR=ImportAddFunc()
def __del__(self):
self._drawObj=[]
self._drawArg=[]
self._tmpTFile.Close() # write nothing
def grabrootobj(self, obj, opt):
self._drawObj.append(obj)
self._drawArg.append(opt)
return self._drawObj[-1]
def AddPlotContent(self, **kwargs):
if not 'function' in kwargs:
logging.error('importing function but no any "function" argument input')
exit(1)
self._addfuncMGR.ImportFunction(**kwargs)
def ExportFig(self, output='hi.png', logScale=False, transparentCanv=True, redraw=False):
canv=ROOT.TCanvas('c1','', self._cwidth,self._cheight)
canv.SetLogy(logScale)
if transparentCanv:
canv.SetFillColor(4000)
canv.SetFillStyle(4000)
canv.SetFrameFillColor(4000)
canv.SetFrameFillStyle(4000)
for funcMgr in self._addfuncMGR:
funcMgr.Exec()
if redraw:
for funcMgr in self._addfuncMGR:
funcMgr.GetExecRes().Draw( funcMgr.GetArg('drawOpt') )
canv.SaveAs(output)
def CanvasSetup(self, logScale=False): # asdf not completed
self._canvasSetting
def Delete(self):
self.__del__()
@staticmethod
def GeneralSetting():
ROOT.gROOT.SetBatch(True)
class DrawableMgr(object):
def __init__(self):
self._drawObj=[]
self._drawArg=[]
self._drawPad=[]
self._addfuncMGR=ImportAddFunc()
#?
def grabrootobj(self, obj, opt):
self._drawObj.append(obj)
self._drawArg.append(opt)
return self._drawObj[-1]
def AddPlotContent(self, **kwargs):
if not 'function' in kwargs:
logging.error('importing function but no any "function" argument input')
exit(1)
self._addfuncMGR.ImportFunction(**kwargs)
''' need to be put at MyCanvas
def __init__(self):
self._drawObj=[]
self._drawArg=[]
self._drawPad=[]
self._addfuncMGR=ImportAddFunc()
class RooFitSpaceMgr(object):
def __init__(self, workspace='space', loadFile=''):
logger.debug('init space')
self._loadfile = ROOT.TFile.Open(
loadFile) if '.root' in loadFile else None
self._space = self._loadfile.Get(
workspace) if self._loadfile else ROOT.RooWorkspace(
'space', False)
self._keptItem = []
self._additionalInfo = ImportAddFunc()
self._additionalWriting = []
self._written = False
self._loadinfos = [] # (tfile, {'label':tobject, 'label2':tobject2 }
def __del__(self):
logger.info('deleting RooFitSpaceMgr')
del self._space
self._space = None
if self._loadfile: self._loadfile.Close()
logger.info('deleted RooFitSpaceMgr')
def check_duplicate(self, newobj):
for storedobj in self._keptItem:
if newobj.GetName() == storedobj:
raise IOError(
'Duplicated check failed! please change imported object name : "{0}"'
.format(obj.GetName()))
def check_inputtype(self, obj, thetypes):
if not isinstance(obj, thetypes):
raise TypeError(
'input object as an argument of function in a wrong type. This object belongs to "{belong}" but "{types}" are needed'
.format(belong=type(obj), types=accaptabletypes))
def saving(self, obj):
logger.debug('saving %s in workspace' % obj.GetName())
getattr(self._space, 'import')(obj) # for ROOT 5.x
#self._space.Import(obj) # for ROOT 6.x
logger.debug(
' %s saved (for check, this name needs to be the same as above.)'
% obj.GetName())
def namingitem(self, obj, newname=''):
if newname:
obj.SetName(newname)
def writetofile(self, filename):
if self._written:
logger.error('This workspace has been written!')
raise IOError()
outfile = ROOT.TFile(filename, 'recreate')
outfile.cd()
self._space.Write()
for obj in self._additionalWriting:
obj.Write()
outfile.Close()
logger.debug('space written to %s' % (filename))
#del self._space
self._space = None
self.written = True
logger.debug('workspace destroyed')
def ReserveItem(self, obj, newname=''):
self.namingitem(obj, newname)
self.check_duplicate(obj)
self.saving(obj)
self._keptItem.append(obj.GetName())
def AddComponent(self, **kwargs):
self._additionalInfo.ImportFunction(**kwargs)
def AdditionalWrite(self, *args):
self._additionalWriting = args
def Write(self, newfilename=None):
self.writetofile(
newfilename if newfilename else 'storedWorkspace.root')
def RenameObj(self, obj, newname):
if newname: obj.SetName(newname)
def LoadVar(self, name):
return self._space.var(name)
def LoadPdf(self, name):
return self._space.pdf(name)
def Factory(self, content):
self._space.factory(content)
def CreateDataHist(self, hist, obsname, outname):
logger.debug('data hist creating!')
roobs = self.LoadVar(obsname)
datahist = ROOT.RooDataHist(outname, outname, ROOT.RooArgList(roobs),
hist)
self.ReserveItem(datahist)
return datahist
def CreatePDF_Add(self, extpdfnames, outname):
for pdfname in extpdfnames:
self.check_inputtype(pdfname, (str))
extpdfs = [self.LoadPdf(pdfname) for pdfname in extpdfnames]
extpdf0 = self.LoadPdf(extpdfnames[0])
extpdf1 = self.LoadPdf(extpdfnames[1])
outpdf = ROOT.RooAddPdf(outname, outname, ROOT.RooArgList(*extpdfs))
self.ReserveItem(outpdf)
return outpdf
def CreatePDF_Extended(self, pdfname, yieldname, outname):
self.check_inputtype(pdfname, str)
self.check_inputtype(yieldname, str)
logger.debug('extPDF creating! with name %s' % outname)
xvar = self.LoadVar(yieldname)
yieldvar = self.LoadVar(yieldname)
pdf = self.LoadPdf(pdfname)
extpdf = ROOT.RooExtendPdf(outname, outname, pdf, yieldvar)
self.ReserveItem(extpdf)
return extpdf
def CreatePDF_Hist(self, datahist, obsname, outname):
logger.debug('histPDF creating! with name %s' % datahist.GetName())
xvar = self.LoadVar(obsname)
histpdf = ROOT.RooHistPdf(outname, outname, ROOT.RooArgSet(xvar),
datahist, 0)
self.ReserveItem(histpdf)
logger.debug('histPDF created and stored!')
return histpdf
def CreateVar_const(self, name, xval):
xvar = ROOT.RooRealVar(name, name, xval)
self.ReserveItem(xvar)
return xvar
def CreateVar_Yield(self, name, maxval, initval=0.):
ival = initval if initval else maxval * 0.7
xvar = ROOT.RooRealVar(name, name, ival, 0., maxval)
self.ReserveItem(xvar)
return xvar
def CreateVar(self, name, xrange=[0.0, 1.1]):
if not isinstance(xrange, (tuple, list)):
log.error(
'input a wrong range format in xrange variable. (the content is {0})'
.format(xrange))
exit(1)
xvar = ROOT.RooRealVar(name, name, xrange[0], xrange[1])
self.ReserveItem(xvar)
return xvar
class RooFitFittingMgr(object):
def __init__(self, inputworkspace):
if not isinstance(inputworkspace, (RooFitSpaceMgr, None)):
logger.error(
'constructing object failed. Input RooFitSpaceMgr object')
self._workspace = inputworkspace
self._observ = None
self._target = None
self._fitpdf = None # pdf
self._pdfcomponents = [] # [ (label,pdf) ]
self._additionalInfo = ImportAddFunc()
self.loadinfos = []
pass
def __del__(self):
#self._workspace.Write()
self._workspace = None
for info in self.loadinfos:
logger.info('Closing file ' + info['file'].GetName())
info['file'].Close()
# input RooDataHist or RooDataSet. RooRealVar
def SetFitTarget(self, dataset):
self._target = dataset
def SetObservable(self, obs):
if not isinstance(obs, ROOT.RooRealVar):
raise ImportError(
'RoOFitFittingMgr::SetObservable() : input observable is not a RooRealVar'
)
self._observ = obs
def SetPDF_Components(self, label, pdf):
self._pdfcomponents.append((label, pdf))
def SetPDF_Target(self, pdf):
self._fitpdf = pdf
# input the whole building function, which returns a tuple in (name, RooAbsPdf)
def BuildPDFComponent(self, **kwargs):
label, pdf = self._additionalInfo.ImportFunction(**kwargs)
self._pdfcomponents.append((label, pdf))
def BuildPDFTotal(self, **kwargs):
self.SetPDF_Target(self._additionalInfo.ImportFunction(**kwargs))
for infoMgr in self._additionalInfo:
a = infoMgr.GetExecRes()
def reserveitem(self, item):
self._workspace.ReserveItem(item,
PROCESSNAMEPOSTFIX.format(item.GetName()))
logger.debug(item.GetName())
def PerformFitting(self, useMinos=False):
self._fitpdf.fitTo(self._target, ROOT.RooFit.Minos(useMinos))
def CalculateDrawingContent(self):
plotframe = self._observ.frame(ROOT.RooFit.Title(''))
self._target.plotOn(plotframe, ROOT.RooFit.Name('data'))
self._fitpdf.plotOn(plotframe, ROOT.RooFit.LineColor(4),
ROOT.RooFit.LineWidth(4),
ROOT.RooFit.Name('totFit'))
i = 2
for label, pdf in self._pdfcomponents:
self._fitpdf.plotOn(plotframe, ROOT.RooFit.LineColor(i),
ROOT.RooFit.LineWidth(5),
ROOT.RooFit.Name(label),
ROOT.RooFit.Components(pdf.GetName()))
i = i + 4
logger.debug('Plot component with name : ' + label)
return plotframe
# loadinfo = [ ('label','objname') ]
def LoadObjects(self, filepath, loadinfo, saveANDrenameToworkspace=False):
openedfile = ROOT.TFile.Open(filepath)
label = loadinfo[0]
name = loadinfo[1]
print name
loadedobj = openedfile.Get(name)
#loadedobj=( label, openedfile.Get(name) )
#self.loadinfos.append( (openedfile, loadedobj) )
if saveANDrenameToworkspace:
self._workspace.ReserveItem(
loadedobj,
Naming(label, loadedobj.GetName(), PROCESSNAMEPOSTFIX))
self.loadinfos.append({
'file': openedfile,
'obj': loadedobj,
'label': label
})
return self.loadinfos[-1]['obj']
def GetObservableName(self):
return self._observ.GetName()
def GetObservable(self):
return self._observ