def getColor(color, transparency = None): from ROOT import TColor try: color = TColor.GetColor( *color ) except: if type(color) is not int: color = TColor.GetColor( color ) if transparency is not None: color = TColor.GetColorTransparent( color, transparency ) return color
import math
import os
import random
from array import array
from multiprocessing import Pool
import numpy as np
import yaml
from ROOT import (TF1, TH1D, TH2D, TAxis, TCanvas, TColor, TFile, TFrame,
TIter, TKey, TPaveText, gDirectory, gPad, gROOT, gStyle,
kBlue, kRed)
from scipy import stats
kBlueC = TColor.GetColor('#1f78b4')
kBlueCT = TColor.GetColorTransparent(kBlueC, 0.5)
kRedC = TColor.GetColor('#e31a1c')
kRedCT = TColor.GetColorTransparent(kRedC, 0.5)
kPurpleC = TColor.GetColor('#911eb4')
kPurpleCT = TColor.GetColorTransparent(kPurpleC, 0.5)
kOrangeC = TColor.GetColor('#ff7f00')
kOrangeCT = TColor.GetColorTransparent(kOrangeC, 0.5)
kGreenC = TColor.GetColor('#33a02c')
kGreenCT = TColor.GetColorTransparent(kGreenC, 0.5)
kMagentaC = TColor.GetColor('#f032e6')
kMagentaCT = TColor.GetColorTransparent(kMagentaC, 0.5)
kYellowC = TColor.GetColor('#ffe119')
kYellowCT = TColor.GetColorTransparent(kYellowC, 0.5)
kBrownC = TColor.GetColor('#b15928')
kBrownCT = TColor.GetColorTransparent(kBrownC, 0.5)
gROOT.ProcessLine("gErrorIgnoreLevel = kFatal;")
# kGray_2
local_these_colors = [
kBlack, kBlue - 4, kRed - 2, kAzure + 2, kMagenta + 2, kGray + 1,
kCyan + 1, kOrange + 1, kBlack + 2, kRed + 3, kBlue + 3, kGreen + 3,
kMagenta + 3, kCyan + 3, kOrange + 3, kGray, kRed - 7, kBlue - 7,
kGreen - 7, kMagenta - 7, kCyan - 7, kOrange - 7, kYellow + 2, kRed - 5,
kBlue - 5, kGreen - 5, kMagenta - 5, kCyan - 5, kOrange - 5, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30
]
local_these_transcolors = [
TColor.GetColorTransparent(c, .5) for c in local_these_colors
]
local_these_marker = (23, 24, 22, 26, 32, 23, 20, 25)
local_these_marker_full = (20, 21, 22, 23, 33, 34)
local_these_marker_open = (24, 25, 26, 32, 27, 28)
mainLogger = Logger.getModuleLogger("PlotTools", LoggingLevel.INFO)
parser = argparse.ArgumentParser(description='', add_help=False)
parser = argparse.ArgumentParser()
parser.add_argument('-l',
'--legends',
action='store',
dest='legends',
required=False,
str(etalist[etaidx]) + ' < #eta < 2.47')
extraText.append(binEta)
DrawText(can,extraText,.14,.68,.35,.93,totalentries=4)
except NameError, e:
if logger:
logger.warning("Couldn't print test due to error: %s", e)
pass
binLabel = ''
if etBin is not None and etaBin is not None:
binLabel = '_'.join( [ str(etBin[0]).zfill(4), str(etaBin[0]).zfill(4) ] )
canvas1 = TCanvas(title, title, 500, 500)
histEff.SetTitle(title + ' in: ' + binLabel if binLabel else title )
histEff.SetLineColor(kGray)
histEff.SetMarkerColor(kGray)
# FIXME Care with Transparent
histEff.SetFillColor(TColor.GetColorTransparent(kGray, .5))
histEffCorr.SetLineColor(kBlue+1)
histEffCorr.SetMarkerColor(kBlue+1)
histEffCorr.SetFillColor(TColor.GetColorTransparent(kBlue+1, .5))
drawopt='lpE2'
AddHistogram(canvas1,histEff,drawopt)
AddHistogram(canvas1,histEffCorr,drawopt)
l0 = TLine(limits[0],refValue,limits[2],refValue)
l0.SetLineColor(kBlack)
l0.Draw()
#l1 = TLine(limits[0],refValue_requested,limits[2],refValue_requested)
#l1.SetLineColor(kGray+2)
#l1.SetLineStyle(9)
#l1.Draw()
AddTopLabels( canvas1, [ eff_uncorr.thresstr( prefix = 'Raw threshold' )
, eff.thresstr( prefix = 'Threshold Correction' )
class DataMcRatioPlot(DoublePlot):
from AtlasStyle import Style
from ROOT import kRed, kSpring, kGray, TColor
defaultStatErrorTitle = 'Stat. Uncertainty'
defaultSystErrorTitle = 'Syst. Uncertainty'
defaultCombinedErrorTitle = 'Stat #oplus Syst'
defaultStatErrorStyle = Style(TColor.GetColorTransparent(kSpring, 0.3),
lineWidth=0,
fillStyle=1000,
markerStyle=0)
defaultSystErrorStyle = Style(kGray + 3,
lineWidth=0,
fillStyle=3354,
markerStyle=0)
defaultCombinedErrorStyle = Style(kGray + 3,
lineWidth=0,
fillStyle=3354,
markerStyle=0)
defaultBaseLineStyle = Style(kRed, lineWidth=2, markerStyle=0)
def __init__(self,
title='DataMcPlot',
xVariable=None,
yVariableUp=var_Events,
yVariableDown=var_dataMc,
upperFraction=0.7,
lowerFraction=0.3):
DoublePlot.__init__(self, title, xVariable, yVariableUp, yVariableDown,
upperFraction, lowerFraction)
from ROOT import TF1
## settings from default settings
self.baseLineStyle = copy(self.defaultBaseLineStyle)
self.statErrorStyle = copy(self.defaultStatErrorStyle)
self.systErrorStyle = copy(self.defaultSystErrorStyle)
self.combinedErrorStyle = copy(self.defaultCombinedErrorStyle)
self.statErrorTitle = copy(self.defaultStatErrorTitle)
self.systErrorTitle = copy(self.defaultSystErrorTitle)
self.combinedErrorTitle = copy(self.defaultCombinedErrorTitle)
self._dataGraph = None
self._dataMcRatioGraph = None
self._mcCombinedErrorGraph = None
self._mcCombinedErrorRatioGraph = None
self._mcSystGraph = None
self._mcSystRatioGraph = None
self._mcSumHist = None
self._mcSumRatioHist = None
self._baseLine = TF1('%s_baseLine' % self.title, '1',
xVariable.binning.low, xVariable.binning.up)
self.plotDown.addFunction(self._baseLine)
# flags to decide which errors bars are shown
self.drawStatErrorDown = True
self.drawStatErrorUp = False
self.drawSystErrorDown = False
self.drawSystErrorUp = False
self.drawCombinedErrorUp = True
self.drawCombinedErrorDown = True
self.drawOutOfRangeArrows = False
def addHistogram(self,
histogram,
drawOption='HIST',
stacked=True,
copy=False):
if not self._mcSumHist:
self._mcSumHist = histogram.Clone('%s_McSumHist_%s' %
(self.title, uuid.uuid1()))
self._mcSumRatioHist = histogram.Clone('%s_McSumRatioHist_%s' %
(self.title, uuid.uuid1()))
self.plotUp.addHistogram(self._mcSumHist, 'E2')
self.plotDown.addHistogram(self._mcSumRatioHist,
'E2',
stacked=False)
if not self._mcSumHist.GetSumw2N():
self._mcSumHist.Sumw2()
self._mcSumRatioHist.Sumw2()
return self.plotUp.addHistogram(histogram, drawOption, stacked, copy)
def addGraph(self, graph, drawOption='P', copy=False):
return self.plotUp.addGraph(graph, drawOption, copy)
def addFunction(self, function, drawOption, legendTitle='', copy=False):
return self.plotUp.addFunction(function, drawOption, legendTitle, copy)
def addFitFunction(self,
obj,
function,
drawOption='',
fitOption='QN0',
xMin=None,
xMax=None,
legendTitle='',
copy=False):
return self.plotUp.addFitFunction(obj, function, xMin, xMax,
legendTitle, copy)
def setMCSystematicsGraph(self, graph):
if not graph:
return
self._mcSystGraph = self.addGraph(
graph.Clone('%s_McSystGraph_%s' % (self.title, uuid.uuid1())), '2')
self._mcSystRatioGraph = self.plotDown.addGraph(
graph.Clone('%s_McSystRatioGraph_%s' % (self.title, uuid.uuid1())),
'2')
self._mcCombinedErrorGraph = self.addGraph(
graph.Clone('%s_McCombinedErrorGraph_%s' %
(self.title, uuid.uuid1())), '2')
self._mcCombinedErrorRatioGraph = self.plotDown.addGraph(
graph.Clone('%s_McCombinedErrorRatioGraph_%s' %
(self.title, uuid.uuid1())), '2')
def setDataHistogram(self, histogram, copy=False):
## Sets the data histogram
# internally this is handled as TGraphAsymmErrors with proper Poisson errors
if not histogram:
return
# convert to TGraphAsymmErrors to store correct Poisson errors
self._dataGraph = self.plotUp.addGraph(
histToGraph(histogram,
'%s_DataGraph_%s' % (self.title, uuid.uuid1()),
poissonErrors=True), 'P0')
self._dataMcRatioGraph = self._dataGraph.Clone(
'%s_DataMcRatioGraph_%s' % (self.title, uuid.uuid1()))
self.plotDown.addGraph(self._dataMcRatioGraph, 'P0')
def __initAction__(self):
DoublePlot.__initAction__(self)
# remove the histograms / graphs with special roles to add them in correct order
# note: the stacked histogram order is defined by the order in which they were added
for obj in [
self._dataGraph, self._mcSumHist, self._mcSystGraph,
self._mcCombinedErrorGraph
]:
if obj in self.plotUp.objects:
self.plotUp.objects.pop(self.plotUp.objects.index(obj))
for obj in [
self._dataMcRatioGraph, self._mcSumRatioHist,
self._mcSystRatioGraph, self._mcCombinedErrorRatioGraph
]:
if obj in self.plotDown.objects:
self.plotDown.objects.pop(self.plotDown.objects.index(obj))
self.baseLineStyle.apply(self._baseLine)
for obj in [self._mcSumHist, self._mcSumRatioHist]:
if obj:
self.statErrorStyle.apply(obj)
obj.SetTitle(self.statErrorTitle)
for obj in [self._mcSystGraph, self._mcSystRatioGraph]:
if obj:
self.systErrorStyle.apply(obj)
obj.SetTitle(self.systErrorTitle)
for obj in [
self._mcCombinedErrorGraph, self._mcCombinedErrorRatioGraph
]:
if obj:
self.combinedErrorStyle.apply(obj)
obj.SetTitle(self.combinedErrorTitle)
if self.drawStatErrorUp and self._mcSumHist:
self.plotUp.objects.insert(0, self._mcSumHist)
if self.drawStatErrorDown and self._mcSumRatioHist:
self.plotDown.objects.insert(0, self._mcSumRatioHist)
self._mcSumRatioHist.Reset()
if self.drawSystErrorUp and self._mcSystGraph:
self.plotUp.objects.insert(0, self._mcSystGraph)
if self.drawSystErrorDown and self._mcSystRatioGraph:
self.plotDown.objects.insert(0, self._mcSystRatioGraph)
resetGraph(self._mcSystRatioGraph)
if self.drawCombinedErrorUp and self._mcCombinedErrorGraph:
self.plotUp.objects.insert(0, self._mcCombinedErrorGraph)
resetGraph(self._mcCombinedErrorGraph)
if self.drawCombinedErrorDown and self._mcCombinedErrorRatioGraph:
self.plotDown.objects.insert(0, self._mcCombinedErrorRatioGraph)
resetGraph(self._mcCombinedErrorRatioGraph)
if self._mcSumHist:
self._mcSumHist.Reset()
if self._dataGraph:
resetGraph(self._dataMcRatioGraph)
addGraphs(self._dataMcRatioGraph,
self._dataGraph,
poissonErrors=True)
self.plotUp.objects.append(self._dataGraph)
self.plotDown.objects.append(self._dataMcRatioGraph)
def __mainAction__(self):
if self._mcSumHist:
for hist in self.stackedHistograms:
self._mcSumHist.Add(hist)
if self._mcSystGraph and self._mcCombinedErrorGraph:
addGraphs(self._mcCombinedErrorGraph, self._mcSystGraph)
if self._mcSumHist and self._mcCombinedErrorGraph:
combineStatsAndSystematics(self._mcSumHist,
self._mcCombinedErrorGraph)
DoublePlot.__mainAction__(self)
if self._mcSumHist:
for hist in self.plotUp.stackedHistograms:
self._mcSumHist.Add(hist)
self._mcSumRatioHist.Add(self._mcSumHist)
divideHistograms(self._mcSumRatioHist, self._mcSumHist)
if self._mcSystGraph and self._mcCombinedErrorGraph:
addGraphs(self._mcCombinedErrorGraph, self._mcSystGraph)
addGraphs(self._mcSystRatioGraph, self._mcSystGraph)
divideGraphs(self._mcSystRatioGraph, self._mcSystGraph)
if self._mcSumHist and self._mcCombinedErrorGraph:
combineStatsAndSystematics(self._mcSumHist,
self._mcCombinedErrorGraph)
addGraphs(self._mcCombinedErrorRatioGraph,
self._mcCombinedErrorGraph)
divideGraphs(self._mcCombinedErrorRatioGraph,
self._mcCombinedErrorGraph)
if self._dataMcRatioGraph and self._mcSumHist:
divideGraphs(self._dataMcRatioGraph, self._mcSumHist)
if self.drawOutOfRangeArrows:
for obj in createOutOfRangeArrows(
self._dataMcRatioGraph,
self.plotDown.yVariable.binning.low,
self.plotDown.yVariable.binning.up):
self.plotDown.decoratorObjects.append(obj)
def __drawDecorations__(self):
# reverse the order of the legend entries
self.legendElements.reverse()
if not self.drawStatErrorUp and self.drawStatErrorDown:
self.legendElements.append(
LegendElement(self._mcSumHist, self.statErrorTitle, 'f'))
if not self.drawSystErrorUp and self.drawSystErrorDown:
self.legendElements.append(
LegendElement(self._mcSystGraph, self.systErrorTitle, 'f'))
if not self.drawCombinedErrorUp and self.drawCombinedErrorDown:
self.legendElements.append(
LegendElement(self._mcCombinedErrorGraph,
self.combinedErrorTitle, 'f'))
self.plotDown.canvas.cd()
DoublePlot.__drawDecorations__(self)
