def main(opts):
# Assume by default that the observed limit should be blinded
if not opts.unblinded:
print "Working in BLINDED mode, i.e. I will not tell you the observed limit before you say please ..."
limits = limit.BRLimits()
# Enable OpenGL
if opts.excludedArea:
ROOT.gEnv.SetValue("OpenGL.CanvasPreferGL", 1)
# Apply TDR style
style = tdrstyle.TDRStyle()
if not limits.isHeavyStatus:
# Give more space for four digits on the y axis labels
style.tdrStyle.SetPadLeftMargin(0.19)
style.tdrStyle.SetTitleYOffset(1.6)
# Set the paper mode
limit.forPaper = True
if opts.paper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
if opts.unpublished:
histograms.cmsTextMode = histograms.CMSMode.UNPUBLISHED
if opts.parentheses:
limit.useParentheses()
doBRlimit(limits, opts.unblinded, opts)
doBRlimit(limits, opts.unblinded, opts, log=True)
doLimitError(limits, opts.unblinded)
limits.print2(opts.unblinded)
limits.saveAsLatexTable(opts.unblinded)
def main(opts):
if opts.saveDir == "":
opts.saveDir = os.getcwd()
# Assume by default that the observed limit should be blinded
if not opts.unblinded:
msg = "Working in BLINDED mode, i.e. I will not tell you the observed limit before you say please ..."
Print(msg, True)
limits = limit.BRLimits()
# Enable OpenGL
if opts.excludedArea:
ROOT.gEnv.SetValue("OpenGL.CanvasPreferGL", 1)
# Apply TDR style
style = tdrstyle.TDRStyle()
if not limits.isHeavyStatus:
# Give more space for four digits on the y axis labels
style.tdrStyle.SetPadLeftMargin(0.19)
style.tdrStyle.SetTitleYOffset(1.6)
# Set the paper mode
if opts.paper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
# Set the paper mode
if opts.unpublished:
histograms.cmsTextMode = histograms.CMSMode.UNPUBLISHED
# Use BR symbol for H+ decay channel with subscript or parentheses?
if opts.parentheses:
limit.useParentheses()
else:
limit.useSubscript(True)
# Do the limit plots
doBRlimit(limits, opts.unblinded, opts, logy=False)
doBRlimit(limits, opts.unblinded, opts, logy=True)
doLimitError(limits, opts.unblinded)
# Print the Limits
limits.printLimits(unblindedStatus=opts.unblinded, nDigits=opts.digits)
# limits.print2(unblindedStatus=opts.unblinded)
# Save the Limits in a LaTeX table file
limits.saveAsLatexTable(unblindedStatus=opts.unblinded,
nDigits=opts.digits)
limits.saveAsLatexTable(unblindedStatus=opts.unblinded,
nDigits=opts.digits,
savePath=os.path.join(opts.saveDir, opts.subdir))
return
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
jsonfile = "limits.json"
root_re = re.compile("(?P<rootfile>(\S*\.root))")
json_re = re.compile("(?P<jsonfile>(\S*\.json))")
for argv in sys.argv:
match = root_re.search(argv)
if match:
rootfile = match.group(0)
match = json_re.search(argv)
if match:
jsonfile = match.group(0)
limits = limit.BRLimits(
limitsfile=jsonfile,
configfile="limitdata/lightHplus_configuration.json")
# Enable OpenGL
ROOT.gEnv.SetValue("OpenGL.CanvasPreferGL", 1)
# Apply TDR style
style = tdrstyle.TDRStyle()
if limit.forPaper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
#histograms.cmsTextMode = histograms.CMSMode.PAPER # tmp
#histograms.cmsTextMode = histograms.CMSMode.UNPUBLISHED # tmp
limit.forPaper = True # to get GeV without c^2
# Get BR limits
masses = limits.mass
brs = limits.observed
print "Observed masses and BR's"
for i in range(len(masses)):
print " ", masses[i], brs[i]
global db
db = BRXSDB.BRXSDatabaseInterface(rootfile)
for i, m in enumerate(masses):
db.addExperimentalBRLimit(m, brs[i])
graphs = {}
obs = limits.observedGraph()
# Remove blinded obs points
for i in reversed(range(0, obs.GetN())):
if obs.GetY()[i] < 0.00000001:
print " REMOVING POINT", obs.GetY(
)[i], " corresponding mass=", obs.GetX()[i]
obs.RemovePoint(i)
print
graphs["exp"] = limits.expectedGraph()
graphs["exp1"] = limits.expectedBandGraph(sigma=1)
graphs["exp2"] = limits.expectedBandGraph(sigma=2)
if obs.GetN() > 0:
graphs["obs"] = obs
# Get theory uncertainties on observed
# obs_th_plus = limit.getObservedPlus(obs,0.21)
# obs_th_minus = limit.getObservedMinus(obs,0.21)
# for gr in [obs_th_plus, obs_th_minus]:
# gr.SetLineWidth(2)
# gr.SetLineStyle(9)
# graphs["obs_th_plus"] = obs_th_plus
# graphs["obs_th_minus"] = obs_th_minus
# Remove m=80
for gr in graphs.values():
limit.cleanGraph(gr, minX=90)
print "Plotting graphs"
for key in graphs.keys():
for i in range(graphs[key].GetN()):
xs = graphs[key].GetX()
ys = graphs[key].GetY()
print " ", key, xs[i], ys[i]
print
# Interpret in MSSM
xVariable = "mHp"
# selection = "mu==200"
selection = "mHp > 0"
# scenario = "MSSM m_{h}^{max}"
scenario = os.path.split(rootfile)[-1].replace(".root", "")
for key in graphs.keys():
print "Graph--------------------------------", key
graphs[key] = db.graphToTanBetaCombined(graphs[key], xVariable,
selection)
#if key == "obs":
#obsplus = db.getTheorUncert(graphs[key],xVariable,selection,"+")
#graphs["obs_th_plus"] = db.graphToTanBetaCombined(obsplus,xVariable,selection)
#obsminus = db.getTheorUncert(graphs[key],xVariable,selection,"-")
#graphs["obs_th_minus"] = db.graphToTanBetaCombined(obsminus,xVariable,selection)
print key, "done"
graphs["mintanb"] = db.minimumTanbGraph("mHp", selection)
if scenario == "lowMH-LHCHXSWG":
graphs["Allowed"] = db.mhLimit("mH", "mHp", selection, "125.0+-3.0")
else:
graphs["Allowed"] = db.mhLimit("mh", "mHp", selection, "125.0+-3.0")
graphs["isomass"] = None
limit.doTanBetaPlotLight("limitsTanb_light_" + scenario, graphs,
limits.getLuminosity(),
limits.getFinalstateText(), limit.mHplus(),
scenario)
# mH+ -> mA
print "Replotting the graphs for (mA,tanb)"
for key in graphs.keys():
print key
#db.PrintGraph(graphs[key])
#print "check loop db.graphToMa"
db.graphToMa(graphs[key])
graphs["isomass"] = db.getIsoMass(160)
limit.doTanBetaPlotLight("limitsTanb_mA_light_" + scenario, graphs,
limits.getLuminosity(),
limits.getFinalstateText(), limit.mA(), scenario)
def main():
limits = limit.BRLimits()
# Apply TDR style
style = tdrstyle.TDRStyle()
if limit.forPaper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
# Get BR limits
graphs = {}
obs = limits.observedGraph()
myBlindedStatus = True
for i in xrange(0, obs.GetN()):
if abs(obs.GetY()[i]) > 0.00001:
myBlindedStatus = False
if not myBlindedStatus:
graphs["obs"] = obs
graphs["exp"] = limits.expectedGraph()
graphs["exp1"] = limits.expectedBandGraph(sigma=1)
graphs["exp2"] = limits.expectedBandGraph(sigma=2)
# Remove m=80
for gr in graphs.values():
limit.cleanGraph(gr, minX=100)
# Get theory uncertainties on observed
if not myBlindedStatus:
obs_th_plus = limit.getObservedPlus(obs)
obs_th_minus = limit.getObservedMinus(obs)
for gr in [obs_th_plus, obs_th_minus]:
gr.SetLineWidth(3)
gr.SetLineStyle(5)
# gr.SetLineStyle(9)
graphs["obs_th_plus"] = obs_th_plus
graphs["obs_th_minus"] = obs_th_minus
# Interpret in MSSM
global mu
for key in graphs.keys():
removeNotValid = not (key in ["exp1", "exp2"])
graphs[key] = limit.graphToTanBeta(graphs[key], mu, removeNotValid)
doPlot("limitsTanb_mh", graphs, limits, limit.mHplus())
for gr in graphs.values():
limit.graphToMa(gr)
doPlot("limitsTanb_ma", graphs, limits, limit.mA())
if myBlindedStatus:
print "Refusing cowardly to do mu variation plots for blinded results"
return
# Mu variations
mus = [1000, 200, -200, -1000]
muGraphs = [(limit.graphToTanBeta(obs, m), m) for m in mus]
def muStyle(h, markerStyle, lineStyle, color):
rh = h.getRootHisto()
rh.SetMarkerStyle(markerStyle)
rh.SetMarkerColor(color)
rh.SetLineStyle(lineStyle)
rh.SetLineColor(color)
rh.SetLineWidth(504)
rh.SetFillStyle(3005)
st = [
lambda h: muStyle(h, 21, 1, 4), lambda h: muStyle(h, 20, 1, 1),
lambda h: muStyle(h, 20, 2, 1), lambda h: muStyle(h, 21, 2, 4)
]
doPlotMu("limitsTanb_mus_mh", muGraphs, st, limits, limit.mHplus())
for gr, mu in muGraphs:
limit.graphToMa(gr)
doPlotMu("limitsTanb_mus_ma", muGraphs, st, limits, limit.mA())
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
jsonfile = "limits.json"
root_re = re.compile("(?P<rootfile>(\S*\.root))")
json_re = re.compile("(?P<jsonfile>(\S*\.json))")
for argv in sys.argv:
match = root_re.search(argv)
if match:
rootfile = match.group(0)
match = json_re.search(argv)
if match:
jsonfile = match.group(0)
# jsonfile = "limits_heavy2016.json"
# jsonfile = "limits2016/limitsForMSSMplots_ICHEP_v3_heavy.json"
jsonfile = "limits2016/limits_heavy_20171011.json"
# limits = limit.BRLimits(limitsfile=jsonfile,configfile="configurationHeavy.json")
limits = limit.BRLimits(
limitsfile=jsonfile,
configfile="limits2016/heavyHplus_configuration.json")
# Enable OpenGL
ROOT.gEnv.SetValue("OpenGL.CanvasPreferGL", 1)
# Apply TDR style
style = tdrstyle.TDRStyle()
#if limit.forPaper:
# histograms.cmsTextMode = histograms.CMSMode.PAPER
#histograms.cmsTextMode = histograms.CMSMode.PAPER # tmp
#histograms.cmsTextMode = histograms.CMSMode.UNPUBLISHED # tmp
histograms.cmsTextMode = histograms.CMSMode.PRELIMINARY
limit.forPaper = True # to get GeV without c^2
# Get BR limits
masses = limits.mass
brs = limits.observed
print "Observed masses and sigma*BR's"
for i in range(len(masses)):
print " ", masses[i], brs[i]
global db
db = BRXSDB.BRXSDatabaseInterface(rootfile)
db.BRvariable = "2*0.001*tHp_xsec*BR_Hp_taunu" # XSEC only for H-, multiply with 2 to get H+ and H- ; multiply by 0.001 to fb -> pb
for i, m in enumerate(masses):
db.addExperimentalBRLimit(m, brs[i])
graphs = {}
obs = limits.observedGraph()
# Remove blinded obs points
for i in reversed(range(0, obs.GetN())):
if obs.GetY()[i] < 0.00000001:
print " REMOVING POINT", obs.GetY(
)[i], " corresponding mass=", obs.GetX()[i]
obs.RemovePoint(i)
print
graphs["exp"] = limits.expectedGraph()
graphs["exp1"] = limits.expectedBandGraph(sigma=1)
graphs["exp2"] = limits.expectedBandGraph(sigma=2)
if obs.GetN() > 0:
graphs["obs"] = obs
# Get theory uncertainties on observed
# obs_th_plus = limit.getObservedPlus(obs,0.32)
# obs_th_minus = limit.getObservedMinus(obs,0.32)
# for gr in [obs_th_plus, obs_th_minus]:
# gr.SetLineWidth(2)
# gr.SetLineStyle(9)
# graphs["obs_th_plus"] = obs_th_plus
# graphs["obs_th_minus"] = obs_th_minus
# Remove m=180,190
for gr in graphs.values():
# limit.cleanGraph(gr, 750)
limit.cleanGraph(gr, 800)
limit.cleanGraph(gr, 1000)
limit.cleanGraph(gr, 2000)
limit.cleanGraph(gr, 3000)
print "Plotting graphs"
for key in graphs.keys():
for i in range(graphs[key].GetN()):
xs = graphs[key].GetX()
ys = graphs[key].GetY()
print " ", key, xs[i], ys[i]
print
# Interpret in MSSM
xVariable = "mHp"
selection = "mHp > 0 && mu==200"
# selection = "mHp > 0 && mu==500"
# scenario = "MSSM m_{h}^{max}"
scenario = os.path.split(rootfile)[-1].replace(".root", "")
print scenario
from JsonWriter import JsonWriter
jsonWriter = JsonWriter()
for key in graphs.keys():
print "Graph--------------------------------", key
graphs[key] = db.graphToTanBeta(graphs[key],
xVariable,
selection,
highTanbRegion=True)
#if key == "obs":
#obsplus = db.getTheorUncert(graphs[key],xVariable,selection,"+")
#graphs["obs_th_plus"] = db.graphToTanBeta(obsplus,xVariable,selection)
#obsminus = db.getTheorUncert(graphs[key],xVariable,selection,"-")
#graphs["obs_th_minus"] = db.graphToTanBeta(obsminus,xVariable,selection)
print key, "done"
jsonWriter.addGraph(key, graphs[key])
# graphs["mintanb"] = db.minimumTanbGraph("mHp",selection)
if scenario == "lowMH-LHCHXSWG":
graphs["Allowed"] = db.mhLimit("mH", "mHp", selection, "125.0+-3.0")
else:
graphs["Allowed"] = db.mhLimit("mh", "mHp", selection + "&&mHp>175",
"125.0+-3.0")
if scenario == "tauphobic-LHCHXSWG":
# Fix a buggy second upper limit (the order of points is left to right, then right to left; remove further passes to fix the bug)
decreasingStatus = False
i = 0
while i < graphs["Allowed"].GetN():
removeStatus = False
y = graphs["Allowed"].GetY()[i]
if i > 0:
if graphs["Allowed"].GetY()[i - 1] - y < 0:
decreasingStatus = True
else:
if decreasingStatus:
graphs["Allowed"].RemovePoint(i)
removeStatus = True
if not removeStatus:
i += 1
#for i in range(0, graphs["Allowed"].GetN()):
#print graphs["Allowed"].GetX()[i], graphs["Allowed"].GetY()[i]
# del graphs["isomass"]
jsonWriter.addGraph("Allowed", graphs["Allowed"])
jsonWriter.addParameter("name", "limitsTanb_heavy_" + scenario)
jsonWriter.addParameter("scenario", scenario)
jsonWriter.addParameter("luminosity", limits.getLuminosity())
jsonWriter.addParameter("finalStateText", limits.getFinalstateText())
jsonWriter.addParameter("mHplus", limit.mHplus())
jsonWriter.addParameter("selection", selection)
jsonWriter.addParameter("regime", "heavy")
jsonWriter.write("MSSMLimitHeavy_" + scenario + ".json")
limit.doTanBetaPlotHeavy("limitsTanb_heavy_" + scenario, graphs,
limits.getLuminosity(),
limits.getFinalstateText(), limit.mHplus(),
scenario)
sys.exit()
# mH+ -> mA
print "Replotting the graphs for (mA,tanb)"
for key in graphs.keys():
print key
#db.PrintGraph(graphs[key])
#print "check loop db.graphToMa"
db.graphToMa(graphs[key])
graphs["isomass"] = db.getIsoMass(200)
# doPlot("limitsTanb_mA_heavy_"+scenario, graphs, limits, limit.mA(),scenario)
limit.doTanBetaPlotHeavy("limitsTanb_mA_heavy_" + scenario, graphs,
limits.getLuminosity(),
limits.getFinalstateText(), limit.mA(), scenario)
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
jsonfile = "limits.json"
root_re = re.compile("(?P<rootfile>(\S*\.root))")
json_re = re.compile("(?P<jsonfile>(\S*\.json))")
for argv in sys.argv:
match = root_re.search(argv)
if match:
rootfile = match.group(0)
match = json_re.search(argv)
if match:
jsonfile = match.group(0)
limits = limit.BRLimits(
limitsfile=jsonfile,
configfile="limitdata/lightHplus_configuration.json")
# Enable OpenGL
ROOT.gEnv.SetValue("OpenGL.CanvasPreferGL", 1)
# Apply TDR style
style = tdrstyle.TDRStyle()
if limit.forPaper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
# Get BR limits
masses = limits.mass
brs = limits.observed
print "Observed masses and BR's"
for i in range(len(masses)):
print " ", masses[i], brs[i]
global db
db = BRXSDB.BRXSDatabaseInterface(rootfile)
for i, m in enumerate(masses):
db.addExperimentalBRLimit(m, brs[i])
graphs = {}
obs = limits.observedGraph()
# Remove blinded obs points
for i in reversed(range(0, obs.GetN())):
if obs.GetY()[i] < 0.00000001:
print " REMOVING POINT", obs.GetY(
)[i], " corresponding mass=", obs.GetX()[i]
obs.RemovePoint(i)
print
scenario = os.path.split(rootfile)[-1].replace(".root", "")
selection = ""
for i in range(len(masses)):
mass = masses[i]
brlimit = brs[i]
if mass < 90:
continue
# if not mass == 160:
# continue
selection = "mHp == %s" % mass
graphs["muexcluded"] = db.muLimit(mass, "mu", selection, brlimit)
if int(mass) in [155, 160]:
graphs["obs_th_plus"] = db.muLimit(mass, "mu", selection,
brlimit * (1 + 0.29))
graphs["obs_th_minus"] = db.muLimit(mass, "mu", selection,
brlimit * (1 - 0.29))
for gr in [graphs["obs_th_plus"], graphs["obs_th_minus"]]:
gr.SetLineWidth(2)
gr.SetLineStyle(9)
graphs["observed"] = graphs["muexcluded"].Clone()
graphs["observed"].SetLineWidth(2)
graphs["observed"].SetLineStyle(ROOT.kSolid)
graphs["observed"].SetLineColor(ROOT.kBlack)
# Remove obs point
for name in ["observed", "obs_th_plus", "obs_th_minus"]:
gr = graphs[name]
print "Graph", name
for i in reversed(range(0, gr.GetN())):
if gr.GetY()[i] < 2 or gr.GetY()[i] > 65:
print " REMOVING POINT", gr.GetY(
)[i], " corresponding mass=", gr.GetX()[i]
gr.RemovePoint(i)
graphs["Allowed"] = db.getHardCoded_mH_limitForMu(mass, 0)
graphs["Allowed2"] = db.getHardCoded_mH_limitForMu(mass, 1)
doPlot(("limitsMu_light_mHp%s_" + scenario) % (int(mass)), graphs,
limits, "#mu (GeV)", scenario, int(mass))
sys.exit()
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
jsonfile = "limits.json"
root_re = re.compile("(?P<rootfile>(\S*\.root))")
json_re = re.compile("(?P<jsonfile>(\S*\.json))")
for argv in sys.argv:
match = root_re.search(argv)
if match:
rootfile = match.group(0)
match = json_re.search(argv)
if match:
jsonfile = match.group(0)
jsonfile = "limits2016/limits_withLeptonic_180522.json"
limits = limit.BRLimits(limitsfile=jsonfile,
configfile="limits2016/mu_configuration.json")
# Enable OpenGL
ROOT.gEnv.SetValue("OpenGL.CanvasPreferGL", 1)
# Apply TDR style
style = tdrstyle.TDRStyle()
if limit.forPaper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
# Get BR limits
masses = limits.mass
brs = limits.observed
print "Observed masses and BR's"
for i in range(len(masses)):
print " ", masses[i], brs[i]
global db
db = BRXSDB.BRXSDatabaseInterface(
rootfile, BRvariable="0.001*831.76*2*tHp_xsec*BR_Hp_taunu")
for i, m in enumerate(masses):
db.addExperimentalBRLimit(m, brs[i])
graphs = {}
obs = limits.observedGraph()
# Remove blinded obs points
for i in reversed(range(0, obs.GetN())):
if obs.GetY()[i] < 0.00000001:
print " REMOVING POINT", obs.GetY(
)[i], " corresponding mass=", obs.GetX()[i]
obs.RemovePoint(i)
print
# graphs["exp"] = limits.expectedGraph()
#x = array.array('d',masses)
#y = array.array('d',[0.02]*len(masses))
#graphs["exp"] = ROOT.TGraph(len(masses),x,y)
# graphs["exp1"] = limits.expectedBandGraph(sigma=1)
# graphs["exp2"] = limits.expectedBandGraph(sigma=2)
if obs.GetN() > 0:
graphs["obs"] = obs
# Remove m=80
for gr in graphs.values():
limit.cleanGraph(gr, 80)
print "Plotting graphs"
for key in graphs.keys():
for i in range(graphs[key].GetN()):
xs = graphs[key].GetX()
ys = graphs[key].GetY()
print " ", key, xs[i], ys[i]
print
# Interpret in MSSM
xVariable = "mu"
scenario = os.path.split(rootfile)[-1].replace(".root", "")
if scenario == "lowMHaltv-LHCHXSWG":
xVariable = "mHp"
selection = ""
from JsonWriter import JsonWriter
# for i in range(len(masses)):
# mass = masses[i]
# brlimit = brs[i]
# if mass < 90:
# continue
# if not mass == 160:
# continue
# selection = "mHp == %s"%mass
#graphs["muexcluded"] = db.muLimit(mass,"mu",selection,brlimit)
#db.PrintGraph(graphs["muexcluded"],"muexcluded")
jsonWriter = JsonWriter()
print "check keys", graphs.keys()
for key in graphs.keys():
print "Graph--------------------------------", key
#db.PrintGraph(graphs[key],"Before graphToTanBetaCombined")
graphs[key] = db.graphToTanBetaMu(graphs[key], xVariable, selection,
True)
print key, "done"
jsonWriter.addGraph(key, graphs[key])
#graphs["Allowed"] = db.mhLimit("mH","mu",selection,"125.0+-3.0")
if xVariable == "mHp":
graphs["Allowed"] = db.mHLimit_mHp(selection, "125.0+-3.0")
else:
graphs["Allowed"] = db.mHLimit_mu(selection, "125.0+-3.0")
jsonWriter.addGraph("Allowed", graphs["Allowed"])
graphs["Inaccessible"] = db.inaccessible(xVariable, selection)
jsonWriter.addGraph("Inaccessible", graphs["Inaccessible"])
jsonWriter.addParameter("name", "limitsTanb_light_" + scenario)
jsonWriter.addParameter("scenario", scenario)
jsonWriter.addParameter("luminosity", limits.getLuminosity())
jsonWriter.addParameter("finalStateText", limits.getFinalstateText())
xvar = limit.mu()
if xVariable == "mHp":
xvar = limit.mHplus()
jsonWriter.addParameter("mHplus", xvar)
jsonWriter.addParameter("selection", selection)
jsonWriter.addParameter("regime", "mu")
jsonWriter.write("MSSMLimitMu_" + scenario + ".json")
#limit.doTanBetaPlotLight("limitsTanb_light_"+scenario, graphs, limits.getLuminosity(), limits.getFinalstateText(), limit.mHplus(), scenario)
# if int(mass) in [155, 160]:
# graphs["obs_th_plus"] = db.muLimit(mass,"mu",selection,brlimit*(1+0.29))
# graphs["obs_th_minus"] = db.muLimit(mass,"mu",selection,brlimit*(1-0.29))
#
# for gr in [graphs["obs_th_plus"], graphs["obs_th_minus"]]:
# gr.SetLineWidth(2)
# gr.SetLineStyle(9)
#
# graphs["observed"] = graphs["muexcluded"].Clone()
# graphs["observed"].SetLineWidth(2)
# graphs["observed"].SetLineStyle(ROOT.kSolid)
# graphs["observed"].SetLineColor(ROOT.kBlack)
#
# # Remove obs point
# for name in ["observed", "obs_th_plus", "obs_th_minus"]:
# gr = graphs[name]
# print "Graph", name
# for i in reversed(range(0,gr.GetN())):
# if gr.GetY()[i] < 2 or gr.GetY()[i] > 65:
# print " REMOVING POINT",gr.GetY()[i]," corresponding mass=",gr.GetX()[i]
# gr.RemovePoint(i)
#
# graphs["Allowed"] = db.getHardCoded_mH_limitForMu(mass,0)
# graphs["Allowed2"] = db.getHardCoded_mH_limitForMu(mass,1)
#
# doPlot(("limitsMu_light_mHp%s_"+scenario)%(int(mass)), graphs, limits, "#mu (GeV)",scenario, int(mass))
sys.exit()
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
jsonfile = "limits.json"
root_re = re.compile("(?P<rootfile>(\S*\.root))")
json_re = re.compile("(?P<jsonfile>(\S*\.json))")
for argv in sys.argv:
match = root_re.search(argv)
if match:
rootfile = match.group(0)
match = json_re.search(argv)
if match:
jsonfile = match.group(0)
# jsonfile = "limits_light2016.json"
# jsonfile = "limits2016/limitsForMSSMplots_ICHEP_v2_light.json"
# jsonfile = "limits2016/limits_light_20171011.json"
# jsonfile = "limits2016/limits_light_180131.json"
# jsonfile = "limits2016/limits_light_180205.json"
# jsonfile = "limits2016/limits_light_180318.json"
# jsonfile = "limits2016/limits_light_180417.json"
# jsonfile = "limits2016/limits_unblinded_180809/limits_light.json"
# jsonfile = "limits2016/limits_unblinded_180809/limits_full_leptonic+hadronic_with_intermediate.json"
jsonfile = "limits2016/limits_unblinded_withLeptonic_30082018/taunu_extInt_BR.json"
# limits = limit.BRLimits(limitsfile=jsonfile,configfile="limitdata/lightHplus_configuration.json")
limits = limit.BRLimits(
limitsfile=jsonfile,
configfile="limits2016/lightHplus_configuration.json")
# Enable OpenGL
ROOT.gEnv.SetValue("OpenGL.CanvasPreferGL", 1)
# Apply TDR style
style = tdrstyle.TDRStyle()
# if limit.forPaper:
# histograms.cmsTextMode = histograms.CMSMode.PAPER
histograms.cmsTextMode = histograms.CMSMode.PRELIMINARY
# histograms.cmsTextMode = histograms.CMSMode.PAPER # tmp
#histograms.cmsTextMode = histograms.CMSMode.UNPUBLISHED # tmp
limit.forPaper = True # to get GeV without c^2
# Get BR limits
masses = limits.mass
brs = limits.observed
print "Observed masses and BR's"
for i in range(len(masses)):
print " ", masses[i], brs[i]
global db
db = BRXSDB.BRXSDatabaseInterface(rootfile)
for i, m in enumerate(masses):
db.addExperimentalBRLimit(m, brs[i])
graphs = {}
obs = limits.observedGraph()
# Remove blinded obs points
for i in reversed(range(0, obs.GetN())):
if obs.GetY()[i] < 0.00000001:
print " REMOVING POINT", obs.GetY(
)[i], " corresponding mass=", obs.GetX()[i]
obs.RemovePoint(i)
print
graphs["exp"] = limits.expectedGraph()
graphs["exp1"] = limits.expectedBandGraph(sigma=1)
graphs["exp2"] = limits.expectedBandGraph(sigma=2)
if obs.GetN() > 0:
graphs["obs"] = obs
# Get theory uncertainties on observed
# obs_th_plus = limit.getObservedPlus(obs,0.21)
# obs_th_minus = limit.getObservedMinus(obs,0.21)
# for gr in [obs_th_plus, obs_th_minus]:
# gr.SetLineWidth(2)
# gr.SetLineStyle(9)
# graphs["obs_th_plus"] = obs_th_plus
# graphs["obs_th_minus"] = obs_th_minus
# Remove m=80
for gr in graphs.values():
limit.cleanGraph(gr, 80)
print "Plotting graphs"
for key in graphs.keys():
for i in range(graphs[key].GetN()):
xs = graphs[key].GetX()
ys = graphs[key].GetY()
print " ", key, xs[i], ys[i]
print
# Interpret in MSSM
xVariable = "mHp"
selection = "mu==200"
# selection = "mHp > 0"
# scenario = "MSSM m_{h}^{max}"
scenario = os.path.split(rootfile)[-1].replace(".root", "")
from JsonWriter import JsonWriter
jsonWriter = JsonWriter()
for key in graphs.keys():
print "Graph--------------------------------", key
graphs[key] = db.graphToTanBetaCombined(graphs[key], xVariable,
selection)
#if key == "obs":
#obsplus = db.getTheorUncert(graphs[key],xVariable,selection,"+")
#graphs["obs_th_plus"] = db.graphToTanBetaCombined(obsplus,xVariable,selection)
#obsminus = db.getTheorUncert(graphs[key],xVariable,selection,"-")
#graphs["obs_th_minus"] = db.graphToTanBetaCombined(obsminus,xVariable,selection)
print key, "done"
jsonWriter.addGraph(key, graphs[key])
graphs["mintanb"] = db.minimumTanbGraph("mHp", selection)
if scenario == "lowMH-LHCHXSWG":
graphs["Allowed"] = db.mhLimit("mH", "mHp", selection, "125.0+-3.0")
else:
graphs["Allowed"] = db.mhLimit("mh", "mHp", selection, "125.0+-3.0")
# graphs["isomass"] = None
jsonWriter.addGraph("Allowed", graphs["Allowed"])
jsonWriter.addGraph("mintanb", graphs["mintanb"])
name = "limitsTanb_light_"
finalStateText = limits.getFinalstateText()
if "leptonic" in jsonfile:
name = "limitsTanb_light_LeptHadrFS_"
finalStateText = "#tau+jets final state"
jsonWriter.addParameter("name", name + scenario)
jsonWriter.addParameter("scenario", scenario)
jsonWriter.addParameter("luminosity", limits.getLuminosity())
jsonWriter.addParameter("finalStateText", finalStateText)
jsonWriter.addParameter("mHplus", limit.mHplus())
jsonWriter.addParameter("selection", selection)
jsonWriter.addParameter("regime", "light")
jsonWriter.write(name + scenario + ".json")
limit.doTanBetaPlotLight("limitsTanb_light_" + scenario, graphs,
limits.getLuminosity(),
limits.getFinalstateText(), limit.mHplus(),
scenario)
sys.exit()
# mH+ -> mA
print "Replotting the graphs for (mA,tanb)"
for key in graphs.keys():
print key
#db.PrintGraph(graphs[key])
#print "check loop db.graphToMa"
db.graphToMa(graphs[key])
graphs["isomass"] = db.getIsoMass(160)
limit.doTanBetaPlotLight("limitsTanb_mA_light_" + scenario, graphs,
limits.getLuminosity(),
limits.getFinalstateText(), limit.mA(), scenario)
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
root_re = re.compile("(?P<rootfile>(\S*\.root))")
match = root_re.search(sys.argv[1])
if match:
rootfile = match.group(0)
limits = limit.BRLimits()
# Apply TDR style
style = tdrstyle.TDRStyle()
if limit.forPaper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
# Get BR limits
masses = limits.mass
brs = limits.observed
#print masses,brs
db = BRXSDB.BRXSDatabaseInterface(rootfile, heavy=True, program="2HDMC")
progversion = db.GetProgram() + " v" + db.GetVersion()
for i, m in enumerate(masses):
db.addExperimentalBRLimit(m, brs[i])
graphs = {}
obs = limits.observedGraph()
graphs["obs"] = obs
graphs["exp"] = limits.expectedGraph()
# graphs["exp"].SetLineStyle(2)
graphs["exp1"] = limits.expectedBandGraph(sigma=1)
graphs["exp2"] = limits.expectedBandGraph(sigma=2)
# Remove m=80
for gr in graphs.values():
limit.cleanGraph(gr, minX=100)
N = gr.GetN()
# for i in range(gr.GetN()):
# j = N - 1 - i
# if gr.GetX()[j] > 154 and gr.GetX()[j] < 156:
# gr.RemovePoint(j)
# Get theory uncertainties on observed
obs_th_plus = limit.getObservedPlus(obs)
obs_th_minus = limit.getObservedMinus(obs)
for gr in [obs_th_plus, obs_th_minus]:
gr.SetLineWidth(2)
gr.SetLineStyle(9)
graphs["obs_th_plus"] = obs_th_plus
graphs["obs_th_minus"] = obs_th_minus
# Interpret in MSSM
xVariable = "mHp"
#### selection = "mu==200&&Xt==2000&&m2==200"
# selection = "mu==200"
# scenario = "MSSM m_{h}^{max}"
# scenario = "MSSM m_{h}^{max up}"
# scenario = "MSSM m_{h}^{mod+}"
# scenario = "MSSM m_{h}^{mod-}"
# scenario = "MSSM #tau-phobic" #mu=500
# scenario = "MSSM light #tilde{#tau}" #mu=500
# scenario = "MSSM light #tilde{t}" #mu=350
# scenario = "MSSM low m_{H}" #mu=1700
selection = ""
scenario = "Type II 2HDM"
for key in graphs.keys():
# removeNotValid = not (key in ["exp1", "exp2"])
# graphs[key] = limit.graphToTanBeta(graphs[key], mu, removeNotValid)
graphs[key] = db.graphToTanBeta(graphs[key],
xVariable,
selection,
highTanbRegion=True,
limitBRtoMin=False)
# graphs[key] = db.graphToTanBetaCombined(graphs[key],xVariable,selection)
# graphs[key] = db.graphToSharpTanbExclusion(graphs[key],xVariable,selection)
#### graphs["mintanb"] = db.minimumTanbGraph("mHp",selection)
#### graphs["Allowed"] = db.mhLimit("mh","mHp",selection,"125.9+-3.0")
graphs["excluded"] = db.excluded(graphs["obs"], "ExcludedArea")
# doPlot("limitsTanb_mh", graphs, limits, limit.mHplus(),scenario)
doPlot("limitsmHpTanb_" + rootfile.replace(".root", ""), graphs, limits,
"m_{H^{+}} (" + GeVUnit + ")", scenario, progversion)
def doCompare(name, compareList, **kwargs):
# Define lists
legendLabels = []
limits = []
# For-loop: All label-path pairs
for label, path in compareList:
legendLabels.append(label)
dirs = glob.glob(path)
dirs.sort()
if len(dirs) == 0:
raise Exception("No directories for pattern '%s'" % path)
directory = dirs[-1]
Verbose("Picked %s" % directory, True)
limits.append(limit.BRLimits(directory, excludeMassPoints=["155"]))
# ================================================================================================================
# Do the sigma bands
# ================================================================================================================
Verbose("Creating the sigma-bands plots", True)
_opts = copy.deepcopy(opts)
doPlotSigmaBands(limits, legendLabels, opts.name + "_sigmaBands", _opts)
# ================================================================================================================
# Do expected
# ================================================================================================================
Verbose("Creating the expected plots", True)
observedList = [l.observedGraph() for l in limits]
expectedList = [l.expectedGraph() for l in limits]
# 1) Expected: Median +/- 1,2 sigma
doPlot(limits,
legendLabels,
expectedList,
opts.name + "_median",
limit.BRlimit,
_opts,
yTitle="Expected Sigma Bands")
# 2) Expected: +/- 1 sigma
list1 = [l.expectedGraph(sigma=+1) for l in limits]
list2 = [l.expectedGraph(sigma=-1) for l in limits]
exp1sigmaList = list1 + list2
legendLabels2 = legendLabels + [None] * len(legendLabels)
doPlot(limits,
legendLabels2,
exp1sigmaList,
opts.name + "_sigma1",
"Expected #pm1#sigma",
_opts,
yTitle="Expected #pm1sigma")
# 3) Expected: +/- 2 sigma
list1 = [l.expectedGraph(sigma=+2) for l in limits]
list2 = [l.expectedGraph(sigma=-2) for l in limits]
exp2sigmaList = list1 + list2
doPlot(limits,
legendLabels2,
exp2sigmaList,
opts.name + "_sigma2",
"Expected #pm2#sigma",
_opts,
yTitle="Expected #pm2sigma")
# ================================================================================================================
# Do the observed plots
# ================================================================================================================
Verbose("Creating the observed plots", True)
if opts.unblinded:
doPlot(limits,
legendLabels,
observedList,
opts.name,
limit.BRlimit,
_opts,
yTitle="Observed")
# ================================================================================================================
# Do the relative plots
# ================================================================================================================
Verbose("Creating the relative plots", True)
if not opts.relative:
return
# Overwrite some settings
_opts.yMin = 0.0
_opts.yMax = 2.5
_opts.logY = False
# 1) Relative: median
relLimits = GetRelativeLimits(limits)
expectedList = [l.expectedGraph() for l in relLimits]
doPlot(relLimits,
legendLabels,
expectedList,
opts.name + "_medianRelative",
opts.relativeYlabel,
_opts,
yTitle="Expected median")
# 2) Relative: (expected 1 sigma) / (median)
list1 = [
limit.divideGraph(l.expectedGraph(sigma=+1), l.expectedGraph())
for l in limits
]
list2 = [
limit.divideGraph(l.expectedGraph(sigma=-1), l.expectedGraph())
for l in limits
]
sigma1List = list1 + list2
doPlot(limits,
legendLabels2,
sigma1List,
opts.name + "_sigma1Relative",
"Expected #pm1#sigma / median",
_opts,
yTitle="Expected #pm1#sigma / median")
# 3) Relative: (expected 2 sigma) / (median)
list1 = [
limit.divideGraph(l.expectedGraph(sigma=+2), l.expectedGraph())
for l in limits
]
list2 = [
limit.divideGraph(l.expectedGraph(sigma=-2), l.expectedGraph())
for l in limits
]
sigma2List = list1 + list2
doPlot(limits,
legendLabels2,
sigma2List,
opts.name + "_sigma2Relative",
"Expected #pm2#sigma / median",
_opts,
yTitle="Expected #pm2#sigma / median")
return
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
root_re = re.compile("(?P<rootfile>(\S*\.root))")
match = root_re.search(sys.argv[1])
if match:
rootfile = match.group(0)
limits = limit.BRLimits()
# Apply TDR style
style = tdrstyle.TDRStyle()
if limit.forPaper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
xvar = "mHp"
yvars = []
yvars.append("BR_Hp_taunu")
yvars.append("BR_Hp_tb")
yvars.append("BR_Hp_h0W")
yvars.append("BR_Hp_A0W")
yvars.append("BR_Hp_HW")
# yvars.append("BR_Hp_Neu1Cha1")
# yvars.append("BR_Hp_Neu2Cha1")
susyvars = []
susyvars.append("BR_Hp_Neu1Cha1")
susyvars.append("BR_Hp_Neu2Cha1")
# susyvars.append("BR_Hp_Neu3Cha1")
# susyvars.append("BR_Hp_Neu4Cha1")
# susyvars.append("BR_Hp_Neu1Cha2")
# susyvars.append("BR_Hp_Neu2Cha2")
# susyvars.append("BR_Hp_Neu3Cha2")
# susyvars.append("BR_Hp_Neu4Cha2")
# db = BRXSDB.BRXSDatabaseInterface(rootfile,heavy=True,program="2HDMC")
db = BRXSDB.BRXSDatabaseInterface(rootfile,
heavy=True,
program="FeynHiggs")
progversion = db.GetProgram() + " v" + db.GetVersion()
selection = "tanb==10"
# scenario = "2HDM Type II"
scenario = "mhmax"
graphs = {}
for icolor, yvar in enumerate(yvars):
tmpsel = selection
br = db.getGraph(xvar, yvar, tmpsel)
xarray = array.array('d')
yarray = array.array('d')
for i in range(0, br.GetN()):
x = ROOT.Double()
y = ROOT.Double()
br.GetPoint(i, x, y)
xarray.append(x)
yarray.append(y)
newx, newy = sort(xarray, yarray)
newGraph = ROOT.TGraph(len(newx), newx, newy)
newGraph.SetLineWidth(3)
newGraph.SetLineColor(1 + icolor)
graphs[yvar] = newGraph
xsusy = array.array('d')
ysusy = array.array('d')
for yvar in susyvars:
tmpsel = selection
br = db.getGraph(xvar, yvar, tmpsel)
xarray = array.array('d')
yarray = array.array('d')
for i in range(0, br.GetN()):
x = ROOT.Double()
y = ROOT.Double()
br.GetPoint(i, x, y)
xarray.append(x)
yarray.append(y)
print "check x,y", x, y
xsusy, ysusy = add(xsusy, ysusy, xarray, yarray)
print "check len", len(xsusy)
newx, newy = sort(xsusy, ysusy)
for i in range(len(newx)):
print newx[i], newy[i]
susyGraph = ROOT.TGraph(len(newx), newx, newy)
susyGraph.SetLineWidth(3)
susyGraph.SetLineColor(1 + len(graphs))
graphs["BR_Hp_SUSY"] = susyGraph
plot = plots.PlotBase([
histograms.HistoGraph(graphs["BR_Hp_taunu"],
"BR(H^{+}#rightarrow#tau#nu)",
drawStyle="L",
legendStyle="l"),
histograms.HistoGraph(graphs["BR_Hp_tb"],
"BR(H^{+}#rightarrow tb)",
drawStyle="L",
legendStyle="l"),
histograms.HistoGraph(graphs["BR_Hp_h0W"],
"BR(H^{+}#rightarrow hW)",
drawStyle="L",
legendStyle="l"),
histograms.HistoGraph(graphs["BR_Hp_A0W"],
"BR(H^{+}#rightarrow AW)",
drawStyle="L",
legendStyle="l"),
histograms.HistoGraph(graphs["BR_Hp_HW"],
"BR(H^{+}#rightarrow HW)",
drawStyle="L",
legendStyle="l"),
histograms.HistoGraph(graphs["BR_Hp_SUSY"],
"BR(H^{+}#rightarrow#chi_{i}^{0}#chi_{j}^{+})",
drawStyle="L",
legendStyle="l"),
# histograms.HistoGraph(graphs["BR_Hp_Neu1Cha1"], "BR(H^{+}#rightarrow#chi_{1}^{0}#chi_{1}^{+})", drawStyle="L", legendStyle="l"),
# histograms.HistoGraph(graphs["BR_Hp_Neu2Cha1"], "BR(H^{+}#rightarrow#chi_{2}^{0}#chi_{1}^{+})", drawStyle="L", legendStyle="l"),
])
plot.setLegend(histograms.createLegend(0.57, 0.60, 0.87, 0.80))
plot.legend.SetFillColor(0)
plot.legend.SetFillStyle(1001)
plot.createFrame("br",
opts={
"ymin": 0.0001,
"ymax": 1,
"xmin": 180,
"xmax": 600
})
plot.frame.GetXaxis().SetTitle("m_{H^{+}} (" + GeVUnit + ")")
plot.frame.GetYaxis().SetTitle("BR")
ROOT.gPad.SetLogy(True)
plot.draw()
size = 20
x = 0.57
# histograms.addText(x, 0.9, limit.processHeavy, size=size)
# histograms.addText(x, 0.863, limits.getFinalstateText(), size=size)
#### histograms.addText(x, 0.815, "MSSM m_{h}^{max}", size=size)
histograms.addText(x, 0.863, scenario, size=size)
selectiontxt = selection.replace("==", "=")
histograms.addText(x, 0.815, selectiontxt, size=size)
#Adding a LHC label:
ROOT.LHCHIGGS_LABEL(0.97, 0.72, 1)
# histograms.addText(x, 0.55, progversion, size=size)
plot.save()
def doCompare(name, compareList, opts, **kwargs):
legendLabels = []
limits = []
for label, path in compareList:
legendLabels.append(label)
dirs = glob.glob(path)
dirs.sort()
if len(dirs) == 0:
raise Exception("No directories for pattern '%s'" % path)
directory = dirs[-1]
print "Picked %s" % directory
limits.append(limit.BRLimits(directory, excludeMassPoints=["155"]))
doPlot2(limits, legendLabels, name)
limitOpts = kwargs.get(
"limitOpts",
{"ymax": _ifNotNone(opts.ymax, limits[0].getFinalstateYmaxBR())})
expectedSigmaRelativeOpts = kwargs.get("expectedSigmaRelativeOpts",
{"ymaxfactor": 1.2})
moveLegend = kwargs.get("moveLegend", {})
doPlot(limits,
legendLabels, [l.observedGraph() for l in limits],
name + "_observed",
limit.BRlimit,
opts=kwargs.get("observedOpts", limitOpts),
moveLegend=moveLegend,
plotLabel="Observed")
doPlot(limits,
legendLabels, [l.expectedGraph() for l in limits],
name + "_expectedMedian",
limit.BRlimit,
opts=kwargs.get("expectedMedianOpts", limitOpts),
moveLegend=moveLegend,
log=kwargs.get("log", False),
plotLabel="Expected median")
if opts.relative:
for i in range(1, len(limits)):
limits[i].divideByLimit(limits[0])
# Set reference to 1
for j in range(0, len(limits[0].expectedMedian)):
limits[0].expectedMedian[j] = 1.0
limits[0].expectedMinus2[j] = 1.0
limits[0].expectedMinus1[j] = 1.0
limits[0].expectedPlus2[j] = 1.0
limits[0].expectedPlus1[j] = 1.0
limits[0].observed[j] = 1.0
# Set y scale and require it to be linear
kwargs["expectedMedianOptsRelative"] = {
"ymin": 0.5,
"ymax": _ifNotNone(opts.relativeYmax, 1.5)
}
kwargs["log"] = False
doPlot(limits,
legendLabels, [l.expectedGraph() for l in limits],
name + "_expectedMedianRelative",
opts.relativeYlabel,
opts=kwargs.get("expectedMedianOptsRelative", limitOpts),
moveLegend=moveLegend,
log=kwargs.get("log", False),
plotLabel="Expected median")
print "Skipping +-1 and 2 sigma plots for --relative"
sys.exit()
if opts.relativePairs:
if len(limits) % 2 != 0:
print "Number of limits is not even!"
sys.exit(1)
divPoint = len(limits) / 2
denoms = limits[:divPoint]
numers = limits[divPoint:]
for i in xrange(0, divPoint):
numers[i].divideByLimit(denoms[i])
doPlot(numers,
legendLabels[:divPoint], [l.expectedGraph() for l in numers],
name + "_expectedMedianRelative",
opts.relativeYlabel,
opts={
"ymin": 0.5,
"ymax": _ifNotNone(opts.relativeYmax, 1.5)
},
plotLabel="Expected median")
print "Skipping +-1 and 2 sigma plots for --relativePairs"
sys.exit()
legendLabels2 = legendLabels + [None] * len(legendLabels)
doPlot(limits,
legendLabels2,
[
limit.divideGraph(l.expectedGraph(sigma=+1), l.expectedGraph())
for l in limits
] + [
limit.divideGraph(l.expectedGraph(sigma=-1), l.expectedGraph())
for l in limits
],
name + "_expectedSigma1Relative",
"Expected #pm1#sigma / median",
opts=kwargs.get("expectedSigma1RelativeOpts",
expectedSigmaRelativeOpts),
moveLegend=moveLegend,
plotLabel="Expected #pm1#sigma / median")
doPlot(limits,
legendLabels2,
[
limit.divideGraph(l.expectedGraph(sigma=+2), l.expectedGraph())
for l in limits
] + [
limit.divideGraph(l.expectedGraph(sigma=-2), l.expectedGraph())
for l in limits
],
name + "_expectedSigma2Relative",
"Expected #pm2#sigma / median",
opts=kwargs.get("expectedSigma2RelativeOpts",
expectedSigmaRelativeOpts),
moveLegend=moveLegend,
plotLabel="Expected #pm2#sigma / median")
doPlot(limits,
legendLabels2,
[l.expectedGraph(sigma=+1)
for l in limits] + [l.expectedGraph(sigma=-1) for l in limits],
name + "_expectedSigma1",
"Expected #pm1#sigma",
opts=kwargs.get("expectedSigma1Opts", limitOpts),
moveLegend=moveLegend,
plotLabel="Expexted #pm1sigma")
doPlot(limits,
legendLabels2,
[l.expectedGraph(sigma=+2)
for l in limits] + [l.expectedGraph(sigma=-2) for l in limits],
name + "_expectedSigma2",
"Expected #pm2#sigma",
opts=kwargs.get("expectedSigma2Opts", limitOpts),
moveLegend=moveLegend,
plotLabel="Expected #pm2sigma")
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
root_re = re.compile("(?P<rootfile>(\S*\.root))")
match = root_re.search(sys.argv[1])
if match:
rootfile = match.group(0)
limits = limit.BRLimits()
# Apply TDR style
style = tdrstyle.TDRStyle()
if limit.forPaper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
# Get BR limits
masses = limits.mass
brs = limits.observed
#print masses,brs
db = BRXSDB.BRXSDatabaseInterface(rootfile)
for i, m in enumerate(masses):
db.addExperimentalBRLimit(m, brs[i])
# # SUSY parameter variations (mu, Xt, m2, mgluino, mSUSY, read from the db)
xVariable = "mHp"
xLabel = "m_{H^{+}} [GeV/c^{2}]"
# variationVariable = "mu"
# variationLabel = "#mu"
# variationValues = [-1000,-200,200,1000]
# variationVariable = "mSUSY"
# variationLabel = "M_{SUSY}"
# variationValues = [500,1000,2000]
# variationVariable = "mGluino"
# variationLabel = "m_{#tilde{g}}"
# variationValues = [200,800,2000]
# variationVariable = "m2"
# variationLabel = "M_{2}"
# variationValues = [200,1000]
variationVariable = "Xt"
variationLabel = "X_{t}"
variationValues = [-2000, 2000]
variationSelection = "mHp>99&&" + variationVariable + "==%s"
plot(db, limits, xVariable, xLabel, variationVariable, variationLabel,
variationValues, variationSelection)
# x-axis and variation parameter definitions, y-axis=tanb
# xVariable = "mu"
# xLabel = "#mu [GeV/c^{2}]"
# xVariable = "Xt"
# xLabel = "X_{t} [GeV/c^{2}]"
# xVariable = "m2"
# xLabel = "M_{2} [GeV/c^{2}]"
# xVariable = "mGluino"
# xLabel = "m_{#tilde{g}} [GeV/c^{2}]"
# xVariable = "mSUSY"
# xLabel = "M_{SUSY} [GeV/c^{2}]"
xVariable = variationVariable
xLabel = variationLabel + " [GeV/c^{2}]"
variationVariable = "m_{H^{#pm}}"
variationValues = [100, 120, 140, 150, 155, 160]
# variationValues = [140]
variationSelection = "mHp==%s"
plot(db, limits, xVariable, xLabel, variationVariable, variationLabel,
variationValues, variationSelection)
def main():
if len(sys.argv) == 1:
usage()
rootfile = ""
jsonfile = "limits.json"
root_re = re.compile("(?P<rootfile>(\S*\.root))")
json_re = re.compile("(?P<jsonfile>(\S*\.json))")
for argv in sys.argv:
match = root_re.search(argv)
if match:
rootfile = match.group(0)
match = json_re.search(argv)
if match:
jsonfile = match.group(0)
limits = limit.BRLimits(
limitsfile=jsonfile,
configfile="limitdata/lightHplus_configuration.json")
# Enable OpenGL
ROOT.gEnv.SetValue("OpenGL.CanvasPreferGL", 1)
# Apply TDR style
style = tdrstyle.TDRStyle()
if limit.forPaper:
histograms.cmsTextMode = histograms.CMSMode.PAPER
limit.forPaper = True # to get GeV without c^2
# Get BR limits
masses = limits.mass
brs = limits.observed
print "Observed masses and BR's"
for i in range(len(masses)):
print " ", masses[i], brs[i]
global db
db = BRXSDB.BRXSDatabaseInterface(rootfile,
program="2HDMC",
BRvariable="BR_tHpb")
for i, m in enumerate(masses):
db.addExperimentalBRLimit(m, brs[i])
graphs = {}
obs = limits.observedGraph()
# Remove blinded obs points
for i in reversed(range(0, obs.GetN())):
if obs.GetY()[i] < 0.00000001:
print " REMOVING POINT", obs.GetY(
)[i], " corresponding mass=", obs.GetX()[i]
obs.RemovePoint(i)
print
graphs["exp"] = limits.expectedGraph()
graphs["exp1"] = limits.expectedBandGraph(sigma=1)
graphs["exp2"] = limits.expectedBandGraph(sigma=2)
if obs.GetN() > 0:
graphs["obs"] = obs
# Get theory uncertainties on observed
obs_th_plus = limit.getObservedPlus(obs, 0.21)
obs_th_minus = limit.getObservedMinus(obs, 0.21)
for gr in [obs_th_plus, obs_th_minus]:
gr.SetLineWidth(2)
gr.SetLineStyle(9)
graphs["obs_th_plus"] = obs_th_plus
graphs["obs_th_minus"] = obs_th_minus
# Remove m=80
for gr in graphs.values():
limit.cleanGraph(gr, minX=90)
print "Plotting graphs"
for key in graphs.keys():
for i in range(graphs[key].GetN()):
xs = graphs[key].GetX()
ys = graphs[key].GetY()
print " ", key, xs[i], ys[i]
print
# Interpret in MSSM
xVariable = "mHp"
# selection = "mu==200"
selection = "mHp>0"
# scenario = "MSSM m_{h}^{max}"
scenario = os.path.split(rootfile)[-1].replace(".root", "")
for key in graphs.keys():
print "Graph--------------------------------", key
# graphs[key] = db.graphToTanBetaCombined(graphs[key],xVariable,selection)
graphs[key] = db.graphToTanBeta(graphs[key], xVariable, selection,
False)
print key, "done"
graphs["mintanb"] = db.minimumTanbGraph("mHp", selection)
doPlot("limitsTanb_light_" + scenario, graphs, limits, limit.mHplus(),
scenario)
def doCompare(name, compareList, gOpts, **kwargs):
# Define lists
legendLabels = []
limits = []
# For-loop: All label-path pairs
for label, path in compareList:
legendLabels.append(label)
dirs = glob.glob(path)
dirs.sort()
if len(dirs) == 0:
raise Exception("No directories for pattern '%s'" % path)
directory = dirs[-1]
Print("Picked %s" % directory, True)
limits.append(limit.BRLimits(directory, excludeMassPoints=["155"]))
# Do the plot
doPlotSigmaBands(limits, legendLabels, gOpts.name)
# Define the graph lists
observedList = [l.observedGraph() for l in limits]
expectedList = [l.expectedGraph() for l in limits]
doPlot(limits,
legendLabels,
expectedList,
gOpts.name + "_expectedMedian",
limit.BRlimit,
myOpts=gOpts,
plotLabel="Expected median")
if gOpts.unblinded:
doPlot(limits,
legendLabels,
observedList,
gOpts.name + "_observed",
limit.BRlimit,
myOpts=gOpts,
plotLabel="Observed")
if gOpts.relative:
nLimits = len(limits)
# For-loop: All limits
for i in range(1, nLimits):
limits[i].divideByLimit(limits[0])
# Set reference values to 1
for j in range(0, len(limits[0].expectedMedian)):
limits[0].expectedMedian[j] = 1.0
limits[0].expectedMinus2[j] = 1.0
limits[0].expectedMinus1[j] = 1.0
limits[0].expectedPlus2[j] = 1.0
limits[0].expectedPlus1[j] = 1.0
limits[0].observed[j] = 1.0
# Do the relative plot
doPlot(limits,
legendLabels,
expectedList,
gOpts.name + "_expectedMedianRelative",
gOpts.relativeYlabel,
myOpts=gOpts,
plotLabel="Expected median")
Print("Skipping +-1 and 2 sigma plots for --relative", True)
sys.exit()
if gOpts.relativePairs:
if len(limits) % 2 != 0:
Print("Number of limits is not even!", True)
sys.exit(1)
divPoint = len(limits) / 2
denoms = limits[:divPoint]
numers = limits[divPoint:]
# For-loop: All division points
for i in xrange(0, divPoint):
numers[i].divideByLimit(denoms[i])
expectedNumersList = [l.expectedGraph() for l in numers]
doPlot(numers,
legendLabels[:divPoint],
gexpectedNumersList,
gOpts.name + "_expectedMedianRelative",
gOpts.relativeYlabel,
plotLabel="Expected median")
Print("Skipping +-1 and 2 sigma plots for --relativePairs", True)
sys.exit()
legendLabels2 = legendLabels + [None] * len(legendLabels)
doPlot(limits,
legendLabels2,
[
limit.divideGraph(l.expectedGraph(sigma=+1), l.expectedGraph())
for l in limits
] + [
limit.divideGraph(l.expectedGraph(sigma=-1), l.expectedGraph())
for l in limits
],
gOpts.name + "_expectedSigma1Relative",
"Expected #pm1#sigma / median",
myOpts=gOpts,
plotLabel="Expected #pm1#sigma / median")
doPlot(limits,
legendLabels2,
[
limit.divideGraph(l.expectedGraph(sigma=+2), l.expectedGraph())
for l in limits
] + [
limit.divideGraph(l.expectedGraph(sigma=-2), l.expectedGraph())
for l in limits
],
gOpts.name + "_expectedSigma2Relative",
"Expected #pm2#sigma / median",
myOpts=gOpts,
plotLabel="Expected #pm2#sigma / median")
doPlot(limits,
legendLabels2,
[l.expectedGraph(sigma=+1)
for l in limits] + [l.expectedGraph(sigma=-1) for l in limits],
gOpts.name + "_expectedSigma1",
"Expected #pm1#sigma",
myOpts=gOpts,
plotLabel="Expexted #pm1sigma")
doPlot(limits,
legendLabels2,
[l.expectedGraph(sigma=+2)
for l in limits] + [l.expectedGraph(sigma=-2) for l in limits],
gOpts.name + "_expectedSigma2",
"Expected #pm2#sigma",
myOpts=gOpts,
plotLabel="Expected #pm2sigma")
return
