def Seed_test():
fileNames = dm.GetFileNames('\seed_test') # get filenames
events = fileNames[0:5] # split the dataset in half
events_CP = fileNames[5:10] # make this half CP data
value = []
error = []
for i in range(5):
p = dm.AmpGendf(events[i], False) # generate particle data
pbar = dm.AmpGendf(events_CP[i], True)
C_T = kin.Scalar_TP(kin.Vector_3(p['p_3']), kin.Vector_3(p['p_4']),
kin.Vector_3(
p['p_1'])) # calcualtes scalar triple product
C_Tbar = -kin.Scalar_TP(kin.Vector_3(
pbar['p_3']), kin.Vector_3(pbar['p_4']), kin.Vector_3(pbar['p_1']))
A_T = kin.TP_Amplitude(C_T) # calculate parity asymmetries
A_Tbar = kin.TP_Amplitude(C_Tbar)
A_CP = kin.A_CP(A_T, A_Tbar) # calculate A_CP
value.append(A_CP[0])
error.append(A_CP[1])
pt.ErrorPlot([np.linspace(1, 5, 5), value],
axis=True,
y_error=error,
x_axis="Iteration",
y_axis="$\mathcal{A}_{CP}$") # plots data
def CPConvergenceTest():
value = []
error = []
eventFiles = dm.GetFileNames('\Samples') # get filenames
eventFiles_CP = dm.GetFileNames('\Samples_CP')
for i in range(len(eventFiles)):
p = dm.AmpGendf(eventFiles[i], False) # generate particle data
pbar = dm.AmpGendf(eventFiles_CP[i], True) # generate CP particle data
C_T = kin.Scalar_TP(kin.Vector_3(p['p_3']), kin.Vector_3(p['p_4']),
kin.Vector_3(
p['p_1'])) # calcualtes scalar triple product
C_Tbar = -kin.Scalar_TP(
kin.Vector_3(pbar['p_3']), kin.Vector_3(pbar['p_4']),
kin.Vector_3(pbar['p_1'])) # -sign for parity flip
A_T = kin.TP_Amplitude(C_T) # calculate parity asymmetries
A_Tbar = kin.TP_Amplitude(C_Tbar)
A_CP = kin.A_CP(A_T, A_Tbar) # calculate A_CP
value.append(A_CP[0])
error.append(A_CP[1])
pt.ErrorPlot([np.linspace(1, 10, len(eventFiles)), value],
axis=True,
y_error=error,
x_axis="Number of Events ($10^{5}$)",
y_axis="$\mathcal{A}_{CP}$") # plots data
def PlotFitProjections(file_name, plotData=True, fit_color="red"):
file = uproot.open(file_name) # open root file
names = [*dict(file)] # branch names
names = [names[x].decode("utf-8")[:-2]
for x in range(len(names))] # convert names from bytes to string
model_names = names[:int(len(names) / 2)] # get model histogram names
if plotData is True:
data_names = names[int(len(names) / 2):] # get data histogram names
particle_names = [
"$m_{D^{0}\\bar{D}^{0}}$", "$m_{D^{0}K^{+}}$", "$m_{D^{0}\pi^{-}}$",
"$m_{\\bar{D}^{0}K^{+}}$", "$m_{\\bar{D}^{0}\pi^{-}}$",
"$m_{K^{+}\pi^{-}}$", "$m_{D^{0}\\bar{D}^{0}K^{+}}$",
"$m_{D^{0}\\bar{D}^{0}\pi^{-}}$", "$m_{D^{0}K^{+}\pi^{-}}$",
"$m_{\\bar{D}^{0}K^{+}\pi^{-}}$"
] # x_labels
"""Plots the data and respective fit calcualted by AMPGEN"""
for i in range(len(model_names)):
plt.subplot(3, 4, i + 1) # define subplot in figure
model = Hist(file[model_names[i]]) # get data from histogram
model[0] = np.sqrt(
model[0]) # turn invarnat mass squared to invariant mass
pt.ErrorPlot(model, alpha=0.5, markersize=2.5,
color=fit_color) # plot fitted data
if plotData is True:
data = Hist(file[data_names[i]])
data[0] = np.sqrt(data[0])
pt.ErrorPlot(data,
y_error=np.sqrt(data[0]),
marker=None,
capsize=2,
alpha=0.5,
x_axis=particle_names[i] + "(GeV)",
axis=True,
y_axis="Number of Events") # plot data with errorbars
def PlotData(A_Ts, A_Tbars, A_CPs, A_T, A_Tbar):
global Asyms, Asym_mean, Asym_error
Asyms = [A_Ts, A_Tbars, A_CPs] # stores values in a list for easy access
labels = ['$A_{T}$', '$\\bar{A}_{T}$',
'$\mathcal{A}_{CP}$'] # labels for each plot
A_CP = kin.A_CP(A_T, A_Tbar)
plot = 131 # 1 row, 3 columns, start at 1st postition
"""Loops through each figure and plots the asymmetry, global asymmetry and 1 and 5 sigma error bars for the global asymmetry"""
for i in range(len(Asyms)):
if i == 0:
glob = A_T
if i == 1:
glob = A_Tbar
if i == 2:
glob = A_CP
ax = plt.subplot(plot + i) # create the subplot
Asym_val = [Asyms[i][j][0]
for j in range(len(Asyms[i]))] # get mean values
Asym_error = [Asyms[i][j][1]
for j in range(len(Asyms[i]))] # get uncertainties
Asym_val = np.array(Asym_val)
Asym_error = np.array(Asym_error)
chisqr = np.sum((Asym_val / Asym_error)**2)
print(str(chisqr) + "/" + str(len(Asym_val)))
p = 1 - stats.chi2.cdf(chisqr, 32)
print(p)
pt.ErrorPlot([bin_regions, Asym_val],
axis=True,
x_axis='Bin Region',
y_axis=labels[i],
y_error=Asym_error,
legend=False) # plot bin region values
plt.hlines(glob[0], -5, 35,
linestyle='--') # plot line indicating the global asymmetry
plt.fill_between(np.linspace(-5, 35, 40),
glob[0] + glob[1],
glob[0] - glob[1],
color="black",
alpha=0.1) # 1 sigma global uncertainty region
plt.fill_between(np.linspace(-5, 35, 40),
glob[0] + 5 * glob[1],
glob[0] - 5 * glob[1],
color="black",
alpha=0.1) # 5 sigma global uncertainty region
ax.set_ylim(
(-0.1, 0.1
)) # det plot limits equal to each other for easy interpretation
ax.set_xlim((-5, 35))
def AnalysePwave(directory,
factors,
label,
CP=False,
plot=True,
color=None,
marker=None):
data = dm.GenerateDataFrames(
directory, CP) # gets particle data from the event files in directory
""""Adjusts value of C_T if we use CP data or not"""
if CP is False:
f = 1
else:
f = -1
value = [] # mean asymmetry value
error = []
for i in range(len(factors)):
data_amp = data[i * 10:(i + 1) * 10] # gets every 10 data points
data_amp = dm.MergeData(
data_amp) # combines the different seeded data into one set
C_T = f * kin.Scalar_TP(
kin.Vector_3(data_amp[3]), kin.Vector_3(data_amp[4]),
kin.Vector_3(data_amp[1])) # calculate scalar triple product
A_T = kin.TP_Amplitude(C_T) # calculates parity asymmetry
value.append(A_T[0] * 100)
error.append(A_T[1] * 100)
# will return the plot so figures can be built
if plot is True:
return pt.ErrorPlot([factors, value],
label=label,
legend=True,
axis=True,
y_error=error,
x_axis="relative P-wave amplitudes",
y_axis="",
capsize=5,
markersize=5,
linestyle="-",
marker=marker,
color=color)
# in case we want to do something else
if plot is False:
return value, error
def AnalyseCPwave(direct, direct_CP, factors, label, plot=True):
datas = dm.GenerateDataFrames(
direct, False) # gets particle data from the event files in directory
datas_CP = dm.GenerateDataFrames(
direct_CP,
True) # gets particle CP data from the event files in directory
value = [] # mean asymmetry value
error = []
for i in range(len(factors)):
data_amp = datas[i * 10:(i + 1) * 10] # gets every 10 data points
data_amp = dm.MergeData(
data_amp) # combines the different seeded data into one set
data_amp_CP = datas_CP[i * 10:(i + 1) * 10]
data_amp_CP = dm.MergeData(data_amp_CP)
C_T = kin.Scalar_TP(
kin.Vector_3(data_amp[3]), kin.Vector_3(data_amp[4]),
kin.Vector_3(data_amp[1])) # calculate scalar triple product
C_Tbar = -kin.Scalar_TP(kin.Vector_3(data_amp_CP[3]),
kin.Vector_3(data_amp_CP[4]),
kin.Vector_3(data_amp_CP[1]))
A_T = kin.TP_Amplitude(C_T) # calculates parity asymmetry
A_Tbar = kin.TP_Amplitude(C_Tbar)
A_CP = kin.A_CP(A_T, A_Tbar) # calculates CP asymmetry
value.append(A_CP[0])
error.append(A_CP[1])
# will return the plot so figures can be built
if plot is True:
return pt.ErrorPlot([factors, value],
label=label,
legend=False,
axis=True,
y_error=error,
x_axis="relative P-wave amplitudes",
y_axis="$\mathcal{A}_{CP}$")
# in case we want to do something else
if plot is False:
return value, error
def PlotConvergence():
global A_T, A_Tbar, A_CP
x = [1E3, 1E4, 1E5, 1E6, 1E7] # number of events per sample
A_T = np.load("Convergence_Test/A_T.npy") # load the numpy data
A_Tbar = np.load("Convergence_Test/A_Tbar.npy")
A_CP = np.load("Convergence_Test/A_CP.npy")
Asyms = [A_T, A_Tbar, A_CP] # list of data to plot
labels = ["$A_{T}$", "$\\bar{A}_{T}$", "$\\mathcal{A}_{CP}$"] # y labels
loc = 131 # initial figure location
j = 0 # which figure to plot to - 1
"""Will plot each asymmetry in a figure"""
for Asym in Asyms:
plt.subplot(loc + j) # assign figure
mean = [Asym[i][0] for i in range(len(Asym))] # get the mean values
error = [Asym[i][1] for i in range(len(Asym))] # get the errors
pt.ErrorPlot((x, mean),
y_error=error,
x_axis="Number of Events",
axis=True,
y_axis=labels[j]) # plot with error bars
plt.xscale("log") # switch to a log scale on x
j += 1 # move on the the next figure
