def createPlots2D_(plot, compounddetectorname):
"""2D material budget map to know exactly what we are adding.
"""
#IBs = ["InnerServices", "Phase2PixelBarrel", "TIB", "TIDF", "TIDB"]
theDirname = "Figures"
hist_X0_detectors = OrderedDict()
if plot not in plots.keys():
print("Error: chosen plot name not known %s" % plot)
return
# We need to keep the file content alive for the lifetime of the
# full function....
subDetectorFiles = []
hist_X0_elements = OrderedDict()
prof_X0_elements = OrderedDict()
for subDetector, color in DETECTORS.items():
subDetectorFilename = "matbdg_%s.root" % subDetector
if not checkFile_(subDetectorFilename):
print("Error opening file: %s" % subDetectorFilename)
continue
subDetectorFiles.append(TFile(subDetectorFilename))
subDetectorFile = subDetectorFiles[-1]
print("Opening file: %s" % subDetectorFilename)
prof_X0_XXX = subDetectorFile.Get("%d" % plots[plot].plotNumber)
#hist_X0_detectors[subDetector] = prof_X0_XXX
hist_X0_detectors[subDetector] = prof_X0_XXX.ProjectionXY("_pxy", "B")
print(subDetector)
# First Plot: BeamPipe + Tracker + ECAL + HCal + HGCal + MB + MGNT
# Create "null" histo
minX = 1.03 * hist_X0_detectors["BeamPipe"].GetXaxis().GetXmin()
maxX = 1.03 * hist_X0_detectors["BeamPipe"].GetXaxis().GetXmax()
minY = 1.03 * hist_X0_detectors["BeamPipe"].GetYaxis().GetXmin()
maxY = 1.03 * hist_X0_detectors["BeamPipe"].GetYaxis().GetXmax()
frame = TH2F("frame", "", 10, minX, maxX, 10, minY, maxY)
frame.SetMinimum(0.1)
frame.SetMaximum(10.)
frame.GetXaxis().SetTickLength(frame.GetXaxis().GetTickLength() * 0.50)
frame.GetYaxis().SetTickLength(frame.GetXaxis().GetTickLength() / 4.)
hist2d_X0_total = hist_X0_detectors["BeamPipe"]
# stack
hist2dTitle = (
'%s %s;%s;%s;%s' %
(plots[plot].quotaName, "All detectors", plots[plot].abscissa,
plots[plot].ordinate, plots[plot].quotaName))
hist2d_X0_total.SetTitle(hist2dTitle)
frame.SetTitle(hist2dTitle)
frame.SetTitleOffset(0.5, "Y")
#If here you put different histomin,histomaxin plot_utils you won't see anything
#for the material plots.
if plots[plot].histoMin != -1.:
hist2d_X0_total.SetMinimum(plots[plot].histoMin)
if plots[plot].histoMax != -1.:
hist2d_X0_total.SetMaximum(plots[plot].histoMax)
#
# canvas
can_SubDetectors = TCanvas("can_SubDetectors", "can_SubDetectors",
2480 + 248, 580 + 58 + 58)
can_SubDetectors.SetTopMargin(0.1)
can_SubDetectors.SetBottomMargin(0.1)
can_SubDetectors.SetLeftMargin(0.04)
can_SubDetectors.SetRightMargin(0.06)
can_SubDetectors.SetFillColor(kWhite)
gStyle.SetOptStat(0)
gStyle.SetTitleFillColor(0)
gStyle.SetTitleBorderSize(0)
gStyle.SetOptTitle(0)
hist2d_X0_total.GetYaxis().SetTickLength(
hist2d_X0_total.GetXaxis().GetTickLength() / 4.)
hist2d_X0_total.GetYaxis().SetTickLength(
hist2d_X0_total.GetXaxis().GetTickLength() / 4.)
hist2d_X0_total.SetTitleOffset(0.5, "Y")
hist2d_X0_total.GetYaxis().SetTitleOffset(0.50)
#hist2d_X0_total.GetXaxis().SetTitleOffset(1.15);
#hist2d_X0_total.GetXaxis().SetNoExponent(True)
#hist2d_X0_total.GetYaxis().SetNoExponent(True)
# colors
for det, color in DETECTORS.items():
hist_X0_detectors[det].SetMarkerColor(color)
hist_X0_detectors[det].SetFillColor(color)
for det, histo in hist_X0_detectors.items():
print(det)
histo.Draw("same")
# Legenda
theLegend_SubDetectors = TLegend(0.100, 0.7, 0.90,
0.90) #(0.180,0.8,0.98,0.90)
theLegend_SubDetectors.SetNColumns(3)
theLegend_SubDetectors.SetFillColor(0)
theLegend_SubDetectors.SetFillStyle(0)
theLegend_SubDetectors.SetBorderSize(0)
for det, histo in hist_X0_detectors.items():
theLegend_SubDetectors.AddEntry(histo, det, "f")
#theLegend_SubDetectors.AddEntry(hgbound1, "HGCal Eta Boundaries [1.3, 3.0]", "l")
theLegend_SubDetectors.Draw()
# text
text_SubDetectors = TPaveText(0.100, 0.627, 0.322, 0.687,
"NDC") #(0.180,0.727,0.402,0.787,"NDC")
text_SubDetectors.SetFillColor(0)
text_SubDetectors.SetBorderSize(0)
text_SubDetectors.AddText("CMS Simulation")
text_SubDetectors.SetTextAlign(11)
text_SubDetectors.Draw()
#Add eta labels
keep_alive = []
if plots[plot].iDrawEta:
keep_alive.extend(drawEtaValues())
# Store
can_SubDetectors.Update()
if not checkFile_(theDirname):
os.mkdir(theDirname)
can_SubDetectors.SaveAs("%s/MaterialBdg_%s_%s.png" %
(theDirname, compounddetectorname, plot))
#It seems that it is too heavy to create .pdf and .root
#can_SubDetectors.SaveAs("%s/MaterialBdg_FromVertexToEndofHGCal_%s.pdf" % (theDirname, plot))
#can_SubDetectors.SaveAs("%s/MaterialBdg_FromVertexToEndofHGCal_%s.root" % (theDirname, plot))
hist2d_X0_total.GetXaxis().SetRangeUser(0., 7000.)
#Draw eta values in the zoom case
keep_alive = []
keep_alive.extend(drawHalfEtaValues())
#hist2d_X0_total.Draw("COLZ")
can_SubDetectors.Update()
can_SubDetectors.Modified()
can_SubDetectors.SaveAs("%s/MaterialBdg_%s_%s_Zpluszoom.png" %
(theDirname, compounddetectorname, plot))
eta_bins.append(float(l[0]))
for n in range(int(len(l) / 3) - 1):
pt_bins.append(float(l[3 * (n + 1)]))
eta_bins.append(float(l[1]))
pt_bins.append(10000.)
nbinsx = len(pt_bins) - 1
xbins = array('f', pt_bins)
nbinsy = len(eta_bins) - 1
ybins = array('f', eta_bins)
dhn = 'hJetShift_' + key + '_Down'
uhn = 'hJetShift_' + key + '_Up'
hJetShiftDown = TH2F(dhn, dhn, nbinsx, xbins, nbinsy, ybins)
hJetShiftUp = TH2F(uhn, uhn, nbinsx, xbins, nbinsy, ybins)
with open(s['txt']) as f:
next(f) # skip first line
for y_, line in enumerate(f):
l = line.split()
y = y_ + 1
for x_, n in enumerate(range(int(len(l) / 3) - 1)):
x = x_ + 1
down = float(l[3 * (n + 1) + 1])
up = float(l[3 * (n + 1) + 2])
hJetShiftDown.SetBinContent(x, y, down)
hJetShiftUp.SetBinContent(x, y, up)
hists.append(hJetShiftDown.Clone(dhn))
def main():
f = open(filelistStr,"r")
rtfileoutput = TFile(rtfileoutputStr,"recreate")
waveDir = rtfileoutput.mkdir("Waveforms")
resultsDir = rtfileoutput.mkdir("Results")
# prepare for histgorams
hAmplitude_list = []
hAmplitudeBin_list = []
hWave_list = []
hPedMean_list = []
hPedWidth_list = []
hFinalCharge_list = []
hNbOfPulses_list = []
hPulseStartTime_list = [] # start time of the pulse
hPulseTimeDist_list = [] # time distribution of the pulses that are not due to fiber trigger (ie., dark pulses or else)
hPulseWidth_list = [] # time distribution of the pulses that are not due to fiber trigger (ie., dark pulses or else)
hPulseAmplitudeVsTime_list = [] # 2D histogram: pulse amplitude vs. pulse time bin
hPulseAmplitudeVsWidth_list = [] # 2D histogram: pulse amplitude vs. pulse time bin
hWaveAvg_list = [] # average of raw waveforms
#special test on time difference between the first channel
hTimeDiff = TH1F("hTimeDiff","Time diference",100,-10,10) # unit in ns
hTimeDiff.SetXTitle("Time difference (ns)");
hTimeDiff.SetYTitle("N");
for i in range(0,NCH,1):
# will keep a few waveforms
name = "Wave_" + str(i)
hist = TH1F(name,"",NSamples,0,NSamples)
hist.SetXTitle("Sample number")
hist.SetYTitle("Amplitude (mV)")
hist.SetLineColor(i+1)
hWave_list.append(hist)
# will keep average waveforms
name = "WaveAvg_" + str(i)
hist = TH1F(name,"",NSamples,0,NSamples)
hist.SetXTitle("Sample number")
hist.SetYTitle("Amplitude (mV)")
hist.SetLineColor(i+1)
hWaveAvg_list.append(hist)
# histogram of pulse baseline
name = "PedMean_" + str(i)
hist = TH1F(name,"",1000,-5,5)
hist.SetXTitle("Amplitude (mv)")
hist.SetYTitle("Counts")
hist.SetLineColor(i+1)
hPedMean_list.append(hist)
# histogram of pulse baseline width
name = "PedWidth_" + str(i)
hist = TH1F(name,"",1000,-5,5)
hist.SetXTitle("Amplitude (mV)")
hist.SetYTitle("Counts")
hist.SetLineColor(i+1)
hPedWidth_list.append(hist)
# pulse charge due to fiber triggers, unit converted to fC
name = "FinalCharge_" + str(i)
# would be best to have different settings for LED on vs LED off
if ledStatus == 0:
hist = TH1F(name,"",80,-3,3)
else:
hist = TH1F(name,"",18,-4,50)
hist.SetXTitle("Charge (pC)")
hist.SetYTitle("Counts")
hist.SetLineColor(i+1)
hFinalCharge_list.append(hist)
# pulse amplitude, or nimimum (because of negative pulse)
name = "PulseAmplitude_" + str(i)
hist = TH1F(name,"",500,0,500)
hist.SetXTitle("Amplitude (mV)")
hist.SetYTitle("Counts")
hist.SetLineColor(i+1)
hAmplitude_list.append(hist)
# pulse width, or nimimum (because of negative pulse)
name = "PulseWidth_" + str(i)
hist = TH1F(name,"",100,0,100)
hist.SetXTitle("Pulse width (ns)")
hist.SetYTitle("Counts")
#hist.SetLineColor(i+1)
hPulseWidth_list.append(hist)
# time bin where pulse amplitude is found, used to determine charge integration region
name = "PulseAmplitudeBin_" + str(i)
hist = TH1F(name,"",200,100,300)
hist.SetXTitle("Amplitude bin number")
hist.SetYTitle("Counts")
hist.SetLineColor(i+1)
hAmplitudeBin_list.append(hist)
# number of pulses found in the waveform not in the fiber trigger region
name = "NbOfPulses_" + str(i)
hist = TH1F(name,"",20,0,20)
hist.SetXTitle("Number of pulses in a 20 #mus window")
hist.SetYTitle("Counts")
hist.SetLineColor(i+1)
hNbOfPulses_list.append(hist)
# pulse start time, only choose those pulses above threshold
name = "PulseStartTime_" + str(i)
hist = TH1F(name,"",200,100,300)
hist.SetXTitle("Pulse start time bin (1.6 ns/bin)")
hist.SetYTitle("Counts")
#hist.SetLineColor(i+1)
hPulseStartTime_list.append(hist)
# pulse time distributions for those pulses are 100 ns later than the fiber triggered pulse
name = "PulseTimeDist_" + str(i)
hist = TH1F(name,"",NSamples/10,0,NSamples)
hist.SetXTitle("Pulse time bin (16 ns/bin)")
hist.SetYTitle("Counts")
hist.SetLineColor(i+1)
hPulseTimeDist_list.append(hist)
# pulse time distributions for those pulses are 100 ns later than the fiber triggered pulse
name = "PulseAmpVsTimeBin_" + str(i)
hist = TH2F(name,"",NSamples/10,0,NSamples,500,0,500)
hist.SetXTitle("Pulse time bin")
hist.SetYTitle("Pulse Amplitude (mV)")
hist.SetLineColor(i+1)
hPulseAmplitudeVsTime_list.append(hist)
# pulse time distributions for those pulses are 100 ns later than the fiber triggered pulse
name = "PulseAmpVsWidth_" + str(i)
hist = TH2F(name,"",100,0,100,500,0,500)
hist.SetXTitle("Pulse time bin")
hist.SetYTitle("Pulse Amplitude (mV)")
hPulseAmplitudeVsWidth_list.append(hist)
#process the waveforms
baseline_mean = 0.0
baseline_width = 0.0
threshold = 0.0
sumwave = [[0 for x in range(NSamples)] for y in range(NCH)]
#special test for time diff
flag1 = [ False for x in range(Nwaves)]
time1 = [ 0 for x in range(Nwaves)]
flag2 = [ False for x in range(Nwaves)]
time2 = [ 0 for x in range(Nwaves)]
for ch in range(NCH):
for waveNb in range(Nwaves):
afilename = f.readline().rstrip()
#print afilename
#if waveNb>20:
# continue
awave = np.asarray(decode_wfm(dataDirectory + afilename))
#print "dump data "
#for bin in range(NSamples):
# print awave[bin]
#print NSamples, len(awave)
baseline_mean = np.average(awave[NSamples-200:NSamples])
baseline_width = np.std(awave[NSamples-200:NSamples])
threshold = baseline_mean - Nsigma*baseline_width
hPedMean_list[ch].Fill(baseline_mean)
hPedWidth_list[ch].Fill(baseline_width)
TimeBinOfAmplitude = np.argmin(awave[70:800]) + 70
if ch == 0 and awave[TimeBinOfAmplitude]<threshold:
flag1[waveNb] = True
time1[waveNb] = TimeBinOfAmplitude
if ch == 1 and awave[TimeBinOfAmplitude]<threshold:
flag2[waveNb] = True
time2[waveNb] = TimeBinOfAmplitude
# get charge integration about the amplitude: 20.8 ns before to 36.8 ns after the amplitude
#sumcharge = 0.0
#if TimeBinOfAmplitude>=168 and TimeBinOfAmplitude<=180:
sumcharge = np.sum(awave[TimeBinOfAmplitude-13:TimeBinOfAmplitude+23])
pulsestartbin = TimeBinOfAmplitude
while awave[pulsestartbin]<threshold and pulsestartbin>=TimeBinOfAmplitude-20:
pulsestartbin -= 1
hPulseStartTime_list[ch].Fill(pulsestartbin-1)
#else:
# sumcharge = np.sum(awave[172-13:172+23])
fC = (sumcharge-baseline_mean*(23+13+1))*QFactor # convert charge involving the 50 Ohm impedience
#if awave[TimeBinOfAmplitude] < threshold:
hAmplitude_list[ch].Fill(-1000.0*(awave[TimeBinOfAmplitude]-baseline_mean))
hAmplitudeBin_list[ch].Fill(TimeBinOfAmplitude)
#print TimeBinOfAmplitude, awave[TimeBinOfAmplitude]
hFinalCharge_list[ch].Fill(-1.0*fC)
# search for number of pulses
peakindex = peakutils.peak.indexes(-1.0*awave[0:NSamples],thres=abs(threshold), min_dist=31, thres_abs=True)
for pulse_i in range(len(peakindex)):
if awave[peakindex[pulse_i]] > (baseline_mean - 2.0*Nsigma*baseline_width):
continue
hPulseTimeDist_list[ch].Fill(peakindex[pulse_i]) #+TimeBinOfAmplitude+200
hPulseAmplitudeVsTime_list[ch].Fill(peakindex[pulse_i], -1000.0*(awave[peakindex[pulse_i]]-baseline_mean))
#determine the pulse width
thisindex = peakindex[pulse_i]
thiswidth = 0
while awave[thisindex]<=threshold and thisindex>=2:
#print pulse_i, ch, thiswaveform[ch][thisindex], threshold[ch]
thiswidth += 1
thisindex -= 1
#if thisindex<=1:
# print eventNb, ch, pulse_i, thiswaveform[ch][thisindex]
thisindex = peakindex[pulse_i]
while awave[thisindex+1]<=threshold and thisindex<=NSamples-3:
thiswidth += 1
thisindex += 1
# if thisindex>=NSamples-2:
# print eventNb, ch, pulse_i, thiswaveform[ch][thisindex]
hPulseWidth_list[ch].Fill((thiswidth+2)*2)
hPulseAmplitudeVsWidth_list[ch].Fill((thiswidth+2)*2, -1000.0*(awave[peakindex[pulse_i]]-baseline_mean))
#print ch, waveNb, peakindex
if waveNb%100 ==0:
print ch, waveNb, afilename
for bin in range(0,NSamples,1):
hWave_list[ch].SetBinContent(bin+1,-1000.0*(awave[bin]-baseline_mean))
#hWave_list[ch].SetBinContent(bin+1,awave[bin])
waveDir.cd()
lenname = int(len(afilename))
newName = "Wave_Ch_" + str(ch) + "_" + str(waveNb)+afilename[lenname-4-17:lenname-4]
titleName = "Evt "+str(waveNb)+"_Ch"+str(ch)+"_PulseBins_"
for pulse_i in range(len(peakindex)):
titleName += str(peakindex[pulse_i])
titleName += "_"
hWave_list[ch].SetName(newName)
hWave_list[ch].SetTitle(titleName)
hWave_list[ch].SetEntries(NSamples)
hWave_list[ch].Write()
#for bin in range(0,NSamples,1):
# hWave_list[ch].SetBinContent(bin+1,0);
#if len(peakindex)>0:
hNbOfPulses_list[ch].Fill( len(peakindex) )
#average of raw waveforms for each PMT
for bin in range(0,NSamples,1):
sumwave[ch][bin] += 1000.0*(awave[bin]-baseline_mean)
for ch in range(NCH):
for bin in range(NSamples):
hWaveAvg_list[ch].SetBinContent(bin+1,sumwave[ch][bin]/Nwaves)
waveDir.cd()
hWaveAvg_list[ch].Write()
for waveNb in range(Nwaves):
if flag1[waveNb] is True and flag2[waveNb] is True:
hTimeDiff.Fill(time1[waveNb]-time2[waveNb])
f.close()
resultsDir.cd()
for i in range(0,NCH,1):
# fit the charge distributions with Poisson distribution plus exponetional background
hFinalCharge_list[i].Write()
for i in range(0,NCH,1):
hAmplitude_list[i].Write()
for i in range(0,NCH,1):
hAmplitudeBin_list[i].Write()
for i in range(0,NCH,1):
hPedMean_list[i].Write()
for i in range(0,NCH,1):
hPulseStartTime_list[i].Write()
for i in range(0,NCH,1):
hPedWidth_list[i].Write()
for i in range(0,NCH,1):
hPulseTimeDist_list[i].Write()
print "number of pulses: ", hPulseTimeDist_list[i].GetEntries()
for i in range(0,NCH,1):
hPulseWidth_list[i].Write()
for i in range(0,NCH,1):
hPulseAmplitudeVsTime_list[i].Write()
for i in range(0,NCH,1):
hPulseAmplitudeVsWidth_list[i].Write()
for i in range(0,NCH,1):
#darkrate = 0.0
#for j in range(2,21):
# if hNbOfPulses_list[i].GetBinContent(j)>0:
# darkrate += hNbOfPulses_list[i].GetBinContent(j)*(j-1)
#darkrate = darkrate/(10.0*1.0e-6*hNbOfPulses_list[i].GetEntries())
#title = "dark rate on average " + str(darkrate) + " Hz"
#hNbOfPulses_list[i].SetTitle(title)
hNbOfPulses_list[i].Write()
hTimeDiff.Write()
rtfileoutput.Close()
smoothed = smooth(data_mean, n // 5)
pos_min = (np.diff(np.sign(np.diff(smoothed))) > 0).nonzero()[0] + 1
pos_max = (np.diff(np.sign(np.diff(smoothed))) < 0).nonzero()[0] + 1
pos_extrema = np.sort(np.concatenate((pos_min, pos_max)))
pos_extrema = np.insert(pos_extrema, 0, 0)
pos_extrema = np.append(pos_extrema, len(smoothed) - 1)
extrema = list()
for i, length in enumerate(np.diff(pos_extrema)):
#Filter out extrema that are very close to one another
if length > 10:
extrema.append((int(pos_extrema[i + 1]), pos_extrema[i + 1]
in pos_max))
print("Plotting...")
c_diff = TCanvas("c_diff", "Differences", 200, 10, 700, 500)
c_diff_hist = TH2F("h1", "Deviation", 10, -10, 30, 10, 0, 3)
c_diff_hist.SetStats(False)
c_diff_hist.Draw()
diff_graphs = list()
prev_pos = 0
for pos_extremum, is_maximum in extrema:
g_diff = TGraph(pos_extremum - prev_pos,
data_mean[prev_pos:pos_extremum],
data_std[prev_pos:pos_extremum])
g_diff.SetTitle("Deviation")
x_axis = g_diff.GetXaxis()
#x_axis.SetTimeDisplay(1)
#x_axis.SetTitle("Time")
#x_axis.SetTimeFormat("%H:%M:%S")
x_axis.SetTitle(field[2])
def jetdisplay():
outputfile = "zjj"
displayfile = TFile(outputfile + ".root", "RECREATE")
energies = [30, 50, 70, 90, 150, 250]
cut = [16.72, 31.115, 55.548, 58.715, 99.335, 160.8]
inputfiles = [
"jetscan_leakage_029/jetscan_" + str(e) + ".root" for e in energies
]
#for geant4.10.5
inputfiles = [
"resultsgeant4.10.5/jetscan_leakage/jetscan/jetscan" + str(e) + ".root"
for e in energies
]
#end of geant4.10.5
#for geant4.10.5 with X0 or B
#inputfiles = ["resultsgeant4.10.5/jetscan_leakage_X0/jetscan/jetscan"+str(e)+".root" for e in energies]
#end of geant4.10.5 with X0 or B
#for CaloLoop
#inputfiles = ["/home/software/Calo/CaloLoop/CaloJet/resultsgeant4.10.5/jetscan_leakage_B/jetscan/jetscan"+str(e)+".root" for e in energies]
#end CaloLoop
#for geant4.10.5.p01 FTFPBERT
inputfiles = [
"results_FTFPBERT/noBnoX0/jetscan/jetscan_" + str(e) + ".root"
for e in energies
]
#end geant4.10.5.p01 FTFPBERT
for counter, inputfile in enumerate(inputfiles):
inputfile = TFile(inputfile)
print "Analyzing: " + str(inputfile) + " \n"
tree = TTree()
inputfile.GetObject("MyTree", tree)
#graphEjet1 = TH1F("energyjet1", "energyjet1", 100, 0., 200.)
#graphEjet2 = TH1F("energyjet2", "energyjet2", 100, 0., 200.)
#graphEcherjet1 = TH1F("energycher1", "energycherjet", 100, 0., 200.)
#graph3 = TH1F("energyscinjet", "energyscinjet", 100, 0., 200.)
#graphmass = TH1F("mass_jet", "mass_jet", 100, 0., 200.)
graphtest = TH1F("test" + str(energies[counter]),
"test" + str(energies[counter]), 80, -40., 40.)
graphenergy = TH1F("energy" + str(energies[counter]),
"energy" + str(energies[counter]), 200, 0., 100.)
graphenergytruth = TH1F("energytruth" + str(energies[counter]),
"energytruth" + str(energies[counter]), 200,
0., 100.)
graphjs = TH1F("energyjs" + str(energies[counter]),
"energyjs" + str(energies[counter]), 200, 0., 100.)
graphjc = TH1F("energyjc" + str(energies[counter]),
"energyjc" + str(energies[counter]), 200, 0., 100.)
graph_emcomp02 = TH1F("emcomp02_" + str(energies[counter]),
"emcomp02" + str(energies[counter]), 80, -40, 40)
graph_emcomp04 = TH1F("emcomp04_" + str(energies[counter]),
"emcomp04" + str(energies[counter]), 80, -40, 40)
graph_emcomp06 = TH1F("emcomp06_" + str(energies[counter]),
"emcomp06" + str(energies[counter]), 80, -40, 40)
graph_emcomp08 = TH1F("emcomp08_" + str(energies[counter]),
"emcomp08" + str(energies[counter]), 80, -40, 40)
graph_emcomp1 = TH1F("emcomp1_" + str(energies[counter]),
"emcomp1" + str(energies[counter]), 80, -40, 40)
scatterplot = TH2F("diff_" + str(energies[counter]),
"diff_" + str(energies[counter]), 70, -20., 50., 70,
-50., 20)
scatterplotedep = TH2F("edep_" + str(energies[counter]),
"edep_" + str(energies[counter]), 100, 0.0,
100.0, 100, 0.0, 100.0)
#loop over events
for Event in range(tree.GetEntries()):
tree.GetEntry(Event)
#print "Event "+str(Event)
nmuon = tree.nmuon
nneu = tree.nneu
mjjr = tree.mjjr
mjjt = tree.mjjt
edep = tree.edep
muene_che = tree.muene_che
muene_sci = tree.muene_sci
emcomp1 = tree.emcomp1
emcomp2 = tree.emcomp2
eleak = tree.eleak
eleakn = tree.eleakn
j1t_E = tree.j1t_E
j1t_m = tree.j1t_m
j1t_theta = tree.j1t_theta
j1t_pt = tree.j1t_pt
j1t_eta = tree.j1t_eta
j1t_phi = tree.j1t_phi
j2t_E = tree.j2t_E
j2t_m = tree.j2t_m
j2t_theta = tree.j2t_theta
j2t_pt = tree.j2t_pt
j2t_eta = tree.j2t_eta
j2t_phi = tree.j2t_phi
j1r_E = tree.j1r_E
j1r_m = tree.j1r_m
j1r_theta = tree.j1r_theta
j1r_pt = tree.j1r_pt
j1r_eta = tree.j1r_eta
j1r_phi = tree.j1r_phi
j2r_E = tree.j2r_E
j2r_m = tree.j2r_m
j2r_theta = tree.j2r_theta
j2r_pt = tree.j2r_pt
j2r_eta = tree.j2r_eta
j2r_phi = tree.j2r_phi
j1s_E = tree.j1s_E
j1s_m = tree.j1s_m
j1s_theta = tree.j1s_theta
j1s_pt = tree.j1s_pt
j1s_eta = tree.j1s_eta
j1s_phi = tree.j1s_phi
j2s_E = tree.j2s_E
j2s_m = tree.j2s_m
j2s_theta = tree.j2s_theta
j2s_pt = tree.j2s_pt
j2s_eta = tree.j2s_eta
j2s_phi = tree.j2s_phi
j1c_E = tree.j1c_E
j1c_m = tree.j1c_m
j1c_theta = tree.j1c_theta
j1c_pt = tree.j1c_pt
j1c_eta = tree.j1c_eta
j1c_phi = tree.j1c_phi
j2c_E = tree.j2c_E
j2c_m = tree.j2c_m
j2c_theta = tree.j2c_theta
j2c_pt = tree.j2c_pt
j2c_eta = tree.j2c_eta
j2c_phi = tree.j2c_phi
cut1 = nmuon == 0 and nneu == 0
cut2 = abs(j1t_eta) < 2.0 and abs(j2t_eta) < 2.0
eleak = eleak / 1000.
cut3 = eleak < 0.1
#cut3 = True
cut4 = j1s_E + j2s_E > cut[counter]
cut4 = True
#cut5 = abs(j1t_E-j2t_E)<5.
#cut5 = abs(j1t_phi-j2t_phi)>0.1
cut5 = True
if cut1 and cut2 and cut3 and cut4 and cut5:
#deltaj1 = 0.04406*j1r_E+0.1158
#deltaj2 = 0.04406*j2r_E+0.1158
#deltaj1 = 0.02825*j1r_E+0.4056
#deltaj2 = 0.02825*j2r_E+0.4056
#deltaj1 = 0.04135*j1r_E+0.08789
#deltaj2 = 0.04135*j2r_E+0.08789
#deltaj1 = 0.07113*j1r_E+0.5201
#deltaj2 = 0.07113*j2r_E+0.5201
deltaj1 = 0.0
deltaj2 = 0.0
graphtest.Fill(j1r_E + deltaj1 - j1t_E)
graphtest.Fill(j2r_E + deltaj2 - j2t_E)
'''
if (emcomp1+emcomp2)<0.2*90.:
graph_emcomp02.Fill(j1r_E+deltaj1-j1t_E)
graph_emcomp02.Fill(j2r_E+deltaj2-j2t_E)
if 0.2*90.<emcomp1+emcomp2<0.4*90.:
graph_emcomp04.Fill(j1r_E+deltaj1-j1t_E)
graph_emcomp04.Fill(j2r_E+deltaj2-j2t_E)
if 0.4*90.<emcomp1+emcomp2<0.6*90.:
graph_emcomp06.Fill(j1r_E+deltaj1-j1t_E)
graph_emcomp06.Fill(j2r_E+deltaj2-j2t_E)
if 0.6*90.<emcomp1+emcomp2<0.8*90.:
graph_emcomp08.Fill(j1r_E+deltaj1-j1t_E)
graph_emcomp08.Fill(j2r_E+deltaj2-j2t_E)
if 0.8*90.<emcomp1+emcomp2<90.:
graph_emcomp1.Fill(j1r_E+deltaj1-j1t_E)
graph_emcomp1.Fill(j2r_E+deltaj2-j2t_E)
'''
graphenergy.Fill(j1r_E + deltaj1)
graphenergy.Fill(j2r_E + deltaj2)
graphenergytruth.Fill(j1t_E)
graphenergytruth.Fill(j2t_E)
graphjs.Fill(j2s_E)
graphjs.Fill(j1s_E)
graphjc.Fill(j2c_E)
graphjc.Fill(j1c_E)
scatterplot.Fill(j2r_E + deltaj2 - j2t_E,
j1r_E + deltaj1 - j1t_E)
scatterplotedep.Fill(edep, j1s_E + j2s_E)
displayfile.cd()
graphtest.Write()
graphenergy.Write()
graphenergytruth.Write()
graphjs.Write()
graphjc.Write()
#graph_emcomp02.Write()
#graph_emcomp04.Write()
#graph_emcomp06.Write()
#graph_emcomp08.Write()
#graph_emcomp1.Write()
scatterplot.Write()
scatterplotedep.Write()
def drawRoiDeltaR(geometry, is2016):
def getTopoCell(mioct, etacode, phicode):
global mioctTCmap
mioctTCmap = {}
mioctid = mioct['id']
if not mioctid in mioctTCmap:
d = {}
for tc in mioct.Decode.TopoCells:
key = (int(tc['etacode'], 16), int(tc['phicode'], 16))
d[key] = tc
mioctTCmap[mioctid] = d
return mioctTCmap[mioctid][(etacode, phicode)]
global h, c, hB, hEC, hFW
gROOT.Reset()
gStyle.SetOptStat(0)
c = TCanvas('c', "Topo encoding", 1400, 950)
c.Divide(2, 2)
c.Draw()
hB = TH2F(
"hb", "Delta R between ROI and TopoCell %i in Barrel" %
(2016 if is2016 else 2015), 64, 0, 64, 32, 0, 32)
hB.SetXTitle("SL")
hB.SetYTitle("ROI ID")
hEC = TH2F(
"hec", "Delta R between ROI and TopoCell %i in Endcap" %
(2016 if is2016 else 2015), 96, 0, 96, 148, 0, 148)
hEC.SetXTitle("SL")
hEC.SetYTitle("ROI ID")
hFW = TH2F(
"hfw", "Delta R between ROI and TopoCell %i in Forward" %
(2016 if is2016 else 2015), 48, 0, 48, 64, 0, 64)
hFW.SetXTitle("SL")
hFW.SetYTitle("ROI ID")
for MioctID in drawOrder:
mioct = geometry.getMIOCT(MioctID)
for sector in mioct.Sectors:
for roi in sector.ROIs:
tc = getTopoCell(mioct, int(roi['etacode'], 16),
int(roi['phicode'], 16))
deltaEta = float(roi['eta']) - float(tc['ieta']) / 10.
deltaPhi = float(roi['phi']) - float(tc['iphi']) / 10.
if deltaPhi > math.pi:
deltaPhi -= 2 * math.pi # some topocells are made up from ROIs that are on both sides of 0
deltaR = math.sqrt(deltaEta * deltaEta + deltaPhi * deltaPhi)
sectorid = int(sector['name'].lstrip('ABCDEF'))
roiid = int(roi['roiid'])
if sector['name'].startswith('B'):
hB.Fill(sectorid, roiid, deltaR)
elif sector['name'].startswith('E'):
if sector['name'].startswith('EA'):
sectorid += 48
hEC.Fill(sectorid, roiid, deltaR)
elif sector['name'].startswith('F'):
if sector['name'].startswith('FA'):
sectorid += 24
hFW.Fill(sectorid, roiid, deltaR)
c.cd(1)
hB.Draw("colz")
c.cd(2)
hEC.Draw("colz")
c.cd(3)
hFW.Draw("colz")
c.Update()
c.SaveAs("ROIDeltaR%s.pdf" % "2016" if is2016 else "2015")
evt0 = 0
evt1 = 0
pidx0 = 0
pidx1 = 0
#initialize dicts
datasetIDX_v_path = {'path': 0}
get_gen_entries0_from_event = {0:0} #event number : entry number
get_gen_entries1_from_event = {0:0}
path_str_dict = {}#{'path':['dataset','module']}
event_dict = {}#{'event':['changed','fired 0not1','fired 1not0']}
output_list = [{} for i in xrange(11)]
#make hists
fired_rel0_not1_decayType_vs_dataset = TH2F("fired_rel0_didntfire_rel1_decay_type_vs_datasets","fired_rel0_didntfire_rel1_decay_type_vs_datasets",44,0,44,11,0,11)
#set bin labels
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(1,"Double Ele")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(2,"Double Mu")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(3,"Double Tau")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(4,"Ele + Mu")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(5,"Ele + Tau")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(6,"Mu + Tau")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(7,"Single Ele")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(8,"Single Mu")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(9,"Single Tau")
fired_rel0_not1_decayType_vs_dataset.GetYaxis().SetBinLabel(10,"All Had")
fired_rel0_not1_decayType_vs_dataset.SetTitle("lost counts going from " + rel0 + " to " + rel1 + ", ttbar decay vs dataset")
fired_rel0_not1_decayType_vs_dataset.GetXaxis().SetLabelSize(0.03)
fired_rel0_not1_decayType_vs_dataset.SetStats(0)
def hvt(benchmark = ['B3', 'A1']):
hxs = {}
hw = {}
gxs = {}
gw = {}
mg = TMultiGraph()
for m in massPoints:
hxs[m] = TH2F("hxs_M%d" % m, ";;", 50, -0.04, 3.96, 100, 0., 2.)
hw[m] = TH2F("hw_M%d" % m, ";;", 50, -0.04, 3.96, 50, 0., 2.)
for m in massPoints:
file = TFile.Open("HVT/scanHVT_M%s.root" % m, "READ")
tree = file.Get("tree")
for entry in range(tree.GetEntries()): # Fill mass points only if NOT excluded
tree.GetEntry(entry)
gH, gF = tree.gv*tree.ch, tree.g*tree.g*tree.cq/tree.gv
XsBr = tree.CX0 * tree.BRbb * 1000. # in fb
if XsBr < observed[m]: hxs[m].Fill(gH, gF)
if tree.total_widthV0/float(m) < width: hw[m].Fill(gH, gF)
for b in range(hxs[m].GetNbinsX()*hxs[m].GetNbinsY()):
hxs[m].SetBinContent(b, 1. if hxs[m].GetBinContent(b)>0. else 0.)
hw[m].SetBinContent(b, 1. if hw[m].GetBinContent(b)>0. else 0.)
#hxs[m].Smooth(20)
#hw[m].Smooth(20)
gxs[m] = getCurve(hxs[m])
for i, g in enumerate(gxs[m]):
g.SetLineColor(massColors[m])
g.SetFillColor(massColors[m])
g.SetFillStyle(massFill[m]) #(3345 if i>1 else 3354)
g.SetLineWidth(503*(1 if i<2 else -1))
mg.Add(g)
if m==3000:
gw[m] = getCurve(hw[m])
for i, g in enumerate(gw[m]):
g.SetPoint(0, 0., g.GetY()[0])
g.SetLineWidth(501*(1 if i<2 else -1))
g.SetLineColor(920+2)
g.SetFillColor(920+1)
g.SetFillStyle(3003)
mg.Add(g)
if options.root:
outFile = TFile("plotsLimit/Model.root", "RECREATE")
outFile.cd()
for m in massPoints:
mg[m].Write("X_M%d" % m)
mgW.Write("width")
outFile.Close()
print "Saved histogram in file plotsLimit/Model.root, exiting..."
exit()
### plot ###
c1 = TCanvas("c1", "HVT Exclusion Limits", 800, 600)
c1.cd()
c1.GetPad(0).SetTopMargin(0.06)
c1.GetPad(0).SetRightMargin(0.05)
c1.GetPad(0).SetTicks(1, 1)
mg.Draw("AC")
#mg.GetXaxis().SetTitle("g_{V} c_{H}")
mg.GetXaxis().SetTitle("Higgs and vector boson coupling g_{H}")
mg.GetXaxis().SetRangeUser(-3.,3.)
mg.GetXaxis().SetLabelSize(0.045)
mg.GetXaxis().SetTitleSize(0.045)
mg.GetXaxis().SetTitleOffset(1.)
#mg.GetYaxis().SetTitle("g^{2} c_{F} / g_{V}")
mg.GetYaxis().SetTitle("Fermion coupling g_{F}")
mg.GetYaxis().SetLabelSize(0.045)
mg.GetYaxis().SetTitleSize(0.045)
mg.GetYaxis().SetTitleOffset(1.)
mg.GetYaxis().SetRangeUser(-1., 1.)
mg.GetYaxis().SetNdivisions(505)
# hxs[3500].Draw("CONTZ")
drawCMS(LUMI, "", False) #Preliminary
# drawAnalysis("XVH"+category, False)
# latex = TLatex()
# latex.SetNDC()
# latex.SetTextFont(62)
# latex.SetTextSize(0.06)
# latex.DrawLatex(0.10, 0.925, "CMS")
# model B
g_model = {}
for i, b in enumerate(benchmark):
g_model[i] = TGraph(1)
g_model[i].SetTitle(models_name[b])
g_model[i].SetPoint(0, models_point[b][0], models_point[b][1])
g_model[i].SetMarkerStyle(models_style[b])
g_model[i].SetMarkerColor(models_color[b])
g_model[i].SetMarkerSize(1.5)
g_model[i].Draw("PSAME")
# text
latex = TLatex()
latex.SetTextSize(0.045)
latex.SetTextFont(42)
latex.SetTextColor(630)
# for b in benchmark: latex.DrawLatex(models_point[b][0]+0.02, models_point[b][1]+0.02, models_name[b])
latex.SetTextColor(920+2)
latex.DrawLatex(-2.8, -0.875, "#frac{#Gamma_{Z'}}{m_{Z'}} > %.0f%%" % (width*100, ))
leg = TLegend(0.68, 0.60, 0.95, 0.94)
leg.SetBorderSize(1)
leg.SetFillStyle(1001)
leg.SetFillColor(0)
for m in massPoints:
leg.AddEntry(gxs[m][0], "m_{Z'} = %.1f TeV" % (m/1000.), "fl")
for i, b in enumerate(benchmark):
leg.AddEntry(g_model[i], g_model[i].GetTitle(), "P")
leg.SetY1(leg.GetY2()-leg.GetNRows()*0.050)
leg.SetMargin(0.35)
leg.Draw()
gxs_ = gxs[massPoints[0]][0].Clone("gxs_")
gxs_.SetLineColor(1)
# gxs_.SetFillColor(1)
latex.SetNDC()
latex.SetTextColor(1)
latex.SetTextSize(0.04)
latex.SetTextFont(52)
latex.DrawLatex(0.15, 0.95, "q#bar{q} #rightarrow Z' #rightarrow b#bar{b}")
c1.Print("plots/model/HVT.png")
c1.Print("plots/model/HVT.pdf")
c1.Print("plots/model/HVT.root")
c1.Print("plots/model/HVT.C")
#g = 0.646879, cH = 0.976246, cF = 1.02433
print "model B = [", 3*0.976246, ",", 0.646879*0.646879*1.02433/3, "]"
if not gROOT.IsBatch(): raw_input("Press Enter to continue...")
def plot( sample, n, v, sel, hbins, hmin, hmax, hlog, xlabel, ylabel, dim ):
#hlog=False;
global output
file = {}
tree = {}
hist = {}
leaf = {}
xsec = {}
max = 0
min = 1e99
ROOT.gStyle.SetOptStat(1111)
ROOT.gROOT.SetBatch(True)
for i, s in enumerate(sample):
file[s] = TFile( input + s + ".root", "READ")
tree[s] = file[s].Get("Physics")
if dim==1:
hist[s] = TH1F(s, ";"+v, hbins, hmin , hmax)
tree[s].Project(s, v, "%s"%sel)
leaf[s] = tree[s].GetLeaf("xsec1")
leaf[s].GetBranch().GetEntry(1)
xsec[s] = leaf[s].GetValue()
hist[s].SetLineColor(colour[i])
hist[s].SetLineWidth(2)#3
hist[s].SetFillColorAlpha(colour[i],0.35)
hist[s].SetFillStyle(3005)
if hist[s].GetMaximum() > max: max = hist[s].GetMaximum()*6
if hist[s].GetMinimum() < min: min = hist[s].GetMinimum()
#leg = TLegend(0.4, 0.9-0.035*len(sample), 0.68, 0.89)
c1 = TCanvas("c1", "Gen", 1600, 1200)
c1.cd()
hist[sample[0]].SetMaximum(max*1.2)
hist[sample[0]].SetMinimum(min+1.e6)
hist[sample[0]].GetXaxis().SetTitle("%s" %xlabel)
hist[sample[0]].GetYaxis().SetTitle("%s" %ylabel)
hist[sample[0]].SetTitle("%s" %n)
if len(sample)>1:
for i, s in enumerate(sample):
hist[s].Draw("HIST" if i==0 else "HIST, SAME")
else:
hist[s].Draw("HIST")
if hlog:
c1.GetPad(0).SetLogy()
elif dim==2:
if len(hbins)!=2 or len(hmin)!=2 or len(hmax)!=2:
print "dimension of hbins, hmin, hmax does not correspond to\
2 dimensional histogram parameters."; exit;
else:
#X axis parameters follow by Y axis parameters
hist[s] = TH2F( s, ";"+v, hbins[0], hmin[0] , hmax[0], hbins[1], hmin[1] , hmax[1] )
# v in the form of x:y
tree[s].Project(s, v, "%s"%sel,"colz")
c1 = TCanvas("c1", "Gen", 1600, 1200)
c1.cd()
hist[s].Draw("COLZ")
#if hlog:
# c1.GetPad(0).SetLogy()
# c1.GetPad(0).SetLogx()
else:
print "Unkown dimension"
exit;
#leg.Draw()
c1.Update()
drawlabel( 0.37 , 0.934 , "CMS Simulation" )
output+="VH/"+sample[0]+"/"
if not hlog:
output+="Lin/"
elif hlog:
output+="Log/"
if not os.path.exists(output):
os.makedirs(output)
c1.Print( output + n + ".pdf")
c1.Print( output + n + ".png")
def pullsVertical(fileName):
content = filterPullFile(fileName)
nbins, off = len(content), 0.10
b_pulls = TH1F("b_pulls", ";;Pulls", nbins, 0.-off, nbins-off)
s_pulls = TH1F("s_pulls", ";;Pulls", nbins, 0.+off, nbins+off) #
for i, s in enumerate(content):
l = s.split()
b_pulls.GetXaxis().SetBinLabel(i+1, l[0])
s_pulls.GetXaxis().SetBinLabel(i+1, l[0])
b_pulls.SetBinContent(i+1, float(l[1]))
b_pulls.SetBinError(i+1, float(l[2]))
s_pulls.SetBinContent(i+1, float(l[3]))
s_pulls.SetBinError(i+1, float(l[4]))
b_pulls.SetFillStyle(3005)
b_pulls.SetFillColor(923)
b_pulls.SetLineColor(923)
b_pulls.SetLineWidth(1)
b_pulls.SetMarkerStyle(20)
b_pulls.SetMarkerSize(1.25)
s_pulls.SetLineColor(602)
s_pulls.SetMarkerColor(602)
s_pulls.SetMarkerStyle(24) #24
s_pulls.SetLineWidth(1)
b_pulls.GetYaxis().SetRangeUser(-2.5, 2.5)
# Graphs
h_pulls = TH2F("pulls", "", 6, -3., 3., nbins, 0, nbins)
B_pulls = TGraphAsymmErrors(nbins)
S_pulls = TGraphAsymmErrors(nbins)
boxes = []
canvas = TCanvas("canvas", "Pulls", 600, 150+nbins*10)#nbins*20)
canvas.cd()
canvas.SetGrid(0, 1)
canvas.GetPad(0).SetTopMargin(0.01)
canvas.GetPad(0).SetRightMargin(0.01)
canvas.GetPad(0).SetBottomMargin(0.05)
canvas.GetPad(0).SetLeftMargin(0.25)#(0.25)#(0.065)
canvas.GetPad(0).SetTicks(1, 1)
for i, s in enumerate(content):
l = s.split()
if "1034h" in l[0]: l[0]="CMS_PDF_13TeV"
h_pulls.GetYaxis().SetBinLabel(i+1, l[0].replace('CMS2016_', ''))#C
#y1 = gStyle.GetPadBottomMargin()
#y2 = 1. - gStyle.GetPadTopMargin()
#h = (y2 - y1) / float(nbins)
#y1 = y1 + float(i) * h
#y2 = y1 + h
#box = TPaveText(0, y1, 1, y2, 'NDC')
#box.SetFillColor(0)
#box.SetTextSize(0.02)
#box.SetBorderSize(0)
#box.SetTextAlign(12)
#box.SetMargin(0.005)
#if i % 2 == 0:
# box.SetFillColor(18)
#box.Draw()
#boxes.append(box)
B_pulls.SetPoint(i+1,float(l[1]),float(i+1)-0.3)#C
B_pulls.SetPointError(i+1,float(l[2]),float(l[2]),0.,0.)#C
for i, s in enumerate(content):
l = s.split()
S_pulls.SetPoint(i+1,float(l[3]),float(i+1)-0.7)#C
S_pulls.SetPointError(i+1,float(l[4]),float(l[4]),0.,0.)#C
h_pulls.GetXaxis().SetTitle("(#hat{#theta} - #theta_{0}) / #Delta#theta")
h_pulls.GetXaxis().SetLabelOffset(-0.01)
h_pulls.GetXaxis().SetTitleOffset(.6)
h_pulls.GetYaxis().SetNdivisions(nbins, 0, 0)
B_pulls.SetFillColor(1)
B_pulls.SetLineColor(1)
B_pulls.SetLineStyle(1)
B_pulls.SetLineWidth(2)
B_pulls.SetMarkerColor(1)
B_pulls.SetMarkerStyle(20)
B_pulls.SetMarkerSize(1)#(0.75)
S_pulls.SetFillColor(629)
S_pulls.SetLineColor(629)
S_pulls.SetMarkerColor(629)
S_pulls.SetLineWidth(2)
S_pulls.SetMarkerStyle(20)
S_pulls.SetMarkerSize(1)
box1 = TBox(-1., 0., 1., nbins)
box1.SetFillStyle(3001)
#box1.SetFillStyle(0)
box1.SetFillColor(417)
box1.SetLineWidth(2)
box1.SetLineStyle(2)
box1.SetLineColor(417)
box2 = TBox(-2., 0., 2., nbins)
box2.SetFillStyle(3001)
#box2.SetFillStyle(0)
box2.SetFillColor(800)
box2.SetLineWidth(2)
box2.SetLineStyle(2)
box2.SetLineColor(800)
leg = TLegend(0.1, -0.05, 0.7, 0.08)
leg.SetBorderSize(0)
leg.SetFillStyle(0)
leg.SetFillColor(0)
leg.SetNColumns(2)
leg.AddEntry(B_pulls, "B-only fit", "lp")
leg.AddEntry(S_pulls, "S+B fit", "lp")
if text: leg.AddEntry(0, text, "")
h_pulls.Draw("")
box2.Draw()
box1.Draw()
B_pulls.Draw("P6SAME")
S_pulls.Draw("P6SAME")
leg.Draw()
# drawCMS(35867, "Preliminary")
# drawAnalysis("VH")
# drawRegion(outName)
canvas.Print(outName+".png")
canvas.Print(outName+".pdf")
if not gROOT.IsBatch(): raw_input("Press Enter to continue...")
def pullsVertical_noBonly(fileName):
content = filterPullFile(fileName)
nbins, off = len(content), 0.10
# Graphs
h_pulls = TH2F("pulls", "", 6, -3., 3., nbins, 0, nbins)
S_pulls = TGraphAsymmErrors(nbins)
boxes = []
canvas = TCanvas("canvas", "Pulls", 720, 300+nbins*18)#nbins*20)
canvas.cd()
canvas.SetGrid(0, 1)
canvas.SetTopMargin(0.01)
canvas.SetRightMargin(0.01)
canvas.SetBottomMargin(0.10)
canvas.SetLeftMargin(0.40)
canvas.SetTicks(1, 1)
for i, s in enumerate(content):
l = s.split()
h_pulls.GetYaxis().SetBinLabel(i+1, l[0])
S_pulls.SetPoint(i,float(l[3]),float(i+1)-0.5)
S_pulls.SetPointError(i,float(l[4]),float(l[4]),0.,0.)
h_pulls.GetXaxis().SetTitle("(#hat{#theta} - #theta_{0}) / #Delta#theta")
h_pulls.GetXaxis().SetLabelOffset(0.0)
h_pulls.GetXaxis().SetTitleOffset(0.8)
h_pulls.GetXaxis().SetLabelSize(0.045)
h_pulls.GetXaxis().SetTitleSize(0.050)
h_pulls.GetYaxis().SetLabelSize(0.046)
h_pulls.GetYaxis().SetNdivisions(nbins, 0, 0)
S_pulls.SetFillColor(kBlack)
S_pulls.SetLineColor(kBlack)
S_pulls.SetMarkerColor(kBlack)
S_pulls.SetLineWidth(2)
S_pulls.SetMarkerStyle(20)
S_pulls.SetMarkerSize(1)
box1 = TBox(-1., 0., 1., nbins)
#box1.SetFillStyle(3001) # 3001 checkered
#box1.SetFillStyle(0)
box1.SetFillColor(kGreen+1) # 417
box1.SetLineWidth(2)
box1.SetLineStyle(2)
box1.SetLineColor(kGreen+1) # 417
box2 = TBox(-2., 0., 2., nbins)
#box2.SetFillStyle(3001) # 3001 checkered
#box2.SetFillStyle(0)
box2.SetFillColor(kOrange) # 800
box2.SetLineWidth(2)
box2.SetLineStyle(2)
box2.SetLineColor(kOrange) # 800
leg = TLegend(0.01, 0.01, 0.3, 0.15)
leg.SetTextSize(0.05)
leg.SetBorderSize(0)
leg.SetFillStyle(0)
leg.SetFillColor(0)
#leg.SetNColumns(2)
leg.AddEntry(S_pulls, "S+B fit", "lp")
if text: leg.AddEntry(0, text, "")
h_pulls.Draw("")
box2.Draw()
box1.Draw()
S_pulls.Draw("P6SAME")
leg.Draw()
canvas.RedrawAxis()
canvas.Print(outName+".png")
canvas.Print(outName+".pdf")
if not gROOT.IsBatch(): raw_input("Press Enter to continue...")
def dqm_getSingleHist_json(server, run, dataset, hist, rootContent=False):
postfix = "?rootcontent=1" if rootContent else ""
datareq = urllib2.Request(('%s/jsonfairy/archive/%s/%s/%s%s') %
(server, run, dataset, hist, postfix))
datareq.add_header('User-agent', ident)
# Get data
data = eval(
re.sub(r"\bnan\b", "0",
urllib2.build_opener(X509CertOpen()).open(datareq).read()),
{"__builtins__": None}, {})
histo = data['hist']
# Now convert into real ROOT histogram object
if 'TH1' in histo['type']:
# The following assumes a TH1F object
contents = histo['bins']['content']
nbins = len(contents)
xmin = histo['xaxis']['first']['value']
xmax = histo['xaxis']['last']['value']
roothist = TH1F(histo['stats']['name'], histo['title'], nbins, xmin,
xmax)
for xx in range(1, nbins + 1):
roothist.SetBinContent(xx, contents[xx - 1])
roothist.SetBinError(xx, histo['bins']['error'][xx - 1])
roothist.SetEntries(histo['stats']['entries'])
stats = array('d')
stats.append(histo['stats']['entries'])
stats.append(histo['stats']['entries'])
stats.append(histo['stats']['entries'] *
histo['stats']['mean']['X']['value'])
stats.append(
(histo['stats']['rms']['X']['value'] *
histo['stats']['rms']['X']['value'] +
histo['stats']['mean']['X']['value'] *
histo['stats']['mean']['X']['value']) * histo['stats']['entries'])
roothist.PutStats(stats)
elif (histo['type'] == 'TProfile'):
contents = histo['bins']['content']
nbins = len(contents)
xmin = histo['xaxis']['first']['value']
xmax = histo['xaxis']['last']['value']
roothist = TProfile(histo['stats']['name'], histo['title'], nbins,
xmin, xmax)
roothist.SetErrorOption("g")
for xx in range(0, nbins):
if (histo['bins']['error'][xx] != 0):
ww = 1. / (histo['bins']['error'][xx] *
histo['bins']['error'][xx])
else:
ww = 0.
roothist.Fill(
xmin + (2 * xx + 1) * ((xmax - xmin) / (nbins * 2.0)),
contents[xx], ww)
# roothist.SetBinContent(xx, contents[xx-1])
# roothist.SetBinError(xx, histo['bins']['error'][xx-1])
roothist.SetEntries(histo['stats']['entries'])
stats = array('d')
for i in range(0, 6):
stats.append(i)
roothist.GetStats(stats)
stats[0] = (histo['stats']['entries'])
stats[1] = (histo['stats']['entries'])
stats[2] = (histo['stats']['entries'] *
histo['stats']['mean']['X']['value'])
stats[3] = ((histo['stats']['rms']['X']['value'] *
histo['stats']['rms']['X']['value'] +
histo['stats']['mean']['X']['value'] *
histo['stats']['mean']['X']['value']) *
histo['stats']['entries'])
roothist.PutStats(stats)
elif 'TH2' in histo['type']:
contents = histo['bins']['content']
nbinsx = histo['xaxis']['last']['id']
xmin = histo['xaxis']['first']['value']
xmax = histo['xaxis']['last']['value']
nbinsy = histo['yaxis']['last']['id']
ymin = histo['yaxis']['first']['value']
ymax = histo['yaxis']['last']['value']
roothist = TH2F(histo['stats']['name'], histo['title'], nbinsx, xmin,
xmax, nbinsy, ymin, ymax)
for xx in range(1, nbinsx + 1):
for yy in range(1, nbinsy + 1):
roothist.SetBinContent(xx, yy, contents[yy - 1][xx - 1])
roothist.SetEntries(histo['stats']['entries'])
stats = array('d')
stats.append(histo['stats']['entries'])
stats.append(histo['stats']['entries'])
stats.append(histo['stats']['entries'] *
histo['stats']['mean']['X']['value'])
stats.append(
(histo['stats']['rms']['X']['value'] *
histo['stats']['rms']['X']['value'] +
histo['stats']['mean']['X']['value'] *
histo['stats']['mean']['X']['value']) * histo['stats']['entries'])
stats.append(histo['stats']['entries'] *
histo['stats']['mean']['Y']['value'])
stats.append(
(histo['stats']['rms']['Y']['value'] *
histo['stats']['rms']['Y']['value'] +
histo['stats']['mean']['Y']['value'] *
histo['stats']['mean']['Y']['value']) * histo['stats']['entries'])
roothist.PutStats(stats)
elif (histo['type'] == 'TProfile2D'):
contents = histo['bins']['content']
nbinsx = histo['xaxis']['last']['id']
xmin = histo['xaxis']['first']['value']
xmax = histo['xaxis']['last']['value']
nbinsy = histo['yaxis']['last']['id']
ymin = histo['yaxis']['first']['value']
ymax = histo['yaxis']['last']['value']
roothist = TProfile2D(histo['stats']['name'], histo['title'], nbinsx,
xmin, xmax, nbinsy, ymin, ymax)
for xx in range(0, nbinsx):
for yy in range(0, nbinsy):
roothist.Fill(
xmin + (2 * xx + 1) * ((xmax - xmin) / (nbinsx * 2.0)),
ymin + (2 * yy + 1) * ((ymax - ymin) / (nbinsy * 2.0)), 0,
1)
for xx in range(1, nbinsx + 1):
for yy in range(1, nbinsy + 1):
roothist.SetBinContent(xx, yy, contents[yy - 1][xx - 1])
roothist.SetEntries(histo['stats']['entries'])
return roothist
def main():
#############################################################################################
# Options #
#############################################################################################
parser = argparse.ArgumentParser(
description=
'From given set of root files, make different histograms in a root file'
)
parser.add_argument('-m',
'--model',
action='store',
required=True,
type=str,
default='',
help='NN model to be used')
parser.add_argument('-f',
'--file',
action='store',
required=False,
type=str,
default='',
help='File (full path) to be used')
parser.add_argument('--mA',
action='store',
required=False,
type=int,
default=0,
help='Print as PDf only some of the mass config')
parser.add_argument('--mH',
action='store',
required=False,
type=int,
default=0,
help='Print as PDf only some of the mass config')
parser.add_argument('-n',
'--number',
action='store',
required=False,
type=int,
default=0,
help='Number of events to build the likelihood map')
parser.add_argument('--xmax',
action='store',
required=False,
type=float,
default=1500,
help='Maximum values for mA in the graph')
parser.add_argument('--ymax',
action='store',
required=False,
type=float,
default=1500,
help='Maximum values for mH in the graph')
parser.add_argument('--xmin',
action='store',
required=False,
type=float,
default=0,
help='Minimum values for mA in the graph')
parser.add_argument('--ymin',
action='store',
required=False,
type=float,
default=0,
help='Minimum values for mH in the graph')
parser.add_argument('--zmin',
action='store',
required=False,
type=float,
default=0,
help='Minimum values for z axis in the graph')
parser.add_argument('--zmax',
action='store',
required=False,
type=float,
default=None,
help='Maximum values for z axis in the graph')
parser.add_argument('--bins',
action='store',
required=False,
type=int,
default=100,
help='Bins in both the graph axes')
parser.add_argument(
'--suffix',
action='store',
required=False,
type=str,
default='',
help=
'Suffix to be added to output name (likelihood_suffix.pdf/.root), default to empty string'
)
parser.add_argument('--PDF',
action='store_true',
required=False,
default=False,
help='Produce PDF from the root file')
parser.add_argument(
'--profile',
action='store_true',
required=False,
default=False,
help='Whether to make the profile likelihood starting from the TGraph2D'
)
parser.add_argument('--zoom',
action='store_true',
required=False,
default=False,
help='Zoom the TGraph2D according to given boundaries')
parser.add_argument(
'--norm',
action='store_true',
required=False,
default=False,
help='Use the normalization by the visible cross section')
parser.add_argument('-v',
'--verbose',
action='store_true',
required=False,
default=False,
help='Show DEGUG logging')
opt = parser.parse_args()
# Logging #
if opt.verbose:
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s - %(levelname)s - %(message)s')
else:
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s')
#############################################################################################
# Get objects in TFile #
#############################################################################################
def getall(d, basepath="/"):
"Generator function to recurse into a ROOT file/dir and yield (path, obj) pairs"
for key in d.GetListOfKeys():
kname = key.GetName()
if key.IsFolder():
for i in getall(d.Get(kname), basepath + kname + '/'):
yield i
else:
yield basepath + kname, d.Get(kname)
#############################################################################################
# Profile Likelihood #
#############################################################################################
if opt.profile:
# Path to graph #
path_root = os.path.abspath(
os.path.join('PDF', opt.model,
'likelihood_' + opt.suffix + '.root'))
path_out = os.path.abspath(os.path.join('PDF', opt.model))
# Load TGraph2D #
f = TFile(path_root)
graphs = [(key, obj) for (key, obj) in getall(f)]
for key, obj in graphs:
if key.find('HToZA') == -1:
continue
mH_value = int(re.findall(r'\d+', key)[2])
mA_value = int(re.findall(r'\d+', key)[3])
if mH_value != opt.mH or mA_value != opt.mA:
continue
MakeProfile(graph=obj,
mH=mH_value,
mA=mA_value,
N=10000,
path=path_out,
step=5,
slices=10)
sys.exit(0)
#############################################################################################
# Make PDF #
#############################################################################################
def ZoomHist(graph, bins, xmin, xmax, ymin, ymax):
x = np.linspace(xmin, xmax, bins)
y = np.linspace(ymin, ymax, bins)
X, Y = np.meshgrid(x, y)
X = X.ravel()
Y = Y.ravel()
valid = np.logical_and(np.greater_equal(Y, X),
np.greater_equal(Y, 125))
X = X[valid]
Y = Y[valid]
N = X.shape[0]
new_graph = TGraph2D(N)
manager = enlighten.get_manager()
pbar = manager.counter(total=N, desc='Progress', unit='Point')
for i in range(N):
content = graph.Interpolate(X[i], Y[i])
if content != 0 or Y[i] > 125:
new_graph.SetPoint(i, X[i], Y[i], content)
pbar.update()
new_graph.SetTitle(graph.GetTitle())
return copy.deepcopy(new_graph)
if opt.PDF or opt.zoom:
path_root = os.path.abspath(
os.path.join('PDF', opt.model,
'likelihood_' + opt.suffix + '.root'))
path_pdf = os.path.abspath(
os.path.join('PDF', opt.model,
'likelihood_' + opt.suffix + '.pdf'))
path_zoom = os.path.abspath(
os.path.join('PDF', opt.model,
'likelihood_' + opt.suffix + '_zoom.root'))
f = TFile(path_root)
if opt.PDF:
c1 = TCanvas('c1', 'c1', 1100, 900)
c1.SetGrid()
#canvas = TCanvas('canvas','canvas',900,900)
#canvas.Print(path_pdf+'[')
c1.Print(path_pdf + '[')
c1.SetTopMargin(0.05)
c1.SetBottomMargin(0.18)
c1.SetLeftMargin(0.18)
c1.SetRightMargin(0.2)
graphs = [(key, obj) for (key, obj) in getall(f)]
graphs = sorted(graphs,
key=lambda tup: tup[0]) # Sort according to name
for i, (key, obj) in enumerate(graphs):
mH_value = 0
mA_value = 0
if key.find('DY') != -1:
title = 'DY'
elif key.find('TT') != -1:
title = 'TT'
else:
mH_value = int(re.findall(r'\d+', key)[2])
mA_value = int(re.findall(r'\d+', key)[3])
title = 'HToZATo2L2B_mH_%d_mA_%d' % (mH_value, mA_value)
if (mH_value != opt.mH
or mA_value != opt.mA) and opt.mA != 0 and opt.mH != 0:
continue
logging.info('Processing %s' % key)
try:
if opt.zoom:
new_graph = ZoomHist(obj, opt.bins, opt.xmin, opt.xmax,
opt.ymin, opt.ymax)
if os.path.exists(path_zoom):
root_file = TFile(path_zoom, "update")
new_graph.Write(title, TObject.kOverwrite)
logging.info("Zoomed Graph saved in %s" % path_zoom)
else:
root_file = TFile(path_zoom, "recreate")
new_graph.Write(title)
logging.info("Zoomed Graph replaced in %s" % path_zoom)
if opt.PDF:
base_hist = TH2F('', '', opt.bins, opt.xmin, opt.xmax,
opt.bins, opt.ymin, opt.ymax)
obj.SetHistogram(base_hist)
hist = obj.GetHistogram()
hist.SetContour(1000)
hist.GetXaxis().SetRangeUser(opt.xmin, opt.xmax)
hist.GetYaxis().SetRangeUser(opt.ymin, opt.ymax)
hist.SetMinimum(max(opt.zmin, hist.GetMinimum()))
amax = hist.GetMaximum() if opt.zmax is None else opt.zmax
hist.SetMaximum(amax)
hist.SetTitle(";M_{A} [GeV];M_{H} [GeV];-2 log L")
hist.GetXaxis().SetTitleOffset(1.2)
hist.GetYaxis().SetTitleOffset(1.2)
hist.GetZaxis().SetTitleOffset(1.2)
hist.GetXaxis().SetLabelSize(0.04)
hist.GetYaxis().SetLabelSize(0.04)
hist.GetZaxis().SetLabelSize(0.04)
hist.GetXaxis().SetTitleSize(0.06)
hist.GetYaxis().SetTitleSize(0.06)
hist.GetZaxis().SetTitleSize(0.06)
hist.Draw('colz')
text = TPaveText(.55, .2, .80, .4, 'brNDC')
text.AddText("Events with")
text.AddText("M_{A} = %d GeV" % mA_value)
text.AddText("M_{H} = %d GeV" % mH_value)
text.SetTextColor(1)
text.SetFillStyle(4100)
text.Draw("same")
#hist.SetTitle(obj.GetTitle())
c1.Print(
path_pdf,
'Title:' + key.replace('.root', '').replace('/', ''))
except Exception as e:
logging.critical('Could not save %s due to error "%s"' %
(key, e))
if opt.PDF:
# canvas.Print(path_pdf)
# canvas.Print(path_pdf+']')
logging.info('PDF saved as %s' % path_pdf)
c1.Print(path_pdf + ']')
sys.exit()
#############################################################################################
# Make likelihood map #
#############################################################################################
# Get events from tree #
logging.info('Looking at file %s' % opt.file)
variables = [
'lep1_p4.Pt()',
'lep1_p4.Eta()',
'lep2_p4.Pt()',
'lep2_p4.Eta()',
'lep2_p4.Phi()-lep1_p4.Phi()',
'jet1_p4.Pt()',
'jet1_p4.Eta()',
'jet1_p4.Phi()-lep1_p4.Phi()',
'jet2_p4.Pt()',
'jet2_p4.Eta()',
'jet2_p4.Phi()-lep1_p4.Phi()',
'met_pt',
'met_phi-lep1_p4.Phi()',
]
events = Tree2Pandas(input_file=opt.file,
variables=variables,
n=opt.number).values
if events.shape[0] == 0:
raise RuntimeError("Did you forget -n ?")
# Instantiate the map #
likelihood = LikelihoodMap(name=opt.model,
xmin=opt.xmin,
ymin=opt.ymin,
xmax=opt.xmax,
ymax=opt.ymax,
N=300,
normalize=opt.norm)
# Loop over events #
logging.info('Adding events')
manager = enlighten.get_manager()
pbar = manager.counter(total=opt.number, desc='Progress', unit='Event')
for i in range(events.shape[0]):
likelihood.AddEvent(events[i, :])
pbar.update()
manager.stop()
# Make and print map #
likelihood.MakeGraph(title=os.path.basename(opt.file), suffix=opt.suffix)
def create2DPlots(detector, plot, plotnum, plotmat, dosingledetector=True):
"""Produce the requested plot for the specified detector.
Function that will plot the requested 2D-@plot for the
specified @detector. The specified detector could either be a
real detector or a compound one. The list of available plots
are the keys of plots dictionary imported from plot_utils.
"""
#gStyle.Reset()
#Better to use an underscore.
plotmat = plotmat.replace(" ", "_")
if plotmat != "":
theDirname = ('Images/%s' % plotmat).replace(" ", "")
else:
theDirname = 'Images'
if not checkFile_(theDirname):
os.mkdir(theDirname)
if not os.path.isdir(('Images/%s/ZPlusZoom' % plotmat).replace(" ", "")):
os.mkdir(('Images/%s/ZPlusZoom' % plotmat).replace(" ", ""))
if not os.path.isdir(('Images/%s/ZMinusZoom' % plotmat).replace(" ", "")):
os.mkdir(('Images/%s/ZMinusZoom' % plotmat).replace(" ", ""))
goodToGo, theDetectorFilename = paramsGood_(detector, plot)
if not goodToGo:
return
theDetectorFile = TFile(theDetectorFilename)
prof2d_X0_det_total = TProfile2D()
prof2d_X0_det_total.Reset()
# get TProfiles
#prof2d_X0_det_total = theDetectorFile.Get('%s' % plots[plot].plotNumber)
prof2d_X0_det_total = theDetectorFile.Get('%s' % plotnum)
print("==================================================================")
print(plotnum)
# histos
prof2d_X0_det_total.__class__ = TProfile2D
hist_X0_total = prof2d_X0_det_total.ProjectionXY()
# keep files live forever
files = []
if detector in COMPOUNDS.keys() and not dosingledetector:
#When the loop was:
#for subDetector in COMPOUNDS[detector][1:]:
#and the detector was single it never went in the loop and read the single file
#from above. I alter this to COMPOUNDS[detector] to do the multi material budget plot.
#This won't effect the single detector due to the alter in the if above
for subDetector in COMPOUNDS[detector]:
# filenames of single components
subDetectorFilename = "matbdg_%s.root" % subDetector
# open file
if not checkFile_(subDetectorFilename):
print("Error, missing file %s" % subDetectorFilename)
continue
subDetectorFile = TFile(subDetectorFilename)
files.append(subDetectorFile)
print("*** Open file... %s" % subDetectorFilename)
# subdetector profiles
prof2d_X0_det_total = subDetectorFile.Get('%s' %
plots[plot].plotNumber)
prof2d_X0_det_total.__class__ = TProfile2D
# add to summary histogram
hist_X0_total.Add(
prof2d_X0_det_total.ProjectionXY(
"B_%s" % prof2d_X0_det_total.GetName()), +1.000)
# # properties
#gStyle.SetPalette(1)
gStyle.SetStripDecimals(False)
# #
# Create "null" histo
minX = 1.03 * prof2d_X0_det_total.GetXaxis().GetXmin()
maxX = 1.03 * prof2d_X0_det_total.GetXaxis().GetXmax()
minY = 1.03 * prof2d_X0_det_total.GetYaxis().GetXmin()
maxY = 1.03 * prof2d_X0_det_total.GetYaxis().GetXmax()
frame = TH2F("frame", "", 10, minX, maxX, 10, minY, maxY)
frame.SetMinimum(0.1)
frame.SetMaximum(10.)
frame.GetXaxis().SetTickLength(frame.GetXaxis().GetTickLength() * 0.50)
frame.GetYaxis().SetTickLength(frame.GetXaxis().GetTickLength() / 4.)
# Ratio
if plots[plot].iRebin:
prof2d_X0_det_total.Rebin2D()
# stack
hist2dTitle = ('%s %s;%s;%s;%s' %
(plots[plot].quotaName, detector, plots[plot].abscissa,
plots[plot].ordinate, plots[plot].quotaName))
if dosingledetector:
hist2d_X0_total = prof2d_X0_det_total
else:
hist2d_X0_total = hist_X0_total
hist2d_X0_total.SetTitle(hist2dTitle)
frame.SetTitle(hist2dTitle)
frame.SetTitleOffset(0.5, "Y")
#If here you put different histomin,histomaxin plot_utils you won't see anything
#for the material plots.
if plots[plot].histoMin != -1.:
hist2d_X0_total.SetMinimum(plots[plot].histoMin)
if plots[plot].histoMax != -1.:
hist2d_X0_total.SetMaximum(plots[plot].histoMax)
#
can2name = "MBCan_2D_%s_%s_%s" % (detector, plot, plotmat)
can2 = TCanvas(can2name, can2name, 2480 + 248, 580 + 58 + 58)
can2.SetTopMargin(0.1)
can2.SetBottomMargin(0.1)
can2.SetLeftMargin(0.04)
can2.SetRightMargin(0.06)
can2.SetFillColor(kWhite)
gStyle.SetOptStat(0)
gStyle.SetTitleFillColor(0)
gStyle.SetTitleBorderSize(0)
#hist2d_X0_total.SetMaximum(hist2d_X0_total.GetMaximum())
# Color palette
# gStyle.SetPalette()#1
acustompalette()
ex1 = TExec("ex1", "acustompalette();")
ex1.Draw()
#for i in range(100): MyPaletteArray.append(i+1)
#gStyle.SetPalette(first_color_number);
# Log?
can2.SetLogz(plots[plot].zLog)
# Draw in colors
#frame.Draw()
#hist2d_X0_total.Draw("COLZsame") #Dummy draw to create the palette object
hist2d_X0_total.Draw("COLZ") #Dummy draw to create the palette object
# Store
can2.Update()
#Aesthetic
palette = hist2d_X0_total.GetListOfFunctions().FindObject("palette")
if palette:
palette.__class__ = TPaletteAxis
palette.SetX1NDC(0.945)
palette.SetX2NDC(0.96)
palette.SetY1NDC(0.1)
palette.SetY2NDC(0.9)
palette.GetAxis().SetTickSize(.01)
palette.GetAxis().SetTitle("")
if plots[plot].zLog:
palette.GetAxis().SetLabelOffset(-0.01)
paletteTitle = TLatex(1.12 * maxX, maxY, plots[plot].quotaName)
paletteTitle.SetTextAngle(90.)
paletteTitle.SetTextSize(0.05)
paletteTitle.SetTextAlign(31)
paletteTitle.Draw()
hist2d_X0_total.GetYaxis().SetTickLength(
hist2d_X0_total.GetXaxis().GetTickLength() / 4.)
hist2d_X0_total.GetYaxis().SetTickLength(
hist2d_X0_total.GetXaxis().GetTickLength() / 4.)
hist2d_X0_total.SetTitleOffset(0.5, "Y")
hist2d_X0_total.GetYaxis().SetTitleOffset(0.45)
#hist2d_X0_total.GetXaxis().SetTitleOffset(1.15);
#hist2d_X0_total.GetXaxis().SetNoExponent(True)
#hist2d_X0_total.GetYaxis().SetNoExponent(True)
#Add eta labels
keep_alive = []
if plots[plot].iDrawEta:
keep_alive.extend(drawEtaValues())
can2.Modified()
hist2d_X0_total.SetContour(255)
# Store
can2.Update()
can2.Modified()
can2.SaveAs("%s/%s_%s%s.pdf" % (theDirname, detector, plot, plotmat))
can2.SaveAs("%s/%s_%s%s.png" % (theDirname, detector, plot, plotmat))
#can2.SaveAs( "%s/%s_%s%s.root" % (theDirname, detector, plot, plotmat))
#Zoom in a little bit
if plot == "x_vs_z_vs_Rsum" or plot == "l_vs_z_vs_Rsum" or plot == "x_vs_z_vs_Rsumcos" or plot == "l_vs_z_vs_Rsumcos" or plot == "x_vs_z_vs_Rloc" or plot == "l_vs_z_vs_Rloc" or plot == "x_vs_z_vs_Rloccos" or plot == "l_vs_z_vs_Rloccos":
#Z+
#hist2d_X0_total.GetXaxis().SetLimits( 3100., 5200.)
if dosingledetector:
hist2d_X0_total.GetXaxis().SetRangeUser(3100., 5400.)
else:
hist2d_X0_total.GetXaxis().SetRangeUser(0., 7000.)
#Do not draw eta values in the zoom case
keep_alive = []
#hist2d_X0_total.Draw("COLZ")
can2.Update()
can2.Modified()
can2.SaveAs("%s/%s/%s_%s%s_ZplusZoom.pdf" %
(theDirname, "ZPlusZoom", detector, plot, plotmat))
can2.SaveAs("%s/%s/%s_%s%s_ZplusZoom.png" %
(theDirname, "ZPlusZoom", detector, plot, plotmat))
#Z-
#hist2d_X0_total.GetXaxis().SetLimits( 3100., 5200.)
if dosingledetector:
hist2d_X0_total.GetXaxis().SetRangeUser(-5400., -3100.)
else:
hist2d_X0_total.GetXaxis().SetRangeUser(0., -7000.)
#Do not draw eta values in the zoom case
keep_alive = []
#hist2d_X0_total.Draw("COLZ")
can2.Update()
can2.Modified()
can2.SaveAs("%s/%s/%s_%s%s_ZminusZoom.pdf" %
(theDirname, "ZMinusZoom", detector, plot, plotmat))
can2.SaveAs("%s/%s/%s_%s%s_ZminusZoom.png" %
(theDirname, "ZMinusZoom", detector, plot, plotmat))
gStyle.SetStripDecimals(True)
def drawTopoGeometryEtaPhi(geometry, colorBy, is2016):
if colorBy < ETACODE or colorBy > IPHI:
return
global box, c, h, leg
gROOT.Reset()
gStyle.SetOptStat(0)
c = TCanvas('c', "MuCTPi to Topo Geometry", 1400, 950)
c.Draw()
h = TH2F("h", "Muon Topo Geometry %i" % (2016 if is2016 else 2015), 10,
-2.6, 2.6, 10, -0.15, 6.4)
h.SetXTitle("#eta")
h.SetYTitle("#phi")
h.Draw()
box = TBox()
box.SetFillStyle(0)
box.SetLineColor(3)
circle = TArc()
if colorBy == IPHI:
leg = TLegend(0.9, 0.1, 0.98, 0.9)
else:
leg = TLegend(0.8, 0.1, 0.9, 0.35)
#leg.SetEntrySeparation(0.05)
#leg.SetNColumns(2)
codeInLegend = []
for MioctID in drawOrder:
#for MioctID in [3,4,5,6,7]:
MIOCT = geometry.getMIOCT(MioctID)
fillStyle = 3004
for cellIdx, TopoCell in enumerate(MIOCT.Decode.TopoCells):
if colorBy == ETACODE:
code = int(TopoCell["etacode"], 16)
elif colorBy == PHICODE:
code = int(TopoCell["phicode"], 16)
elif colorBy == IETA:
code = abs(int(TopoCell["ieta"]))
elif colorBy == IPHI:
code = int(TopoCell["iphi"])
else:
raise RuntimeError(
"Don't know how to color the eta-phi map (%r)" % colorBy)
color = colorMap2[code % len(colorMap2)]
fillStyle = fillStyleMap2[code % 4]
box.SetLineColor(color)
box.SetFillColor(color)
circle.SetLineColor(color)
circle.SetFillColor(color)
# corner 1
c1_x = float(TopoCell["etamin"])
c1_y = float(TopoCell["phimin"])
# corner 2
c2_x = float(TopoCell["etamax"])
c2_y = float(TopoCell["phimax"])
# center
c_x = float(TopoCell["ieta"])
c_y = float(TopoCell["iphi"])
#if code>63:
# continue
#print "cell %i : eta [%f - %f], phi [%f - %f]" % (cellIdx, c1_x, c2_x, c1_y, c2_y)
box.SetFillStyle(fillStyle)
b = box.DrawBox(c1_x, c1_y, c2_x, c2_y)
box.SetFillStyle(0)
box.DrawBox(c1_x, c1_y, c2_x, c2_y)
circle.DrawArc(c_x / 10., c_y / 10., 0.02)
if not code in codeInLegend:
codeInLegend += [code]
if colorBy == ETACODE:
leg.AddEntry(b, "etacode %i" % code, "lf")
elif colorBy == PHICODE:
leg.AddEntry(b, "phicode %i" % code, "f")
elif colorBy == IETA:
leg.AddEntry(b, "|ieta| %i" % code, "f")
elif colorBy == IPHI:
leg.AddEntry(b, "iphi %i" % code, "f")
leg.Draw()
c.Update()
if colorBy == ETACODE:
ext = "EtaCode"
elif colorBy == PHICODE:
ext = "PhiCode"
elif colorBy == IETA:
ext = "Eta"
elif colorBy == IPHI:
ext = "Phi"
c.SaveAs("TopoLayout%s%s.pdf" % ("2016" if is2016 else "2015", ext))
def analysis(hadron="Omega_ccc"):
gStyle.SetOptStat(0)
with open(r"databases/theory_yields.yaml") as fileparamyields:
paramyields = yaml.safe_load(fileparamyields)
models = paramyields["comparison_models_AA"][hadron]["models"]
collisions = paramyields["comparison_models_AA"][hadron]["collisions"]
brmodes = paramyields["comparison_models_AA"][hadron]["brmode"]
yranges = paramyields["comparison_models_AA"][hadron]["yrange"]
colors = paramyields["comparison_models_AA"][hadron]["colors"]
useshape = paramyields["comparison_models_AA"][hadron]["useshape"]
ymin = paramyields["comparison_models_AA"][hadron]["ymin"]
ymax = paramyields["comparison_models_AA"][hadron]["ymax"]
binanal = array("d", paramyields["comparison_models_AA"]["pt_binning"][hadron])
with open(r"databases/general.yaml") as fileparamgen:
paramgen = yaml.safe_load(fileparamgen)
histolist = [None] * len(models)
fin = TFile("../InputsTheory/" + useshape + ".root")
histo_norm = fin.Get("hdNdpt_norm") # this is the pT-shape normalized to unity
for icase, _ in enumerate(models):
histolist[icase] = histo_norm.Clone(
"dNdpt%s%s%s" % (models[icase], collisions[icase], brmodes[icase])
)
canvas = TCanvas("canvas", "A Simple Graph Example", 881, 176, 668, 616)
gStyle.SetOptStat(0)
canvas.SetHighLightColor(2)
canvas.Range(-1.25, -4.625, 11.25, 11.625)
canvas.SetFillColor(0)
canvas.SetBorderMode(0)
canvas.SetBorderSize(2)
canvas.SetLogy()
canvas.SetFrameBorderMode(0)
canvas.SetFrameBorderMode(0)
canvas.cd()
gPad.SetLogy()
hempty = TH2F("hempty", ";p_{T};Yields", 100, 0.0, 10.0, 100, ymin, ymax)
hempty.GetXaxis().SetTitle("p_{T}")
hempty.GetXaxis().SetLabelFont(42)
hempty.GetXaxis().SetTitleOffset(1)
hempty.GetXaxis().SetTitleFont(42)
hempty.GetYaxis().SetLabelFont(42)
hempty.GetYaxis().SetTitleOffset(1.35)
hempty.GetYaxis().SetTitleFont(42)
hempty.GetZaxis().SetLabelFont(42)
hempty.GetZaxis().SetTitleOffset(1)
hempty.GetZaxis().SetTitleFont(42)
hempty.Draw()
leg = TLegend(0.1471471, 0.6108291, 0.3018018, 0.8747885, "", "brNDC")
leg.SetBorderSize(1)
leg.SetLineColor(0)
leg.SetLineStyle(1)
leg.SetLineWidth(1)
leg.SetFillColor(0)
leg.SetTextSize(0.022)
leg.SetFillStyle(1001)
# each case represents a combination of expected dNdy,
# collision type and HP on the branching ratio.
for icase, _ in enumerate(models):
brmode = brmodes[icase]
collision = collisions[icase]
model = models[icase]
yrange = yranges[icase]
sigma_aa_b = paramgen["statistics"][collision]["sigmaAA_b"]
lumiaa_monthi_invnb = paramgen["statistics"][collision]["lumiAA_monthi_invnb"]
nevt = sigma_aa_b * lumiaa_monthi_invnb * 1e9 # luminosity given in nb-1
bratio = paramgen["branchingratio"][hadron][brmode]
yieldmid = paramyields[model][collision][yrange][hadron]
text = "%s N_{ev}(%s) = %.1f B, BR=%.5f%%" % (
model,
collision,
nevt / 1e9,
bratio * 100,
)
scalef = bratio * nevt * yieldmid
# before rebinning, the dNdpT is multiplied by the binwidth,
# branching ratios, expected dN/dy and number of events
# so that the yields can be simplied summed in rebinning process.
for ibin in range(histolist[icase].GetNbinsX()):
binwdith = histolist[icase].GetBinWidth(ibin + 1)
yvalue = histolist[icase].GetBinContent(ibin + 1)
histolist[icase].SetBinContent(ibin + 1, binwdith * scalef * yvalue)
histolist[icase] = histolist[icase].Rebin(
len(binanal) - 1, "histo_pred%s%s%s" % (model, collision, brmode), binanal
)
histolist[icase].SetLineColor(colors[icase])
histolist[icase].SetMarkerColor(colors[icase])
histolist[icase].SetLineWidth(2)
histolist[icase].Draw("same")
text = text + " Yield(tot)=%.2f" % (histolist[icase].Integral())
leg.AddEntry(histolist[icase], text, "pF")
leg.Draw()
canvas.SaveAs(hadron + "_results.pdf")
canvas.SaveAs(hadron + "_results.C")
foutput = TFile("foutput" + hadron + ".root", "recreate")
for icase, _ in enumerate(models):
foutput.cd()
histolist[icase].Write()
def drawROIGeometry(geometry, is2016):
outfn = "ROILayout%s.pdf" % ("2016" if is2016 else "2015")
global box, c, h, leg
gROOT.Reset()
gStyle.SetOptStat(0)
c = TCanvas('c', "MuCTPi Geometry %s" % "2016" if is2016 else "2015", 1400,
950)
c.Draw()
#h = TH2F("h","Muon Geometry",10,-2.6,2.6,10,-6.4,6.4)
h = TH2F("h", "Muon Geometry %s" % "2016" if is2016 else "2015", 10, -2.6,
2.6, 10, -0.15, 6.4)
h.SetXTitle("#eta")
h.SetYTitle("#phi")
h.Draw()
box = TBox()
box.SetFillStyle(0)
box.SetLineColor(3)
box.SetLineColor(3)
text = TLatex()
text.SetTextSize(0.005)
text.SetTextFont(42)
text.SetTextAlign(22)
secLabel = TLatex()
secLabel.SetTextSize(0.008)
secLabel.SetTextFont(42)
secLabel.SetTextAlign(22)
leg = TLegend(0.7, 0.1, 0.9, 0.4)
leg.SetEntrySeparation(0.05)
leg.SetNColumns(2)
#for MIOCT in geometry.getMIOCTs():
for colorIndex, MioctID in enumerate(drawOrder):
MIOCT = geometry.getMIOCT(MioctID)
firstBox = True
color = colorMap[colorIndex % len(colorMap)]
#print "Using color ",color
box.SetLineColor(color)
box.SetLineWidth(1)
for Sector in MIOCT.Sectors:
ymin = 10
ymax = -10
for ROI in Sector.ROIs:
c1_x = float(ROI["etamin"])
c1_y = float(ROI["phimin"])
c2_x = float(ROI["etamax"])
c2_y = float(ROI["phimax"])
ymin = min(ymin, c1_y)
ymax = max(ymax, c2_y)
#print "eta [%f - %f], phi [%f - %f]" % (c1_x,c2_x,c1_y,c2_y)
b = box.DrawBox(c1_x, c1_y, c2_x, c2_y)
text.DrawText((c1_x + c2_x) / 2, (c1_y + c2_y) / 2,
ROI["roiid"])
if firstBox:
firstBox = False
leg.AddEntry(b, "Slot %s" % MIOCT["slot"], "l")
if Sector["name"].startswith("B"):
if int(Sector["name"][1:]) < 32:
xpos = -0.02
ypos = (ymin + ymax) / 2 - 0.05
else:
xpos = 0.02
ypos = (ymin + ymax) / 2 + 0.03
secLabel.DrawText(xpos, ypos, Sector["name"])
leg.Draw()
c.Update()
c.SaveAs(outfn)
outfile_newF = TFile.Open('signal_proc_'+section+'.root','RECREATE')
# print ('outfile_newF = signal_proc'+section+'.root');
for i in range(1,len(bins)):
if (model=="par1_TH1" or model=="par1_TF1"):
theBaseData = TH1F('theBaseData_'+section+'_'+str(i),'Base Histogram for RooDataHist',
nGridPar1Bins,par1GridMin,par1GridMax)
newFormatInput = TH1D('bin_content_par1_'+str(i),'bincontent',
nGridPointsForNewF,par1GridMin,par1GridMax)
elif (model=="par1par2_TH2" or model=="par1par2_TF2"):
theBaseData = TH2F('theBaseData_'+section+'_'+str(i),'Base Histogram for RooDataHist',
nGridPar1Bins,par1GridMin,par1GridMax,
nGridPar2Bins,par2GridMin,par2GridMax)
newFormatInput = TH2D('bin_content_par1_par2_'+str(i),'bincontent',
nGridPointsForNewF,par1GridMin,par1GridMax,
nGridPointsForNewF,par2GridMin,par2GridMax)
elif (model=="par1par2par3_TH3" or model=="par1par2par3_TF3"):
theBaseData = TH3F('theBaseData_'+section+'_'+str(i),'Base Histogram for RooDataHist',
nGridPar1Bins,par1GridMin,par1GridMax,
nGridPar2Bins,par2GridMin,par2GridMax,
nGridPar3Bins,par3GridMin,par3GridMax)
newFormatInput = TH3D('bin_content_par1_par2_par3_'+str(i),'bincontent',
nGridPointsForNewF,par1GridMin,par1GridMax,
nGridPointsForNewF,par2GridMin,par2GridMax,
nGridPointsForNewF,par3GridMin,par3GridMax)
if i != len(bins) - 1:
# Open a txt file to save the parameters value for each DC:
myfile = open(
Module_path + '/Outputfiles/Calibration_files/' + 'DC' + str(j) +
'NoCorrected.cal', 'w')
# Create a new canvas, and customize it.
c1 = TCanvas('c1', 'DC' + str(j) + '_calibration', 400, 100, 1000, 700)
c1.SetFillColor(0)
c1.GetFrame().SetFillColor(21)
c1.GetFrame().SetBorderSize(6)
c1.GetFrame().SetBorderMode(-1)
for i in range(0, 160):
h_Q60vsQ = TH2F(
'h_Q60vsQ',
'DC' + str(j) + '_QV[60]:DC' + str(j) + '_QV[' + str(i) + ']',
1000, 0, 3000, 1000, 0, 3000)
h_Q60vsQ.SetFillColor(42)
h_Q60vsQ.SetYTitle('DC' + str(j) + '_QV[60]')
h_Q60vsQ.SetXTitle('DC' + str(j) + '_QV[' + str(i) + ']')
#h_Q60vsQ.SetStats(1)
gStyle.SetOptStat(1000000001) #only write the name of the histogram
mitree.Draw(
"DC" + str(j) + "_QV[60]:DC" + str(j) + "_QV[" + str(i) +
"]>>h_Q60vsQ", "", "col")
func = TF1('func', '[0] + [1]*x', 0, 2500)
fit = h_Q60vsQ.Fit('func', 'SQ') #Q (quit) for turn off the statistics
p0 = func.GetParameter(0)
p1 = func.GetParameter(1)
def findElectrons(opts):
### Load Python modules
import os
import math
import numpy as np
from array import array
from os.path import isdir, abspath
### Load ROOT modules
from ROOT import TClonesArray, TFile, TTree, gSystem, gROOT, AddressOf
from ROOT import TH2F, TH1F, TMath, TGraphAsymmErrors
###Load DAMPE libs
gSystem.Load("libDmpEvent.so")
gSystem.Load("libDmpEventFilter.so")
gSystem.Load("libDmpKernel.so")
gSystem.Load("libDmpService.so")
###Load DAMPE modules
from ROOT import DmpChain, DmpEvent, DmpFilterOrbit, DmpPsdBase, DmpCore
from ROOT import DmpSvcPsdEposCor, DmpVSvc #DmpRecPsdManager
import DMPSW
gROOT.SetBatch(True)
############################# Searching for electrons
####### Reading input files
#Creating DAMPE chain for input files
dmpch = DmpChain("CollectionTree")
#Reading input files
if not opts.input:
files = [f.replace("\n","") for f in open(opts.list,'r').readlines()]
for ifile, f in enumerate(files):
DMPSW.IOSvc.Set("InData/Read" if ifile == 0 else "InData/ReadMore",f)
if os.path.isfile(f):
dmpch.Add(f)
if opts.verbose:
print('\nInput file read: {} -> {}'.format(ifile,f))
else:
DMPSW.IOSvc.Set("InData/Read",opts.input)
if os.path.isfile(opts.input):
dmpch.Add(opts.input)
if opts.verbose:
print('\nInput file read: {}'.format(opts.input))
#Defining the total number of events
nevents = dmpch.GetEntries()
if opts.verbose:
print('\nTotal number of events: {}'.format(nevents))
print("\nPrinting the chain...\n")
dmpch.Print()
####### Setting the output directory to the chain
dmpch.SetOutputDir(abspath(opts.outputDir),"electrons")
####### Processing input files
###Histos
#Defining log binning
#np.logspace binning
nBins=1000
eMax=6
eMin=0
eBinning = np.logspace(eMin, eMax, num=(nBins+1))
#custom binning
'''
nBins = 1000
eMin=0.1
eMax=1000000
EDmax = []
EDEdge = []
EDstepX=np.log10(eMax/eMin)/nBins
for iedge in range(0, nBins):
EDEdge.append(eMin*pow(10,iedge*EDstepX))
EDmax.append(eMin*pow(10,(iedge+1)*EDstepX))
EDEdge.append(EDmax[-1])
Edges= array('d',EDEdge) # this makes a bound array for TH1F
'''
#Pointing
h_terrestrial_lat_vs_long = TH2F("h_terrestrial_lat_vs_long","latitude vs longitude",360,0,360,180,-90,90)
## Energy
h_energy_all = TH1F("h_energy_all","all particle energy",nBins,eBinning)
h_energyCut = TH1F("h_energyCut","all particle energy - 20 GeV cut",nBins,eBinning)
h_energyCut_SAAcut = TH1F("h_energyCut_SAAcut","all particle energy - 20 GeV cut (no SAA)",nBins,eBinning)
h_energyCut_noTrack = TH1F("h_energyCut_noTrack","all particle energy - 20 GeV cut (NO TRACK)",nBins,eBinning)
h_energyCut_Track = TH1F("h_energyCut_Track","all particle energy - 20 GeV cut (TRACK)",nBins,eBinning)
h_energyCut_TrackMatch = TH1F("h_energyCut_TrackMatch","all particle energy - 20 GeV cut (TRACK match)",nBins,eBinning)
##BGO
h_energyBGOl=[] #energy of BGO vertical layer (single vertical plane)
for BGO_idxl in range(14):
histoName = "h_energyBGOl_" + str(BGO_idxl)
histoTitle = "BGO energy deposit layer " + str(BGO_idxl)
tmpHisto = TH1F(histoName,histoTitle,1000,0,1e+6)
h_energyBGOl.append(tmpHisto)
h_energyBGOb = [] #energy of BGO lateral layer (single bars of a plane)
h_BGOb_maxEnergyFraction = [] #fraction of the maximum released energy for each bar on each layer of the BGO calorimeter
for BGO_idxl in range(14):
tmp_eLayer = []
for BGO_idxb in range(23):
histoName = "h_energyBGOl_" + str(BGO_idxl) + "_BGOb_" + str(BGO_idxb)
histoTitle = "BGO energy deposit layer " + str(BGO_idxl) + " bar " + str(BGO_idxb)
tmpHisto = TH1F(histoName,histoTitle,1000,0,1e+6)
tmp_eLayer.append(tmpHisto)
maxhistoName = "h_BGO_maxEnergyFraction_l_" + str(BGO_idxl)
maxhistoTitle = "fraction of the maximum released energy layer " + str(BGO_idxl)
tmpMaxHisto = TH1F(maxhistoName,maxhistoTitle,100,0,1)
h_BGOb_maxEnergyFraction.append(tmpMaxHisto)
h_energyBGOb.append(tmp_eLayer)
h_BGOl_maxEnergyFraction = TH1F("h_BGOl_maxEnergyFraction","Fraction of the maximum released energy",100,0,1)
h_thetaBGO = TH1F("h_thetaBGO","theta BGO",100,0,90)
##STK
h_STK_nTracks = TH1F("h_STK_nTracks","number of tracks",1000,0,1000)
h_STK_trackChi2norm = TH1F("h_STK_trackChi2norm","\chi^2/n track",100,0,200)
h_STK_nTracksChi2Cut = TH1F("h_STK_nTracksChi2Cut","number of tracks (\chi^2 cut)",1000,0,1000)
h_stk_cluster_XvsY = []
for iLayer in range(6):
hName = 'h_stkCluster_XvsY_l_'+str(iLayer)
hTitle = 'cluster X vs Y - plane '+str(iLayer)
tmpHisto = TH2F(hName,hTitle,1000,-500,500,1000,-500,500)
h_stk_cluster_XvsY.append(tmpHisto)
h_ThetaSTK = TH1F("h_ThetaSTK","theta STK",100,0,90)
h_deltaTheta = TH1F("h_deltaTheta","\Delta theta",500,-100,100)
h_resX_STK_BGO = TH1F("h_resX_STK_BGO","BGO/STK residue layer X",200,-1000,1000)
h_resY_STK_BGO = TH1F("h_resY_STK_BGO","BGO/STK residue layer Y",200,-1000,1000)
h_imapctPointSTK = TH2F("h_imapctPointSTK","STK impact point",1000,-500,500,1000,-500,500)
h_stk_chargeClusterX = TH1F("h_stk_chargeClusterX","STK charge on cluster X",10000,0,10000)
h_stk_chargeClusterY = TH1F("h_stk_chargeClusterY","STK charge on cluster Y",10000,0,10000)
##PSD
h_psd_ChargeX = []
for lidx in range (2):
histoName = "h_psd_ChargeX_l" + str(lidx)
histoTitle = "PSD X charge layer " + str(lidx)
tmpHisto = TH1F(histoName,histoTitle,10000,0,10000)
h_psd_ChargeX.append(tmpHisto)
h_psd_ChargeY = []
for lidx in range (2):
histoName = "h_psd_ChargeY_l" + str(lidx)
histoTitle = "PSD Y charge layer " + str(lidx)
tmpHisto = TH1F(histoName,histoTitle,10000,0,10000)
h_psd_ChargeY.append(tmpHisto)
###
### Analysis cuts
eCut = 50 #Energy cut in GeV
### DAMPE geometry
BGOzTop = 46.
BGOzBot = 448.
#Filtering for SAA
if not opts.mc:
DMPSW.IOSvc.Set("OutData/NoOutput", "True")
DMPSW.IOSvc.Initialize()
pFilter = DmpFilterOrbit("EventHeader")
pFilter.ActiveMe()
#Starting loop on files
if opts.debug:
if opts.verbose:
print('\nDebug mode activated... the number of chain events is limited to 1000')
nevents = 1000
for iev in xrange(nevents):
if opts.mc:
DmpVSvc.gPsdECor.SetMCflag(1)
pev=dmpch.GetDmpEvent(iev)
#Get latitude and longitude
longitude = pev.pEvtAttitude().lon_geo
latitude = pev.pEvtAttitude().lat_geo
#Get particle total energy
etot=pev.pEvtBgoRec().GetTotalEnergy()/1000.
h_energy_all.Fill(etot)
if etot < eCut:
continue
h_energyCut.Fill(etot)
#Get BGO energy deposit for each layer (vertical BGO shower profile)
v_bgolayer = np.array([pev.pEvtBgoRec().GetELayer(ibgo) for ibgo in range(14)])
for BGO_idxl in range(14):
h_energyBGOl[BGO_idxl].Fill(v_bgolayer[BGO_idxl])
#Get BGO energy deposit for each bar (lateral BGO shower profile) of each layer
for ilay in xrange(0,14):
v_bgolayer_bars = np.array([pev.pEvtBgoRec().GetEdepPos(ilay,ibar) for ibar in xrange(0,23)])
#Fraction of the maximum energy deposit of the particle crossing the BGO on a certain layer (single bars)
h_BGOb_maxEnergyFraction[ilay].Fill(np.max(v_bgolayer_bars)/1000./etot)
for idx_BGOb in range (23):
h_energyBGOb[ilay][idx_BGOb].Fill(v_bgolayer_bars[idx_BGOb])
#Fraction of the maximum energy deposit of the particle crossing the BGO
h_BGOl_maxEnergyFraction.Fill(np.max(v_bgolayer)/1000./etot)
#BGO acceptance projection
projectionX_BGO_BGOTop = pev.pEvtBgoRec().GetInterceptXZ() +BGOzTop * pev.pEvtBgoRec().GetSlopeXZ()
projectionY_BGO_BGOTop = pev.pEvtBgoRec().GetInterceptYZ() +BGOzTop * pev.pEvtBgoRec().GetSlopeYZ()
#SAA filter
if not opts.mc:
inSAA = pFilter.IsInSAA(pev.pEvtHeader().GetSecond())
#inSAA = False
if (inSAA):
continue
h_energyCut_SAAcut.Fill(etot)
h_terrestrial_lat_vs_long.Fill(longitude,latitude)
tgZ = math.atan(np.sqrt( (pev.pEvtBgoRec().GetSlopeXZ()*pev.pEvtBgoRec().GetSlopeXZ()) + (pev.pEvtBgoRec().GetSlopeYZ()*pev.pEvtBgoRec().GetSlopeYZ()) ) );
theta_bgo = tgZ*180./math.pi
h_thetaBGO.Fill(theta_bgo)
#Tracks
ntracks = pev.NStkKalmanTrack()
if ntracks < 0:
print "\nTRACK ERROR: number of tracks < 0 - ABORTING\n"
break
if ntracks == 0:
h_energyCut_noTrack.Fill(etot)
h_STK_nTracks.Fill(ntracks)
h_energyCut_Track.Fill(etot)
res_X_min = 1000
res_Y_min = 1000
trackID_X = -9
trackID_Y = -9
lTrackIDX = []
lTrackIDY = []
residueXmin = []
residueYmin = []
#Loop on STK tracks to get the STK charge measurement
for iTrack in range(ntracks):
tmpTrack = pev.pStkKalmanTrack(iTrack)
chi2_norm = tmpTrack.getChi2()/(tmpTrack.getNhitX()+tmpTrack.getNhitY()-4)
h_STK_trackChi2norm.Fill(chi2_norm)
if chi2_norm > 25:
continue
h_STK_nTracksChi2Cut.Fill(ntracks)
l0ClusterX = l0ClusterY = False
for iCluster in range(tmpTrack.GetNPoints()):
clux = tmpTrack.pClusterX(iCluster)
cluy = tmpTrack.pClusterY(iCluster)
if clux and clux.getPlane() == 0:
l0ClusterX = True
if cluy and cluy.getPlane() == 0:
l0ClusterY = True
# check plot for the dead region of STK
if(clux and cluy):
h_stk_cluster_XvsY[clux.getPlane()].Fill(clux.GetX(),cluy.GetY())
if l0ClusterX == False and l0ClusterY == False:
continue
#### Tracks characteristics
theta_stk =math.acos(tmpTrack.getDirection().CosTheta())*180./math.pi;
delta_theta_STK_BGO = theta_stk - theta_bgo
#STK impact point
trackImpactPointX = tmpTrack.getImpactPoint().x()
trackImpactPointY = tmpTrack.getImpactPoint().y()
#Track projections
trackProjX = tmpTrack.getDirection().x()*(BGOzTop - tmpTrack.getImpactPoint().z()) + tmpTrack.getImpactPoint().x()
trackProjY = tmpTrack.getDirection().y()*(BGOzTop - tmpTrack.getImpactPoint().z()) + tmpTrack.getImpactPoint().y()
#Track residues
resX_STK_BGO = projectionX_BGO_BGOTop - trackProjX
resY_STK_BGO = projectionY_BGO_BGOTop - trackProjY
resX_STK_BGO_top = trackImpactPointX - (pev.pEvtBgoRec().GetInterceptXZ() + tmpTrack.getImpactPoint().z() * pev.pEvtBgoRec().GetSlopeXZ())
resY_STK_BGO_top = trackImpactPointY - (pev.pEvtBgoRec().GetInterceptYZ() + tmpTrack.getImpactPoint().z() * pev.pEvtBgoRec().GetSlopeYZ())
####
h_ThetaSTK.Fill(theta_stk)
h_deltaTheta.Fill(delta_theta_STK_BGO)
h_imapctPointSTK.Fill(trackImpactPointX,trackImpactPointY)
h_resX_STK_BGO.Fill(tmpTrack.getImpactPoint().x() - (pev.pEvtBgoRec().GetInterceptXZ() + tmpTrack.getImpactPoint().z() * pev.pEvtBgoRec().GetSlopeXZ()))
h_resY_STK_BGO.Fill(tmpTrack.getImpactPoint().y() - (pev.pEvtBgoRec().GetInterceptYZ() + tmpTrack.getImpactPoint().z() * pev.pEvtBgoRec().GetSlopeYZ()))
if abs(theta_stk - theta_bgo) > 25:
continue
#Selecting good tracks for charge measurement
if abs(resX_STK_BGO_top) < 200 and abs(resX_STK_BGO) < 60:
lTrackIDX.append(tmpTrack)
residueXmin.append(res_X_min)
if res_X_min > abs(resX_STK_BGO_top):
res_X_min = abs(resX_STK_BGO_top)
trackID_X = iTrack
if abs(resY_STK_BGO_top) < 200 and abs(resY_STK_BGO) < 60:
lTrackIDY.append(tmpTrack)
residueYmin.append(res_Y_min)
if res_Y_min > abs(resY_STK_BGO_top):
res_Y_min = abs(resY_STK_BGO_top)
trackID_Y = iTrack
if(trackID_X == -9):
continue
if(trackID_Y == -9):
continue
track_ID = -9
#print trackID_X
if(trackID_X == trackID_Y):
track_ID = trackID_X
else:
trackX = pev.pStkKalmanTrack(trackID_X)
trackY = pev.pStkKalmanTrack(trackID_Y)
chi2X = trackX.getChi2() /(trackX.getNhitX()+trackX.getNhitY()-4);
chi2Y = trackY.getChi2() /(trackY.getNhitX()+trackY.getNhitY()-4);
npointX = trackX.GetNPoints()
npointY = trackY.GetNPoints()
if(npointX == npointY or abs(npointX - npointY) == 1):
if(chi2X < chi2Y):
if trackID_X in lTrackIDY:
track_ID = trackID_X
elif trackID_Y in lTrackIDX:
track_ID = trackID_Y
else:
common_id = list(set(lTrackIDX).intersection(lTrackIDY))
searchForTrack(
common_id,
lTrackIDX,
lTrackIDY,
residueXmin,
residueYmin,
track_ID
)
else:
if trackID_Y in lTrackIDX:
track_ID = trackID_Y
elif trackID_X in lTrackIDY:
track_ID = trackID_X
else:
common_id = list(set(lTrackIDX).intersection(lTrackIDY))
searchForTrack(
common_id,
lTrackIDX,
lTrackIDY,
residueXmin,
residueYmin,
track_ID
)
else:
if(npointX > npointY):
if trackID_X in lTrackIDY:
track_ID = trackID_X
elif trackID_Y in lTrackIDX:
track_ID = trackID_Y
else:
common_id = list(set(lTrackIDX).intersection(lTrackIDY))
searchForTrack(
common_id,
lTrackIDX,
lTrackIDY,
residueXmin,
residueYmin,
track_ID
)
else:
if trackID_Y in lTrackIDX:
track_ID = trackID_Y
elif trackID_X in lTrackIDY:
track_ID = trackID_X
else:
common_id = list(set(lTrackIDX).intersection(lTrackIDY))
searchForTrack(
common_id,
lTrackIDX,
lTrackIDY,
residueXmin,
residueYmin,
track_ID
)
if(track_ID == -9):
continue
h_energyCut_TrackMatch.Fill(etot)
#Select the matched track
track_sel = pev.pStkKalmanTrack(track_ID)
theta_track_sel =math.acos(track_sel.getDirection().CosTheta())*180./math.pi;
deltaTheta_rec_sel = theta_bgo - theta_track_sel
track_correction = track_sel.getDirection().CosTheta();
cluChargeX = -1000
cluChargeY = -1000
for iclu in xrange(0,track_sel.GetNPoints()):
clux = track_sel.pClusterX(iclu)
cluy = track_sel.pClusterY(iclu)
if (clux and clux.getPlane() == 0):
cluChargeX = clux.getEnergy()*track_correction
if (cluy and cluy.getPlane() == 0):
cluChargeY = cluy.getEnergy()*track_correction
h_stk_chargeClusterX.Fill(cluChargeX)
h_stk_chargeClusterY.Fill(cluChargeY)
#Loop on PSD hits to get PSD charge measurement
'''
#PSD fiducial volume cut
psd_YZ_top = -324.7
psd_XZ_top = -298.5
stk_to_psd_topY = (track_sel.getDirection().y()*(psd_YZ_top - track_sel.getImpactPoint().z()) + track_sel.getImpactPoint().y())
stk_to_psd_topX = (track_sel.getDirection().x()*(psd_XZ_top - track_sel.getImpactPoint().z()) + track_sel.getImpactPoint().x())
if(abs(stk_to_psd_topX) > 400.):
continue
if(abs(stk_to_psd_topY) > 400.):
continue
'''
PSDXlayer0 = -298.5
PSDXlayer1 = -284.5
PSDYlayer0 = -324.7
PSDYlayer1 = -310.7
psdChargeX = [[]for _ in range(2)]
psdGIDX = [[]for _ in range(2)]
psdPathlengthX = [[]for _ in range(2)]
psdPositionX = [[]for _ in range(2)]
psdChargeY = [[]for _ in range(2)]
psdGIDY = [[]for _ in range(2)]
psdPathlengthY = [[]for _ in range(2)]
psdPositionY = [[]for _ in range(2)]
for lPSD in xrange(0,pev.NEvtPsdHits()):
if pev.pEvtPsdHits().IsHitMeasuringX(lPSD):
crossingX = False
lenghtX = [-99999.,-99999.]
array_lenghtX = array('d',lenghtX)
if(pev.pEvtPsdHits().GetHitZ(lPSD) == PSDXlayer0):
npsdX = 0
if(pev.pEvtPsdHits().GetHitZ(lPSD)== PSDXlayer1):
npsdX = 1
if not opts.mc:
crossingX = DmpVSvc.gPsdECor.GetPathLengthPosition(pev.pEvtPsdHits().fGlobalBarID[lPSD],track_sel.getDirection(),track_sel.getImpactPoint(), array_lenghtX)
if crossingX:
psdChargeX[npsdX].append(pev.pEvtPsdHits().fEnergy[lPSD])
psdGIDX[npsdX].append(pev.pEvtPsdHits().fGlobalBarID[lPSD])
psdPathlengthX[npsdX].append(array_lenghtX[1])
psdPositionX[npsdX].append(pev.pEvtPsdHits().GetHitX(lPSD))
elif pev.pEvtPsdHits().IsHitMeasuringY(lPSD):
crossingY = False
lenghtY = [-99999.,-99999.]
array_lenghtY = array('d',lenghtY)
if(pev.pEvtPsdHits().GetHitZ(lPSD) == PSDYlayer0):
npsdY = 0
if(pev.pEvtPsdHits().GetHitZ(lPSD)== PSDYlayer1):
npsdY = 1
if not opts.mc:
crossingY = DmpVSvc.gPsdECor.GetPathLengthPosition(pev.pEvtPsdHits().fGlobalBarID[lPSD],track_sel.getDirection(),track_sel.getImpactPoint(), array_lenghtY)
if crossingY:
psdChargeY[npsdY].append(pev.pEvtPsdHits().fEnergy[lPSD])
psdGIDY[npsdY].append(pev.pEvtPsdHits().fGlobalBarID[lPSD])
psdPathlengthY[npsdY].append(array_lenghtY[1])
psdPositionY[npsdY].append(pev.pEvtPsdHits().GetHitY(lPSD))
'''
print psdChargeX
print psdGIDX
print psdPathlengthX
print psdPositionX
print psdChargeY
print psdGIDY
print psdPathlengthY
print psdPositionY
'''
psdFinalChargeX = [-999,-999]
psdFinalChargeY = [-999,-999]
#psdFinalChargeX_corr = [-999,-999]
#psdFinalChargeY_corr = [-999,-999]
psdFinalChargeX_proj = [-999,-999]
psdFinalChargeY_proj = [-999,-999]
psdX_pathlength = [-999,-999]
psdY_pathlength = [-999,-999]
psdX_position = [-999,-999]
psdY_position = [-999,-999]
PsdEC_tmpX = 0.
PsdEC_tmpY = 0.
for ipsd in xrange(0,2):
if(len(psdChargeY[ipsd]) > 0):
pos_max_len = np.argmax(psdPathlengthY[ipsd])
lenghtY = [-99999.,-99999.]
array_lenghtY = array('d',lenghtY)
test_pos = False
if not opts.mc:
test_pos = DmpVSvc.gPsdECor.GetPathLengthPosition(psdGIDY[ipsd][pos_max_len],track_sel.getDirection(),track_sel.getImpactPoint(), array_lenghtY)
'''
PsdEC_tmpY = -1.
if test_pos:
PsdEC_tmpY = DmpVSvc.gPsdECor.GetPsdECorSp3(psdGIDY[ipsd][pos_max_len], array_lenghtY[0])
'''
psdFinalChargeY[ipsd] = psdChargeY[ipsd][pos_max_len]
h_psd_ChargeY[ipsd].Fill(psdFinalChargeY[ipsd])
#psdFinalChargeY_corr[ipsd] = psdChargeY[ipsd][pos_max_len]*PsdEC_tmpY
psdFinalChargeY_proj[ipsd] = array_lenghtY[0]
psdY_pathlength[ipsd] = array_lenghtY[1]
psdY_position[ipsd] = psdPositionY[ipsd][pos_max_len]
if(len(psdChargeX[ipsd]) > 0):
pos_max_len = np.argmax(psdPathlengthX[ipsd])
lenghtX = [-99999.,-99999.]
array_lenghtX = array('d',lenghtX)
test_pos = False
if not opts.mc:
test_pos = DmpVSvc.gPsdECor.GetPathLengthPosition(psdGIDX[ipsd][pos_max_len],track_sel.getDirection(),track_sel.getImpactPoint(), array_lenghtY)
'''
PsdEC_tmpY = -1.
if test_pos:
PsdEC_tmpX = DmpVSvc.gPsdECor.GetPsdECorSp3(psdGIDX[ipsd][pos_max_len], array_lenghtX[0])
'''
psdFinalChargeX[ipsd] = psdChargeX[ipsd][pos_max_len]
h_psd_ChargeX[ipsd].Fill(psdFinalChargeX[ipsd])
#psdFinalChargeX_corr[ipsd] = psdChargeX[ipsd][pos_max_len]*PsdEC_tmpX
psdFinalChargeX_proj[ipsd] = array_lenghtX[0]
psdX_pathlength[ipsd] = array_lenghtX[1]
psdX_position[ipsd] = psdPositionX[ipsd][pos_max_len]
### Writing output files to file
if opts.data:
tf_skim = TFile(opts.outputFile,"RECREATE")
h_energy_all.Write()
h_energyCut.Write()
h_energyCut_SAAcut.Write()
h_energyCut_noTrack.Write()
h_energyCut_Track.Write()
h_energyCut_TrackMatch.Write()
for BGO_idxl in range(14):
h_energyBGOl[BGO_idxl].Write()
h_BGOb_maxEnergyFraction[BGO_idxl].Write()
for BGO_idxb in range(23):
h_energyBGOb[BGO_idxl][BGO_idxb].Write()
h_thetaBGO.Write()
h_BGOl_maxEnergyFraction.Write()
h_terrestrial_lat_vs_long.Write()
h_STK_nTracks.Write()
h_STK_trackChi2norm.Write()
h_STK_nTracksChi2Cut.Write()
for iLayer in range(6):
h_stk_cluster_XvsY[iLayer].Write()
h_ThetaSTK.Write()
h_deltaTheta.Write()
h_imapctPointSTK.Write()
h_resX_STK_BGO.Write()
h_resY_STK_BGO.Write()
h_stk_chargeClusterX.Write()
h_stk_chargeClusterY.Write()
h_psd_ChargeX[0].Write()
h_psd_ChargeX[1].Write()
h_psd_ChargeY[0].Write()
h_psd_ChargeY[1].Write()
tf_skim.Close()
def recenergy(name, chivalue):
outputfile = "KaonEnergyRes_" + str(chivalue) + "_" + str(name)
displayfile = TFile(outputfile + ".root", "RECREATE")
'''
if name == "FTFPBERT":
chi = 0.3
if name == "FTFPBERTTRV":
chi = 0.3
if name == "QGSPBERT":
chi = 0.3
if name == "QBBC":
chi = 0.3
'''
MeanEnergyScin = array('d')
MeanEnergyCher = array('d')
Energy = array('d')
Energyerror = array('d')
energyfractionscin = array('d')
energyfractionscinerror = array('d')
energyfractioncher = array('d')
energyfractionchererror = array('d')
energyfraction = array('d')
energyfractionerror = array('d')
resolutionscin = array('d')
resolutionscinerror = array('d')
resolutioncher = array('d')
resolutionchererror = array('d')
resolution = array('d')
resolutionerror = array('d')
chiarray = array('d')
chierrorarray = array('d')
zeros = array('d')
containment = array('d')
containmenterror = array('d')
t = [10, 30, 50, 70, 100, 120, 140, 150]
t = [100]
sqrtenergies = array('d', [1 / (x**0.5) for x in t])
energies = array('d', t)
#inputfiles = ["/home/software/Calo/results/energycont_2p0m/Pion_"+str(i)+".root" for i in t]
#inputfiles = ["/home/software/Calo/results/pionenergyscan_QGSPBICHP/Pion_"+str(i)+".root" for i in t]
#inputfiles = ["/home/lorenzo/Desktop/Calo/newresults/FTFPBERTTRV/Pion_"+str(i)+"_FTFPBERTTRV_office.root" for i in t]
#inputfiles = ["/Users/lorenzo/Desktop/ToPC/newresults/"+str(name)+"/Pion_"+str(i)+".root" for i in t]
#inputfiles = ["/home/lorenzo/Calo/results/Pion_25_3_2020/"+str(name)+""+"/Pion_"+str(i)+".root" for i in t]
#inputfiles = ["/home/lorenzo/Calo/results/geant4.10.4.p01/Pion_30_4_2020/"+str(name)+""+"/Pion_"+str(i)+".root" for i in t]
#inputfiles = ["/home/lorenzo/Calo/results/Proton_25_3_2020/"+str(name)+""+"/Proton_"+str(i)+".root" for i in t]
#inputfiles = ["/home/lorenzo/Calo/results/Neutron_25_3_2020/"+str(name)+""+"/Neutron_"+str(i)+".root" for i in t]
inputfiles = [
"/home/lorenzo/Calo/results/Kaon_5_4_2020/" + str(name) + "" +
"/Kaon_" + str(i) + ".root" for i in t
]
for counter, inputfile in enumerate(inputfiles):
inputfile = TFile(inputfile)
print "Analyzing: " + str(inputfile) + " \n"
tree = TTree()
inputfile.GetObject("B4", tree)
ScinEnergyHist = TH1F("scinenergy_" + str(t[counter]),
str(t[counter]) + "_scin", 400, 0., 200.)
CherEnergyHist = TH1F("cherenergy_" + str(t[counter]),
str(t[counter]) + "_cher", 400, 0., 200.)
RecEnergyHist = TH1F("RecEnergy_" + str(t[counter]),
str(t[counter]) + "_Energy", 400, 0., 200.)
#Signalscinhist = TH1F("scintot_", str(counter+1)+"_scin", 3000, 0., 30000)
EnergyHist = TH1F("Energy_" + str(t[counter]),
str(t[counter]) + "_Energy", 400, 0., 200.)
LeakageHist = TH1F("Leak_" + str(t[counter]),
str(t[counter]) + "_Leak", 1000, 0., 100.)
NeutrinoLeakageHist = TH1F("NeutrinoNeutrinoLeak_" + str(t[counter]),
str(t[counter]) + "_Leak", 1000, 0., 100.)
TotalLeakageHist = TH1F("TotalLeak_" + str(t[counter]),
str(t[counter]) + "_Leak", 1000, 0., 100.)
ChiHist = TH1F("Chi_" + str(t[counter]),
str(t[counter]) + "_Chi", 200, 0., 2.)
scatterplot = TH2F("scatterplot_" + str(t[counter]), str(t[counter]),
int(400), 0., 200., int(400), 0., 200.)
EnergyContHist = TH1F("EnergyCont_" + str(t[counter]),
str(t[counter]) + "_EnergyCont", 400, 0., 200.)
hesscatterplot = TH2F("H/E_S" + str(t[counter]),
"H/E_S" + str(t[counter]), 200, 0., 1.1, 200, 0.,
1.1)
hecscatterplot = TH2F("H/E_C" + str(t[counter]),
"H/E_C" + str(t[counter]), 200, 0., 1.1, 200, 0.,
1.1)
#loop over events
entries = 50000
for Event in range(entries):
tree.GetEntry(Event)
if Event % 1000 == 0:
print Event
#Set values of the tree
PrimaryParticleName = tree.PrimaryParticleName # MC truth: primary particle Geant4 name
PrimaryParticleEnergy = tree.PrimaryParticleEnergy
EnergyTot = tree.EnergyTot # Total energy deposited in calorimeter
Energyem = tree.Energyem # Energy deposited by the em component
EnergyScin = tree.EnergyScin # Energy deposited in Scin fibers (not Birk corrected)
EnergyCher = tree.EnergyCher # Energy deposited in Cher fibers (not Birk corrected)
NofCherenkovDetected = tree.NofCherenkovDetected # Total Cher p.e. detected
BarrelR_VectorSignals = tree.VectorSignalsR # Vector of energy deposited in Scin fibers (Birk corrected)
BarrelL_VectorSignals = tree.VectorSignalsL # Vector of energy deposited in Scin fibers (Birk corrected)
BarrelR_VectorSignalsCher = tree.VectorSignalsCherR # Vector of Cher p.e. detected in Cher fibers
BarrelL_VectorSignalsCher = tree.VectorSignalsCherL
VectorR = tree.VectorR
VectorL = tree.VectorL
Leak = tree.leakage
NeutrinoLeak = tree.neutrinoleakage
#totalsignalscin = sum(BarrelR_VectorSignals)+sum(BarrelL_VectorSignals)
#Signalscinhist.Fill(totalsignalscin)
energytot = (sum(VectorR) + sum(VectorL)) / 1000
EnergyHist.Fill(energytot)
LeakageHist.Fill(Leak / 1000.)
NeutrinoLeakageHist.Fill(NeutrinoLeak / 1000.)
TotalLeakageHist.Fill(Leak / 1000. + NeutrinoLeak / 1000.)
if float(t[counter]) < 12.:
cutleak = 0.5
if float(t[counter]) > 12. and float(t[counter]) < 50.:
cutleak = 1.0
if float(t[counter]) > 50.:
cutleak = 3.0
if (Leak / 1000. + NeutrinoLeak / 1000.) < cutleak:
#apply calibrations
Calib_BarrelL_VectorSignals = calibration.calibscin(
BarrelL_VectorSignals)
Calib_BarrelR_VectorSignals = calibration.calibscin(
BarrelR_VectorSignals)
Calib_BarrelL_VectorSignalsCher = calibration.calibcher(
BarrelL_VectorSignalsCher)
Calib_BarrelR_VectorSignalsCher = calibration.calibcher(
BarrelR_VectorSignalsCher)
#end of calibrations
energyscin = sum(Calib_BarrelR_VectorSignals) + sum(
Calib_BarrelL_VectorSignals)
energycher = sum(Calib_BarrelR_VectorSignalsCher) + sum(
Calib_BarrelL_VectorSignalsCher)
e_c = float(t[counter]) - (Leak / 1000. + NeutrinoLeak / 1000.)
hesscatterplot.Fill(Energyem / 1000. / e_c, energyscin / e_c)
hecscatterplot.Fill(Energyem / 1000. / e_c, energycher / e_c)
EnergyContHist.Fill(e_c)
ScinEnergyHist.Fill(energyscin)
CherEnergyHist.Fill(energycher)
scatterplot.Fill(energyscin / float(t[counter]),
energycher / float(t[counter]))
chi = chivalue
newchi = (energyscin - e_c) / (energycher - e_c)
ChiHist.Fill(newchi)
RecEnergyHist.Fill(
1. / 0.99 * (energyscin - chi * energycher) / (1. - chi))
print energies[counter], ScinEnergyHist.GetMean(
), CherEnergyHist.GetMean(), RecEnergyHist.GetMean()
displayfile.cd()
gStyle.SetOptStat(111)
#ScinEnergyHist.Fit("gaus")
#CherEnergyHist.Fit("gaus")
#RecEnergyHist.Scale(1/RecEnergyHist.Integral())
#print RecEnergyHist.Integral()
RecEnergyHist.Fit("gaus")
RecEnergyHist.Write()
ScinEnergyHist.Write()
CherEnergyHist.Write()
#Signalscinhist.Write()
EnergyHist.Write()
EnergyContHist.Write()
e_cont = EnergyContHist.GetMean()
e_cont_error = EnergyContHist.GetRMS() / float(entries)**0.5
scatterplot.Write()
#cut1 = TCutG("cut1",4)
#cut1.SetVarX("x")
#cut1.SetVarY("y")
#cut1.SetPoint(0,0.,0.)
#cut1.SetPoint(1,1.,0.)
#cut1.SetPoint(2,1.,1.)
#cut1.SetPoint(3,0.,1.)
#profile = scatterplot.ProfileX("",1,400,"[cut1]")
#profile.GetYaxis().SetRangeUser(0.,1.5)
#profile.Write()
func2 = TF1("func2", '[0]+x*(1.-[0])', 0., 1.)
pp = hesscatterplot.ProfileX()
pp.Fit(func2)
pp.Write()
hesscatterplot.Write()
hecscatterplot.Write()
ppc = hecscatterplot.ProfileX()
ppc.Fit(func2)
ppc.Write()
LeakageHist.Write()
NeutrinoLeakageHist.Write()
TotalLeakageHist.Write()
ChiHist.Write()
#scin_sqrtenergies.append(1./(ScinEnergyHist.GetFunction("gaus").GetParameter(1)**0.5))
#cher_sqrtenergies.append(1./(CherEnergyHist.GetFunction("gaus").GetParameter(1)**0.5))
Energy.append(RecEnergyHist.GetFunction("gaus").GetParameter(1))
Energyerror.append(3. *
RecEnergyHist.GetFunction("gaus").GetParameter(2) /
float(entries)**0.5)
MeanEnergyScin.append(ScinEnergyHist.GetMean())
MeanEnergyCher.append(CherEnergyHist.GetMean())
resolution.append(
RecEnergyHist.GetFunction("gaus").GetParameter(2) /
RecEnergyHist.GetFunction("gaus").GetParameter(1))
sigma_energy_e = (
(RecEnergyHist.GetFunction("gaus").GetParameter(2) /
(float(entries)**0.5)) /
RecEnergyHist.GetFunction("gaus").GetParameter(1) +
RecEnergyHist.GetFunction("gaus").GetParError(2) /
RecEnergyHist.GetFunction("gaus").GetParameter(2)) * (
RecEnergyHist.GetFunction("gaus").GetParameter(2) /
RecEnergyHist.GetFunction("gaus").GetParameter(1))
resolutionerror.append(sigma_energy_e)
energyfractionscin.append(ScinEnergyHist.GetMean() / float(t[counter]))
energyfractionscinerror.append(
3 * (ScinEnergyHist.GetRMS() / entries**0.5) / float(t[counter]))
energyfractioncher.append(CherEnergyHist.GetMean() / float(t[counter]))
energyfractionchererror.append(
3 * (CherEnergyHist.GetRMS() / entries**0.5) / float(t[counter]))
energyfraction.append(
RecEnergyHist.GetFunction("gaus").GetParameter(1) /
float(t[counter]))
energyfractionerror.append(
3 * (RecEnergyHist.GetFunction("gaus").GetParameter(2) /
entries**0.5) / float(t[counter]))
resolutionscin.append(ScinEnergyHist.GetRMS() /
ScinEnergyHist.GetMean())
sigma_energy_e = (
ScinEnergyHist.GetMeanError() / ScinEnergyHist.GetMean() +
ScinEnergyHist.GetRMSError() / ScinEnergyHist.GetRMS()) * (
ScinEnergyHist.GetRMS() / ScinEnergyHist.GetMean())
resolutionscinerror.append(sigma_energy_e)
resolutioncher.append(CherEnergyHist.GetRMS() /
CherEnergyHist.GetMean())
sigma_energy_e = (
CherEnergyHist.GetMeanError() / CherEnergyHist.GetMean() +
CherEnergyHist.GetRMSError() / CherEnergyHist.GetRMS()) * (
CherEnergyHist.GetRMS() / CherEnergyHist.GetMean())
resolutionchererror.append(sigma_energy_e)
chiarray.append(ChiHist.GetBinCenter(ChiHist.GetMaximumBin()))
chierrorarray.append(3 * ChiHist.GetRMS() / (entries**0.5))
zeros.append(0.0)
containment.append(e_cont / float(t[counter]))
containmenterror.append(e_cont_error / float(t[counter]))
containmentgraph = TGraphErrors(len(energies), energies, containment,
zeros, containmenterror)
containmentgraph.SetName("containment")
containmentgraph.Write()
ChiGraph = TGraphErrors(len(energies), energies, chiarray, zeros,
chierrorarray)
ChiGraph.SetName("Chi")
ChiGraph.Write()
LinearityGraph2 = TGraphErrors(len(energies), energies, Energy, zeros,
Energyerror)
LinearityGraph2.SetName("LinearityGraph2")
LinearityGraph2.Write()
LinearityGraph = TGraphErrors(len(energies), energies, energyfraction,
zeros, energyfractionerror)
LinearityGraph.SetName("LinearityGraph")
LinearityGraph.Write()
LinearityGraphScin = TGraphErrors(len(energies), energies,
energyfractionscin, zeros,
energyfractionscinerror)
LinearityGraphCher = TGraphErrors(len(energies), energies,
energyfractioncher, zeros,
energyfractionchererror)
LinearityGraphCher.SetName("LinearityGraphCher")
LinearityGraphCher.Write()
LinearityGraphScin.SetName("LinearityGraphScin")
LinearityGraphScin.Write()
ResolutionGraphScin = TGraphErrors(len(energies), sqrtenergies,
resolutionscin, zeros,
resolutionscinerror)
func = TF1("func", "[0]/(x**0.5)+[1]", 10., 150.)
ResolutionGraphCher = TGraphErrors(len(energies), sqrtenergies,
resolutioncher, zeros,
resolutionchererror)
#ResolutionGraphScin.Fit("func", "R")
#ResolutionGraphCher.Fit("func", "R")
ResolutionGraphScin.SetName("ResolutionGraphScin")
ResolutionGraphScin.Write()
ResolutionGraphCher.SetName("ResolutionGraphCher")
ResolutionGraphCher.Write()
ResolutionGraph = TGraphErrors(len(energies), sqrtenergies, resolution,
zeros, resolutionerror)
#ResolutionGraph.Fit("func", "R")
ResolutionGraph.SetName("ResolutionGraph")
ResolutionGraph.Write()
LinearityGraph.SetMinimum(0.976) #0.976
LinearityGraph.SetMaximum(1.024) #1.024
LinearityGraph.GetXaxis().SetLimits(0.0, 155.0)
LinearityGraph.SetTitle("")
LinearityGraph.GetXaxis().SetLabelSize(.105)
LinearityGraph.GetYaxis().SetLabelSize(0.105)
LinearityGraph.GetXaxis().SetNdivisions(520)
LinearityGraph.GetYaxis().SetNdivisions(504)
LinearityGraph2.SetTitle("")
LinearityGraph2.SetMinimum(0.0)
LinearityGraph2.SetMaximum(155.0)
LinearityGraph2.GetXaxis().SetLimits(0.0, 155.0)
LinearityGraph2.GetXaxis().SetLabelSize(0.)
LinearityGraph2.GetXaxis().SetNdivisions(520)
LinearityGraph2.GetYaxis().SetNdivisions(520)
c = TCanvas("c", "canvas", 800, 800)
# Upper histogram plot is pad1
pad1 = TPad("pad1", "pad1", 0, 0.3, 1, 1.0)
pad1.SetBottomMargin(0.02) # joins upper and lower plot
pad1.SetLeftMargin(0.1)
pad1.SetRightMargin(0.1)
pad1.Draw()
# Lower ratio plot is pad2
c.cd() # returns to main canvas before defining pad2
pad2 = TPad("pad2", "pad2", 0, 0.05, 1, 0.3)
pad2.SetTopMargin(0.05) # joins upper and lower plot
pad2.SetBottomMargin(0.3)
pad2.SetLeftMargin(0.1)
pad2.SetRightMargin(0.1)
pad2.Draw()
pad1.cd()
LinearityGraph2.Draw()
pad2.cd()
LinearityGraph.Draw("AP")
ratioline = TF1("ratioline", str(np.mean(energyfraction)), 0., 160.)
ratioline.SetLineColor(1)
ratioline.SetLineWidth(1)
ratioline.SetLineStyle(9)
ratioline.Draw("same")
ratioline.Write()
c.Update()
#c.SaveAs("MLratio.pdf")
c.Write()
'''
Resolutions = TMultiGraph()
Resolutions.Add(ResolutionGraphScin)
Resolutions.Add(ResolutionGraphCher)
Resolutions.Add(ResolutionGraph)
Resolutions.SetName("EMResolutions")
Resolutions.Write()
Linearities = TMultiGraph()
Linearities.Add(LinearityGraph)
Linearities.Add(LinearityGraphScin)
Linearities.Add(LinearityGraphCher)
Linearities.SetName("Linearities")
Linearities.Write()
'''
return RecEnergyHist.GetFunction("gaus").GetParameter(
2), RecEnergyHist.GetFunction("gaus").GetParameter(
1), RecEnergyHist.GetFunction("gaus").GetChisquare()
def __init__(self,
inputfilename="config/configEffPredictor.cfg",
debug=False):
#Set the debug flag
self.DEBUG = debug
#HV Points To Perform Calculations for
self.LIST_HVPTS = []
#Detector Names
self.NAME_DET_DUT = "Detector"
self.NAME_DET_CLUSTQ = "GE11-III-FIT-0001"
self.NAME_DET_CLUSTSIZE = "GE11-IV-CERN-0001"
#Declare Detector Container
self.PARAMS_DET_DUT = PARAMS_DET()
self.SECTOR_IETA_CLUSTSIZENORM = 5
self.SECTOR_IETA_QC5 = 4
self.SECTOR_IPHI_CLUSTSIZENORM = 2
self.SECTOR_IPHI_QC5 = 2
self.ANA_UNI_GRANULARITY = 32
#Declare Gain Containers
self.PARAMS_GAIN_DET_DUT = PARAMS_GAIN()
self.PARAMS_GAIN_DET_CLUSTQ = PARAMS_GAIN()
self.PARAMS_GAIN_DET_CLUSTSIZE = PARAMS_GAIN()
#File Names
self.FILE_CLUSTQ_MEAN = "" #File having ordered triplet of (V_Drift, ClustSize, Mean) data
self.FILE_CLUSTQ_MPV = "" #As above but for MPV
self.FILE_CLUSTQ_SIGMA = "" #As above but for Sigma
self.FILE_MAPPING_DUT = "" #Mapping config file for detector under test
self.FILE_MAPPING_DUT_VFAT2DET = "" #Mapping config file for detectur under test which translates VFAT position to (ieta,iphi) coordinate
self.FILE_MIP_AVG_CLUST_SIZE = "" #File having a TF1 which is a fit of MIP <ClustSize> vs. Gain
self.FILE_OUTPUT = "" #Output filename to be created
self.FILE_QC5_RESP_UNI = "" #Framework output file
self.FILE_SCURVE_DATA = "" #TFile containing the scurveFitTree TTree with SCurve data
#TObject Names
self.TOBJ_NAME_FUNC_AVGCLUSTSIZE = ""
#Load the input file and set all variables
list_strLines = []
with open(inputfilename) as inputFile:
list_strLines = inputFile.readlines()
inputFile.close()
#strip new line character ('\n') from the file
list_strLines = [x.strip() for x in list_strLines]
if self.DEBUG:
print "Field_Name\tValue"
#Set Variables
for iPos in range(0, len(list_strLines)):
#Get this (field_name,value) pair
strLine = list_strLines[iPos].split("\t")
#Skip if commented (e.g. first character of first member is "#")
if strLine[0][0] == "#":
continue
#Transform to upper case
strLine[0] = strLine[0].upper()
#Print (field_name, value) pair
if self.DEBUG:
print "{0}\t{1}".format(strLine[0], strLine[1])
#Set values
if strLine[0] == "FILE_FRAMEWORK_OUTPUT":
#self.ANASUITEGAIN.openInputFile(strLine[1])
self.FILE_QC5_RESP_UNI = strLine[1]
elif strLine[0] == "FILE_CLUSTQ_MEAN":
self.FILE_CLUSTQ_MEAN = strLine[1]
elif strLine[0] == "FILE_CLUSTQ_MPV":
self.FILE_CLUSTQ_MPV = strLine[1]
elif strLine[0] == "FILE_CLUSTQ_SIGMA":
self.FILE_CLUSTQ_SIGMA = strLine[1]
elif strLine[0] == "FILE_CLUSTSIZE":
self.FILE_MIP_AVG_CLUST_SIZE = strLine[1]
elif strLine[0] == "FILE_OUTPUT":
#self.FILE_OUTPUT = strLine[1]
self.FILE_OUTPUT = TFile(strLine[1], "RECREATE", "", 1)
self.DIR_CHARGE = self.FILE_OUTPUT.mkdir("ChargeData")
self.DIR_MAP_EFF = self.FILE_OUTPUT.mkdir("EffMaps")
#self.DIR_MAP_GAIN=self.FILE_OUTPUT.mkdir("GainMaps")
elif strLine[0] == "FILE_DUT_MAPPING_GEO":
self.FILE_MAPPING_DUT = strLine[1]
elif strLine[0] == "FILE_DUT_MAPPING_VFATPOS2IETAIPHI":
self.FILE_MAPPING_DUT_VFAT2DET = strLine[1]
elif strLine[0] == "FILE_DUT_SCURVEDATA":
self.FILE_SCURVE_DATA = strLine[1]
elif strLine[0] == "DUT_GAIN_P0":
self.PARAMS_GAIN_DET_DUT.GAIN_CURVE_P0 = float(strLine[1])
elif strLine[0] == "DUT_GAIN_P0_ERR":
self.PARAMS_GAIN_DET_DUT.GAIN_CURVE_P0_ERR = float(strLine[1])
elif strLine[0] == "DUT_GAIN_P1":
self.PARAMS_GAIN_DET_DUT.GAIN_CURVE_P1 = float(strLine[1])
elif strLine[0] == "DUT_GAIN_P1_ERR":
self.PARAMS_GAIN_DET_DUT.GAIN_CURVE_P1_ERR = float(strLine[1])
elif strLine[0] == "DUT_IETA_CLUST_SIZE_NORM":
self.SECTOR_IETA_CLUSTSIZENORM = int(strLine[1])
elif strLine[0] == "DUT_IETA_QC5_GAIN_CAL":
self.SECTOR_IETA_QC5 = int(strLine[1])
elif strLine[0] == "DUT_IPHI_CLUST_SIZE_NORM":
self.SECTOR_IPHI_CLUSTSIZENORM = int(strLine[1])
elif strLine[0] == "DUT_IPHI_QC5_GAIN_CAL":
self.SECTOR_IPHI_QC5 = int(strLine[1])
elif strLine[0] == "DUT_NUM_SIM_PTS_PER_RO":
self.NUMSIMPTS_PER_RO = int(strLine[1])
elif strLine[0] == "DUT_QC5_RESP_UNI_HVPT":
self.PARAMS_DET_DUT.DET_IMON_QC5_RESP_UNI = float(strLine[1])
elif strLine[0] == "DUT_SERIAL_NUMBER":
self.NAME_DET_DUT = strLine[1]
elif strLine[0] == "DUT_SLICE_GRANULARITY":
self.ANA_UNI_GRANULARITY = int(strLine[1])
elif strLine[0] == "DET_CLUSTQ_SERIAL_NUMBER":
self.NAME_DET_CLUSTQ = strLine[1]
elif strLine[0] == "DET_CLUSTQ_GAIN_P0":
self.PARAMS_GAIN_DET_CLUSTQ.GAIN_CURVE_P0 = float(strLine[1])
elif strLine[0] == "DET_CLUSTQ_GAIN_P0_ERR":
self.PARAMS_GAIN_DET_CLUSTQ.GAIN_CURVE_P0_ERR = float(
strLine[1])
elif strLine[0] == "DET_CLUSTQ_GAIN_P1":
self.PARAMS_GAIN_DET_CLUSTQ.GAIN_CURVE_P1 = float(strLine[1])
elif strLine[0] == "DET_CLUSTQ_GAIN_P1_ERR":
self.PARAMS_GAIN_DET_CLUSTQ.GAIN_CURVE_P1_ERR = float(
strLine[1])
elif strLine[0] == "DET_CLUSTSIZE_SERIAL_NUMBER":
self.NAME_DET_CLUSTSIZE = strLine[1]
elif strLine[0] == "DET_CLUSTSIZE_TF1_TNAME":
self.TOBJ_NAME_FUNC_AVGCLUSTSIZE = strLine[1]
elif strLine[0] == "EFF_HVPT_LIST":
self.LIST_HVPTS = strLine[1].split(",")
else:
print "Input Field Name:"
print strLine[0]
print "Not recognized, please cross-check input file:"
print inputfilename
del list_strLines
#Declare Cluster Charge Analysis Suite
self.ANASUITECLUSTQ = AnalysisSuiteClusterCharge(
file_out=self.FILE_OUTPUT,
params_gain=self.PARAMS_GAIN_DET_CLUSTQ,
calcGain=True,
debug=self.DEBUG)
#Load the Landau Cluster Charge Data
if self.DEBUG:
print "Loading Landau Cluster Charge Data"
if len(self.FILE_CLUSTQ_MEAN) == 0:
print "Landau Cluster Charge Mean Filename not found, problem!"
if len(self.FILE_CLUSTQ_MPV) == 0:
print "Landau Cluster Charge MPV Filename not found, problem!"
if len(self.FILE_CLUSTQ_SIGMA) == 0:
print "Landau Cluster Charge Sigma Filename not found, problem!"
self.ANASUITECLUSTQ.loadData(
inputfilename_MEAN=self.FILE_CLUSTQ_MEAN,
inputfilename_MPV=self.FILE_CLUSTQ_MPV,
inputfilename_SIGMA=self.FILE_CLUSTQ_SIGMA)
#Interpolate the Landau Cluster Charge Data
if self.DEBUG:
print "Interpolating Landau Cluster Charge Data"
self.ANASUITECLUSTQ.interpolateData()
#Declare Gain Map Analysis Suite
self.PARAMS_DET_DUT.DETPOS_IETA = self.SECTOR_IETA_QC5
self.PARAMS_DET_DUT.DETPOS_IPHI = self.SECTOR_IPHI_QC5
if self.DEBUG:
print "Loading Mapping"
self.PARAMS_DET_DUT.loadMapping(self.FILE_MAPPING_DUT, self.DEBUG)
self.ANASUITEGAIN = AnalysisSuiteGainMap(
file_out=self.FILE_OUTPUT,
inputfilename=self.FILE_QC5_RESP_UNI,
#outputfilename=self.FILE_OUTPUT,
#outputfileoption="RECREATE",
params_gain=self.PARAMS_GAIN_DET_DUT,
params_det=self.PARAMS_DET_DUT,
debug=self.DEBUG)
#Make the dictionary for OBS vs cluster position histograms
self.DICT_H_CHON_VS_CLUSTPOS = {}
self.DICT_H_CLUSTQ_VS_CLUSTPOS = {}
self.DICT_H_NOISEQ_VS_CLUSTPOS = {}
self.DICT_H_THRESH_VS_CLUSTPOS = {}
for etaSector in self.PARAMS_DET_DUT.LIST_DET_GEO_PARAMS:
iNumBinsX = self.ANA_UNI_GRANULARITY * etaSector.NBCONNECT
xLower = -0.5 * etaSector.SECTSIZE
xUpper = 0.5 * etaSector.SECTSIZE
#Channels On vs cluster position histograms
h_chOn_vs_clustPos = TH2F(
"h_iEta{0}_chOn_vs_clustPos".format(etaSector.IETA), "",
iNumBinsX, xLower, xUpper, 125, 0, 1.25)
h_chOn_vs_clustPos.SetDirectory(gROOT)
self.DICT_H_CHON_VS_CLUSTPOS[
etaSector.SECTPOS] = h_chOn_vs_clustPos
#Cluster charge vs cluster position histograms
h_clustQ_vs_clustPos = TH2F(
"h_iEta{0}_clustQ_vs_clustPos".format(etaSector.IETA), "",
iNumBinsX, xLower, xUpper, 400, 0, 100)
h_clustQ_vs_clustPos.SetDirectory(gROOT)
self.DICT_H_CLUSTQ_VS_CLUSTPOS[
etaSector.SECTPOS] = h_clustQ_vs_clustPos
#Noise vs cluster position histograms
h_noiseQ_vs_clustPos = TH2F(
"h_iEta{0}_noiseQ_vs_clustPos".format(etaSector.IETA), "",
iNumBinsX, xLower, xUpper, 100, 0, 10)
h_noiseQ_vs_clustPos.SetDirectory(gROOT)
self.DICT_H_NOISEQ_VS_CLUSTPOS[
etaSector.SECTPOS] = h_noiseQ_vs_clustPos
#Thresh vs cluster position histograms
h_thresh_vs_clustPos = TH2F(
"h_iEta{0}_thresh_vs_clustPos".format(etaSector.IETA), "",
iNumBinsX, xLower, xUpper, 100, 0, 10)
h_thresh_vs_clustPos.SetDirectory(gROOT)
self.DICT_H_THRESH_VS_CLUSTPOS[
etaSector.SECTPOS] = h_thresh_vs_clustPos
#Load the MIP average cluster size vs. gain formulat
fileMIPAvgClustSize = TFile(self.FILE_MIP_AVG_CLUST_SIZE, "READ", "",
1)
if self.DEBUG:
print "Loading function for MIP <Clust Size> vs. Gain"
self.FUNC_AVG_MIP_CLUSTSIZE = fileMIPAvgClustSize.Get(
self.TOBJ_NAME_FUNC_AVGCLUSTSIZE)
#Initialize the VFAT noise analysis suite
self.ANASUITENOISE = AnalysisSuiteVFATNoise(
detector=self.PARAMS_DET_DUT,
inputMappingFile=self.FILE_MAPPING_DUT_VFAT2DET,
inputSCurveFile=self.FILE_SCURVE_DATA,
convert2fC=True,
debug=self.DEBUG)
#Make the Dictionary for Efficiency by Readout Sector
#Here each value is a tuple average, std. dev, num pts
self.DICT_EFF_READOUT = {
key: []
for key in self.ANASUITENOISE.DICT_MAPPING
}
#self.DICT_AVGEFF_READOUT = {}
#Make the Dictionary for Efficiency TGraphErrs by Readout Sector
self.DICT_G_EFF_VS_HVPTS_RO = {}
self.DICT_G_ANASLICE_VS_HVPTS_RO = {}
self.DICT_G_EFF_VS_GAIN_RO = {}
for key in self.DICT_EFF_READOUT:
#Avg Eff +/- Std Dev Eff vs. HVPts
g_Eff_vs_HVPts = TGraphErrors(len(self.LIST_HVPTS))
g_Eff_vs_HVPts.SetName("g_iEta{0}iPhi{1}_avgEff_vs_HVPts".format(
int(key[0]), int(key[1])))
g_Eff_vs_HVPts.SetTitle("")
g_Eff_vs_HVPts.SetMarkerStyle(21)
self.DICT_G_EFF_VS_HVPTS_RO[key] = g_Eff_vs_HVPts
#Avg Eff +/- Std Dev Eff vs. HVPts
g_Eff_vs_Gain = TGraphErrors(len(self.LIST_HVPTS))
g_Eff_vs_Gain.SetName("g_iEta{0}iPhi{1}_avgEff_vs_Gain".format(
int(key[0]), int(key[1])))
g_Eff_vs_Gain.SetTitle("")
g_Eff_vs_Gain.SetMarkerStyle(21)
self.DICT_G_EFF_VS_GAIN_RO[key] = g_Eff_vs_Gain
#Number of Slices used for analysis (here a slice is counted if the landau charge interpolation was valid)
g_AnaSlices_vs_HVPts = TGraph(len(self.LIST_HVPTS))
g_AnaSlices_vs_HVPts.SetName(
"g_iEta{0}iPhi{1}_anaSlices_vs_HVPts".format(
int(key[0]), int(key[1])))
g_AnaSlices_vs_HVPts.SetTitle("")
g_AnaSlices_vs_HVPts.SetMarkerStyle(21)
self.DICT_G_ANASLICE_VS_HVPTS_RO[key] = g_AnaSlices_vs_HVPts
#Tell user initialization completed successfully
#if self.DEBUG:
print "AnalysisSuiteEfficiencyPredictor::init() - Initialization completed successfully"
return
def test():
setStyle()
h2 = TH2F('h2', 'h2;Col;Row', 64, -0.5, 63.5, 128, -0.5, 127.5)
h2.SetLineColor(920)
h2C = h2.Clone('h2C')
valid_list = [(i + 32 * k, j, 0, 1) for i in range(24, 32)
for j in range(32) for k in range(3, 4)]
# valid_list = [(i+32*k,j,0,1) for i in range(7) for j in range(32) for k in range(4)]
# for t in [(i+32*k,j,0,1) for i in range(7) for j in range(32) for k in range(4)]:
for t in valid_list:
h2C.Fill(t[1], t[0])
lt = TLatex()
cav1 = TCanvas('cav1', 'cav1', 800, 700)
cav1.Divide(2)
cav1a = cav1.cd(1)
h2C.Draw('box')
htx = h2.Clone('htx')
htx.Draw("colzsame")
lt0 = lt.DrawLatexNDC(0.2, 0.95, "empty")
cav1b = cav1.cd(2)
h2C.Draw('box')
htC = h2.Clone('htC')
htC.Draw("colzsame")
cav1.cd()
# waitRootCmdX()
#
figI = 0
with open('../data/xRay/data_xRayTest_Jul27_1.dat', 'r') as fin1:
started = False
date0 = parse('2018-07-27 16:05:33.9')
date1 = parse('2018-09-11 22:52:35.0')
# datax = None
datax = []
while True:
line = fin1.readline()
if len(line) == 0: break
if line[0:5] == '#2018':
# print line,
date = parse(line[1:])
# print date
started = date0 < date < date1
elif started:
# print [ord(w) for w in line]
if datax:
print '-->', datax
print '===', [ord(w) for w in line[:-1]]
datax += [ord(w) for w in line[:-1]]
adds, r = getAddressesN(datax, False)
if r:
print '>>>>', datax
print '++++', r
if adds == [] or adds is None:
print '---:', date
print datax
print
datax = r
# continue
bc1.show("OKBLUE", str(date))
# print date
print adds
if adds:
htx.Reset()
for x in adds:
# if x not in valid_list:
# print [ord(w) for w in line[:-1]]
# print adds
# getAddresses(line[:-1],True)
# print x
# return 0
# h2.Fill(x[1],x[0])
htx.Fill(x[1], x[0])
htC.Fill(x[1], x[0])
lt0.SetText(0.2, 0.95, str(date))
cav1a.Modified()
cav1b.Modified()
waitRootCmdX(sDir + sTag + str(figI), autoSave)
figI += 1
h2.Draw('colzsame')
waitRootCmdX()
def write_1(var, sample):
for s in attr:
if sample == 'qcd':
color1 = 4
elif sample == 'ttt':
color1 = 880 + 1 #400+3
elif sample == 'ct0':
color1 = 8 #634
elif sample == 'ct0p05':
color1 = 3
elif sample == 'ct1':
color1 = 2
elif sample == 'ct100':
color1 = 6
elif sample == 'vbfHToBB':
color1 = 800 + 10
elif sample == 'vbfct0p':
color1 = 3
elif sample == 'vbfct1p':
color1 = 860
elif sample == 'vbfct100p':
color1 = 1
elif sample == 'vbfct0p60g':
color1 = 3
elif sample == 'vbfct100p60g':
color1 = 3
elif sample == 'zhct0p40g':
color1 = 3
if s == 'pt':
h_par = [number_of_bin, 0, 300]
elif s == 'eta':
h_par = [number_of_bin, -2.5, 2.5]
elif s == 'phi':
h_par = [number_of_bin, -math.pi, math.pi]
elif s == 'CSV':
h_par = [number_of_bin, 0, 1]
elif s == 'chf':
h_par = [number_of_bin, 0, 1]
elif s == 'nhf':
h_par = [number_of_bin, 0, 1]
elif s == 'phf':
h_par = [number_of_bin, 0, 1]
elif s == 'elf':
h_par = [number_of_bin, 0, 1]
elif s == 'muf':
h_par = [number_of_bin, 0, 1]
elif s == 'chm':
h_par = [number_of_bin, 0, 100]
elif s == 'chm':
h_par = [number_of_bin, 0, 100]
elif s == 'cm':
h_par = [number_of_bin, 0, 100]
elif s == 'nm':
h_par = [number_of_bin, 0, 100]
elif s == 'dR_q1':
h_par = [number_of_bin, -1.1, 3 * math.pi]
elif s == 'dR_q2':
h_par = [number_of_bin, -1.1, 3 * math.pi]
elif s == 'dR_q3':
h_par = [number_of_bin, -1.1, 3 * math.pi]
elif s == 'dR_q4':
h_par = [number_of_bin, -1.1, 3 * math.pi]
elif s == 'nPV':
h_par = [number_of_bin, 0, 80]
tree[sample] = file_dict[sample].Get('reconstruction;1').Get(
'tree') #.Get('ntuple;1').Get('tree')
if twoD == 0:
hist[sample][s] = TH1F(sample + s, '; %s; events' % s, h_par[0],
h_par[1], h_par[2])
#hist_CHS[sample][s] = TH1F(sample+s + 'CHS', '; %s; events' %s , h_par[0], h_par[1], h_par[2])
elif twoD == 1:
hist[sample][s] = TH2F(sample + s, '; %s; events' % s, h_par[0],
h_par[1], h_par[2], number_of_bin, 0, 300)
#hist_CHS[sample][s] = TH2F(sample+s +'CHS', '; %s; events' %s , h_par[0], h_par[1], h_par[2] , number_of_bin, 0, 300)
print(tree[sample])
hist[sample][s].Sumw2()
#hist_CHS[sample][s].Sumw2()
if twoD == 0:
#tree[sample].Project(sample+s, var + '.' + s, cutting )
tree[sample].Project(sample + s, s, cutting)
#tree[sample].Project(sample+s+'CHS', 'CHS' + var + '.' + s, cutting_CHS )
elif twoD == 1:
#tree[sample].Project(sample+s, var + '.' + s + ':' + var + '.' + 'pt', cutting )
tree[sample].Project(sample + s, s + ':' + var + '.' + 'pt',
cutting)
#tree[sample].Project(sample+s+'CHS', 'CHS' + var + '.' + s + ':' + var + '.' + 'pt', cutting_CHS )
if hist[sample][s].Integral(
) != 0: #and hist_CHS[sample][s].Integral() != 0:
hist[sample][s].Scale(1 / float(hist[sample][s].Integral()))
#hist_CHS[sample][s].Scale(1/float(hist_CHS[sample][s].Integral()))
else:
print("zero denominator!")
entr = tree[sample].GetEntries(cutting)
hist[sample][s].SetLineColor(color1)
hist[sample][s].SetLineWidth(3)
hist[sample][s].SetTitle(
'cut: ' + cutting.replace('(', '_').replace(')', '_').replace(
'&&', ',').replace('Jet', 'J').replace('GenBquark', 'GBQ') +
'[entries:' + str(entr) + ']')
#hist_CHS[sample][s].SetLineColor(color1+44)
#hist_CHS[sample][s].SetLineWidth(3)
#hist[sample][s].SetTitleSize(0.4,'t')
#hist[sample][s].GetYaxis().SetTitleOffset(1.6)
if s == 'elf':
hist[sample][s].SetAxisRange(0., 0.02, "Y")
#hist_CHS[sample][s].SetAxisRange(0., 0.02,"Y")
elif s == 'muf':
hist[sample][s].SetAxisRange(0., 0.02, "Y")
#hist_CHS[sample][s].SetAxisRange(0., 0.02,"Y")
print(hist[sample][s].GetEntries())
# Trick for docker install to run headless
# and never use plt.show()
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from array import array
from ROOT import (TH1F, TH2F, TH1D, TF1, TFile, TCanvas,
gPad, gStyle, TLatex, TGraphErrors, TLine,
kGray, kRed, kBlue, kBlack)
default_histo = TH1F('default', '', 100, 0, 1)
default_histo2d = TH2F('default', '', 100, 0, 1, 100, 0, 1)
def load_histos(file):
''' Use the ROOT file structure to load a dictionary of histograms. '''
h = {}
for k in file.GetListOfKeys():
h[k.GetName()] = file.Get(k.GetName())
return h
def numpify(histo):
""" TH1F to np.arrays. """
if type(histo) not in [TH1F, TH1D]:
raise NotImplementedError('Can not numpify type {}'.format(type(histo)))
nbins = histo.GetNbinsX()
leg.Draw()
c.Print(remainder[0] + ".pdf", "Title:data_1d")
radfracHist_10 = radHist_10.Clone("radfrac_10mrad")
radfracHist_10.SetLineColor(1)
radfracHist_10.SetTitle("Radiative fraction (10mrad)")
radfracHist_10.GetXaxis().SetTitle("pair invariant mass [GeV]")
radfracHist_10.GetYaxis().SetTitle("radiative fraction")
radfracHist_10.Divide(totalHist_10)
radfracHist_10.Draw()
radfracHist_10.GetXaxis().SetRangeUser(0, 0.17)
radfracHist_10.GetYaxis().SetRangeUser(0, 0.5)
radfracHist_10.Fit("pol3", "", "", 0.027, 0.18)
c.Print(remainder[0] + ".pdf", "Title:data_1d")
radFracAt40 = TH2F("radFracAt40", "RadFrac vs. theta cut (40 MeV)", 9, 1, 10,
10, 0.065, 0.1)
radFracAt50 = TH2F("radFracAt50", "RadFrac vs. theta cut (50 MeV)", 9, 1, 10,
10, 0.065, 0.1)
radFracAt60 = TH2F("radFracAt60", "RadFrac vs. theta cut (60 MeV)", 9, 1, 10,
10, 0.065, 0.1)
radFracAt70 = TH2F("radFracAt70", "RadFrac vs. theta cut (70 MeV)", 9, 1, 10,
10, 0.065, 0.1)
radFracAt80 = TH2F("radFracAt80", "RadFrac vs. theta cut (80 MeV)", 9, 1, 10,
10, 0.065, 0.1)
radFracAt90 = TH2F("radFracAt90", "RadFrac vs. theta cut (90 MeV)", 9, 1, 10,
10, 0.065, 0.1)
radFracAt100 = TH2F("radFracAt100", "RadFrac vs. theta cut (100 MeV)", 9, 1,
10, 10, 0.065, 0.1)
radFracAt110 = TH2F("radFracAt110", "RadFrac vs. theta cut (110 MeV)", 9, 1,
10, 10, 0.065, 0.1)
radFracAt120 = TH2F("radFracAt120", "RadFrac vs. theta cut (120 MeV)", 9, 1,
# -------- Fill dictionaries with function AnalyseThresholdScan() in functions.pyc
DIC_AnalyseThresholdScan = AnalyseThresholdScan(FileDataThrScan)
TDAC_value_dic = DIC_AnalyseThresholdScan[0]
Threshold_value_dic = DIC_AnalyseThresholdScan[1]
Sigma_value_dic = DIC_AnalyseThresholdScan[2]
Chi2_value_dic = DIC_AnalyseThresholdScan[3]
Scurve_plot_dic = DIC_AnalyseThresholdScan[4]
Data_pointsX_dic = DIC_AnalyseThresholdScan[5]
Data_pointsY_dic = DIC_AnalyseThresholdScan[6]
# -------- Set histograms and fitting function
myfit = TF1("myfit", "[0]+0.5*TMath::Erf([1]*([2]+x))", -1., 3000.)
TDAC2D = TH2F("TDAC2D", "TDAC 2D plot;#Row;#Column;Threshold [e]", 24, 0,
24, 36, 12, 48)
TDAC1D = TH1F("TDACDist", "TDAC distribution;Threshold [e];nb of pixels",
16, 0, 16)
thresh2D = TH2F("thresh2D", "Threshold 2D plot;#Row;#Column;Threshold [e]",
24, 0, 24, 36, 12, 48)
thresh1D = TH1F("threshDist",
"Threshold distribution;Threshold [e];nb of pixels", 300,
-.1, 4000)
sigma2D = TH2F("sigma2D", "Sigma 2D plot;#Row;#Column;Sigma [e]", 24, 0,
24, 36, 12, 48)
sigma1D = TH1F("sigmaDist", "Sigma distribution;Sigma [e];nb of pixels",
300, -.1, 500)
chi2_1D = TH1F("chi2Dist", "Chi2 distribution; ;nb of pixels", 300, 0, 1)
chi2_2D = TH2F("chi2_2D", "Chi2 2D plot;#Row;#Column;chi2", 24, 0, 24, 36,
12, 48)
correlation = TH2F("correlation", "Threshold vs TDAC;TDAC;Threshold [e]",
inputfile = "/eos/uscms/store/user/cmstestbeam/2019_04_April_CMSTiming/KeySightScope/RecoData/TimingDAQRECO/RecoWithTracks/v6_CACTUSSkim/Completed/Data_CACTUSDigital_TimingOptimized_HighTreshold_16492-16516.root"
#inputfile = "/eos/uscms/store/user/cmstestbeam/2019_04_April_CMSTiming/KeySightScope/RecoData/TimingDAQRECO/RecoWithTracks/v6_CACTUSSkim/Completed/Data_CACTUSDigital_TimingOptimized_LowThreshold_16517-16711.root"
if not os.path.exists(inputfile):
print "input file " + inputfile + " does not exist"
exit()
file = TFile(inputfile)
tree = file.Get("pulse")
#c = TCanvas("cv","cv",800,800)
##########################
#2D Efficiency
##########################
den = TH2F("den", ";x;y", 20, 19, 21, 20, 23, 25)
num = TH2F("num", ";x;y", 20, 19, 21, 20, 23, 25)
tree.Draw("y_dut[2]:x_dut[2]>>den",
"ntracks==1 && y_dut[0] > 0 && npix>0 && nback>0", "colz")
tree.Draw("y_dut[2]:x_dut[2]>>num",
"ntracks==1 && y_dut[0] > 0 && npix>0 && nback>0 && amp[3] > 200 ",
"colz")
EfficiencyUtils.Plot2DEfficiency(num, den, "CACTUSEfficiencyVsXY",
"CACTUS Pixel (5,3) Digital", "X [mm]", 19.0,
21.0, "Y [mm]", 23.0, 25.0, -0.001, 0.20)
##########################
#1D Efficiency Vs X
##########################
def analysis(
hadron="Lambda_c",
collision="pp14p0",
yrange="absy3p0",
brmode="central",
model="Pyhia8mode2",
use_unnorm=1,
):
gStyle.SetOptStat(0)
with open(r"databases/significance.yaml") as filesignificance:
paramsignificance = yaml.safe_load(filesignificance)
ymin = paramsignificance[hadron][collision][yrange]["ymin"]
ymax = paramsignificance[hadron][collision][yrange]["ymax"]
# bin of the final analysis, has to be the binning of efficiency, bkg histos
binanal = array("d",
paramsignificance[hadron][collision][yrange]["binning"])
nfileyieldth = paramsignificance[hadron][collision][yrange]["theoryfile"]
nfileeff = paramsignificance[hadron][collision][yrange]["efffile"]
nhistoeff = paramsignificance[hadron][collision][yrange]["histoeff"]
nfilebkg = paramsignificance[hadron][collision][yrange]["bkgfile"]
nhistobkg = paramsignificance[hadron][collision][yrange]["histobkg"]
nhistoyieldth = paramsignificance[hadron][collision][yrange]["histoyield"]
nhistoyieldth_norm = paramsignificance[hadron][collision][yrange][
"histoyield_norm"]
with open(r"databases/general.yaml") as fileparamgen:
paramgen = yaml.safe_load(fileparamgen)
with open(r"databases/theory_yields.yaml") as fileyields:
paramyields = yaml.safe_load(fileyields)
textcollision = paramgen["text_string"][collision]
textrapid = paramgen["text_string"][yrange]
textmodel = paramgen["text_string"][model]
sigma_aa_b = paramgen["statistics"][collision]["sigmaAA_b"]
lumiaa_monthi_invnb = paramgen["statistics"][collision][
"lumiAA_monthi_invnb"]
nevt = sigma_aa_b * lumiaa_monthi_invnb * 1e9
# nevt = 2.*1e9
bratio = paramgen["branchingratio"][hadron][brmode]
decaychannel = paramgen["latexparticle"][hadron]
if hadron == "Chi_c" and yrange == "absy1p44":
bratio *= 0.8 # chi_c1 and chi_c2 are measured together: non-weighted average of their BRs
decaychannel = "#chi_{c} #rightarrow J/#psi #gamma"
yieldmid = paramyields[model][collision][yrange][hadron]
text = "%s, N_{ev} = %f 10^{9}" % (textmodel, (float)(nevt) / 1.0e9)
text_a = "%s, %s, BR=%.2f%%" % (decaychannel, textrapid, bratio * 100)
text_b = "ALICE3 projection, with IRIS, no PID, %s" % textcollision
fileeff = TFile(nfileeff)
histoeff = fileeff.Get(nhistoeff)
filebkg = TFile(nfilebkg)
hbkgperevent = filebkg.Get(nhistobkg)
fileyieldth = TFile(nfileyieldth)
histoyieldth = None
if use_unnorm == 1:
histodndptth = fileyieldth.Get(nhistoyieldth)
histodndptth.Scale(
1.0 / 70000.0) # TEMPORARY this is a fix to account for the
# conversion from a cross-section in mub
# to yields, sigma=70000 mub
else:
histodndptth = fileyieldth.Get(nhistoyieldth_norm)
integral = 0
for ibin in range(histodndptth.GetNbinsX()):
binwdith = histodndptth.GetBinWidth(ibin + 1)
integral += histodndptth.GetBinContent(ibin + 1) * binwdith
histodndptth.Scale(1.0 / integral)
histodndptth.Scale(yieldmid)
print("yieldmid = %f\n", yieldmid)
integral = 0
for ibin in range(histodndptth.GetNbinsX()):
binwdith = histodndptth.GetBinWidth(ibin + 1)
integral += histodndptth.GetBinContent(ibin + 1) * binwdith
print("yieldmid = %f\n", yieldmid)
if hadron == "Chi_c" and collision == "pp14p0":
print("scaling signal yield by 0.1")
histodndptth.Scale(0.1) # because pythia8 is wrong by a factor ~10
if hadron == "Chi_c" and yrange == "absy1p44":
print("scaling bkg by 2*2, and signal by 3.4")
hbkgperevent.Scale(
2
) # to take approximately into account the worsening of the sig/bkg in the full
# rapidity range (PbWO4 and W+Sci)
hbkgperevent.Scale(
2
) # because in |y| < 1.44 we sum chi_c1 and chi_c2 (states are not resolved)
histodndptth.Scale(
3.4
) # because in |y| < 1.44 we sum chi_c1 and chi_c2 (states are not resolved).
# Assuming chi_c2/chi_c1 (!!) from Pythia8
if hadron == "Chi_c" and yrange == "absy0p33":
print("scaling signal and bkg by 0.23, from |y| < 1.44 to |y| < 0.33")
hbkgperevent.Scale(
0.23
) # to take into account the reduction of the statistics from |y| < 1.44 to |y| < 0.33
# (the input file for chi_c is always |y| < 1.44)
histodndptth.Scale(
0.23
) # to take into account the reduction of the statistics from |y| < 1.44 to |y| < 0.33
# (the input file for chi_c is always |y| < 1.44)
histoyieldth = histodndptth.Clone("histoyieldth")
for ibin in range(histoyieldth.GetNbinsX()):
binwdith = histoyieldth.GetBinWidth(ibin + 1)
yieldperevent = histoyieldth.GetBinContent(ibin +
1) * binwdith * bratio
histoyieldth.SetBinContent(ibin + 1, yieldperevent)
histoyieldth.SetBinError(ibin + 1, 0.0)
histoyieldth = histoyieldth.Rebin(
len(binanal) - 1, "histoyieldth", binanal)
histosignfperevent = histoyieldth.Clone("histosignfperevent")
histosignf = histoyieldth.Clone("histosignf")
histosigoverbkg = histoyieldth.Clone("histosigoverbkg")
canvas = TCanvas("canvas", "A Simple Graph Example", 881, 176, 668, 616)
gStyle.SetOptStat(0)
canvas.SetHighLightColor(2)
canvas.Range(-1.25, -4.625, 11.25, 11.625)
canvas.SetFillColor(0)
canvas.SetBorderMode(0)
canvas.SetBorderSize(2)
canvas.SetLogy()
canvas.SetFrameBorderMode(0)
canvas.SetFrameBorderMode(0)
canvas.cd()
gPad.SetLogy()
hempty = TH2F(
"hempty",
";p_{T} (GeV/c); Significance(3#sigma)",
100,
0.0,
10.0,
100,
ymin,
ymax,
)
hempty.GetXaxis().SetTitle("p_{T} (GeV/c)")
hempty.GetXaxis().SetLabelFont(42)
hempty.GetXaxis().SetTitleOffset(1)
hempty.GetXaxis().SetTitleFont(42)
hempty.GetYaxis().SetLabelFont(42)
hempty.GetYaxis().SetTitleOffset(1.35)
hempty.GetYaxis().SetTitleFont(42)
hempty.GetZaxis().SetLabelFont(42)
hempty.GetZaxis().SetTitleOffset(1)
hempty.GetZaxis().SetTitleFont(42)
hempty.Draw()
histosignf = histosignfperevent.Clone("histosignf")
for ibin in range(histoyieldth.GetNbinsX()):
yieldperevent = histoyieldth.GetBinContent(ibin + 1)
bkgperevent = hbkgperevent.GetBinContent(ibin + 1)
eff = histoeff.GetBinContent(ibin + 1)
signalperevent = eff * yieldperevent
significanceperevent = 0
if bkgperevent > 0:
significanceperevent = signalperevent / sqrt(signalperevent +
bkgperevent)
signaloverbkg = 0
if bkgperevent > 0:
signaloverbkg = signalperevent / bkgperevent
histosignfperevent.SetBinContent(ibin + 1, significanceperevent)
histosignfperevent.SetBinError(ibin + 1, 0.0)
histosignf.SetBinContent(ibin + 1, significanceperevent * sqrt(nevt))
histosignf.SetBinError(ibin + 1, 0.0)
histosigoverbkg.SetBinContent(ibin + 1, signaloverbkg)
histosigoverbkg.SetBinError(ibin + 1, 0.0)
histosignfperevent.SetLineColor(1)
histosignfperevent.SetMarkerColor(1)
histosignfperevent.SetLineWidth(1)
histosignf.SetLineColor(1)
histosignf.SetMarkerColor(1)
histosignf.SetLineWidth(2)
histosignf.Draw("same")
t_b = TLatex()
t_b.SetNDC()
t_b.SetTextFont(42)
t_b.SetTextColor(1)
t_b.SetTextSize(0.035)
t_b.SetTextAlign(12)
t_b.DrawLatex(0.2, 0.85, text_b)
t_c = TLatex()
t_c.SetNDC()
t_c.SetTextFont(42)
t_c.SetTextColor(1)
t_c.SetTextSize(0.03)
t_c.SetTextAlign(12)
t_c.DrawLatex(0.2, 0.80, text)
t_a = TLatex()
t_a.SetNDC()
t_a.SetTextFont(42)
t_a.SetTextColor(1)
t_a.SetTextSize(0.035)
t_a.SetTextAlign(12)
t_a.DrawLatex(0.2, 0.75, text_a)
canvas.SaveAs(hadron + "_" + collision + "_" + yrange + "_results.pdf")
canvas.SaveAs(hadron + "_" + collision + "_" + yrange + "_results.C")
foutput = TFile(
"foutput" + hadron + "_" + collision + "_" + yrange + ".root",
"recreate")
foutput.cd()
histoeff.Write()
hbkgperevent.Write()
histosignfperevent.Write()
histoyieldth.Write()
histosignf.Write()
histodndptth.Write()
histosigoverbkg.Write()
from ROOT import TCanvas, TFile, TProfile, TNtuple, TH1F, TH2F from ROOT import gROOT, gBenchmark, gRandom, gSystem, Double
# Create a new canvas, and customize it.
c1 = TCanvas( 'c1', 'Dynamic Filling Example', 200, 10, 700, 500 ) c1.SetFillColor( 42 ) c1.GetFrame().SetFillColor( 21 )
c1.GetFrame().SetBorderSize( 6 ) c1.GetFrame().SetBorderMode( -1 )
# Create a new ROOT binary machine independent file. Note that this file may contain any kind of ROOT objects, histograms,
# pictures, graphics objects, detector geometries, tracks, events, etc.. This file is now becoming the current directory.
hfile = gROOT.FindObject( 'py-hsimple.root' ) if hfile:
hfile.Close() hfile = TFile( 'py-hsimple.root', 'RECREATE', 'Demo ROOT file with histograms' )
# Create some histograms, a profile histogram and an ntuple
hpx = TH1F( 'hpx', 'This is the px distribution', 100, -4, 4 ) hpxpy = TH2F( 'hpxpy', 'py vs px', 40, -4, 4, 40, -4, 4 ) hprof =
TProfile( 'hprof', 'Profile of pz versus px', 100, -4, 4, 0, 20 ) ntuple = TNtuple( 'ntuple', 'Demo ntuple', 'px:py:pz:random:i' )
# Set canvas/frame attributes.
hpx.SetFillColor( 48 ) gBenchmark.Start( 'hsimple' )
# Initialize random number generator.
gRandom.SetSeed() rannor, rndm = gRandom.Rannor, gRandom.Rndm
# For speed, bind and cache the Fill member functions,
histos = [ 'hpx', 'hpxpy', 'hprof', 'ntuple' ] for name in histos:
exec('%sFill = %s.Fill' % (name,name))
# Fill histograms randomly.
px, py = Double(), Double() kUPDATE = 1000 for i in range( 25000 ):
# Generate random values.
rannor( px, py )
pz = px*px + py*py
random = rndm(1)
# Fill histograms.
hpx.Fill( px )
hpxpy.Fill( px, py )
hprof.Fill( px, pz )
ntuple.Fill( px, py, pz, random, i )
# Update display every kUPDATE events.
if i and i%kUPDATE == 0:
