def draw2DHist(h,
xlabel,
ylabel,
output,
year,
option="ETextColz",
x_log=False,
y_log=False):
tdr.setTDRStyle()
GeneralSettings("4.3f")
gStyle.SetPalette(ROOT.kIsland)
gStyle.SetPadRightMargin(0.15)
#Create Canvas
Canv = TCanvas("Canv" + output, "Canv" + output, 1000, 1000)
if x_log:
Canv.SetLogx()
if y_log:
Canv.SetLogy()
h.SetTitle(';' + xlabel + ';' + ylabel)
h.Draw(option)
#Throw CMs lumi at it
cl.CMS_lumi(Canv, 4, 0, year, 'Preliminary', True)
#Save everything
savePlots(Canv, output)
ROOT.SetOwnership(
Canv, False
) #https://root-forum.cern.ch/t/tlatex-crashing-in-pyroot-after-many-uses/21638/4
return
def TopMassStyle():
"""Set the style plot in order to create fancier plots!"""
gStyle.SetPadTickX(1);
gStyle.SetPadTickY(1);
gStyle.SetHistLineWidth(3);
gStyle.SetMarkerStyle(1);
gStyle.SetTextSize(0.065);
gStyle.SetOptFit(1111);
gStyle.SetTitleSize(.05,"X");#.055
gStyle.SetTitleOffset(1.1,"X");#1.2,0.9
gStyle.SetLabelSize(.05,"X");
gStyle.SetTitleSize(.05,"Y");#.055
gStyle.SetTitleOffset(1.1,"Y");
gStyle.SetLabelSize(.05,"Y");
gStyle.SetPadLeftMargin(.16);
gStyle.SetPadBottomMargin(.12);
gStyle.SetTitleSize(.05,"Z");
gStyle.SetTitleOffset(1.8,"Z");
gStyle.SetLabelSize(0.06,"Z");
gStyle.SetLegendTextSize(0.04);
gStyle.SetOptStat(112210);
gStyle.SetPadLeftMargin(.12);
gStyle.SetPadRightMargin(.02);
gStyle.SetPadBottomMargin(.12);
gStyle.SetPadTopMargin(.07);
gStyle.SetPadGridX(1);
gStyle.SetPadGridY(1);
def set2DStyle(self, opt="BasicRainBow"):
gStyle.SetPadRightMargin(
0.2
) # Leave more space to the right side of the current Pad to show the histogram scale
if opt == "FancyRainBow":
icol = 0
gStyle.SetFrameBorderMode(icol)
gStyle.SetFrameFillColor(icol)
gStyle.SetCanvasBorderMode(icol)
gStyle.SetCanvasColor(icol)
gStyle.SetPadBorderMode(icol)
gStyle.SetPadColor(icol)
gStyle.SetStatColor(icol)
gStyle.SetOptTitle(0)
gStyle.SetOptStat(0)
gStyle.SetOptFit(0)
ncontours = 999
s = array.array('d', [0.00, 0.34, 0.61, 0.84, 1.00])
r = array.array('d', [0.00, 0.00, 0.87, 1.00, 0.51])
g = array.array('d', [0.00, 0.81, 1.00, 0.20, 0.00])
b = array.array('d', [0.51, 1.00, 0.12, 0.00, 0.00])
npoints = len(s)
TColor.CreateGradientColorTable(npoints, s, r, g, b, ncontours)
gStyle.SetNumberContours(ncontours)
if opt == "BasicRainBow":
gStyle.SetPalette(
1
) # This resets the color palette to a simple Rainbow Color Map w/ 50 colors. See https://root.cern.ch/doc/master/classTColor.html
def set_pub_style():
from ROOT import gStyle
# No Canvas Border
gStyle.SetCanvasBorderMode(0)
gStyle.SetCanvasBorderSize(0)
# White BG
gStyle.SetCanvasColor(10)
# Format for axes
gStyle.SetLabelFont(42, 'xyz')
gStyle.SetLabelSize(0.05, 'xyz')
gStyle.SetLabelOffset(0.01, 'xyz')
# gStyle->SetNdivisions(510, 'xyz')
gStyle.SetTitleFont(42, 'xyz')
gStyle.SetTitleColor(1, 'xyz')
gStyle.SetTitleSize(0.06, 'xyz')
gStyle.SetTitleOffset(1.25, 'xyz')
# No pad borders
gStyle.SetPadBorderMode(0)
gStyle.SetPadBorderSize(0)
# White BG
gStyle.SetPadColor(10)
# Margins for labels etc.
gStyle.SetPadLeftMargin(0.155)
gStyle.SetPadBottomMargin(0.155)
gStyle.SetPadRightMargin(0.15)
gStyle.SetPadTopMargin(0.1)
# No error bars in x direction
gStyle.SetErrorX(0)
# Format legend
gStyle.SetLegendBorderSize(0)
def rootSetup():
from ROOT import gStyle
gStyle.SetStatColor(0)
gStyle.SetFillColor(38)
gStyle.SetCanvasColor(0)
gStyle.SetPadColor(0)
gStyle.SetPadBorderMode(0)
gStyle.SetCanvasBorderMode(0)
gStyle.SetFrameBorderMode(0)
gStyle.SetOptStat(1110)
gStyle.SetStatH(0.3)
gStyle.SetStatW(0.3)
gStyle.SetTitleFillColor(0)
#gStyle.SetTitleY(1.)
#gStyle.SetTitleX(.1)
gStyle.SetTitleBorderSize(0)
gStyle.SetHistLineWidth(2)
gStyle.SetFrameFillColor(0)
#gStyle.SetLineWidth(2)
#gStyle.SetTitleColor(0)
#gStyle.SetTitleColor(1)
gStyle.SetLabelSize(0.05, "x")
gStyle.SetLabelSize(0.05, "y")
gStyle.SetLabelOffset(0.02, "y")
gStyle.SetTitleOffset(1.8, "y")
gStyle.SetTitleSize(0.04, "y")
gStyle.SetPadRightMargin(0.02)
gStyle.SetPadLeftMargin(0.14) # Used to be 0.20 --> Salva
gStyle.SetPadBottomMargin(0.14)
def load_joeys_style():
from ROOT import gStyle, gROOT
font_id = 12
gStyle.SetOptStat(0)
gStyle.SetTitleFont(font_id, "X") # LaTeX typeface
gStyle.SetTitleFont(font_id, "Y")
gStyle.SetTitleFont(font_id, "Z")
gStyle.SetTitleFont(font_id, "T")
gStyle.SetLabelFont(font_id, "X") # LaTeX typeface
gStyle.SetLabelFont(font_id, "Y")
gStyle.SetLabelFont(font_id, "Z")
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
gStyle.SetPadTopMargin(0.13)
gStyle.SetPadBottomMargin(0.25)
gStyle.SetPadLeftMargin(0.17)
gStyle.SetPadRightMargin(0.25)
gStyle.SetCanvasDefW(1500)
gStyle.SetCanvasDefH(900)
gStyle.SetTitleSize(0.06,"X")
gStyle.SetTitleSize(0.06,"Y")
gStyle.SetTitleSize(0.06,"Z")
gStyle.SetTitleSize(0.06,"T") # for title
gStyle.SetLabelSize(0.04,"X")
gStyle.SetLabelSize(0.04,"Y")
gStyle.SetLabelSize(0.04,"Z")
gStyle.SetTitleOffset(1.5,"X")
gStyle.SetTitleOffset(1.1,"Y")
gStyle.SetTitleOffset(1.3,"Z")
gROOT.ForceStyle()
def SetStyle():
gROOT.SetStyle('Plain')
gROOT.ForceStyle()
gStyle.SetTextFont(42)
gStyle.SetOptTitle(0)
gStyle.SetOptFit(1112)
gStyle.SetOptStat(1110)
gStyle.SetPadRightMargin(0.08)
gStyle.SetPadTopMargin(0.11)
gStyle.SetPadBottomMargin(0.12)
gStyle.SetTitleFont(42, 'x')
gStyle.SetTitleFont(42, 'y')
gStyle.SetTitleFont(42, 'z')
gStyle.SetTitleOffset(1.05, 'x')
gStyle.SetTitleOffset(1.00, 'y')
gStyle.SetTitleSize(0.05, 'x')
gStyle.SetTitleSize(0.05, 'y')
gStyle.SetTitleSize(0.05, 'z')
gStyle.SetLabelFont(42, 'x')
gStyle.SetLabelFont(42, 'y')
gStyle.SetLabelFont(42, 'z')
gStyle.SetLabelSize(0.05, 'x')
gStyle.SetLabelSize(0.05, 'y')
gStyle.SetLabelSize(0.05, 'z')
TGaxis.SetMaxDigits(3)
gStyle.SetStatY(0.9)
def setStyle():
gStyle.SetOptStat(0)
gStyle.SetPadRightMargin(0.18)
gStyle.SetPadLeftMargin(0.15)
gStyle.SetPadBottomMargin(0.1)
gStyle.SetPadTopMargin(0.06)
gStyle.SetOptTitle(0)
gStyle.SetPalette(55)
def set_style():
gStyle.SetPadRightMargin(0.035)
gStyle.SetPadLeftMargin(0.18)
gStyle.SetPadTopMargin(0.05)
gStyle.SetTitleSize(0.045, 'xy')
gStyle.SetLabelSize(0.040, 'xy')
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
gStyle.SetLegendBorderSize(0)
gStyle.SetOptStat(0)
def Init():
from ROOT import gStyle
from ROOT import gROOT
gROOT.ProcessLine("gErrorIgnoreLevel = 2000;")
gStyle.SetCanvasColor(0);
gStyle.SetCanvasBorderMode(0);
gStyle.SetCanvasBorderSize(3);
gStyle.SetPadLeftMargin(0.125);
gStyle.SetPadBottomMargin(0.12);
gStyle.SetPadColor(0);
gStyle.SetPadBorderMode(0);
gStyle.SetFrameBorderMode(0);
gStyle.SetFrameBorderSize(0);
gStyle.SetFrameFillColor(0);
gStyle.SetOptStat(0);
gStyle.SetLabelOffset(0.005,"X");
gStyle.SetLabelSize(0.03,"X");
gStyle.SetLabelFont(42,"X");
gStyle.SetTitleOffset(.85,"X");
gStyle.SetTitleSize(0.04,"X");
gStyle.SetTitleFont(42,"X");
gStyle.SetLabelOffset(0.005,"Y");
gStyle.SetLabelSize(0.03,"Y");
gStyle.SetLabelFont(42,"Y");
gStyle.SetTitleOffset(.98,"Y");
gStyle.SetTitleSize(0.04,"Y");
gStyle.SetTitleFont(42,"Y");
gStyle.SetStatColor(0);
gStyle.SetStatBorderSize(0);
gStyle.SetTextFont(2);
gStyle.SetTextSize(.05);
gStyle.SetLegendBorderSize(1);
gStyle.SetHistLineWidth(2);
gStyle.SetTitleFillColor(0);
gStyle.SetTitleFontSize(0.06);
gStyle.SetTitleBorderSize(0);
gStyle.SetTitleAlign(13);
gStyle.SetTextAlign(22);
#RJ
gStyle.SetPadTickX(1);
gStyle.SetPadTickY(1);
gStyle.SetPadTopMargin(0.05);
gStyle.SetPadBottomMargin(0.13);
gStyle.SetPadLeftMargin(0.16);
gStyle.SetPadRightMargin(0.03);
def looks():
gROOT.ProcessLine('TGaxis::SetMaxDigits(3)')
gStyle.SetFrameBorderMode(0)
gStyle.SetFrameFillColor(0)
gStyle.SetCanvasBorderMode(0)
gStyle.SetCanvasColor(0)
gStyle.SetPadBorderMode(0)
gStyle.SetPadColor(0)
gStyle.SetStatColor(0)
gStyle.SetTitleFont(42, '')
gStyle.SetLabelFont(42, 'x')
gStyle.SetTitleFont(42, 'x')
gStyle.SetLabelFont(42, 'y')
gStyle.SetTitleFont(42, 'y')
gStyle.SetLabelFont(42, 'z')
gStyle.SetTitleFont(42, 'z')
gStyle.SetLabelSize(0.048, 'x')
gStyle.SetTitleSize(0.048, 'x')
gStyle.SetLabelSize(0.048, 'y')
gStyle.SetTitleSize(0.048, 'y')
gStyle.SetLabelSize(0.048, 'z')
gStyle.SetTitleSize(0.048, 'z')
gStyle.SetTitleSize(0.048, '')
gStyle.SetTitleAlign(23)
gStyle.SetTitleX(0.5)
gStyle.SetTitleBorderSize(0)
gStyle.SetTitleFillColor(0)
gStyle.SetTitleStyle(0)
gStyle.SetOptStat('emr')
gStyle.SetOptStat(0)
gStyle.SetStatBorderSize(0)
gStyle.SetStatFont(42)
gStyle.SetStatFontSize(0.048)
gStyle.SetStatY(0.9)
gStyle.SetStatX(0.86)
gStyle.SetHistLineColor(ROOT.kBlue + 2)
gStyle.SetLegendBorderSize(0)
gStyle.SetLegendFillColor(0)
gStyle.SetFuncWidth(2)
gStyle.SetFuncColor(2)
gStyle.SetPadTopMargin(0.08)
gStyle.SetPadBottomMargin(0.12)
gStyle.SetPadLeftMargin(0.12)
gStyle.SetPadRightMargin(0.06)
gStyle.SetCanvasDefX(400)
gStyle.SetCanvasDefY(20)
gStyle.SetCanvasDefH(420)
gStyle.SetCanvasDefW(610)
gStyle.SetFrameBorderMode(0)
gStyle.SetFrameLineWidth(2)
gStyle.SetHistLineWidth(2)
gStyle.SetTitleOffset(1.16, 'y')
gStyle.SetTitleOffset(1.20, 'x')
def set_root_style(stat=1110,
grid=0,
PadTopMargin=0.08,
PadLeftMargin=0.10,
TitleOffsetY=1.2):
# must be used in the beginning
from ROOT import gROOT, gStyle
gROOT.SetBatch(1)
gROOT.Reset()
gStyle.SetOptTitle(1)
gStyle.SetTitleFillColor(0)
gStyle.SetTitleBorderSize(0)
# gStyle.SetTitleFont(22)
# gStyle.SetStatFont(22)
# gStyle.SetStatColor(1)
# gStyle.SetLabelFont(22,"X")
# gStyle.SetLabelFont(22,"Y")
gStyle.SetCanvasBorderMode(0)
gStyle.SetCanvasColor(0)
gStyle.SetCanvasDefX(0)
gStyle.SetCanvasDefY(0)
gStyle.SetFrameBorderMode(0)
gStyle.SetFrameBorderSize(1)
gStyle.SetFrameFillColor(0)
gStyle.SetFrameFillStyle(0)
gStyle.SetFrameLineColor(1)
gStyle.SetFrameLineStyle(1)
gStyle.SetFrameLineWidth(1)
gStyle.SetPadTopMargin(PadTopMargin)
gStyle.SetPadLeftMargin(PadLeftMargin)
gStyle.SetPadRightMargin(0.05)
gStyle.SetLabelSize(0.03, "XYZ")
gStyle.SetTitleSize(0.04, "XYZ")
gStyle.SetTitleOffset(TitleOffsetY, "Y")
gStyle.SetPadBorderMode(0)
gStyle.SetPadColor(0)
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
gStyle.SetPadGridX(grid)
gStyle.SetPadGridY(grid)
gStyle.SetOptStat(stat)
gStyle.SetStatColor(0)
gStyle.SetStatBorderSize(1)
def rootlogon():
from ROOT import gStyle
gStyle.SetOptStat(0)
gStyle.SetPadTopMargin(0.07)
gStyle.SetPadRightMargin(0.05)
gStyle.SetPadBottomMargin(0.13)
gStyle.SetPadLeftMargin(0.19)
gStyle.SetTitleOffset(1.2, 'x')
gStyle.SetTitleOffset(1.8, 'y')
gStyle.SetTextSize(0.05)
gStyle.SetLabelSize(0.05, 'xyz')
gStyle.SetTitleSize(0.05, 'xyz')
gStyle.SetTitleSize(0.05, 't')
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
def setStyle():
gROOT.Reset()
icol = 0
# WHITE
font = 42
# Helvetica
tsize = 0.05
gStyle.SetFrameBorderMode(icol)
gStyle.SetFrameFillColor(icol)
gStyle.SetCanvasBorderMode(icol)
gStyle.SetCanvasColor(icol)
gStyle.SetPadBorderMode(icol)
gStyle.SetPadColor(icol)
gStyle.SetStatColor(icol)
gStyle.SetPaperSize(20, 26)
gStyle.SetPadTopMargin(0.05)
gStyle.SetPadRightMargin(0.08)
gStyle.SetPadBottomMargin(0.15)
gStyle.SetPadLeftMargin(0.12)
gStyle.SetTitleXOffset(1.05)
gStyle.SetTitleYOffset(0.95)
gStyle.SetTextFont(font)
gStyle.SetTextSize(tsize)
gStyle.SetLabelFont(font, "x")
gStyle.SetTitleFont(font, "x")
gStyle.SetLabelFont(font, "y")
gStyle.SetTitleFont(font, "y")
gStyle.SetLabelFont(font, "z")
gStyle.SetTitleFont(font, "z")
gStyle.SetLabelSize(tsize * 0.85, "x")
gStyle.SetTitleSize(tsize * 1.10, "x")
gStyle.SetLabelSize(tsize * 0.85, "y")
gStyle.SetTitleSize(tsize * 1.10, "y")
gStyle.SetLabelSize(tsize * 0.85, "z")
gStyle.SetTitleSize(tsize * 1.10, "z")
gStyle.SetMarkerStyle(20)
gStyle.SetMarkerSize(1.)
gStyle.SetHistLineWidth(2)
gStyle.SetLineStyleString(2, "[12 12]")
# postscript dashes
gStyle.SetEndErrorSize(0.)
# gStyle.SetOptTitle(0);
gStyle.SetOptStat(0)
gStyle.SetOptFit(0)
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
gStyle.SetPaintTextFormat("4.1f")
def plot_response(histos,profiles,profiles_noReg,profiles_Cat,style=False,outString=None):
if style==True:
gROOT.SetBatch(True)
gROOT.ProcessLineSync(".x /mnt/t3nfs01/data01/shome/nchernya/HHbbgg_ETH_devel/scripts/setTDRStyle.C")
gROOT.ForceStyle()
gStyle.SetPadTopMargin(0.06)
gStyle.SetPadRightMargin(0.04)
gStyle.SetPadLeftMargin(0.15)
c = ROOT.TCanvas("c","c",900,900)
c.cd()
histos.Draw("HISTBOX")
colors=[ROOT.kRed,ROOT.kOrange-3,ROOT.kAzure+10]
profiles.SetLineColor(colors[0])
profiles.SetLineWidth(3)
profiles.SetMarkerColor(colors[0])
profiles.SetStats(0)
profiles.Draw("PLsame")
profiles_noReg.SetLineColor(colors[1])
profiles_noReg.SetLineWidth(3)
profiles_noReg.SetMarkerColor(colors[1])
profiles_noReg.SetStats(0)
profiles_noReg.Draw("PLsame")
profiles_Cat.SetLineColor(colors[2])
profiles_Cat.SetLineWidth(3)
profiles_Cat.SetMarkerColor(colors[2])
profiles_Cat.SetStats(0)
profiles_Cat.Draw("PLsame")
line = ROOT.TLine(histos.GetXaxis().GetBinCenter(0),1,histos.GetXaxis().GetBinCenter(histos.GetXaxis().GetNbins()),1)
line.SetLineStyle(9)
line.SetLineWidth(3)
line.SetLineColor(ROOT.kGreen+1)
line.Draw("Lsame")
leg = ROOT.TLegend(0.72,0.75,0.95,0.9)
leg.SetFillStyle(-1)
leg.SetBorderSize(0)
leg.SetTextFont(42)
leg.SetTextSize(0.03)
leg.AddEntry(profiles,"XGboost","PL")
leg.AddEntry(profiles_noReg,"no regression","PL")
leg.AddEntry(profiles_Cat,"HIG-16-044","PL")
leg.Draw("same")
c.SaveAs(utils.IO.plotFolder+"Response_"+histos.GetTitle()+'_'+str(outString)+'.png')
c.SaveAs(utils.IO.plotFolder+"Response_"+histos.GetTitle()+'_'+str(outString)+'.pdf')
def plot_ROC_curve(ROC_curve, file_name_portion):
gStyle.SetOptStat(0)
gStyle.SetLabelSize(0.03, "xy")
gStyle.SetTitleSize(0.03, "xy")
gStyle.SetTitleOffset(1.2, "xy")
gStyle.SetPadLeftMargin(0.15)
gStyle.SetPadRightMargin(0.1)
gStyle.SetPadTopMargin(0.1)
gStyle.SetPadBottomMargin(0.15)
canvas = TCanvas("c1", "c1", 800, 800)
canvas.SetTickx()
canvas.SetTicky()
ROC_curve.GetYaxis().SetTitle('Background rejection')
ROC_curve.GetXaxis().SetTitle('Signal efficiency')
ROC_curve.SetLineColor(TColor.kAzure)
ROC_curve.SetFillColor(TColor.kAzure - 2)
ROC_curve.SetLineWidth(2)
ROC_curve.SetFillStyle(0)
from array import array
x, y = array('d'), array('d')
x.append(EFF_SIGNAL_DIRECT_CUT)
y.append(1 - EFF_BACKGROUND_DIRECT_CUT)
dot = TGraph(1, x, y)
dot.SetMarkerColor(8)
dot.SetMarkerSize(3)
dot.SetMarkerStyle(21)
legend = TLegend(0.2, 0.2, 0.4, 0.4)
legend.SetTextSize(0.04)
legend.SetTextFont(42)
legend.SetFillColor(10)
legend.SetLineColor(10)
legend.SetBorderSize(0)
legend.AddEntry(ROC_curve, "BDT 500 trees", "l")
legend.AddEntry(dot, "m_{jj} > 500 GeV and |#Delta#eta_{jj}| > 3 cut", "P")
ROC_curve.Draw("HIST")
legend.Draw("same")
dot.Draw("LPsame")
canvas.RedrawAxis()
canvas.Print(file_name_portion + "_ROC" + ".png")
def __init__(self):
'''
Set up PlotStyle, set gStyle for things we always want no matter what.
'''
# CMS-approved everything
tdrstyle.setTDRStyle()
### Differences from TDR standard:
# Big canvas (can always shrink later)
gStyle.SetCanvasDefH(1200)
gStyle.SetCanvasDefW(1200)
# Tick marks on all sides
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
# Everything has white backgrounds
gStyle.SetLegendFillColor(0)
# Colors that don't suck
gStyle.SetPalette(1)
# Make axis title and labels just a little smaller and (for Y) closer to the axis
gStyle.SetTitleSize(0.044, "XYZ")
gStyle.SetLabelSize(0.033, "XYZ")
gStyle.SetTitleYOffset(1.15)
gStyle.SetTitleXOffset(0.95)
gStyle.SetPadLeftMargin(0.1)
gStyle.SetPadRightMargin(0.025)
gStyle.SetPadBottomMargin(0.095)
gStyle.SetTitleAlign(12)
# Apply changes
gROOT.ForceStyle()
# Force exponentials when axes are over 3 digits
TGaxis.SetMaxDigits(3)
TGaxis.SetExponentOffset(-0.060, 0.008, "y")
TGaxis.SetExponentOffset(
-0.055, -0.062,
"x") # will overlap with title unless title is centered
def __init__(self):
# Setup argument parser
self.parser = argparse.ArgumentParser()
#self.parser.add_argument("--infile", default="histos.root", help="input file (default: %(default)s)")
self.parser.add_argument(
"--outdir",
default="figures/",
help="output directory (default: %(default)s)")
self.parser.add_argument("-v",
"--verbose",
action="count",
default=0,
help="verbosity (default: %(default)s)")
self.options = self.parser.parse_args()
if not self.options.outdir.endswith("/"):
self.options.outdir += "/"
if not os.path.exists(self.options.outdir):
os.makedirs(self.options.outdir)
#if not os.path.isfile(self.options.infile):
# raise Exception("File does not exist: %s" % self.options.infile)
#self.options.tfile = TFile.Open(self.options.infile)
self.options.palette = ("#333333", "#377eb8", "#e41a1c", "#984ea3",
"#ff7f00", "#4daf4a")
# Setup basic drawer
gROOT.LoadMacro("tdrstyle.C")
gROOT.ProcessLine("setTDRStyle();")
#gROOT.ProcessLine("gErrorIgnoreLevel = kWarning;")
gROOT.SetBatch(True)
gStyle.SetNdivisions(510, "Y")
gStyle.SetEndErrorSize(0)
gStyle.SetPadGridX(True)
gStyle.SetPadGridY(True)
#gStyle.SetOptStat(111110)
gStyle.SetPadRightMargin(0.05)
gStyle.SetTitleOffset(1.1, "Y")
gStyle.SetPalette(57) # kBird
gStyle.SetNumberContours(50)
def my_style():
gStyle.SetLabelSize(fontsize, "x")
gStyle.SetLabelSize(fontsize, "y")
gStyle.SetLabelSize(fontsize, "z")
gStyle.SetTitleFontSize(1.5 * fontsize)
gStyle.SetTitleSize(fontsize, "x")
gStyle.SetTitleSize(fontsize, "y")
gStyle.SetTitleSize(fontsize, "z")
gStyle.SetTickLength(0, "Y")
gStyle.SetTitleOffset(1.5, "xy")
gStyle.SetTitleFont(62, "bla")
gStyle.SetPadBottomMargin(0.15)
gStyle.SetPadTopMargin(0.10)
gStyle.SetPadLeftMargin(0.32)
gStyle.SetPadRightMargin(0.05)
gStyle.SetStatX(0.88)
gStyle.SetStatY(0.87)
gStyle.SetNdivisions(505)
gStyle.SetCanvasColor(-1)
gStyle.SetPadColor(-1)
gStyle.SetFrameFillColor(-1)
gStyle.SetTitleFillColor(-1)
gStyle.SetFillColor(-1)
gStyle.SetFillStyle(4000)
gStyle.SetStatStyle(0)
gStyle.SetTitleStyle(0)
gStyle.SetCanvasBorderSize(0)
gStyle.SetFrameBorderSize(0)
gStyle.SetLegendBorderSize(0)
gStyle.SetStatBorderSize(0)
gStyle.SetTitleBorderSize(0)
def __init__(self):
# ROOT
gROOT.LoadMacro("tdrstyle.C")
gROOT.LoadMacro("../interface/HelperMath.h")
gROOT.LoadMacro("../../AMSimulationIO/src/AMSimulationIOLinkDef.h")
gROOT.ProcessLine("setTDRStyle()")
gStyle.SetEndErrorSize(2)
gStyle.SetPadRightMargin(0.05)
gStyle.SetTitleOffset(1.1, "Y")
gStyle.SetLabelSize(0.04, "Y")
gStyle.SetLabelSize(0.04, "Z")
gStyle.SetNdivisions(505, "XY")
gStyle.SetPalette(55) # rainbow color map
gStyle.SetNumberContours(100)
gStyle.SetOptStat(111110)
gStyle.SetStatX(0.94)
gStyle.SetStatY(0.93)
gStyle.SetStatH(0.30)
gStyle.SetStatW(0.28)
TH1.SetDefaultSumw2()
def main():
# usage description
usage = "Example: ./scripts/plotSignificance.py -l logs -f qq --massrange 1200 6000 100"
# input parameters
parser = ArgumentParser(
description='Script that plots significance for specified mass points',
epilog=usage)
parser.add_argument('analysis', type=str, help='Analysis name')
parser.add_argument('model', type=str, help='Model name')
parser.add_argument("-M",
"--method",
dest="method",
choices=['ProfileLikelihood', 'HybridNew', 'theta'],
default='ProfileLikelihood',
help="Method to calculate upper limits",
metavar="METHOD")
parser.add_argument(
'--fit_function',
type=str,
default="dijet4",
help="Name of fit function used for background estimate")
parser.add_argument(
"--sigRange",
dest="sigRange",
type=float,
default=2.5,
help="Significance range to plot (default: %(default)f)")
parser.add_argument(
"--postfix",
dest="postfix",
default='',
help="Postfix for the output plot name (default: %(default)s)")
parser.add_argument(
"--fileFormat",
dest="fileFormat",
default='pdf',
help="Format of the output plot (default: %(default)s)")
parser.add_argument("--extraText",
dest="extraText",
default='Preliminary',
help="Extra text on the plot (default: %(default)s)")
parser.add_argument(
"--lumi_sqrtS",
dest="lumi_sqrtS",
default='19.7 fb^{-1} (13 TeV)',
help=
"Integrated luminosity and center-of-mass energy (default: %(default)s)"
)
parser.add_argument("--printResults",
dest="printResults",
default=False,
action="store_true",
help="Print results to the screen")
parser.add_argument('--fitTrigger',
action='store_true',
help="Use trigger fit")
parser.add_argument('--correctTrigger',
action='store_true',
help="Use trigger correction")
parser.add_argument('--useMCTrigger',
action='store_true',
help="Use MC trigger emulation")
parser.add_argument("--noSyst",
action="store_true",
help="Make plots for limits without systematics")
parser.add_argument(
"--freezeNuisances",
type=str,
help="Make plots for limits with frozen nuisance parameters")
mass_group = parser.add_mutually_exclusive_group(required=True)
mass_group.add_argument(
"--mass",
type=int,
nargs='*',
default=1000,
help=
"Mass can be specified as a single value or a whitespace separated list (default: %(default)i)"
)
mass_group.add_argument(
"--massrange",
type=int,
nargs=3,
help="Define a range of masses to be produced. Format: min max step",
metavar=('MIN', 'MAX', 'STEP'))
mass_group.add_argument("--masslist",
help="List containing mass information")
args = parser.parse_args()
# mass points for which resonance shapes will be produced
input_masses = []
if args.massrange != None:
MIN, MAX, STEP = args.massrange
input_masses = range(MIN, MAX + STEP, STEP)
elif args.masslist != None:
# A mass list was provided
print "Will create mass list according to", args.masslist
masslist = __import__(args.masslist.replace(".py", ""))
input_masses = masslist.masses
else:
input_masses = args.mass
# sort masses
input_masses.sort()
# arrays holding results
masses = array('d')
significances = array('d')
p0_values = array('d')
for mass in input_masses:
masses.append(mass)
#print ">> Reading results for resonance with m = %i GeV..."%(int(mass))
log_file = open(
limit_config.get_combine_log_path(
args.analysis,
args.model,
mass,
args.fit_function,
args.method,
what="significance",
systematics=(not args.noSyst),
frozen_nps=args.freezeNuisances,
fitTrigger=args.fitTrigger,
correctTrigger=args.correctTrigger,
useMCTrigger=args.useMCTrigger), 'r')
if args.method == 'theta':
logName = logName.replace('significance_', '')
# read the log file
for line in log_file:
if args.method == 'theta':
if re.search("^{'signal': {'Z':", line):
significances.append(
float(line.split()[-1].lstrip('[').rstrip('}').rstrip(
']')))
else:
if re.search("^Significance:", line):
significances.append(float(line.split()[1]))
elif re.search("^Null p-value:", line):
p0_values.append(float(line.split()[2]))
if len(masses) != len(significances):
print "** ERROR: ** Could not find significance for m =", int(
mass), "GeV. Aborting."
sys.exit(1)
if len(masses) != len(p0_values):
print "** ERROR: ** Could not find p0 value for m =", int(
mass), "GeV. Aborting."
sys.exit(1)
# Allow only positive fluctuations
if significances[-1] < 0:
significances[-1] = 0.
if args.printResults:
print "masses =", masses.tolist()
print "significances =", significances.tolist()
print "p0_values =", p0_values.tolist()
# import ROOT stuff
from ROOT import kTRUE, kFALSE, gROOT, gStyle, gPad, TGraph, TCanvas, TLegend
from ROOT import kGreen, kYellow, kWhite, kRed, kBlue
gROOT.SetBatch(kTRUE)
gStyle.SetOptStat(0)
gStyle.SetOptTitle(0)
gStyle.SetTitleFont(42, "XYZ")
gStyle.SetTitleSize(0.06, "XYZ")
gStyle.SetLabelFont(42, "XYZ")
gStyle.SetLabelSize(0.05, "XYZ")
gStyle.SetCanvasBorderMode(0)
gStyle.SetFrameBorderMode(0)
gStyle.SetCanvasColor(kWhite)
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
gStyle.SetPadLeftMargin(0.15)
gStyle.SetPadRightMargin(0.05)
gStyle.SetPadTopMargin(0.05)
gStyle.SetPadBottomMargin(0.15)
gROOT.ForceStyle()
graph_sig = TGraph(len(masses), masses, significances)
graph_sig.GetXaxis().SetTitle("Resonance mass [GeV]")
graph_sig.GetYaxis().SetTitle("p_0")
graph_sig.GetYaxis().SetTitleOffset(1.2)
graph_sig.GetYaxis().SetRangeUser(0., args.sigRange)
graph_sig.SetLineWidth(2)
graph_sig.SetLineColor(kRed)
graph_sig.SetMarkerStyle(21)
graph_sig.SetMarkerSize(1)
graph_sig.SetMarkerColor(kBlue)
c = TCanvas("c", "", 800, 800)
c.cd()
graph_sig.Draw("ALP")
# draw the lumi text on the canvas
CMS_lumi.extraText = args.extraText
CMS_lumi.lumi_sqrtS = args.lumi_sqrtS # used with iPeriod = 0 (free form)
iPos = 11
iPeriod = 0
CMS_lumi.CMS_lumi(c, iPeriod, iPos)
gPad.RedrawAxis()
c.SetGridx()
c.SetGridy()
fileName = limit_config.paths[
"limit_plots"] + '/significance_%s_%s_%s_%s.%s' % (
args.method, args.analysis, args.model + args.postfix,
args.fit_function, args.fileFormat.lower())
c.SaveAs(fileName)
#print "Significance plot saved to '%s'"%(fileName)
graph_p0 = TGraph(len(masses), masses, p0_values)
graph_p0.GetXaxis().SetTitle("Resonance mass [GeV]")
graph_p0.GetYaxis().SetTitle("p_{0} (local)")
graph_p0.GetYaxis().SetTitleOffset(1.2)
graph_p0.GetYaxis().SetRangeUser(1.e-3, 1.)
graph_p0.SetLineWidth(2)
graph_p0.SetLineColor(kRed)
graph_p0.SetMarkerStyle(21)
graph_p0.SetMarkerSize(1)
graph_p0.SetMarkerColor(kBlue)
c_p0 = TCanvas("c_p0", "", 800, 800)
c_p0.SetLogy()
c_p0.cd()
graph_p0.Draw("ALP")
# draw the lumi text on the canvas
# draw the lumi text on the canvas
CMS_lumi.extraText = args.extraText
CMS_lumi.lumi_sqrtS = args.lumi_sqrtS # used with iPeriod = 0 (free form)
iPos = 11
iPeriod = 0
CMS_lumi.CMS_lumi(c, iPeriod, iPos)
#Root.CMSLabel(0.2, 0.2, "Internal", 1, 0.65)
gPad.RedrawAxis()
c_p0.SetGridx()
c_p0.SetGridy()
fileName = limit_config.paths["limit_plots"] + '/p0_%s_%s_%s_%s.%s' % (
args.method, args.analysis, args.model + args.postfix,
args.fit_function, args.fileFormat.lower())
c_p0.SaveAs(fileName)
print "p0 plot saved to '%s'" % (fileName)
__author__ = "Maoqiang JING <*****@*****.**>"
__copyright__ = "Copyright (c) Maoqiang JING"
__created__ = "[2020-10-20 Tue 20:13]"
import ROOT
from ROOT import TCanvas, gStyle
from ROOT import TFile, TH2F, TPaveText, TArrow
import sys, os
import logging
from math import *
logging.basicConfig(level=logging.DEBUG,
format=' %(asctime)s - %(levelname)s- %(message)s')
gStyle.SetPaperSize(20, 30)
gStyle.SetPadTopMargin(0.05)
gStyle.SetPadRightMargin(0.08)
gStyle.SetPadBottomMargin(0.18)
gStyle.SetPadLeftMargin(0.16)
gStyle.SetOptTitle(0)
gStyle.SetOptTitle(0)
def usage():
sys.stdout.write('''
NAME
opt_2D.py
SYNOPSIS
./opt_2D.py [ecms]
AUTHOR
def initialize2(self):
# For the canvas:
gStyle.SetCanvasBorderMode(0)
gStyle.SetCanvasColor(kWhite)
gStyle.SetCanvasDefH(600) #Height of canvas
gStyle.SetCanvasDefW(600) #Width of canvas
gStyle.SetCanvasDefX(0) #POsition on screen
gStyle.SetCanvasDefY(0)
# For the Pad:
gStyle.SetPadBorderMode(0)
# gStyle.SetPadBorderSize(Width_t size = 1)
gStyle.SetPadColor(kWhite)
gStyle.SetPadGridX(False)
gStyle.SetPadGridY(False)
gStyle.SetGridColor(0)
gStyle.SetGridStyle(3)
gStyle.SetGridWidth(1)
# For the frame:
gStyle.SetFrameBorderMode(0)
gStyle.SetFrameBorderSize(1)
gStyle.SetFrameFillStyle(1000)
gStyle.SetFrameFillColor(0)
gStyle.SetFrameFillStyle(0)
gStyle.SetFrameLineColor(1)
gStyle.SetFrameLineStyle(1)
gStyle.SetFrameLineWidth(1)
# For the histo:
# gStyle.SetHistFillColor(1)
# gStyle.SetHistFillStyle(0)
gStyle.SetHistLineColor(1)
gStyle.SetHistLineStyle(0)
gStyle.SetHistLineWidth(1)
# gStyle.SetLegoInnerR(Float_t rad = 0.5)
# gStyle.SetNumberContours(Int_t number = 20)
gStyle.SetEndErrorSize(2)
# gStyle.SetErrorMarker(20)
gStyle.SetErrorX(0.)
gStyle.SetMarkerStyle(20)
#For the fit/function:
gStyle.SetOptFit(1)
gStyle.SetFitFormat("5.4g")
gStyle.SetFuncColor(2)
gStyle.SetFuncStyle(1)
gStyle.SetFuncWidth(1)
#For the date:
gStyle.SetOptDate(0)
# gStyle.SetDateX(Float_t x = 0.01)
# gStyle.SetDateY(Float_t y = 0.01)
# For the statistics box:
gStyle.SetOptFile(0)
gStyle.SetOptStat(
0) # To display the mean and RMS: SetOptStat("mr")
gStyle.SetStatColor(kWhite)
gStyle.SetStatFont(42)
gStyle.SetStatFontSize(0.025)
gStyle.SetStatTextColor(1)
gStyle.SetStatFormat("6.4g")
gStyle.SetStatBorderSize(1)
gStyle.SetStatH(0.1)
gStyle.SetStatW(0.15)
# gStyle.SetStatStyle(Style_t style = 1001)
# gStyle.SetStatX(Float_t x = 0)
# gStyle.SetStatY(Float_t y = 0)
# Margins:
gStyle.SetPadTopMargin(0.05)
gStyle.SetPadBottomMargin(0.13)
gStyle.SetPadLeftMargin(0.16)
gStyle.SetPadRightMargin(0.02)
# For the Global title:
gStyle.SetOptTitle(0)
gStyle.SetTitleFont(42)
gStyle.SetTitleColor(1)
gStyle.SetTitleTextColor(1)
gStyle.SetTitleFillColor(10)
gStyle.SetTitleFontSize(0.05)
# gStyle.SetTitleH(0) # Set the height of the title box
# gStyle.SetTitleW(0) # Set the width of the title box
# gStyle.SetTitleX(0) # Set the position of the title box
# gStyle.SetTitleY(0.985) # Set the position of the title box
# gStyle.SetTitleStyle(Style_t style = 1001)
# gStyle.SetTitleBorderSize(2)
# For the axis titles:
gStyle.SetTitleColor(1, "XYZ")
gStyle.SetTitleFont(42, "XYZ")
gStyle.SetTitleSize(0.06, "XYZ")
# gStyle.SetTitleXSize(Float_t size = 0.02) # Another way to set the size?
# gStyle.SetTitleYSize(Float_t size = 0.02)
gStyle.SetTitleXOffset(0.9)
gStyle.SetTitleYOffset(1.25)
# gStyle.SetTitleOffset(1.1, "Y") # Another way to set the Offset
# For the axis labels:
gStyle.SetLabelColor(1, "XYZ")
gStyle.SetLabelFont(42, "XYZ")
gStyle.SetLabelOffset(0.007, "XYZ")
gStyle.SetLabelSize(0.05, "XYZ")
# For the axis:
gStyle.SetAxisColor(1, "XYZ")
gStyle.SetStripDecimals(True)
gStyle.SetTickLength(0.03, "XYZ")
gStyle.SetNdivisions(510, "XYZ")
gStyle.SetPadTickX(
1) # To get tick marks on the opposite side of the frame
gStyle.SetPadTickY(1)
# Change for log plots:
gStyle.SetOptLogx(0)
gStyle.SetOptLogy(0)
gStyle.SetOptLogz(0)
# Postscript options:
gStyle.SetPaperSize(20., 20.)
def setTDRStyle(force):
gStyle.SetCanvasBorderMode(0)
gStyle.SetCanvasColor(kWhite)
gStyle.SetCanvasDefH(600)
gStyle.SetCanvasDefW(600)
gStyle.SetCanvasDefX(0)
gStyle.SetCanvasDefY(0)
gStyle.SetPadBorderMode(0)
gStyle.SetPadColor(kWhite)
gStyle.SetPadGridX(False)
gStyle.SetPadGridY(False)
gStyle.SetGridColor(0)
gStyle.SetGridStyle(3)
gStyle.SetGridWidth(1)
gStyle.SetFrameBorderMode(0)
gStyle.SetFrameBorderSize(1)
gStyle.SetFrameFillColor(0)
gStyle.SetFrameFillStyle(0)
gStyle.SetFrameLineColor(1)
gStyle.SetFrameLineStyle(1)
gStyle.SetFrameLineWidth(1)
if force:
gStyle.SetHistLineColor(1)
gStyle.SetHistLineStyle(0)
gStyle.SetHistLineWidth(1)
gStyle.SetEndErrorSize(2)
gStyle.SetErrorX(0.)
gStyle.SetMarkerStyle(20)
gStyle.SetOptFit(1)
gStyle.SetFitFormat("5.4g")
gStyle.SetFuncColor(2)
gStyle.SetFuncStyle(1)
gStyle.SetFuncWidth(1)
gStyle.SetOptDate(0)
gStyle.SetOptFile(0)
gStyle.SetOptStat(0)
gStyle.SetStatColor(kWhite)
gStyle.SetStatFont(42)
gStyle.SetStatFontSize(0.04)
gStyle.SetStatTextColor(1)
gStyle.SetStatFormat("6.4g")
gStyle.SetStatBorderSize(1)
gStyle.SetStatH(0.1)
gStyle.SetStatW(0.2)
gStyle.SetPadTopMargin(0.05)
gStyle.SetPadBottomMargin(0.13)
gStyle.SetPadLeftMargin(0.16)
gStyle.SetPadRightMargin(0.04)
gStyle.SetOptTitle(0)
gStyle.SetTitleFont(42)
gStyle.SetTitleColor(1)
gStyle.SetTitleTextColor(1)
gStyle.SetTitleFillColor(10)
gStyle.SetTitleFontSize(0.05)
gStyle.SetTitleColor(1, "XYZ")
gStyle.SetTitleFont(42, "XYZ")
gStyle.SetTitleSize(0.06, "XYZ")
gStyle.SetTitleXOffset(0.9)
gStyle.SetTitleYOffset(1.25)
gStyle.SetLabelColor(1, "XYZ")
gStyle.SetLabelFont(42, "XYZ")
gStyle.SetLabelOffset(0.007, "XYZ")
gStyle.SetLabelSize(0.05, "XYZ")
gStyle.SetAxisColor(1, "XYZ")
gStyle.SetStripDecimals(True)
gStyle.SetTickLength(0.03, "XYZ")
gStyle.SetNdivisions(510, "XYZ")
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
gStyle.SetOptLogx(0)
gStyle.SetOptLogy(0)
gStyle.SetOptLogz(0)
gStyle.SetPaperSize(20.,20.)
gROOT.ForceStyle()
def SetGlobalStyle(**kwargs):
'''
Method to set global style.
Parameters
----------
- padrightmargin (float), default = 0.035
- padleftmargin (float), default = 0.12
- padtopmargin (float), default = 0.035
- padbottommargin (float), default = 0.12
- titlesize (float), default = 0.050
- titlesizex (float), default = 0.050
- titlesizey (float), default = 0.050
- titlesizez (float), default = 0.050
- labelsize (float), default = 0.045
- labelsizex (float), default = 0.045
- labelsizey (float), default = 0.045
- labelsizez (float), default = 0.045
- titleoffset (float), default = 1.2
- titleoffsetx (float), default = 1.2
- titleoffsey (float), default = 1.2
- titleoffsetz (float), default = 1.2
- opttitle (int), default = 0
- optstat (int), default = 0
- padtickx (int), default = 1
- padticky (int), default = 1
- maxdigits (int), default no max value
- palette (int), default kBird
'''
# pad margins
if 'padrightmargin' in kwargs:
gStyle.SetPadRightMargin(kwargs['padrightmargin'])
else:
gStyle.SetPadRightMargin(0.035)
if 'padleftmargin' in kwargs:
gStyle.SetPadLeftMargin(kwargs['padleftmargin'])
else:
gStyle.SetPadLeftMargin(0.12)
if 'padtopmargin' in kwargs:
gStyle.SetPadTopMargin(kwargs['padtopmargin'])
else:
gStyle.SetPadTopMargin(0.035)
if 'padbottommargin' in kwargs:
gStyle.SetPadBottomMargin(kwargs['padbottommargin'])
else:
gStyle.SetPadBottomMargin(0.1)
# title sizes
if 'titlesize' in kwargs:
gStyle.SetTitleSize(kwargs['titlesize'], 'xyz')
else:
gStyle.SetTitleSize(0.050, 'xyz')
if 'titlesizex' in kwargs:
gStyle.SetTitleSize(kwargs['titlesizex'], 'x')
if 'titlesizey' in kwargs:
gStyle.SetTitleSize(kwargs['titlesizex'], 'y')
if 'titlesizez' in kwargs:
gStyle.SetTitleSize(kwargs['titlesizex'], 'z')
# label sizes
if 'labelsize' in kwargs:
gStyle.SetLabelSize(kwargs['labelsize'], 'xyz')
else:
gStyle.SetLabelSize(0.045, 'xyz')
if 'labelsizex' in kwargs:
gStyle.SetLabelSize(kwargs['labelsizex'], 'x')
if 'labelsizey' in kwargs:
gStyle.SetLabelSize(kwargs['labelsizex'], 'y')
if 'labelsizez' in kwargs:
gStyle.SetLabelSize(kwargs['labelsizex'], 'z')
# title offsets
if 'titleoffset' in kwargs:
gStyle.SetTitleOffset(kwargs['titleoffset'], 'xyz')
else:
gStyle.SetTitleOffset(1.2, 'xyz')
if 'titleoffsetx' in kwargs:
gStyle.SetTitleOffset(kwargs['titleoffsetx'], 'x')
if 'titleoffsety' in kwargs:
gStyle.SetTitleOffset(kwargs['titleoffsety'], 'y')
if 'titleoffsetz' in kwargs:
gStyle.SetTitleOffset(kwargs['titleoffsetz'], 'z')
# other options
if 'opttitle' in kwargs:
gStyle.SetOptTitle(kwargs['opttitle'])
else:
gStyle.SetOptTitle(0)
if 'optstat' in kwargs:
gStyle.SetOptStat(kwargs['optstat'])
else:
gStyle.SetOptStat(0)
if 'padtickx' in kwargs:
gStyle.SetPadTickX(kwargs['padtickx'])
else:
gStyle.SetPadTickX(1)
if 'padticky' in kwargs:
gStyle.SetPadTickY(kwargs['padticky'])
else:
gStyle.SetPadTickY(1)
gStyle.SetLegendBorderSize(0)
if 'maxdigits' in kwargs:
TGaxis.SetMaxDigits(kwargs['maxdigits'])
if 'palette' in kwargs:
gStyle.SetPalette(kwargs['palette'])
gROOT.ForceStyle()
def setStyle():
gStyle.SetCanvasColor(0)
gStyle.SetCanvasBorderSize(10)
gStyle.SetCanvasBorderMode(0)
gStyle.SetCanvasDefH(700)
gStyle.SetCanvasDefW(700)
gStyle.SetPadColor(0)
gStyle.SetPadBorderSize(10)
gStyle.SetPadBorderMode(0)
gStyle.SetPadBottomMargin(0.13)
gStyle.SetPadTopMargin(0.08)
gStyle.SetPadLeftMargin(0.15)
gStyle.SetPadRightMargin(0.05)
gStyle.SetPadGridX(0)
gStyle.SetPadGridY(0)
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
gStyle.SetFrameFillStyle(0)
gStyle.SetFrameFillColor(0)
gStyle.SetFrameLineColor(1)
gStyle.SetFrameLineStyle(0)
gStyle.SetFrameLineWidth(1)
gStyle.SetFrameBorderSize(10)
gStyle.SetFrameBorderMode(0)
gStyle.SetNdivisions(505)
gStyle.SetLineWidth(2)
gStyle.SetHistLineWidth(2)
gStyle.SetFrameLineWidth(2)
gStyle.SetLegendFillColor(root.kWhite)
gStyle.SetLegendFont(42)
gStyle.SetMarkerSize(1.2)
gStyle.SetMarkerStyle(20)
gStyle.SetLabelSize(0.040, "X")
gStyle.SetLabelSize(0.040, "Y")
gStyle.SetLabelOffset(0.010, "X")
gStyle.SetLabelOffset(0.010, "Y")
gStyle.SetLabelFont(42, "X")
gStyle.SetLabelFont(42, "Y")
gStyle.SetTitleBorderSize(0)
gStyle.SetTitleFont(42)
gStyle.SetTitleFont(42, "X")
gStyle.SetTitleFont(42, "Y")
gStyle.SetTitleSize(0.045, "X")
gStyle.SetTitleSize(0.045, "Y")
gStyle.SetTitleOffset(1.4, "X")
gStyle.SetTitleOffset(1.4, "Y")
gStyle.SetTextSize(0.055)
gStyle.SetTextFont(42)
gStyle.SetOptStat(0)
def setStyle():
TColor.InitializeColors()
stops = array('d', [
0.0000, 0.1250, 0.2500, 0.3750, 0.5000, 0.6250, 0.7500, 0.8750, 1.0000
])
red = array('d', [
0.9764, 0.9956, 0.8186, 0.5301, 0.1802, 0.0232, 0.0780, 0.0592, 0.2082
])
green = array('d', [
0.9832, 0.7862, 0.7328, 0.7492, 0.7178, 0.6419, 0.5041, 0.3599, 0.1664
])
blue = array('d', [
0.0539, 0.1968, 0.3499, 0.4662, 0.6425, 0.7914, 0.8385, 0.8684, 0.5293
])
TColor.CreateGradientColorTable(9, stops, red, green, blue, 255, 1.0)
gStyle.SetHatchesLineWidth(1)
gStyle.SetNumberContours(255)
gStyle.SetNdivisions(505, "xyz")
gStyle.SetTitleBorderSize(0)
gStyle.SetTitleColor(1)
gStyle.SetTitleStyle(3013)
gStyle.SetTitleFillColor(0)
gStyle.SetTitleX(0.05)
gStyle.SetTitleW(0.4)
gStyle.SetTitleY(0.965)
gStyle.SetTitleH(0.065)
gStyle.SetCanvasBorderMode(0)
gStyle.SetCanvasBorderSize(3)
gStyle.SetCanvasColor(0)
gStyle.SetPadColor(0)
gStyle.SetPadBorderMode(0)
gStyle.SetFuncWidth(3)
gStyle.SetPadGridY(False)
gStyle.SetPadGridX(False)
gStyle.SetFrameLineWidth(1)
gStyle.SetMarkerSize(5)
gStyle.SetPadTickX(True)
gStyle.SetPadTickY(True)
#gStyle.SetPalette(1)
gStyle.SetHistLineWidth(3)
gStyle.SetHistLineColor(1)
gStyle.SetOptStat(0)
gStyle.SetOptFit(0)
gStyle.SetStatW(0.25)
gStyle.SetStatH(0.25)
gStyle.SetStatX(0.9)
gStyle.SetStatY(0.9)
gStyle.SetStatColor(0)
gStyle.SetStatFormat("6.4g")
gStyle.SetPadTopMargin(0.05)
gStyle.SetPadRightMargin(0.05)
gStyle.SetPadBottomMargin(0.16)
gStyle.SetPadLeftMargin(0.12)
font = 42
gStyle.SetTextSize(.055)
gStyle.SetTextFont(font)
gStyle.SetLabelFont(font, "x")
gStyle.SetTitleFont(font, "x")
gStyle.SetLabelFont(font, "y")
gStyle.SetTitleFont(font, "y")
gStyle.SetLabelFont(font, "z")
gStyle.SetTitleFont(font, "z")
gStyle.SetTitleSize(.055, "x")
gStyle.SetTitleSize(.055, "y")
gStyle.SetTitleSize(.05, "z")
gStyle.SetLabelSize(.05, "x")
gStyle.SetLabelSize(.05, "y")
gStyle.SetLabelSize(.05, "z")
gStyle.SetLabelOffset(0.014, "x")
gStyle.SetLabelOffset(0.006, "y")
gStyle.SetLabelOffset(0.008, "z")
gStyle.SetTitleOffset(1, "y")
gStyle.SetTitleXOffset(1.2)
# use bold lines and markers
gStyle.SetMarkerStyle(20)
gStyle.SetMarkerColor(1)
gStyle.SetMarkerSize(1.2)
gStyle.SetLineStyleString(2, "[12 12]")
# postscript dashes
gStyle.SetPadTickX(1)
gStyle.SetPadTickY(1)
def create_image(rootfiledir):
rootfile = rootfiledir.split('/')[-1]
base = rootfiledir.split('/')[6]
rootfilename = rootfile.split('.')
rootfilename = rootfilename[0] + "." + rootfilename[
1] + "." + rootfilename[2]
print rootfilename
#break
#rootfile=root+"/"+rootfile
#print rootfile
f = TFile.Open(rootfiledir)
tree = f.Get("evtdata_cont")
ro = []
phi = []
for index in range(tree.GetEntries()):
tree.GetEntry(index)
bcalro = getattr(tree, "BeamCal_contro")
bcalphi = getattr(tree, "BeamCal_contphi")
for i in range(len(bcalro)):
ro.append(bcalro[i])
phi.append(bcalphi[i])
#
#print max(ro)
#print min(ro)
#
#print max(phi)
#print min(phi)
#hrophi = TH2D("hrophi","BeamCal_contro vs BeamCal_contphi",1000,-3.2,3.2,1000,8.6,152)
hrophi = TH2D("hrophi", "BeamCal_contro vs BeamCal_contphi", 1000,
min(phi), max(phi), 1000, min(ro), max(ro))
#c = TCanvas("c1","",64,64)
c = TCanvas("c1", "", 800, 600)
for index in range(tree.GetEntries()):
tree.GetEntry(index)
bcalro = getattr(tree, "BeamCal_contro")
bcalphi = getattr(tree, "BeamCal_contphi")
bcale = getattr(tree, "BeamCal_energycont")
for i in range(len(bcalro)):
hrophi.Fill(bcalphi[i], bcalro[i], bcale[i])
c.SetFillColor(1)
c.SetBorderMode(0)
c.SetBorderSize(2)
c.SetFrameBorderMode(0)
c.SetFrameFillColor(0)
c.SetFrameLineColor(1)
gStyle.SetOptStat(0)
gPad.SetLogz()
gStyle.SetPalette(52)
gStyle.SetPadTopMargin(0)
gStyle.SetPadBottomMargin(0)
gStyle.SetPadRightMargin(0)
gStyle.SetPadLeftMargin(0)
gStyle.SetPalette(52)
#gStyle.SetPalette(kGreyScale);
#remove title
hrophi.SetTitle("")
hrophi.GetXaxis().SetTitle("")
hrophi.GetXaxis().SetLabelOffset(999)
hrophi.GetXaxis().SetLabelSize(0)
hrophi.GetYaxis().SetTitle("")
hrophi.GetYaxis().SetLabelOffset(999)
hrophi.GetYaxis().SetLabelSize(0)
hrophi.GetZaxis().SetTitle("")
hrophi.GetZaxis().SetLabelOffset(999)
hrophi.GetZaxis().SetLabelSize(0)
hrophi.Draw("COL AH")
imdir = base + "/images"
if not os.path.exists(imdir):
os.makedirs(imdir)
imagename = imdir + "/" + rootfilename
c.Print(imagename + ".png")
def makeLimitPlot(output,
obs,
exp,
chan,
printStats=False,
obs2="",
ratioLabel=""):
#fileForHEPData = TFile("plots/"+output+"_forHEPData.root","RECREATE")
fileObs = open(obs, 'r')
fileExp = open(exp, 'r')
observedx = []
observedy = []
obsLimits = {}
for entry in fileObs:
massPoint = float(entry.split()[0])
limitEntry = float(entry.split()[1])
if massPoint not in obsLimits: obsLimits[massPoint] = []
obsLimits[massPoint].append(limitEntry)
if printStats: print "len obsLimits:", len(obsLimits)
for massPoint in sorted(obsLimits):
observedx.append(massPoint)
observedy.append(numpy.mean(obsLimits[massPoint]))
if (numpy.std(obsLimits[massPoint]) / numpy.mean(obsLimits[massPoint])
> 0.05):
print massPoint, " mean: ", numpy.mean(
obsLimits[massPoint]), " std dev: ", numpy.std(
obsLimits[massPoint]), " from: ", obsLimits[massPoint]
if not obs2 == "":
fileObs2 = open(obs2, 'r')
observedx2 = []
observedy2 = []
obsLimits2 = {}
for entry in fileObs2:
massPoint = float(entry.split()[0])
limitEntry = float(entry.split()[1])
if massPoint not in obsLimits2: obsLimits2[massPoint] = []
obsLimits2[massPoint].append(limitEntry)
if printStats: print "len obsLimits:", len(obsLimits2)
for massPoint in sorted(obsLimits2):
observedx2.append(massPoint)
observedy2.append(numpy.mean(obsLimits2[massPoint]))
if (numpy.std(obsLimits2[massPoint]) /
numpy.mean(obsLimits2[massPoint]) > 0.05):
print massPoint, " mean: ", numpy.mean(
obsLimits2[massPoint]), " std dev: ", numpy.std(
obsLimits2[massPoint]
), " from: ", obsLimits2[massPoint]
limits = {}
expectedx = []
expectedy = []
expected1SigLow = []
expected1SigHigh = []
expected2SigLow = []
expected2SigHigh = []
for entry in fileExp:
massPoint = float(entry.split()[0])
limitEntry = float(entry.split()[1])
if massPoint not in limits: limits[massPoint] = []
limits[massPoint].append(limitEntry)
if printStats: print "len limits:", len(limits)
for massPoint in sorted(limits):
limits[massPoint].sort()
numLimits = len(limits[massPoint])
nrExpts = len(limits[massPoint])
medianNr = int(nrExpts * 0.5)
#get indexes:
upper1Sig = int(nrExpts * (1 - (1 - 0.68) * 0.5))
lower1Sig = int(nrExpts * (1 - 0.68) * 0.5)
upper2Sig = int(nrExpts * (1 - (1 - 0.95) * 0.5))
lower2Sig = int(nrExpts * (1 - 0.95) * 0.5)
if printStats:
print massPoint, ":", limits[massPoint][lower2Sig], limits[
massPoint][lower1Sig], limits[massPoint][medianNr], limits[
massPoint][upper1Sig], limits[massPoint][upper2Sig]
#fill lists:
expectedx.append(massPoint)
print massPoint, limits[massPoint][medianNr]
expectedy.append(limits[massPoint][medianNr])
expected1SigLow.append(limits[massPoint][lower1Sig])
expected1SigHigh.append(limits[massPoint][upper1Sig])
expected2SigLow.append(limits[massPoint][lower2Sig])
expected2SigHigh.append(limits[massPoint][upper2Sig])
expX = numpy.array(expectedx)
expY = numpy.array(expectedy)
values2 = []
xPointsForValues2 = []
values = []
xPointsForValues = []
xPointsForErrors = []
if printStats: print "length of expectedx: ", len(expectedx)
if printStats: print "length of expected1SigLow: ", len(expected1SigLow)
if printStats: print "length of expected1SigHigh: ", len(expected1SigHigh)
#Here is some Voodoo via Sam:
for x in range(0, len(expectedx)):
values2.append(expected2SigLow[x])
xPointsForValues2.append(expectedx[x])
xPointsForErrors.append(0)
for x in range(len(expectedx) - 1, 0 - 1, -1):
values2.append(expected2SigHigh[x])
xPointsForValues2.append(expectedx[x])
if printStats: print "length of values2: ", len(values2)
for x in range(0, len(expectedx)):
values.append(expected1SigLow[x])
xPointsForValues.append(expectedx[x])
for x in range(len(expectedx) - 1, 0 - 1, -1):
values.append(expected1SigHigh[x])
xPointsForValues.append(expectedx[x])
if printStats: print "length of values: ", len(values)
exp2Sig = numpy.array(values2)
xPoints2 = numpy.array(xPointsForValues2)
exp1Sig = numpy.array(values)
xPoints = numpy.array(xPointsForValues)
xPointsErrors = numpy.array(xPointsForErrors)
if printStats: print "xPoints2: ", xPoints2
if printStats: print "exp2Sig: ", exp2Sig
if printStats: print "xPoints: ", xPoints
if printStats: print "exp1Sig: ", exp1Sig
GraphErr2SigForHEPData = TGraphAsymmErrors(len(expX), expX, expY,
numpy.array(xPointsErrors),
numpy.array(xPointsErrors),
numpy.array(expected2SigLow),
numpy.array(expected2SigHigh))
GraphErr1SigForHEPData = TGraphAsymmErrors(len(expX), expX, expY,
numpy.array(xPointsErrors),
numpy.array(xPointsErrors),
numpy.array(expected1SigLow),
numpy.array(expected1SigHigh))
GraphErr2Sig = TGraphAsymmErrors(len(xPoints), xPoints2, exp2Sig)
GraphErr2Sig.SetFillColor(ROOT.kOrange)
GraphErr1Sig = TGraphAsymmErrors(len(xPoints), xPoints, exp1Sig)
GraphErr1Sig.SetFillColor(ROOT.kGreen + 1)
#cCL=TCanvas("cCL", "cCL",0,0,567,384)
cCL = TCanvas("cCL", "cCL", 0, 0, 600, 450)
gStyle.SetOptStat(0)
gStyle.SetPadRightMargin(0.063)
gStyle.SetPadLeftMargin(0.14)
gStyle.SetPadBottomMargin(0.12)
if not obs2 == "":
plotPad = ROOT.TPad("plotPad", "plotPad", 0, 0.3, 1, 1)
ratioPad = ROOT.TPad("ratioPad", "ratioPad", 0, 0., 1, 0.3)
plotPad.Draw()
ratioPad.Draw()
plotPad.cd()
else:
plotPad = ROOT.TPad("plotPad", "plotPad", 0, 0, 1, 1)
plotPad.Draw()
plotPad.cd()
expX = numpy.array(expectedx)
expY = numpy.array(expectedy)
GraphExp = TGraph(len(expX), expX, expY)
GraphExp.SetLineWidth(3)
GraphExp.SetLineStyle(2)
GraphExp.SetLineColor(ROOT.kBlue)
obsX = numpy.array(observedx)
obsY = numpy.array(observedy)
if printStats: print "obsX: ", obsX
if printStats: print "obsY: ", obsY
if SMOOTH:
smooth_obs = TGraphSmooth("normal")
GraphObs_nonSmooth = TGraph(len(obsX), obsX, obsY)
GraphObs = smooth_obs.SmoothSuper(GraphObs_nonSmooth, "linear", 0,
0.005)
else:
GraphObs = TGraph(len(obsX), obsX, obsY)
GraphObs.SetLineWidth(3)
if not obs2 == "":
ratio = []
ratiox = []
for index, val in enumerate(observedy):
mass = observedx[index]
foundIndex = -1
for index2, mass2 in enumerate(observedx2):
if mass == mass2:
foundIndex = index2
if foundIndex > 0:
ratio.append(observedy2[foundIndex] / val)
ratiox.append(mass)
ratioA = numpy.array(ratio)
ratioX = numpy.array(ratiox)
obsX2 = numpy.array(observedx2)
obsY2 = numpy.array(observedy2)
ratioGraph = TGraph(len(ratioX), ratioX, ratioA)
if printStats: print "obsX2: ", obsX2
if printStats: print "obsY2: ", obsY2
if SMOOTH:
smooth_obs2 = TGraphSmooth("normal")
GraphObs2_nonSmooth = TGraph(len(obsX2), obsX2, obsY2)
GraphObs2 = smooth_obs2.SmoothSuper(GraphObs2_nonSmooth, "linear",
0, 0.005)
else:
GraphObs2 = TGraph(len(obsX2), obsX2, obsY2)
GraphObs2.SetLineWidth(3)
if SPIN2:
signals = ["RS_kMpl01", "RS_kMpl005", "RS_kMpl001"]
elif GUT:
signals = ["ssm", "psi", "kai", "eta", "I", "S", "N"]
else:
signals = ["ssm", "psi"]
xSecCurves = []
for signal in signals:
xSecCurves.append(getXSecCurve(signal, kFacs[signal]))
#xSecCurves.append(getXSecCurve(signal,kFacs[signal],massDependent=True))
#Draw the graphs:
plotPad.SetLogy()
DummyGraph = TH1F("DummyGraph", "", 100, 200, 5500)
DummyGraph.GetXaxis().SetTitle("M [GeV]")
if SPIN2:
DummyGraph.GetYaxis().SetTitle(
"[#sigma#upoint#font[12]{B}] G_{KK} / [#sigma#upoint#font[12]{B}] Z"
)
else:
DummyGraph.GetYaxis().SetTitle(
"[#sigma#upoint#font[12]{B}] Z' / [#sigma#upoint#font[12]{B}] Z")
# if SPIN2:
# if chan=="mumu":
# DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowG_{KK}+X#rightarrow#mu^{+}#mu^{-}+X) / #sigma(pp#rightarrowZ+X#rightarrow#mu^{+}#mu^{-}+X)")
# elif chan=="elel":
# DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowG_{KK}+X#rightarrowee+X) / #sigma(pp#rightarrowZ+X#rightarrowee+X)")
# elif chan=="elmu":
# DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowG_{KK}+X#rightarrow#font[12]{ll}+X) / #sigma(pp#rightarrowZ+X#rightarrow#font[12]{ll}+X)")
# else:
# if chan=="mumu":
# DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowZ'+X#rightarrow#mu^{+}#mu^{-}+X) / #sigma(pp#rightarrowZ+X#rightarrow#mu^{+}#mu^{-}+X)")
# elif chan=="elel":
# DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowZ'+X#rightarrowee+X) / #sigma(pp#rightarrowZ+X#rightarrowee+X)")
# elif chan=="elmu":
# DummyGraph.GetYaxis().SetTitle("#sigma(pp#rightarrowZ'+X#rightarrow#font[12]{ll}+X) / #sigma(pp#rightarrowZ+X#rightarrow#font[12]{ll}+X)")
gStyle.SetOptStat(0)
DummyGraph.GetXaxis().SetRangeUser(200, 5500)
DummyGraph.SetMinimum(1e-8)
DummyGraph.SetMaximum(1e-4)
DummyGraph.GetXaxis().SetLabelSize(0.055)
DummyGraph.GetXaxis().SetTitleSize(0.055)
DummyGraph.GetXaxis().SetTitleOffset(1.05)
DummyGraph.GetYaxis().SetLabelSize(0.055)
DummyGraph.GetYaxis().SetTitleSize(0.055)
DummyGraph.GetYaxis().SetTitleOffset(1.3)
DummyGraph.Draw()
if (FULL):
GraphErr2Sig.Draw("F")
GraphErr1Sig.Draw("F")
GraphExp.Draw("lpsame")
else:
if obs2 == "":
GraphExp.Draw("lp")
if not EXPONLY:
GraphObs.Draw("plsame")
if not obs2 == "":
GraphObs2.SetLineColor(ROOT.kRed)
GraphObs2.SetLineStyle(ROOT.kDashed)
GraphObs2.Draw("plsame")
for curve in xSecCurves:
curve.Draw("lsame")
plCMS = TPaveLabel(.16, .81, .27, .88, "CMS", "NBNDC")
#plCMS.SetTextSize(0.8)
plCMS.SetTextAlign(12)
plCMS.SetTextFont(62)
plCMS.SetFillColor(0)
plCMS.SetFillStyle(0)
plCMS.SetBorderSize(0)
plCMS.Draw()
plPrelim = TPaveLabel(.16, .76, .27, .82, "Preliminary", "NBNDC")
plPrelim.SetTextSize(0.6)
plPrelim.SetTextAlign(12)
plPrelim.SetTextFont(52)
plPrelim.SetFillColor(0)
plPrelim.SetFillStyle(0)
plPrelim.SetBorderSize(0)
if "2017" in output or "Combination" in output:
plPrelim.Draw()
cCL.SetTickx(1)
cCL.SetTicky(1)
cCL.RedrawAxis()
cCL.Update()
#leg=TLegend(0.65,0.65,0.87,0.87,"","brNDC")
#leg=TLegend(0.540517,0.623051,0.834885,0.878644,"","brNDC") Default
leg = TLegend(0.5, 0.58, 0.834885, 0.878644, "", "brNDC")
if SPIN2:
leg = TLegend(0.5, 0.58, 0.834885, 0.878644, "", "brNDC")
# leg=TLegend(0.55,0.55,0.87,0.87,"","brNDC")
leg.SetTextSize(0.0425)
if not obs2 == "":
if ratioLabel == "":
ratioLabel = "Variant/Default"
ratioLabels = ratioLabel.split("/")
print ratioLabels
leg.AddEntry(GraphObs, "%s Obs. 95%% CL limit" % ratioLabels[1], "l")
leg.AddEntry(GraphObs2, "%s Obs. 95%% CL limit" % ratioLabels[0], "l")
else:
if not EXPONLY:
leg.AddEntry(GraphObs, "Obs. 95% CL limit", "l")
leg.AddEntry(GraphExp, "Exp. 95% CL limit, median", "l")
if (FULL):
leg.AddEntry(GraphErr1Sig, "Exp. (68%)", "f")
leg.AddEntry(GraphErr2Sig, "Exp. (95%)", "f")
leg1 = TLegend(0.7, 0.4, 0.9, 0.55, "", "brNDC")
leg1.SetTextSize(0.05)
if GUT:
leg1 = TLegend(0.6, 0.35, 0.75, 0.623051, "", "brNDC")
if SPIN2:
leg1 = TLegend(0.7, 0.35, 0.9, 0.58, "G_{KK} (LO x 1.6)", "brNDC")
leg1.SetTextSize(0.045)
for index, signal in enumerate(signals):
xSecCurves[index].SetName(labels[signal])
xSecCurves[index].Write(labels[signal])
leg1.AddEntry(xSecCurves[index], labels[signal], "l")
leg1.SetBorderSize(0)
leg.SetLineWidth(0)
leg.SetLineStyle(0)
leg.SetFillStyle(0)
leg.SetLineColor(0)
leg.Draw("hist")
leg1.SetLineWidth(0)
leg1.SetLineStyle(0)
leg1.SetFillStyle(0)
leg1.SetLineColor(0)
leg1.Draw("hist")
if "Moriond" in output:
if (chan == "mumu"):
plLumi = TPaveLabel(.65, .885, .9, .99,
"36.3 fb^{-1} (13 TeV, #mu^{+}#mu^{-})",
"NBNDC")
elif (chan == "elel"):
plLumi = TPaveLabel(.65, .885, .9, .99,
"35.9 fb^{-1} (13 TeV, ee)", "NBNDC")
elif (chan == "elmu"):
plLumi = TPaveLabel(
.27, .885, .9, .99,
"35.9 fb^{-1} (13 TeV, ee) + 36.3 fb^{-1} (13 TeV, #mu^{+}#mu^{-})",
"NBNDC")
elif "2017" in output or "Combination" in output:
if (chan == "mumu"):
plLumi = TPaveLabel(.65, .885, .9, .99,
"42.4 fb^{-1} (13 TeV, #mu^{+}#mu^{-})",
"NBNDC")
elif (chan == "elel"):
plLumi = TPaveLabel(.65, .885, .9, .99,
"41.4 fb^{-1} (13 TeV, ee)", "NBNDC")
elif (chan == "elmu"):
plLumi = TPaveLabel(
.27, .885, .9, .99,
"77.3 fb^{-1} (13 TeV, ee) + 78.7 fb^{-1} (13 TeV, #mu^{+}#mu^{-})",
"NBNDC")
else:
if (chan == "mumu"):
plLumi = TPaveLabel(.65, .905, .9, .99,
"13.0 fb^{-1} (13 TeV, #mu#mu)", "NBNDC")
elif (chan == "elel"):
plLumi = TPaveLabel(.65, .905, .9, .99, "2.7 fb^{-1} (13 TeV, ee)",
"NBNDC")
elif (chan == "elmu"):
plLumi = TPaveLabel(
.4, .905, .9, .99,
"12.4 fb^{-1} (13 TeV, ee) + 13.0 fb^{-1} (13 TeV, #mu#mu)",
"NBNDC")
plLumi.SetTextSize(0.5)
plLumi.SetTextFont(42)
plLumi.SetFillColor(0)
plLumi.SetBorderSize(0)
plLumi.Draw()
plotPad.SetTicks(1, 1)
plotPad.RedrawAxis()
if not obs2 == "":
ratioPad.cd()
line = ROOT.TLine(200, 1, 5500, 1)
line.SetLineStyle(ROOT.kDashed)
ROOT.gStyle.SetTitleSize(0.12, "Y")
ROOT.gStyle.SetTitleYOffset(0.35)
ROOT.gStyle.SetNdivisions(000, "Y")
ROOT.gStyle.SetNdivisions(408, "Y")
ratioPad.DrawFrame(200, 0.8, 5500, 1.2, "; ; %s" % ratioLabel)
line.Draw("same")
ratioGraph.Draw("sameP")
#GraphErr2SigForHEPData.SetName("graph2Sig")
#GraphErr2SigForHEPData.Write("graph2Sig")
#GraphErr1SigForHEPData.SetName("graph1Sig")
#GraphErr1SigForHEPData.Write("graph1Sig")
#GraphExp.SetName("graphExp")
#GraphExp.Write("graphExp")
#GraphObs.SetName("graphObs")
#GraphObs.Write("graphObs")
#fileForHEPData.Write()
#fileForHEPData.Close()
cCL.Update()
printPlots(cCL, output)
def plot_map(out_file_path, hist):
map_name = out_file_path if '/' not in out_file_path else out_file_path.split(
'/')[-1]
map_name = map_name.replace('.pdf', '')
rho_min = -6.0
rho_max = -2.6
pt_min = 500.
pt_max = 1200.
# rho_min = -10
# rho_max = 0
# pt_min = 200
# pt_max = 5000
disc_min = 0.12
disc_max = 0.3
left_margin = 0.14
right_margin = 0.16
top_margin = 0.08
bottom_margin = 0.12
gStyle.SetPadTickY(1)
gStyle.SetPadTickX(1)
gStyle.SetLegendBorderSize(0)
gROOT.SetBatch(True)
gStyle.SetOptStat(0)
gStyle.SetOptFit(0)
gStyle.SetTitleOffset(0.86, "X")
gStyle.SetTitleOffset(1.6, "Y")
gStyle.SetPadLeftMargin(left_margin)
gStyle.SetPadBottomMargin(bottom_margin)
gStyle.SetPadTopMargin(top_margin)
gStyle.SetPadRightMargin(right_margin)
gStyle.SetMarkerSize(0.5)
gStyle.SetHistLineWidth(1)
gStyle.SetTitleSize(0.05, "XYZ")
gStyle.SetLabelSize(0.04, "XYZ")
gStyle.SetNdivisions(506, "XYZ")
gStyle.SetNumberContours(25)
gStyle.SetLegendBorderSize(0)
hist.GetXaxis().SetTitle("#rho")
hist.GetYaxis().SetTitle("p_{T} [GeV]")
if ('n2' in map_name.lower()):
hist.GetZaxis().SetTitle("N2^{DDT} X% quantile")
else:
hist.GetZaxis().SetTitle("DeepBoosted WvsQCD X% quantile")
disc_max = 1
hist.GetXaxis().SetRangeUser(rho_min, rho_max)
hist.GetYaxis().SetRangeUser(pt_min, pt_max)
# if(disc_max>hist.GetMaximum()):
# hist.GetZaxis().SetRangeUser(disc_min, disc_max)
Font = 43
TitleSize = 24.0
TitleOffset = 1.3
LabelSize = 18.0
hist.GetYaxis().SetTitleFont(Font)
hist.GetYaxis().SetTitleSize(TitleSize)
hist.GetYaxis().SetTitleOffset(TitleOffset)
hist.GetYaxis().SetLabelFont(Font)
hist.GetYaxis().SetLabelSize(LabelSize)
hist.GetXaxis().SetTitleFont(Font)
hist.GetXaxis().SetTitleSize(TitleSize)
hist.GetXaxis().SetTitleOffset(TitleOffset)
hist.GetXaxis().SetLabelFont(Font)
hist.GetXaxis().SetLabelSize(LabelSize)
hist.GetZaxis().SetTitleFont(Font)
hist.GetZaxis().SetTitleSize(TitleSize)
hist.GetZaxis().SetTitleOffset(TitleOffset)
hist.GetZaxis().SetLabelFont(Font)
hist.GetZaxis().SetLabelSize(LabelSize)
# hist.GetZaxis().SetNdivisions(20)
hist.SetTitle(map_name.replace('_', ' '))
hist.SetTitleFont(43)
hist.SetTitleSize(18.0)
# isomasses = [20,55,80,120,200]
# isomasses = [20,65,80,125,200]
# isomasses = range(40,200,20)
isomasses = [40, 80, 110, 120, 200]
str_isomass = "%.2f*TMath::Exp(-x/2)"
tf1_isomasses = []
for i in range(len(isomasses)):
msd = isomasses[i]
new_isomass = TF1('isomass_%i' % int(msd), str_isomass % msd, rho_min,
rho_max)
# new_isomass.SetLineColor(920+i)
new_isomass.SetLineColorAlpha(1, 0.4)
tf1_isomasses.append(new_isomass)
c1 = TCanvas("c1", "c1", 700, 600)
c1.cd()
hist.Draw("colz")
latex_border = TLatex()
latex_border.SetNDC(1)
latex_border.SetTextColor(1)
latex_border.SetTextFont(43)
latex_border.SetTextSize(15.5)
latex_border.SetTextAngle(297)
latex = TLatex()
latex.SetNDC(1)
latex.SetTextColor(920)
latex.SetTextFont(43)
latex.SetTextSize(15)
# latex.SetTextAngle(297)
for i in range(len(isomasses)):
x_pitch = (1 - left_margin - right_margin) / (rho_max - rho_min)
y_pitch = (1 - bottom_margin - top_margin) / (pt_max - pt_min)
msd = isomasses[i]
pt = msd * np.exp(-rho_min / 2)
pt = 800 if pt > pt_max else pt
angle = ((180 / np.pi) * np.arctan(2 * x_pitch / (pt * y_pitch))) + 272
latex.SetTextAngle(angle)
latex_border.SetTextAngle(angle)
tf1_isomass = tf1_isomasses[i]
tf1_isomass.Draw('SAME')
x_pos = left_margin + (
(2 * np.log(msd / pt) - rho_min)) * x_pitch + 0.01
y_pos = bottom_margin + (pt - pt_min) * y_pitch + 0.01
latex_border.DrawLatex(x_pos, y_pos, 'm_{SD} = %.1f GeV' % msd)
# latex.DrawLatex(x_pos,y_pos,'m_{SD} = %.1f GeV'%msd)
c1.SaveAs(out_file_path + ".pdf")
c1.SaveAs(out_file_path + ".png")
c1.SaveAs(out_file_path + ".C")
del c1
