def plotting_init(data, trainvar, histo_dict, masses, weights='totalWeight'):
""" Initializes the plotting
Parameters:
-----------
data : pandas DataFrame
Data to be used for creating the TProfiles
trainvar : str
Name of the training variable.
histo_dict : dict
Dictionary containing the info for plotting for a given trainvar
masses : list
List of masses to be used
[weights='totalWeight'] : str
What column to be used for weight in the data.
Returns:
--------
canvas : ROOT.TCanvas instance
canvas to be plotted on
profile : ROOT.TProfile instance
profile for the fitting
"""
canvas = TCanvas('canvas', 'TProfile plot', 200, 10, 700, 500)
canvas.GetFrame().SetBorderSize(6)
canvas.GetFrame().SetBorderMode(-1)
signal_data = data.loc[data['target'] == 1]
gen_mHH_values = np.array(signal_data['gen_mHH'].values, dtype=np.float)
trainvar_values = np.array(signal_data[trainvar].values, dtype=np.float)
weights = np.array(signal_data[weights].values, dtype=np.float)
sanity_check = len(gen_mHH_values) == len(trainvar_values) == len(weights)
assert sanity_check
title = 'Profile of ' + str(trainvar) + ' vs gen_mHH'
num_bins = (len(masses) - 1)
xlow = masses[0]
xhigh = (masses[(len(masses) - 1)] + 100.0)
ylow = histo_dict["min"]
yhigh = histo_dict["max"]
profile = TProfile('profile', title, num_bins, xlow, xhigh, ylow, yhigh)
mass_bins = np.array(masses, dtype=float)
profile.SetBins((len(mass_bins) - 1), mass_bins)
profile.GetXaxis().SetTitle("gen_mHH (GeV)")
profile.GetYaxis().SetTitle(str(trainvar))
for x, y, w in zip(gen_mHH_values, trainvar_values, weights):
profile.Fill(x, y, w)
profile.Draw()
canvas.Modified()
canvas.Update()
return canvas, profile
def draw_contour(attribute_name, treename='fitted.root', dir=training_dir):
# Create a new canvas, and customize it.
#c1 = TCanvas( 'c1', 'Contour Plot for ', attribute_name, 200, 10, 700, 500 )
c1 = TCanvas()
c1.SetFillColor( 42 )
c1.GetFrame().SetFillColor( 21 )
c1.GetFrame().SetBorderSize( 6 )
c1.GetFrame().SetBorderMode( -1 )
# Open tree
ttree = TChain('nominal', 'nominal')
ttree.AddFile("{0}/{1}".format(dir, treename))
# Draw and save contour plot
ttree.Draw("{0}_true:{0}_fitted".format(attribute_name), "", "colz")
c1.SaveAs("{0}/ContourPlots/{1}.jpg".format(dir, attribute_name))
def DrawMassPlane(data, mA, mH, title, **kwargs):
"""
Draw the mass plane (mlljj,mjj) with our without a cut on the NN output
Inputs : -data : [mlljj,mjj]
kwargs : -prediciton : output of the NN for data
-cut : cut on the NN output
Output : plot the Mass Plane
"""
c1 = TCanvas('c1', 'MassPlane', 200, 10, 700, 500)
c1.SetFillColor(10)
c1.GetFrame().SetFillColor(1)
c1.GetFrame().SetBorderSize(6)
c1.GetFrame().SetBorderMode(-1)
#mass_plane = TH2F( 'mass_plane', 'M_{lljj} vs M_{jj};M_{jj};M_{lljj}',100,mA-50,mA+50, 100,mH-50,mH+50)
mass_plane = TH2F('mass_plane', title + ';M_{jj};M_{lljj}', 100, 0, 2000,
100, 0, 2000)
if kwargs != {}:
#print (kwargs)
pred = kwargs.get("prediction")
cut = kwargs.get('cut')
mask = np.squeeze(
pred > cut) # Only takes the events satisfying the NN output cut
print('Number of events kept after cut = %i (%0.2f%%)' %
(data[mask].shape[0],
(data[mask].shape[0] / data.shape[0]) * 100))
data = data[mask]
fill_hist(mass_plane, data)
mass_plane.Draw('COLZ')
#c1.Modified()
c1.Update()
title = title.replace(' ', '_')
c1.Print('massplane_plots/' + title + '.pdf')
input("Press enter to end")
def printmultigraph(grs, sortk, plotoptions, outn, title, year, doext,
ploterror, ymax):
import CMS_lumi, tdrstyle
import array
#set the tdr style
tdrstyle.setTDRStyle()
#change the CMS_lumi variables (see CMS_lumi.py)
CMS_lumi.writeExtraText = 1
CMS_lumi.extraText = "Preliminary"
if year == 2018:
CMS_lumi.extraText2 = "2018 pp data"
if year == 2017:
CMS_lumi.extraText2 = "2017 pp data"
if year == 2016:
CMS_lumi.extraText2 = "2016 pp data"
CMS_lumi.lumi_sqrtS = "13 TeV" # used with iPeriod = 0, e.g. for simulation-only plots (default is an empty string)
CMS_lumi.writeTitle = 1
CMS_lumi.textTitle = title
iPos = 11
if (iPos == 0): CMS_lumi.relPosX = 0.12
H_ref = 600
W_ref = 800
W = W_ref
H = H_ref
iPeriod = 0
# references for T, B, L, R
T = 0.08 * H_ref
B = 0.12 * H_ref
L = 0.12 * W_ref
R = 0.04 * W_ref
c = TCanvas("c", "c", 50, 50, W, H)
#gStyle.SetOptStat(0)
c.SetFillColor(0)
c.SetBorderMode(0)
c.SetFrameFillStyle(0)
c.SetFrameBorderMode(0)
c.SetLeftMargin(L / W)
c.SetRightMargin(R / W)
c.SetTopMargin(T / H)
c.SetBottomMargin(B / H)
c.SetTickx(0)
c.SetTicky(0)
#canvassettings(c)
mg = TMultiGraph()
#mg = grs['main']
mg.SetTitle(title)
#gStyle.SetTitleAlign(33)
#gStyle.SetTitleX(0.99)
leg = TLegend(
0.345, 0.68, 0.645, 0.88
) #TLegend(1. - c.GetRightMargin() - 0.8, 1. - c.GetTopMargin() - 0.40,1. - c.GetRightMargin()- 0.60, 1. - c.GetTopMargin() -0.02)
leg.SetFillStyle(0)
leg.SetBorderSize(0)
leg.SetMargin(0.1)
#ymax = 0;
ratesFromFit = {}
evVal = 15000
if doext:
evVal = 50000
#f=TFile.Open(outn+".root","RECREATE")
# for name,value in plotoptions.iteritems():
for name in sortk:
if name != 'main': continue
value = plotoptions[name]
#print grs
gr = grs[name]
#print gr
gr.SetName(title)
#extrate = fitGraph(gr,evVal)
#ratesFromFit[name] = extrate
if doext:
#print name, extrate[0], extrate[1]
NN = gr.GetN()
gr.Set(NN + 1)
gr.SetPoint(NN + 1, 50000.0, extrate["rate"][0])
yErr = extrate["rate"][1]
if not ploterror:
yErr = 0.0
gr.SetPointError(NN + 1, 0.0, yErr)
gr.SetMarkerColor(value['color'])
gr.SetMarkerStyle(value['markst'])
gr.SetLineColor(value['color'])
gr.SetMarkerSize(1.15) #1.05
gr.SetMinimum(0.1)
#gr.Write()
mg.Add(gr)
text = title #name #+plotoptions[name]['leg']
leg.AddEntry(gr, text, "p")
continue
mg.SetName(outn)
mg.SetMinimum(0.1)
mg.SetMaximum(ymax) #1.6*ymax
mg.Draw("AP")
mg.GetXaxis().SetRangeUser(2000, 20000)
c.Update()
graphAxis(mg)
CMS_lumi.CMS_lumi(c, iPeriod, iPos)
c.cd()
c.Update()
frame = c.GetFrame()
frame.Draw()
leg.Draw()
c.SaveAs(outn + ".png")
#c.SaveAs(outn+".C")
del c
return ratesFromFit
from ROOT import TCanvas, TFile
from ROOT import TGraph
from ROOT import gStyle
from array import array
import math
c1 = TCanvas( 'c1', 'The Main Canvas', 200, 10, 700, 500 )
c1.SetGridx()
c1.SetGridy()
c1.GetFrame().SetFillColor( 21 )
c1.GetFrame().SetBorderMode(-1 )
c1.GetFrame().SetBorderSize( 5 )
def generator_function(x,par):
return par[0]+par[1]*x+par[2]*x*x+par[3]*x*x*x
xlow = -4.0
xhigh = 4.0
npoints = 10000
xval = array('d')
yval = array('d')
xroots = array('d')
yroots = array('d')
par = array('d')
par.append(1.80)
par.append(-4.05)
par.append(0.40)
par.append(1.00)
def main(argv):
print(len(argv))
if len(argv) == 5:
#print ('The script is called: '+str(script))
print('Number of M bins is: ' + argv[0])
print('Number of t bins is: ' + argv[1])
print('Number of bootstrap samples is:' + argv[2])
print('Directory for bootstrap results for different M bins is: ' +
argv[3])
print(
'Intensity results from fitting the original data are written in: '
+ argv[4])
else:
sys.exit(
"You need to give 5 args..., usage: python script.py Nmassbins Ntbins NBootstrapsamples Bindir fitresultfile"
)
NumBins, NumtBins, kBootstrapPoints, Binfolderdir, Fitresultfile = argv
NumBins = int(NumBins)
NumtBins = int(NumtBins)
kBootstrapPoints = int(kBootstrapPoints)
## Output file to save the histograms in
file_out = TFile('Drawing_Bootstrap_errors_moments.root', 'Recreate')
with open(Fitresultfile, 'r') as f:
t = f.read()
l = t.splitlines()
amps = l[0]
amps = amps.split()[
2::2] # start at 3rd element and take every other element
N_amps = (len(l[0].split()) -
2) / 2 #first two arguments in the line are M and t
print(amps)
print(N_amps)
if N_amps < 1:
sys.exit("You should specify at least one moment")
## column number for M value and each of the amplitude intensities and
##corresponding errors
column_m = 0
column_t = 1
colomn_moments = np.arange(2, 2 * N_amps + 1, 2)
colomn_moments_err = np.arange(3, 2 * N_amps + 2, 2)
mass_bins = np.zeros(NumBins)
## Arrays of intensities from fitting the original data in different M bins
orig_moment = np.zeros((N_amps, NumtBins, NumBins))
##Reading uncertainties from MINUIT
orig_moment_err = np.zeros((N_amps, NumtBins, NumBins))
## Asigning values to arrays of moments from fitting the original fit amplitude calculation in
##different M and t bins by reading from a file
token_origdata_fitresults = open(Fitresultfile, 'r')
linestoken_orig = token_origdata_fitresults.readlines()
j = 0
fit_res_colomns = 0
for x in linestoken_orig[1:]:
fit_res_colomns = len(x.split())
mass_bins[j / NumtBins] = float(x.split()[column_m])
for Moms in range(0, N_amps):
orig_moment[Moms][int(j % NumtBins)][int(j / NumtBins)] = float(
x.split()[colomn_moments[Moms]])
orig_moment_err[Moms][int(j % NumtBins)][j / NumtBins] = float(
x.split()[colomn_moments_err[Moms]])
j = j + 1
if j != NumBins * NumtBins:
sys.exit(
"The total number of bins are different from the one provided")
## Arrays of values for given moment from
##fitting different bootstrapping samples
moments = np.zeros((N_amps, kBootstrapPoints))
#uncertainty on the given moment for each M and t bin
std_moments = np.zeros((N_amps, NumtBins, NumBins))
## Histograms of moments for given mass and t bin and moment from different bootstraping samples
h1_list_moments = []
i_Mbin = 0
for Mb in range(0, NumBins):
h1_list_moments.append([])
for tb in range(0, NumtBins):
h1_list_moments[i_Mbin].append([])
i_Mbin = i_Mbin + 1
#Defining histograms for moments from different bootstraping samples for a given aplitude and M bin
for Bin in range(0, NumBins):
#N_bins=int(300*orig_all_moments[Bin])
N_bins = int(80000)
x_min = int(-500)
for Bint in range(0, NumtBins):
for Moms in range(0, N_amps):
x_max = int(3 * orig_moment[Moms][Bint][Bin])
if Moms == 11 and Bint == 0 and Bin == 5:
x_max = 1000000
h1_list_moments[Bin][Bint].append(
TH1F(
'h1_boot_' + str(amps[Moms]) +
'_Mbin' + str(Bin + 1) + '_tbin' + str(Bint + 1),
str(amps[Moms]), N_bins, x_min, x_max))
## Assigning values to arrays of values for given moment from fitting different bootstrapping samples
## by reading the values from files of each of the M and t bins
##(number of lines in the .txt file corresponds to number of bootstraping samples + 1)
for bin in range(0, NumBins):
for bint in range(0, NumtBins):
token = open(
Binfolderdir + '/bin_' + str(bin) + '_' + str(bint) +
'/etapi_fit.txt', 'r')
linestoken = token.readlines()
i = 0
#Looping through lines corresponding to results from fitting different bottstraping samples
for x in linestoken[1:]: #First line has the names of arguments
if len(x.split()) != fit_res_colomns:
sys.exit(
"Fit results and bootstraping results have different number of moments"
)
for Moms in range(0, N_amps):
moments[Moms][i] = x.split()[colomn_moments[Moms]]
h1_list_moments[bin][bint][Moms].Fill(moments[Moms][i])
i = i + 1
token.close()
for Moms in range(0, N_amps):
std_moments[Moms][bint][bin] = moments[Moms].std()
print('I am here')
##The graphs of intensities of different Moms
error_M = np.zeros(NumBins)
grerr_list_moment = []
t_bin = 0
for Moms in range(0, N_amps):
grerr_list_moment.append(
TGraphErrors(NumBins, mass_bins, orig_moment[Moms][t_bin], error_M,
std_moments[Moms][t_bin]))
c1 = TCanvas('c1', 'A Simple Graph with error bars', 200, 10, 700, 500)
c1.Divide(3, 2)
c1.SetGrid()
c1.GetFrame().SetFillColor(21)
c1.GetFrame().SetBorderSize(12)
for Moms in range(0, N_amps):
grerr_list_moment[Moms].SetMarkerSize(.5)
grerr_list_moment[Moms].SetMarkerStyle(20)
grerr_list_moment[Moms].SetName(amps[Moms])
grerr_list_moment[Moms].SetTitle(amps[Moms])
grerr_list_moment[Moms].SetMaximum(1.2 * np.amax(orig_moment[Moms]))
grerr_list_moment[Moms].SetMinimum(0.8 * np.amin(orig_moment[Moms]))
grerr_list_moment[Moms].Draw('AP')
grerr_list_moment[Moms].SetName(amps[Moms])
grerr_list_moment[Moms].Write()
c1.Print('Plots/Moment_' + amps[Moms] + '_boot.pdf')
file_out.Write()
file_out.Close()
class EEG_Graph(object):
def __init__(self, maxpoints=60):
self.maxpoints = maxpoints
self.gq = False
self.canvas = TCanvas('c1', 'A Simple Graph Example', 200, 10, 700,
500)
self.canvas_1 = TPad("c1_1", "c1_1", 0.01, 0.67, 0.99, 0.99)
self.canvas_2 = TPad("c1_2", "c1_2", 0.01, 0.01, 0.99, 0.66)
self.canvas_1.SetGrid()
self.canvas_2.SetGridx()
self.canvas_1.Draw()
self.canvas_2.Draw()
self.data = [0]
self.data_time = [time.time()]
n = 1
x = array('d')
y = array('d')
x.append(0)
y.append(0)
self.canvas_1.cd()
self.graph = TGraph(n, x, y)
self.graph.SetLineColor(2)
self.graph.SetLineWidth(4)
self.graph.SetMarkerColor(4)
self.graph.SetMarkerStyle(2)
self.graph.SetTitle('EEG Signal')
self.graph.GetXaxis().SetTitle('Time')
self.graph.GetYaxis().SetTitle('Amplitude')
self.graph.GetYaxis().SetRangeUser(-2000, 2000)
self.graph.Draw('ACP')
self.canvas_2.cd()
TVirtualFFT.SetTransform(0)
self.fft = TH1F("fft", "eeg_fft", 3, 0, 3)
self.fft.SetTitle("EEG FFT")
self.fft.Fill("1 Hz", 0)
self.fft.Fill("2 Hz", 0)
self.fft.SetMinimum(0)
self.fft.SetMaximum(100000)
self.fft.SetFillStyle(3001)
self.fft.SetFillColor(30)
self.fft.Draw("B HIST")
self.ampmax = 100000
self.fft.SetStats(False)
self.fft.GetXaxis().SetLabelSize(0.05)
self.fft.GetYaxis().SetLabelSize(0.05)
def setQuality(self, good):
self.gq = good
def append(self, timep, num):
n = self.graph.GetN()
if len(self.data) < 2048:
self.data = self.data + [num]
self.data_time = self.data_time + [time.time()]
else:
self.data = self.data[1:] + [num]
self.data_time = self.data_time[1:] + [time.time()]
if n < self.maxpoints:
self.graph.Set(n + 1)
self.graph.SetPoint(n, timep, num)
else:
self.graph.RemovePoint(0)
self.graph.Set(n)
self.graph.SetPoint(n - 1, timep, num)
self.data_fft = np.abs(np.fft.fft(self.data))
self.fft.Reset()
if len(self.data_fft) > 256:
delta = self.data_time[-1] - self.data_time[0]
for i in range(50):
amp = np.sum(self.data_fft[round(i * delta):round(i * delta +
delta)])
self.fft.Fill("%i Hz" % (i + 1, ), amp)
if amp > self.ampmax:
self.ampmax = amp
self.fft.SetMaximum(amp)
self.update()
def update(self):
self.canvas_1.cd()
if self.gq:
self.canvas_1.GetFrame().SetFillColor(30)
else:
self.canvas_1.GetFrame().SetFillColor(46)
self.canvas.GetFrame().SetBorderSize(12)
self.graph.GetYaxis().SetRangeUser(-2000, 2000)
self.canvas_2.Modified()
self.canvas.Modified()
self.canvas.Update()
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:
def testSensitivity(self,plot=False,path="./output/pT_plots"):
if(self.jetRadius!=8):
print('to calculate estimates of Limits use AK8 Jets!')
return -1
Nbins = self.BHist.GetNbinsX()
bin=0
BSum=0
SSums=[]
for hist in self.SHists:
SSums.append(0)
for i in list(reversed(range(Nbins))):
if(BSum>=10):
break
# if(i==8183):
# continue
BSum+=self.BHist.GetBinContent(i)
for j in range(0,len(self.SHists)):
SSums[j]+=self.SHists[j].GetBinContent(i)
bin=i
print('BSum=',BSum,' -> bin:',bin,';BinCenter:',self.BHist.GetBinCenter(bin))
lower_limit_index= -1
upper_limit_index= -1
expectedLimit_S=7.5312
# if(self.LastCut=='detaAk4sel'):
# expectedLimit_S=7.5938 #for B=10.1607131213
# elif(self.LastCut=='invMAk4sel_1p5_allcuts'):
# expectedLimit_S=7.7188 #for B=10.6225637197
# elif(self.LastCut=='invMAk4sel_2p0_allcuts'):
# expectedLimit_S=7.5312 #for B=10.0067629367
# else:
# expectedLimit_S=1000
for i in range(0,len(SSums)):
print(self.getPoint(i),'-',SSums[i])
if(lower_limit_index==-1):
if( SSums[i]<=expectedLimit_S):
lower_limit_index=i
elif(upper_limit_index==-1):
if( SSums[i]>=expectedLimit_S):
upper_limit_index=i-1
self.limitCalc_succeeded=(lower_limit_index!=-1 and upper_limit_index!=-1)
lower_limit=approxLimit(expectedLimit_S,self.getPoint(lower_limit_index-1),SSums[lower_limit_index-1],self.getPoint(lower_limit_index),SSums[lower_limit_index])
upper_limit=approxLimit(expectedLimit_S,self.getPoint(upper_limit_index),SSums[upper_limit_index],self.getPoint(upper_limit_index+1),SSums[upper_limit_index+1])
self.Limits=(lower_limit,upper_limit)
#Plot SSums and 'calculated limits'
plot1=TCanvas('parameterIntegral','EventYields for Parameter %s (%s)'%(self.OpName,self.channel),600,600)
plot1.SetLogy()
limit_legend = TLegend(0.6,0.12,0.9,0.3)
x, y = array( 'd' ), array( 'd' )
for i in range(0,len(SSums)):
x.append(self.getPoint(i))
y.append(SSums[i])
graph=TGraph(len(SSums),x,y)
graph.SetLineColor( 2 )
graph.SetLineWidth( 2 )
graph.SetMarkerColor( 1 )
graph.SetMarkerStyle( 3 )
graph.SetTitle('EventYields for Parameter F_{%s}'%self.OpName)
graph.GetXaxis().SetTitle('F_{%s}/#Lambda^{4} [TeV^{-4}]'%self.OpName)
graph.GetYaxis().SetTitle('S')
graph.Draw( 'AP' )
limit_legend.AddEntry(graph,"S (for B=%.2f)"%BSum,'p')
#plot Line at expectedLimit_S for the given B
slimit=TGraph()
slimit.SetPoint(0,self.getPoint(0),expectedLimit_S)
slimit.SetPoint(1,self.getPoint(sets[self.OpName][0]-1),expectedLimit_S)
slimit.SetLineWidth(2)
slimit.SetLineStyle(2)
slimit.Draw("LSAME")
if(self.limitCalc_succeeded):
#plot the first points where S<...
llimit=TGraph()
llimit.SetPoint(0,self.getPoint(lower_limit_index),0)
llimit.SetPoint(1,self.getPoint(lower_limit_index),100)
llimit.SetLineWidth(2)
llimit.SetLineStyle(2)
llimit.Draw("LSAME")
ulimit=TGraph()
ulimit.SetPoint(0,self.getPoint(upper_limit_index),0)
ulimit.SetPoint(1,self.getPoint(upper_limit_index),100)
ulimit.SetLineWidth(2)
ulimit.SetLineStyle(2)
ulimit.Draw("LSAME")
limit_legend.AddEntry(ulimit,'first points where S<%.2f'%expectedLimit_S,'l')
#plot the interpolated Limits
llimit_interpolated=TGraph()
llimit_interpolated.SetPoint(0,self.Limits[0],0)
llimit_interpolated.SetPoint(1,self.Limits[0],100)
llimit_interpolated.SetLineWidth(2)
llimit_interpolated.SetLineStyle(2)
llimit_interpolated.SetLineColor(4)
llimit_interpolated.Draw("LSAME")
ulimit_interpolated=TGraph()
ulimit_interpolated.SetPoint(0,self.Limits[1],0)
ulimit_interpolated.SetPoint(1,self.Limits[1],100)
ulimit_interpolated.SetLineWidth(2)
ulimit_interpolated.SetLineStyle(2)
ulimit_interpolated.SetLineColor(4)
ulimit_interpolated.Draw("LSAME")
limit_legend.AddEntry(ulimit_interpolated,'interpolated limits','l')
#Plot the best Limits from CMS/ATLAS
llimit_best=TGraph()
ulimit_best=TGraph()
with open('best_limits_ssWW.csv','rb') as limitcsv:
limitreader=csv.DictReader(limitcsv)
for row in limitreader:
if(row['parameter']==self.OpName):
llimit_best.SetPoint(0,float(row['mob']),0)
llimit_best.SetPoint(1,float(row['mob']),100)
ulimit_best.SetPoint(0,float(row['pob']),0)
ulimit_best.SetPoint(1,float(row['pob']),100)
llimit_best.SetLineWidth(2)
llimit_best.SetLineStyle(2)
llimit_best.SetLineColor(2)
llimit_best.Draw("LSAME")
ulimit_best.SetLineWidth(2)
ulimit_best.SetLineStyle(2)
ulimit_best.SetLineColor(2)
ulimit_best.Draw("LSAME")
limit_legend.AddEntry(ulimit_best,'ssWW Limits (SMP-17-004)','l')
limit_legend.Draw()
plot1.Update()
plot1.GetFrame().SetBorderSize( 12 )
plot1.Modified()
plot1.Update()
if(plot):
plot1.Print('%s/SPlot_%s_%s_%s.eps'%(path,self.channel,self.OpName,self.LastCut))
def main(argv):
print(len(argv))
if len(argv) == 5:
#print ('The script is called: '+str(script))
print('Your waves are: ' + argv[0])
print('Number of M bins is: ' + argv[1])
print('Number of t bins is: ' + argv[2])
print(
'Intensity results from fitting the original data are written in: '
+ argv[3])
print('Phase differences: ' + argv[4])
if len(argv[0].split()) < 2:
sys.exit("You should specify more than one amplitude")
else:
sys.exit(
"You need to give 4 args..., usage: python script.py \"S0mi P1pl D1pl ...\" Nmassbins Ntbins fitresultfile \"P0P1diff \""
)
amps, NumBins, NumtBins, Fitresultfile, phasedifflist = argv
N_amps = len(amps.split())
NumBins = int(NumBins)
NumtBins = int(NumtBins)
Numphasediff = len(phasedifflist.split())
## Output file to save the histograms in
file_out = TFile('Drawing_waves.root', 'Recreate')
## column number for M value and each of the amplitude intensities and
##corresponding errors
column_m = 0
column_t = 1
colomn_Waves = np.arange(2, 2 * N_amps + 1, 2)
colomn_Waves_err = np.arange(3, 2 * N_amps + 2, 2)
column_all_Waves = 2 * N_amps + 2
column_all_Waves_err = 2 * N_amps + 3
column_phasediff = np.arange(column_all_Waves_err + 1,
column_all_Waves_err + 1 + 2 * Numphasediff,
2)
column_phasediff_err = np.arange(
column_all_Waves_err + 2, column_all_Waves_err + 1 + 2 * Numphasediff,
2)
## Arrays of intensities from fitting the original data in different M bins
orig_Wave = np.zeros((N_amps, NumBins))
orig_all_Waves = np.zeros(NumBins)
##Reading uncertainties from MINUIT
orig_Wave_err_square = np.zeros((N_amps, NumBins))
orig_all_Waves_err_square = np.zeros(NumBins)
mass_bins = np.zeros(NumBins)
phase_diff = np.zeros((Numphasediff, NumtBins, NumBins))
phase_diff_err = np.zeros((Numphasediff, NumtBins, NumBins))
## Asigning values to arrays of intensities from fitting the original data in
##different M bins by reading from a file
token_origdata_fitresults = open(Fitresultfile, 'r')
linestoken_orig = token_origdata_fitresults.readlines()
j = 0
fit_res_colomns = 0
for x in linestoken_orig:
fit_res_colomns = len(x.split())
for waves in range(0, N_amps):
orig_Wave[waves][int(j / NumtBins)] = orig_Wave[waves][int(
j / NumtBins)] + float(x.split()[colomn_Waves[waves]])
orig_Wave_err_square[waves][
j /
NumtBins] = orig_Wave_err_square[waves][j / NumtBins] + float(
x.split()[colomn_Waves_err[waves]]) * float(
x.split()[colomn_Waves_err[waves]])
orig_all_Waves[j / NumtBins] = orig_all_Waves[j / NumtBins] + float(
x.split()[column_all_Waves])
orig_all_Waves_err_square[j / NumtBins] = orig_all_Waves_err_square[
j / NumtBins] + float(x.split()[column_all_Waves_err]) * float(
x.split()[column_all_Waves_err])
mass_bins[j / NumtBins] = float(x.split()[column_m])
for N_phase in range(0, Numphasediff):
phase_diff[N_phase][int(j % NumtBins)][int(j / NumtBins)] = float(
x.split()[column_phasediff[N_phase]])
phase_diff_err[N_phase][int(j % NumtBins)][int(
j / NumtBins)] = float(
x.split()[column_phasediff_err[N_phase]])
j = j + 1
if j != NumBins * NumtBins:
sys.exit(
"The total number of bins are different from the one provided")
orig_Wave_err = np.sqrt(orig_Wave_err_square)
orig_all_Waves_err = np.sqrt(orig_all_Waves_err_square)
##Combined intensities of the same amplitudes from diff. sums
N_comb_waves = int(N_amps / 2)
orig_Wave_comb = np.zeros((N_comb_waves, NumBins))
##Combined uncertainty from MINUIT for the same wave from diff. sums
orig_Wave_err_square_comb = np.zeros((N_comb_waves, NumBins))
for waves_comb in range(0, N_comb_waves):
for M_bin in range(0, NumBins):
orig_Wave_comb[waves_comb][M_bin] = orig_Wave[int(
2 * waves_comb)][M_bin] + orig_Wave[int(2 * waves_comb +
1)][M_bin]
orig_Wave_err_square_comb[waves_comb][M_bin] = orig_Wave_err[int(
2 * waves_comb)][M_bin] * orig_Wave_err[int(
2 * waves_comb)][M_bin] + orig_Wave_err[int(
2 * waves_comb + 1)][M_bin] * orig_Wave_err[int(
2 * waves_comb + 1)][M_bin]
orig_Wave_err_comb = np.sqrt(orig_Wave_err_square_comb)
print('I am here')
##The graphs of intensities of different waves
error_M = np.zeros(NumBins)
grerr_list_Wave = []
for waves in range(0, int(N_amps / 2)):
grerr_list_Wave.append(
TGraphErrors(NumBins, mass_bins, orig_Wave_comb[waves], error_M,
orig_Wave_err_comb[waves]))
c1 = TCanvas('c1', 'A Simple Graph with error bars', 200, 10, 700, 500)
c1.Divide(3, 2)
c1.SetGrid()
c1.GetFrame().SetFillColor(21)
c1.GetFrame().SetBorderSize(12)
for waves in range(0, int(N_amps / 2)):
grerr_list_Wave[waves].SetMarkerSize(.5)
grerr_list_Wave[waves].SetMarkerStyle(20)
grerr_list_Wave[waves].SetName(amps.split()[2 * waves])
grerr_list_Wave[waves].SetTitle(amps.split()[2 * waves])
if waves < 6:
grerr_list_Wave[waves].SetMaximum(1.2 *
np.amax(orig_Wave_comb[waves]))
else:
grerr_list_Wave[waves].SetMaximum(1.2 * np.amax(orig_all_Waves))
# grerr_list_Wave[waves].SetMinimum(0.8*np.amin(orig_Wave_comb[waves]))
grerr_list_Wave[waves].SetMinimum(0.8 * np.amin(orig_all_Waves))
grerr_list_Wave[waves].Draw('AP')
c1.Print('Plots/Wave' + amps.split()[2 * waves] + '.pdf')
##The graph of total intensity
c3 = TCanvas('c3', 'A Simple Graph with error bars', 200, 10, 700, 500)
c3.Divide(3, 2)
c3.SetGrid()
c3.GetFrame().SetFillColor(21)
c3.GetFrame().SetBorderSize(12)
gr_all = TGraphErrors(NumBins, mass_bins, orig_all_Waves, error_M,
orig_all_Waves_err)
gr_all.SetMarkerSize(.5)
gr_all.SetMarkerStyle(20)
#gr_all.SetMaximum(max(x_max/2.5))
#gr_all.SetMinimum(min(x_min/5))
gr_all.SetMaximum(1.2 * np.amax(orig_all_Waves))
gr_all.SetMinimum(0.8 * np.amin(orig_all_Waves))
gr_all.SetTitle('All waves')
gr_all.Draw('AP')
c3.Print("Plots/All_waves.pdf")
#plotting phase differences
grerr_list_phasediff = []
t_bin = 0
for N_phasediff in range(0, Numphasediff):
grerr_list_phasediff.append(
TGraphErrors(NumBins, mass_bins, phase_diff[N_phasediff][t_bin],
error_M, phase_diff_err[N_phasediff][t_bin]))
c4 = TCanvas('c4', 'A Simple Graph with error bars', 200, 10, 700, 500)
c4.SetGrid()
c4.GetFrame().SetFillColor(21)
c4.GetFrame().SetBorderSize(12)
for N_phasediff in range(0, Numphasediff):
grerr_list_phasediff[N_phasediff].SetMarkerSize(.5)
grerr_list_phasediff[N_phasediff].SetMarkerStyle(20)
grerr_list_phasediff[N_phasediff].SetName(
phasedifflist.split()[N_phasediff])
grerr_list_phasediff[N_phasediff].SetTitle(
phasedifflist.split()[N_phasediff])
grerr_list_phasediff[N_phasediff].SetMaximum(
1.2 * np.amax(phase_diff[N_phasediff][t_bin]))
grerr_list_phasediff[N_phasediff].SetMinimum(
0.8 * np.amin(phase_diff[N_phasediff][t_bin]))
grerr_list_phasediff[N_phasediff].Draw('AP')
c4.Print('Plots/Phasediff' + phasedifflist.split()[N_phasediff] +
'.pdf')
file_out.Write()
file_out.Close()
gr.SetLineWidth(2)
# gr.SetMarkerColor( color )
gr.SetMarkerStyle(21)
gr.GetXaxis().SetTitle('Energy [GeV]')
gr.GetYaxis().SetTitle('E^{2} x Flux [GeV cm^{-2}s^{-1}]')
gr.SetTitle('')
return gr
################################################################################
################################################################################
# MAIN
can1 = TCanvas('can1', 'A Simple Graph Example', 10, 10, 1810 / 2, 1210 / 2)
can1.SetGrid()
can1.GetFrame().SetFillColor(21)
can1.GetFrame().SetBorderSize(12)
can1.Modified()
can1.Update()
can1.SetLogy()
can1.SetLogx()
leg = TLegend(0.55, 0.78, 0.75, 0.88)
leg.SetBorderSize(0)
leg.SetTextSize(0.03)
dataGraph = readDataIntoGraph()
dataGraph.Draw("AP")
dataGraph.GetYaxis().SetRangeUser(5.0e-12, 1.0e-08)
dataGraph.Draw("AP")
def main(argv):
print(len(argv))
if len(argv) == 3:
#print ('The script is called: '+str(script))
print ('Number of M bins is: '+argv[0])
print ('Number of t bins is: '+argv[1])
print ('Moments are written in: '+argv[2])
else:
sys.exit("You need to give 3 args..., usage: python script.py Nmassbins Ntbins fitresultfile")
NumBins, NumtBins, Fitresultfile = argv
NumBins=int(NumBins)
NumtBins=int(NumtBins)
## Output file to save the histograms in
file_out=TFile('Drawing_moments.root','Recreate')
with open(Fitresultfile,'r') as f:
t=f.read()
l=t.splitlines()
momentlist=l[0]
momentlist=momentlist[3:]
momentlist=momentlist.split()[0::2]
Nummoment=(len(l[0].split())-2)/2
print(momentlist)
print(Nummoment)
## column number for M value and each of the amplitude intensities and
##corresponding errors
column_m = 0
column_t = 1
column_moment=np.arange(column_t+1,column_t+1+2*Nummoment,2)
column_moment_err=np.arange(column_t+2,column_t+1+2*Nummoment,2)
##Moments in different M and t bins
mass_bins=np.zeros(NumBins)
Mom=np.zeros((Nummoment,NumtBins,NumBins))
Mom_err=np.zeros((Nummoment,NumtBins,NumBins))
## Asigning values to arrays of intensities from fitting the original data in
##different M bins by reading from a file
token_origdata_fitresults=open(Fitresultfile,'r')
linestoken_orig=token_origdata_fitresults.readlines()
j=0
fit_res_colomns=0
for x in linestoken_orig[1:]:
fit_res_colomns=len(x.split())
mass_bins[j/NumtBins]=float(x.split()[column_m])
for N_phase in range(0,Nummoment):
Mom[N_phase][int(j%NumtBins)][int(j/NumtBins)]=float(x.split()[column_moment[N_phase]])
Mom_err[N_phase][int(j%NumtBins)][int(j/NumtBins)]=float(x.split()[column_moment_err[N_phase]])
j=j+1
if j != NumBins*NumtBins:
sys.exit("The total number of bins are different from the one provided")
print('I am here')
##The graphs of intensities of different waves
error_M=np.zeros(NumBins)
#plotting phase differences
grerr_list_moment=[]
t_bin=0
for N_moment in range(0,Nummoment):
grerr_list_moment.append(TGraphErrors( NumBins, mass_bins,Mom[N_moment][t_bin], error_M,Mom_err[N_moment][t_bin]))
# print(Mom_err[N_moment][t_bin])
c4 = TCanvas( 'c4', 'A Simple Graph with error bars', 200, 10, 700, 500 )
c4.SetGrid()
c4.GetFrame().SetFillColor( 21 )
c4.GetFrame().SetBorderSize( 12 )
for N_moment in range(0,Nummoment):
grerr_list_moment[N_moment].SetMarkerSize( .5 )
grerr_list_moment[N_moment].SetMarkerStyle( 20 )
grerr_list_moment[N_moment].SetName(momentlist[N_moment])
grerr_list_moment[N_moment].SetTitle(momentlist[N_moment])
grerr_list_moment[N_moment].SetMaximum(1.2*np.amax(Mom[N_moment][t_bin]))
grerr_list_moment[N_moment].SetMinimum(0.8*np.amin(Mom[N_moment][t_bin]))
grerr_list_moment[N_moment].Draw( 'AP' )
grerr_list_moment[N_moment].SetName(momentlist[N_moment])
grerr_list_moment[N_moment].Write()
print(momentlist[N_moment])
c4.Print('Plots/Moments'+momentlist[N_moment]+'.pdf')
file_out.Write()
file_out.Close()
def main(argv):
print(len(argv))
if len(argv) == 6:
#print ('The script is called: '+str(script))
print('Your waves are: ' + argv[0])
print('Number of M bins is: ' + argv[1])
print('Number of t bins is: ' + argv[2])
print('Number of bootstrap samples is:' + argv[3])
print('Directory for bootstrap results for different M bins is: ' +
argv[4])
print(
'Intensity results from fitting the original data are written in: '
+ argv[5])
if len(argv[0].split()) < 2:
sys.exit("You should specify more than one amplitude")
else:
sys.exit(
"You need to give 6 args..., usage: python script.py \"S0mi P1pl D1pl ...\" Nmassbins NBootstrapsamples Bindir fitresultfile"
)
amps, NumBins, NumtBins, kBootstrapPoints, Binfolderdir, Fitresultfile = argv
N_amps = len(amps.split())
NumBins = int(NumBins)
NumtBins = int(NumtBins)
kBootstrapPoints = int(kBootstrapPoints)
## Output file to save the histograms in
file_out = TFile('Drawing_Bootstrap_errors.root', 'Recreate')
## column number for M value and each of the amplitude intensities and
##corresponding errors
column_m = 0
column_t = 1
colomn_Waves = np.arange(2, 2 * N_amps + 1, 2)
colomn_Waves_err = np.arange(3, 2 * N_amps + 2, 2)
column_all_Waves = 2 * N_amps + 2
column_all_Waves_err = 2 * N_amps + 3
## Arrays of intensities from fitting the original data in different M bins
orig_Wave = np.zeros((N_amps, NumBins))
orig_all_Waves = np.zeros(NumBins)
##Reading uncertainties from MINUIT
orig_Wave_err_square = np.zeros((N_amps, NumBins))
orig_all_Waves_err_square = np.zeros(NumBins)
## Asigning values to arrays of intensities from fitting the original data in
##different M bins by reading from a file
token_origdata_fitresults = open(Fitresultfile, 'r')
linestoken_orig = token_origdata_fitresults.readlines()
j = 0
fit_res_colomns = 0
for x in linestoken_orig:
fit_res_colomns = len(x.split())
for waves in range(0, N_amps):
orig_Wave[waves][int(j / NumtBins)] = orig_Wave[waves][int(
j / NumtBins)] + float(x.split()[colomn_Waves[waves]])
orig_Wave_err_square[waves][
j /
NumtBins] = orig_Wave_err_square[waves][j / NumtBins] + float(
x.split()[colomn_Waves_err[waves]]) * float(
x.split()[colomn_Waves_err[waves]])
orig_all_Waves[j / NumtBins] = orig_all_Waves[j / NumtBins] + float(
x.split()[column_all_Waves])
orig_all_Waves_err_square[j / NumtBins] = orig_all_Waves_err_square[
j / NumtBins] + float(x.split()[column_all_Waves_err]) * float(
x.split()[column_all_Waves_err])
j = j + 1
if j != NumBins * NumtBins:
sys.exit(
"The total number of bins are different from the one provided")
orig_Wave_err = np.sqrt(orig_Wave_err_square)
orig_all_Waves_err = np.sqrt(orig_all_Waves_err_square)
## Arrays of intensities for given amplitude from
##fitting different bootstrapping samples
mass = np.zeros(kBootstrapPoints)
Waves = np.zeros((N_amps, kBootstrapPoints))
Waves_err = np.zeros((N_amps, kBootstrapPoints))
all_Waves = np.zeros(kBootstrapPoints)
all_Waves_err = np.zeros(kBootstrapPoints)
## Arrays of mean intensities from bootstrapping for different M bins
mass_bins = np.zeros(NumBins)
## Arrays of std intensities from bootstrapping for different M bins
std_Waves_square = np.zeros((N_amps, NumBins))
std_all_Waves_square = np.zeros(NumBins)
## Histograms of intensities for given mass bin and amplitude from different bootstraping samples
h1_list_Waves = []
h1_list_all = []
i_Mbin = 0
for Mb in range(0, NumBins):
h1_list_Waves.append([])
h1_list_all.append([])
for tb in range(0, NumtBins):
h1_list_Waves[i_Mbin].append([])
i_Mbin = i_Mbin + 1
main = []
#Defining histograms for intensities from different bootstraping samples for a given aplitude and M bin
for Bin in range(0, NumBins):
#N_bins=int(300*orig_all_Waves[Bin])
N_bins = int(80000)
x_min = int(-500)
x_max = int(3 * orig_all_Waves[Bin])
outer = []
for Bint in range(0, NumtBins):
inner = []
for waves in range(0, N_amps):
h1_list_Waves[Bin][Bint].append(
TH1F(
'h1_boot_' + str(amps.split()[waves]) + '_Mbin' +
str(Bin + 1) + '_tbin' + str(Bint + 1),
str(amps.split()[waves]), N_bins, x_min, x_max))
#inner.append(TH1F('h1_boot_'+str(amps.split()[waves])+'_Mbin'+str(Bin+1)+'_tbin'+str(Bint+1),str(amps.split()[waves]),N_bins,x_min,x_max))
#hh = TH1F('h1_boot_'+str(amps.split()[waves])+'_Mbin'+str(Bin+1)+'_tbin'+str(Bint+1),str(amps.split()[waves]),N_bins,x_min,x_max)
#print( "N_bins = " + str(N_bins) + " x_min = " + str(x_min) + " x_max = " + str(x_max) )
#inner.append(hh)
h1_list_all[Bin].append(
TH1F(
'h1_boot_All_' + 'Mbin' + str(Bin + 1) + '_tbin' +
str(Bint + 1), 'All waves', N_bins, x_min, x_max))
#outer.append(inner);
#main.append(outer)
## Assigning values to arrays of intensities for given amplitude from fitting different bootstrapping samples
## by reading the values from files of each of the M bins
##(number of lines in the .txt file corresponds to number of bootstraping samples)
for bin in range(0, NumBins):
for bint in range(0, NumtBins):
token = open(
Binfolderdir + '/bin_' + str(bin) + '_' + str(bint) +
'/etapi_fit.txt', 'r')
linestoken = token.readlines()
i = 0
#Looping through lines corresponding to results from fitting different bottstraping samples
for x in linestoken:
if len(x.split()) != fit_res_colomns:
sys.exit(
"Fit results and bootstraping results have different number of waves"
)
mass[i] = x.split()[column_m]
for waves in range(0, N_amps):
Waves[waves][i] = x.split()[colomn_Waves[waves]]
Waves_err[waves][i] = x.split()[colomn_Waves_err[waves]]
h1_list_Waves[bin][bint][waves].Fill(Waves[waves][i])
all_Waves[i] = x.split()[column_all_Waves]
all_Waves_err[i] = x.split()[column_all_Waves_err]
h1_list_all[bin][bint].Fill(all_Waves[i])
i = i + 1
token.close()
mass_bins[bin] = mass[0]
for waves in range(0, N_amps):
std_Waves_square[waves][bin] = std_Waves_square[waves][
bin] + Waves[waves].std() * Waves[waves].std()
std_all_Waves_square[bin] = std_all_Waves_square[
bin] + all_Waves.std() * all_Waves.std()
std_Waves = np.sqrt(std_Waves_square)
std_all_Waves = np.sqrt(std_all_Waves_square)
print('I am here')
##The graphs of intensities of different waves
error_M = np.zeros(NumBins)
grerr_list_Wave = []
for waves in range(0, N_amps):
grerr_list_Wave.append(
TGraphErrors(NumBins, mass_bins, orig_Wave[waves], error_M,
std_Waves[waves]))
c1 = TCanvas('c1', 'A Simple Graph with error bars', 200, 10, 700, 500)
c1.Divide(3, 2)
c1.SetGrid()
c1.GetFrame().SetFillColor(21)
c1.GetFrame().SetBorderSize(12)
for waves in range(0, N_amps):
grerr_list_Wave[waves].SetMarkerSize(.5)
grerr_list_Wave[waves].SetMarkerStyle(20)
grerr_list_Wave[waves].SetName(amps.split()[waves])
grerr_list_Wave[waves].SetTitle(amps.split()[waves])
grerr_list_Wave[waves].SetMaximum(1.2 * np.amax(orig_Wave[waves]))
grerr_list_Wave[waves].SetMinimum(0.8 * np.amin(orig_Wave[waves]))
grerr_list_Wave[waves].Draw('AP')
c1.Print('Wave' + amps.split()[waves] + '.pdf')
##The graph of total intensity
c3 = TCanvas('c3', 'A Simple Graph with error bars', 200, 10, 700, 500)
c3.Divide(3, 2)
c3.SetGrid()
c3.GetFrame().SetFillColor(21)
c3.GetFrame().SetBorderSize(12)
gr_all = TGraphErrors(NumBins, mass_bins, orig_all_Waves, error_M,
std_all_Waves)
gr_all.SetMarkerSize(.5)
gr_all.SetMarkerStyle(20)
#gr_all.SetMaximum(max(x_max/2.5))
#gr_all.SetMinimum(min(x_min/5))
gr_all.SetMaximum(1.2 * np.amax(orig_all_Waves))
gr_all.SetMinimum(0.8 * np.amin(orig_all_Waves))
gr_all.SetTitle('All waves')
gr_all.Draw('AP')
c3.Print("All_waves.pdf")
## Plotting with MINUIT uncertainties
grerr_list_Wave_minuit = []
for waves in range(0, N_amps):
grerr_list_Wave_minuit.append(
TGraphErrors(NumBins, mass_bins, orig_Wave[waves], error_M,
orig_Wave_err[waves]))
c4 = TCanvas('c4', 'A Simple Graph with error bars', 200, 10, 700, 500)
#c4.Divide(3,2)
c4.SetGrid()
c4.GetFrame().SetFillColor(21)
c4.GetFrame().SetBorderSize(12)
for waves in range(0, N_amps):
grerr_list_Wave_minuit[waves].SetMarkerSize(.5)
grerr_list_Wave_minuit[waves].SetMarkerStyle(20)
grerr_list_Wave_minuit[waves].SetName(amps.split()[waves])
grerr_list_Wave_minuit[waves].SetTitle(amps.split()[waves])
grerr_list_Wave_minuit[waves].SetMaximum(1.2 *
np.amax(orig_Wave[waves]))
grerr_list_Wave_minuit[waves].SetMinimum(0.8 *
np.amin(orig_Wave[waves]))
grerr_list_Wave_minuit[waves].Draw('AP')
c4.Print('Wave' + amps.split()[waves] + 'minuit.pdf')
##The graph of total intensity
c5 = TCanvas('c5', 'A Simple Graph with error bars', 200, 10, 700, 500)
#c5.Divide(3,2)
c5.SetGrid()
c5.GetFrame().SetFillColor(21)
c5.GetFrame().SetBorderSize(12)
gr_all_minuit = TGraphErrors(NumBins, mass_bins, orig_all_Waves, error_M,
orig_all_Waves_err)
gr_all_minuit.SetMarkerSize(.5)
gr_all_minuit.SetMarkerStyle(20)
#gr_all_minuit .SetMaximum(max(x_max/2.5))
#gr_all_minuit .SetMinimum(min(x_min/5))
gr_all_minuit.SetMaximum(1.2 * np.amax(orig_all_Waves))
gr_all_minuit.SetMinimum(0.8 * np.amin(orig_all_Waves))
gr_all_minuit.SetTitle('All waves')
gr_all_minuit.Draw('AP')
c3.Print("All_waves_minuit.pdf")
file_out.Write()
file_out.Close()
#*-* - a profile histogram
#*-* - a memory-resident ntuple
#*-*
#*-* These objects are filled with some random numbers and saved on a file.
#*-*
#*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
from ROOT import TCanvas, TFile, TProfile, TNtuple, TH1F, TH2F
from ROOT import gROOT, gBenchmark, gRandom, gSystem
gROOT.Reset()
# 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('hsimple.root')
if hfile:
hfile.Close()
hfile = TFile('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)
from ROOT import TChain, TFile, TTree, TCanvas, TH2F, gStyle
from array import array
import root_numpy
###############################################################################
# Open root files and create new one with lljj_M and jj_M #
###############################################################################
#INPUT_FOLDER = '/home/ucl/cp3/swertz/scratch/CMSSW_8_0_25/src/cp3_llbb/HHTools/slurm/170728_skimForTrainingExtra/slurm/output/*.root'
INPUT_FOLDER = '/nfs/scratch/fynu/asaggio/CMSSW_8_0_30/src/cp3_llbb/ZATools/factories_ZA/add_met_mll_forFlorian/slurm/output/*.root'
OUTPUT_FOLDER = '/home/ucl/cp3/fbury/storage/'
c1 = TCanvas('c1', 'Dynamic Filling Example', 200, 10, 700, 500)
c1.SetFillColor(10)
c1.GetFrame().SetFillColor(1)
c1.GetFrame().SetBorderSize(6)
c1.GetFrame().SetBorderMode(-1)
c1.SetRightMargin(.15)
gStyle.SetOptStat(0)
mass_plane = TH2F('mass_plane', 'Mass Plane;M_{bb} [GeV];M_{llbb} [GeV]', 200,
0, 1000, 200, 0, 1000)
for f_in in glob.glob(INPUT_FOLDER):
print('\nOpening : ', f_in)
file_in = ROOT.TFile.Open(f_in)
t_in = file_in.Get("t")
for entry in t_in:
gr1.GetYaxis().SetTitleSize(textsize)
gr1.GetXaxis().SetLabelSize(textsize)
gr1.GetXaxis().SetTitleSize(textsize)
gr1.GetYaxis().SetLabelSize(textsize)
gr1.GetYaxis().SetRangeUser(-0.15, 0.15)
gr1.GetYaxis().SetNdivisions(505)
gr1.Draw( 'AP' )
func2 = TF1('fun2','0', 0., 100.)
func2.SetLineColor(4)
func2.SetLineStyle(2)
func2.Draw('same')
# TCanvas.Update() draws the frame, after which one can change it
c1.Update()
c1.GetFrame().SetBorderSize( 12 )
c1.Modified()
c1.Update()
c1.Print('linearity.eps')
#-------------------------------------------------
c2 = TCanvas( 'c2', 'resolution', 300, 400 )
gr2 = TGraphErrors( n, energyVec, relEnergyErrorVec , energyErrorVec, relEnergyErrorErrorVec)
gr2.SetName('gr2')
gr2.SetLineColor( 1 )
gr2.SetLineWidth( 1 )
gr2.SetLineStyle( 2 )
gr2.SetMarkerColor( 2 )
"""
#--------------------------------
#No PU sample
#--------------------------------
h_depth1_o.Fit("landau","R","",0.06,1.16)
h_depth2_o.Fit("landau","R","",0.08,1.2)
h_depth3_o.Fit("landau","R","",0.1,1.2)
h_depth4_o.Fit("landau","R","",0.1,1.2)
h_depth5_o.Fit("landau","R","",0.26,1.38)
h_depth6_o.Fit("landau","R","",0.36,1.5)
h_depth7_o.Fit("landau","R","",0.26,1.78)
"""
c1 = TCanvas('c1', '', 200, 10, 700, 500)
c1.GetFrame().SetBorderMode(-1)
c1.GetFrame().SetBorderSize(5)
h_depth1_o.SetFillColor(17)
h_depth1_o.Draw()
c2 = TCanvas('c2', '', 200, 10, 700, 500)
h_depth2_o.SetFillColor(17)
h_depth2_o.Draw()
c3 = TCanvas('c3', '', 200, 10, 700, 500)
h_depth3_o.SetFillColor(17)
h_depth3_o.Draw()
c4 = TCanvas('c4', '', 200, 10, 700, 500)
