def multiclass_graph(mt_dec,probas,name,axis_range=[0.,250.]) :
#create a graph and save it as root file
dec_modes = [0.0,1.0,10.0]
print np.shape(mt_dec)
print np.shape(probas)
num_of_classes = len(probas[0])
all_input = np.transpose(np.vstack((mt_dec[:,0],mt_dec[:,1], probas[:,0], probas[:,1], probas[:,2], probas[:,3], probas[:,4], probas[:,5])))
for j in dec_modes :
x = np.array(filter(lambda x: x[1] == j, all_input))[:,0]
for k in xrange(0,num_of_classes,1) :
y = np.array(filter(lambda x: x[1] == j, all_input))[:,k+2]
graph = Graph(len(x),"g1")
#create a root file and fill it with the graph P(W+jet) vs mt
root_open("plots/ROOTfiles/G_"+name+GetClass(k+1)+'_dec_'+str(j)+".root", 'recreate')
fill_graph(graph,np.column_stack((x,y)))
graph.Write()
#create Canvas and save the plot as png
c = Canvas()
graph.SetTitle(name+GetClass(k+1)+'_dec_'+str(j))
graph.SetMarkerSize(0.3)
graph.GetXaxis().SetRangeUser(axis_range[0],axis_range[1])
graph.Draw("AP")
c.SaveAs("plots/G_"+name+GetClass(k+1)+'_dec_'+str(j)+".png")
def efficiency_bdt(pass_function, function_inputs, xs):
pass_results = pass_function(function_inputs)
xs_train = xs.reshape(-1, 1)
clf = GradientBoostingClassifier()
clf.fit(xs_train, pass_results)
graph = Graph(100)
xs_graph = np.linspace(np.amin(xs), np.amax(xs), num=100)
probas = clf.predict_proba(xs_graph.reshape(-1, 1))[:, [1]]
print probas
fill_graph(graph, np.column_stack((xs_graph, probas)))
print np.column_stack((xs_graph, probas))
return graph
def efficiency_bdt(pass_function, function_inputs, xs):
pass_results = pass_function(function_inputs)
xs_train = xs.reshape(-1,1)
clf = GradientBoostingClassifier()
clf.fit(xs_train, pass_results)
graph = Graph(100)
xs_graph = np.linspace(np.amin(xs), np.amax(xs), num=100)
probas = clf.predict_proba(xs_graph.reshape(-1,1))[:, [1]]
print probas
fill_graph(graph, np.column_stack((xs_graph, probas)))
print np.column_stack((xs_graph, probas))
return graph
def ClassProba(path) :
inputs_test = pickle.load( open( path+"/"+"inputs_test.pck", "rb" ) )
Wjet_proba = pickle.load( open( path+"/"+"class_proba.pck", "rb" ) )[:,0]
c = Canvas()
graph = Graph(len(inputs_test),"WjetProba")
print len(inputs_test)
print len(Wjet_proba)
root_open("WjetProba.root", 'recreate')
fill_graph(graph,np.column_stack((inputs_test,Wjet_proba)))
graph.SetMarkerSize(0.3)
graph.GetXaxis().SetRangeUser(0.,250.)
graph.Draw("AP")
c.SaveAs(path+"/"+"WjetProba_mt.png")
def test_fill_graph():
n_samples = 1000
data2D = RNG.randn(n_samples, 2)
data3D = RNG.randn(n_samples, 3)
graph = TGraph()
rnp.fill_graph(graph, data2D)
graph2d = TGraph2D()
rnp.fill_graph(graph2d, data3D)
# array not 2-d
for g in (graph, graph2d):
assert_raises(ValueError, rnp.fill_graph, g, RNG.randn(10))
# length of second axis does not match dimensionality of histogram
for g in (graph, graph2d):
assert_raises(ValueError, rnp.fill_graph, g, RNG.randn(10, 4))
# wrong type
h = list()
a = RNG.randn(10)
assert_raises(TypeError, rnp.fill_graph, h, a)
def test_fill_graph():
np.random.seed(0)
data2D = np.random.randn(1E6, 2)
data3D = np.random.randn(1E4, 3)
graph = TGraph()
rnp.fill_graph(graph, data2D)
graph2d = TGraph2D()
rnp.fill_graph(graph2d, data3D)
# array not 2-d
for g in (graph, graph2d):
assert_raises(ValueError, rnp.fill_graph, g, np.random.randn(1E4))
# length of second axis does not match dimensionality of histogram
for g in (graph, graph2d):
assert_raises(ValueError, rnp.fill_graph, g, np.random.randn(1E4, 4))
# wrong type
h = list()
a = np.random.randn(100)
assert_raises(TypeError, rnp.fill_graph, h, a)
def test_fill_graph():
n_samples = 1000
data2D = RNG.randn(n_samples, 2)
data3D = RNG.randn(n_samples, 3)
graph = TGraph()
rnp.fill_graph(graph, data2D)
graph2d = TGraph2D()
rnp.fill_graph(graph2d, data3D)
# array not 2-d
for g in (graph, graph2d):
assert_raises(ValueError, rnp.fill_graph, g, RNG.randn(10))
# length of second axis does not match dimensionality of histogram
for g in (graph, graph2d):
assert_raises(ValueError, rnp.fill_graph, g, RNG.randn(10, 4))
# wrong type
h = list()
a = RNG.randn(10)
assert_raises(TypeError, rnp.fill_graph, h, a)
def find_best_working_point(effs, signal_efficiencies, background_efficiencies, signal_probabilities, background_probabilities):
# Compute ratios of background and signal probabilities and truncate the array
# to match the gradient array size
probability_ratios = background_probabilities/signal_probabilities
probability_ratios = probability_ratios[1:]
# Compute efficiency gradients
effs_diff = np.ediff1d(effs)
signal_efficiencies_diff = np.ediff1d(signal_efficiencies)
background_efficiencies_diff = np.ediff1d(background_efficiencies)
signal_efficiencies_diff = np.divide(signal_efficiencies_diff, effs_diff)
background_efficiencies_diff = np.divide(background_efficiencies_diff, effs_diff)
# Apply averaging over 3 or 2 values in order to smooth the gradients
signal_efficiencies_diff_3 = np.convolve(signal_efficiencies_diff, np.repeat(1.0, 3.)/3., 'valid')
signal_efficiencies_diff_2 = np.convolve(signal_efficiencies_diff, np.repeat(1.0, 2.)/2., 'valid')
signal_efficiencies_diff = np.append(signal_efficiencies_diff_3, [signal_efficiencies_diff_2[-1],signal_efficiencies_diff[-1]])
background_efficiencies_diff_3 = np.convolve(background_efficiencies_diff, np.repeat(1.0, 3.)/3., 'valid')
background_efficiencies_diff_2 = np.convolve(background_efficiencies_diff, np.repeat(1.0, 2.)/2., 'valid')
background_efficiencies_diff = np.append(background_efficiencies_diff_3, [background_efficiencies_diff_2[-1],background_efficiencies_diff[-1]])
# Apply the signal and background probabilities in order to weight the efficiency gradients
# If it is more likely to have background than signal in this bin, then the background efficiency gradient
# will be increased accordingly
background_efficiencies_diff = background_efficiencies_diff * probability_ratios
# Interpolate and find points where background efficiency gradient > signal efficiency gradient (with some tolerance)
interp_x = np.linspace(np.amin(effs[1:]), np.amax(effs[1:]), 1000)
interp_signal = np.interp(interp_x, effs[1:], signal_efficiencies_diff)
interp_background = np.interp(interp_x, effs[1:], background_efficiencies_diff)
optimal_points = np.argwhere(np.greater(interp_background-0.05, interp_signal)).ravel() # Use a tolerance of 0.02 in case of fluctuations
if len(optimal_points)==0:
print 'WARNING: no working point found where the efficiency gradient is larger for background than for signal'
# Find optimal point with smallest efficiency
## Compute spacing between points, and select those with an efficiency separation > 2%
optimal_discontinuities = np.argwhere(np.ediff1d(interp_x[optimal_points])>0.02).ravel()
## Select the point with the largest efficiency
optimal_index = np.amax(optimal_discontinuities)+1 if len(optimal_discontinuities)>0 else 0
optimal_point = interp_x[optimal_points[optimal_index]]
# Create graphs
signal_efficiencies_diff_graph = Graph(len(effs)-1)
background_efficiencies_diff_graph = Graph(len(effs)-1)
optimal_points_graph = Graph(len(optimal_points))
fill_graph(signal_efficiencies_diff_graph, np.column_stack((effs[1:], signal_efficiencies_diff)))
fill_graph(background_efficiencies_diff_graph, np.column_stack((effs[1:], background_efficiencies_diff)))
fill_graph(optimal_points_graph, np.column_stack((interp_x[optimal_points], interp_signal[optimal_points])))
signal_efficiencies_diff_graph.SetName('efficiencies_signal')
background_efficiencies_diff_graph.SetName('efficiencies_background')
optimal_points_graph.SetName('signal_background_optimal_points')
return signal_efficiencies_diff_graph, background_efficiencies_diff_graph, optimal_points_graph, optimal_point
def find_best_working_point(effs, signal_efficiencies,
background_efficiencies):
# Compute efficiency gradients
effs_diff = np.ediff1d(effs)
signal_efficiencies_diff = np.ediff1d(signal_efficiencies)
background_efficiencies_diff = np.ediff1d(background_efficiencies)
signal_efficiencies_diff = np.divide(signal_efficiencies_diff, effs_diff)
background_efficiencies_diff = np.divide(background_efficiencies_diff,
effs_diff)
# Interpolate and find points where background efficiency gradient > signal efficiency gradient (with some tolerance)
interp_x = np.linspace(np.amin(effs[1:]), np.amax(effs[1:]), 1000)
interp_signal = np.interp(interp_x, effs[1:], signal_efficiencies_diff)
interp_background = np.interp(interp_x, effs[1:],
background_efficiencies_diff)
optimal_points = np.argwhere(
np.greater(interp_background - 0.05, interp_signal)).ravel(
) # Use a tolerance of 0.02 in case of fluctuations
if len(optimal_points) == 0:
print 'WARNING: no working point found where the efficiency gradient is larger for background than for signal'
# Find optimal point with smallest efficiency
## Compute spacing between points, and select those with an efficiency separation > 2%
optimal_discontinuities = np.argwhere(
np.ediff1d(interp_x[optimal_points]) > 0.02).ravel()
## Select the point with the largest efficiency
optimal_index = np.amax(optimal_discontinuities) + 1 if len(
optimal_discontinuities) > 0 else 0
optimal_point = interp_x[optimal_points[optimal_index]]
# Create graphs
signal_efficiencies_diff_graph = Graph(len(effs) - 1)
background_efficiencies_diff_graph = Graph(len(effs) - 1)
optimal_points_graph = Graph(len(optimal_points))
fill_graph(signal_efficiencies_diff_graph,
np.column_stack((effs[1:], signal_efficiencies_diff)))
fill_graph(background_efficiencies_diff_graph,
np.column_stack((effs[1:], background_efficiencies_diff)))
fill_graph(
optimal_points_graph,
np.column_stack(
(interp_x[optimal_points], interp_signal[optimal_points])))
signal_efficiencies_diff_graph.SetName('efficiencies_signal')
background_efficiencies_diff_graph.SetName('efficiencies_background')
optimal_points_graph.SetName('signal_background_optimal_points')
return signal_efficiencies_diff_graph, background_efficiencies_diff_graph, optimal_points_graph, optimal_point
def remake_arrays(input_arr_):
w_r_bins = 0.01
# need z-binning corresponding to 1 roc
w_z_bins = 52 # # of pixels in a roc
# need phi-binning corresponding to 1 roc (maybe 2?)
w_phi_bins = 80
n_z_bins = int(3328 / w_z_bins) # 3328 is number of pixels in a ladder row
n_phi_bins = int(
960 / w_phi_bins
) # 1440 is number of pixels around phi for all ladders, 960 for inner ladders
inner_array = np.array(
[row for row in input_arr_ if not np.all(row == None)])
cleaned_array = np.array(
[[x if x is not None else [0, np.nan, np.nan, np.nan] for x in row]
for row in inner_array])
r_min = np.nanmin(cleaned_array[:, :, 1])
r_max = np.nanmax(cleaned_array[:, :, 1])
# separate pixels into groups corresponding to rocs in phi and z
array_by_rocs = np.array([
cleaned_array[j * w_phi_bins:(j + 1) * w_phi_bins,
i * w_z_bins:(i + 1) * w_z_bins] for i in range(n_z_bins)
for j in range(n_phi_bins)
])
#roc_index = [0, 1]
roc_index = range(0, n_z_bins * n_phi_bins)
# fig, axs = plt.subplots(8, 8, sharex=False, sharey=False, figsize=(160, 160), tight_layout=True) #all rocs and modules
# fig, axs = plt.subplots(12, 2, sharex=True, sharey=True, figsize=(20, 20), tight_layout=False) # fraction of rocs and modules
# fig, axs = plt.subplots(1, sharex=True, sharey=True, figsize=(20, 20), tight_layout=True) # fraction of rocs and modules
#fig = plt.figure() # fraction of rocs and modules
#axs = fig.add_subplot(111, projection='3d') # fraction of rocs and modules
# minus - 0-383
# plus - 384-767
occ = []
x_array = []
y_array = []
z_array = []
z_err_array = []
phi_array = []
phi_err_array = []
r_array = []
r_err_array = []
z_hl = []
z_err_hl = []
phi_hl = []
r_hl = []
r_err_hl = []
occ_hl = []
occ_ring = []
r_ring = []
phi_ring = []
z_ring = []
n_ladders = 12
n_rings = 64
for x in range(n_ladders):
occ_hl.append([])
r_hl.append([])
r_err_hl.append([])
phi_hl.append([])
z_hl.append([])
z_err_hl.append([])
for x in range(n_rings):
occ_ring.append([])
r_ring.append([])
phi_ring.append([])
z_ring.append([])
i_ladder = 0
i_ring = 0
# section off rocs into roc ladders (12 'ladders'), each true ladder is split in half 6 * 2 = 12
for roc in roc_index:
occ_tmp = np.concatenate(array_by_rocs[roc, :, :, 0])
r = np.concatenate(array_by_rocs[roc, :, :, 1])
phi = np.concatenate(array_by_rocs[roc, :, :, 2])
z = np.concatenate(array_by_rocs[roc, :, :, 3])
z_avg = np.nanmean(z)
x = r[~np.isnan(z)] * np.cos(phi[~np.isnan(z)])
y = r[~np.isnan(z)] * np.sin(phi[~np.isnan(z)])
r = r[~np.isnan(z)]
phi = phi[~np.isnan(z)]
occ_tmp = occ_tmp[~np.isnan(z)]
z = z[~np.isnan(z)]
r = np.sqrt(x**2 + y**2 + z**2)
occ.append(np.sum(occ_tmp))
x_array.append(np.average(x, weights=occ_tmp))
y_array.append(np.average(y, weights=occ_tmp))
z_array.append(np.average(z, weights=occ_tmp))
z_err_array.append(np.std(z))
phi_array.append(np.average(phi, weights=occ_tmp))
phi_err_array.append(np.average(phi, weights=occ_tmp))
r_array.append(np.average(r, weights=occ_tmp))
r_err_array.append(np.std(r))
occ_hl[i_ladder].append(np.sum(occ_tmp))
r_hl[i_ladder].append(np.average(r, weights=occ_tmp))
r_err_hl[i_ladder].append(np.std(r))
phi_hl[i_ladder].append(np.average(phi, weights=occ_tmp))
z_hl[i_ladder].append(np.average(z, weights=occ_tmp))
z_err_hl[i_ladder].append(np.std(z))
occ_ring[i_ring].append(np.sum(occ_tmp))
r_ring[i_ring].append(np.average(r, weights=occ_tmp))
phi_ring[i_ring].append(np.average(phi, weights=occ_tmp))
z_ring[i_ring].append(np.average(z, weights=occ_tmp))
i_ladder += 1
if i_ladder == n_ladders:
i_ring += 1
i_ladder = 0
occ = np.array(occ)
x_array = np.array(x_array)
y_array = np.array(y_array)
z_array = np.array(z_array)
z_err_array = np.array(z_err_array)
phi_array = np.array(phi_array)
phi_err_array = np.array(phi_err_array)
r_array = np.array(r_array)
r_err_array = np.array(r_err_array)
phi_sort = np.argsort(phi_array)
z_sort = np.argsort(z_array)
occ = occ[z_sort]
x_array = x_array[z_sort]
y_array = y_array[z_sort]
z_array = z_array[z_sort]
z_err_array = z_err_array[z_sort]
phi_array = phi_array[z_sort]
phi_err_array = phi_err_array[z_sort]
r_array = r_array[z_sort]
r_err_array = r_err_array[z_sort]
# removing rocs
remove_z = (z_array > -12.5) * (z_array < 12.5)
remove_z += (z_array < -12.5) + (z_array > 12.5)
remove_z *= (z_array > -25) * (z_array < 25)
remove_blips = (z_array < -21) + (z_array > -20)
remove_blips *= (z_array < -14.5) + (z_array > -13.5)
remove_blips *= (z_array < -7.5) + (z_array > -6.5)
remove_blips *= (z_array < 5.75) + (z_array > 6.5)
remove_blips *= (z_array < 12.5) + (z_array > 13.5)
remove_blips *= (z_array < 19) + (z_array > 20)
remove_hl = (phi_array < -2.3) + (phi_array > -2)
remove_hl *= (phi_array < -1.3) + (phi_array > -1)
remove_hl *= (phi_array < -0.25) + (phi_array > 0)
remove_hl *= (phi_array < 0.8) + (phi_array > 1.1)
remove_hl *= (phi_array < 1.8) + (phi_array > 2.2)
remove_hl *= (phi_array < 2.4) + (phi_array > 2.7)
remove_hl_low = (phi_array > -2.3) * (phi_array < -2)
remove_hl_low += (phi_array > -1.3) * (phi_array < -1)
remove_hl_low += (phi_array > -0.25) * (phi_array < 0)
remove_hl_low += (phi_array > 0.8) * (phi_array < 1.1)
remove_hl_low += (phi_array > 1.8) * (phi_array < 2.2)
remove_hl_low += (phi_array > 2.4) * (phi_array < 2.7)
#occ = occ[remove_z*remove_blips*remove_hl_low]
#x_array = x_array[remove_z*remove_blips*remove_hl_low]
#y_array = y_array[remove_z*remove_blips*remove_hl_low]
#z_array = z_array[remove_z*remove_blips*remove_hl_low]
#phi_array = phi_array[remove_z*remove_blips*remove_hl_low]
#r_array = r_array[remove_z*remove_blips*remove_hl_low]
#occ = occ[remove_z*remove_blips*remove_hl]
#x_array = x_array[remove_z*remove_blips*remove_hl]
#y_array = y_array[remove_z*remove_blips*remove_hl]
#z_array = z_array[remove_z*remove_blips*remove_hl]
#phi_array = phi_array[remove_z*remove_blips*remove_hl]
#r_array = r_array[remove_z*remove_blips*remove_hl]
#occ = occ[remove_z*remove_blips]
#x_array = x_array[remove_z*remove_blips]
#y_array = y_array[remove_z*remove_blips]
#z_array = z_array[remove_z*remove_blips]
#phi_array = phi_array[remove_z*remove_blips]
#r_array = r_array[remove_z*remove_blips]
occ = occ[remove_z * remove_blips]
x_array = x_array[remove_z * remove_blips]
y_array = y_array[remove_z * remove_blips]
z_array = z_array[remove_z * remove_blips]
phi_array = phi_array[remove_z * remove_blips]
r_array = r_array[remove_z * remove_blips]
r_err_array = r_err_array[remove_z * remove_blips]
z_err_array = z_err_array[remove_z * remove_blips]
phi_err_array = phi_err_array[remove_z * remove_blips]
phi_sort = np.argsort(phi_array)
z_sort = np.argsort(z_array)
r_sort = np.argsort(r_array)
occ_r = occ[r_sort]
x_r_array = x_array[r_sort]
y_r_array = y_array[r_sort]
z_r_array = z_array[r_sort]
z_err_r_array = z_err_array[r_sort]
phi_r_array = phi_array[r_sort]
r_r_array = r_array[r_sort]
r_err_r_array = r_err_array[r_sort]
occ_z = occ[z_sort]
x_z_array = x_array[z_sort]
y_z_array = y_array[z_sort]
z_z_array = z_array[z_sort]
z_err_z_array = z_err_array[z_sort]
phi_z_array = phi_array[z_sort]
r_z_array = r_array[z_sort]
r_err_z_array = r_err_array[z_sort]
occ_phi = occ[phi_sort]
x_phi_array = x_array[phi_sort]
y_phi_array = y_array[phi_sort]
z_phi_array = z_array[phi_sort]
z_err_phi_array = z_err_array[phi_sort]
phi_phi_array = phi_array[phi_sort]
phi_err_phi_array = phi_err_array[phi_sort]
r_phi_array = r_array[phi_sort]
r_err_phi_array = r_err_array[phi_sort]
####### begin condensing for projections ###############
z_condense = []
z_err_condense = []
occ_z_condense = []
n_half_ladders = 12
for iz, z in enumerate(z_z_array):
if iz % n_half_ladders == 0:
z_section = iz // n_half_ladders
z_condense.append(
np.average(z_z_array[iz:n_half_ladders * (z_section + 1)],
weights=occ_z[iz:n_half_ladders * (z_section + 1)]))
z_err_condense.append(
np.sqrt(
np.sum(z_err_z_array[iz:n_half_ladders *
(z_section + 1)]**2)))
occ_z_condense.append(
np.sum(occ_z[iz:n_half_ladders * (z_section + 1)]))
else:
continue
phi_condense = []
phi_err_condense = []
occ_phi_condense = []
n_z_sections = 64
for iphi, phi in enumerate(phi_phi_array):
if iphi % n_z_sections == 0:
phi_section = iphi // n_z_sections
phi_condense.append(
np.average(
phi_phi_array[iphi:n_z_sections * (phi_section + 1)],
weights=occ_phi[iphi:n_z_sections * (phi_section + 1)]))
phi_err_condense.append(
np.sqrt(
np.sum(phi_err_phi_array[iphi:n_z_sections *
(phi_section + 1)]**2)))
occ_phi_condense.append(
np.sum(occ_phi[iphi:n_z_sections * (phi_section + 1)]))
else:
continue
r_condense = []
r_err_condense = []
occ_r_condense = []
for ir, r in enumerate(r_r_array):
if ir % n_half_ladders == 0:
r_section = ir // n_half_ladders
r_condense.append(
np.average(r_r_array[ir:n_half_ladders * (r_section + 1)],
weights=occ_r[ir:n_half_ladders * (r_section + 1)]))
r_err_condense.append(
np.sqrt(
np.sum(r_err_r_array[ir:n_half_ladders *
(r_section + 1)]**2)))
occ_r_condense.append(
np.sum(occ_r[ir:n_half_ladders * (r_section + 1)]))
else:
continue
r_condense_comb = []
r_err_condense_comb = []
occ_r_condense_comb = []
for ir, r in enumerate(r_condense):
if ir % 2 == 0:
r_condense_comb.append((r + r_condense[ir + 1]) / 2)
r_err_condense_comb.append(
np.sqrt(r_err_condense[ir]**2 + r_err_condense[ir + 1]**2))
occ_r_condense_comb.append(
np.mean([occ_r_condense[ir], occ_r_condense[ir + 1]]))
else:
continue
########### end condensing for projections ################
gr_r_hl = []
gr_z_hl = []
phi_avg_hl = np.array([np.mean(phi) for phi in phi_hl])
avg_phi_sort = np.argsort(phi_avg_hl)
r_hl = np.array(r_hl)
r_err_hl = np.array(r_err_hl)
z_hl = np.array(z_hl)
z_err_hl = np.array(z_err_hl)
occ_hl = np.array(occ_hl)
r_hl = r_hl[avg_phi_sort]
r_err_hl = r_err_hl[avg_phi_sort]
z_hl = z_hl[avg_phi_sort]
z_err_hl = z_err_hl[avg_phi_sort]
occ_hl = occ_hl[avg_phi_sort]
for hl in range(n_ladders):
r_hl[hl] = np.array(r_hl[hl])
r_err_hl[hl] = np.array(r_err_hl[hl])
z_hl[hl] = np.array(z_hl[hl])
z_err_hl[hl] = np.array(z_err_hl[hl])
occ_z_hl = np.array(occ_hl[hl])
occ_r_hl = np.array(occ_hl[hl])
remove_z_hl = (z_hl[hl] > -12.5) * (z_hl[hl] < 12.5)
remove_z_hl += (z_hl[hl] < -12.5) + (z_hl[hl] > 12.5)
remove_blips_hl = (z_hl[hl] < -21) + (z_hl[hl] > -20)
remove_blips_hl *= (z_hl[hl] < -14.5) + (z_hl[hl] > -13.5)
remove_blips_hl *= (z_hl[hl] < -7.5) + (z_hl[hl] > -6.5)
remove_blips_hl *= (z_hl[hl] < 5.75) + (z_hl[hl] > 6.5)
remove_blips_hl *= (z_hl[hl] < 12.5) + (z_hl[hl] > 13.5)
remove_blips_hl *= (z_hl[hl] < 19) + (z_hl[hl] > 20)
z_new_hl = z_hl[hl][remove_z_hl * remove_blips_hl]
r_new_hl = r_hl[hl][remove_z_hl * remove_blips_hl]
r_err_new_hl = r_err_hl[hl][remove_z_hl * remove_blips_hl]
z_err_new_hl = z_err_hl[hl][remove_z_hl * remove_blips_hl]
occ_z_hl = occ_z_hl[remove_z_hl * remove_blips_hl]
occ_r_hl = occ_r_hl[remove_z_hl * remove_blips_hl]
r_sort = np.argsort(r_new_hl)
z_sort = np.argsort(z_new_hl)
r_new_hl = r_new_hl[r_sort]
r_err_new_hl = r_new_hl[r_sort]
occ_r_hl = occ_r_hl[r_sort]
r_condense_hl = []
r_err_condense_hl = []
occ_r_condense_hl = []
for ir, r in enumerate(r_new_hl):
if ir % 2 == 0:
r_condense_hl.append((r + r_new_hl[ir + 1]) / 2)
r_err_condense_hl.append(
np.sqrt(r_err_new_hl[ir]**2 + r_new_hl[ir + 1]**2))
occ_r_condense_hl.append(
np.mean([occ_r_hl[ir], occ_r_hl[ir + 1]]))
else:
continue
z_new_hl = z_new_hl[z_sort]
z_err_new_hl = z_err_new_hl[z_sort]
occ_z_hl = occ_z_hl[z_sort]
gr_r_hl.append(rt.TGraph())
rnp.fill_graph(gr_r_hl[hl],
np.swapaxes([r_condense_hl, occ_r_condense_hl], 0, 1))
gr_r_hl[hl].SetName("gr_r_occ_hl_" + str(hl))
gr_z_hl.append(rt.TGraph())
rnp.fill_graph(gr_z_hl[hl], np.swapaxes([z_new_hl, occ_z_hl], 0, 1))
gr_z_hl[hl].SetName("gr_z_occ_hl_" + str(hl))
gr_phi_ring = []
z_avg_ring = np.array([np.mean(z) for z in z_ring])
avg_z_sort = np.argsort(z_avg_ring)
occ_ring = np.array(occ_ring)
phi_ring = np.array(phi_ring)
phi_ring = phi_ring[avg_z_sort]
occ_ring = occ_ring[avg_z_sort]
for ring in range(n_rings):
phi_ring[ring] = np.array(phi_ring[ring])
occ_phi_ring = np.array(occ_ring[ring])
phi_sort = np.argsort(phi_ring[ring])
phi_ring[ring] = phi_ring[ring][phi_sort]
occ_phi_ring = occ_phi_ring[phi_sort]
gr_phi_ring.append(rt.TGraph())
rnp.fill_graph(gr_phi_ring[ring],
np.swapaxes([phi_ring[ring], occ_phi_ring], 0, 1))
gr_phi_ring[ring].SetName("gr_phi_occ_ring_" + str(ring))
gr_phi = rt.TGraph()
rnp.fill_graph(gr_phi, np.swapaxes([phi_condense, occ_phi_condense], 0, 1))
gr_phi.SetName("gr_phi_occ")
gr_z = rt.TGraph()
rnp.fill_graph(gr_z, np.swapaxes([z_condense, occ_z_condense], 0, 1))
gr_z.SetName("gr_z_occ")
gr_r3d = rt.TGraph()
rnp.fill_graph(gr_r3d, np.swapaxes([r_condense, occ_r_condense], 0, 1))
gr_r3d.SetName("gr_r_occ")
gr_r3d = rt.TGraph()
rnp.fill_graph(gr_r3d,
np.swapaxes([r_condense_comb, occ_r_condense_comb], 0, 1))
gr_r3d.SetName("gr_r_occ_pm_comb")
#file_out = rt.TFile("output_0_charge_l200_nosmear.root", "RECREATE")
#file_out = rt.TFile("output_0p1_neg0p08_charge_l200_nosmear.root", "RECREATE")
#file_out = rt.TFile("output_neg0p1_0p2_charge_l200_nosmear.root", "RECREATE")
#file_out = rt.TFile("output_0p2_0p19_charge_l200_nosmear.root", "RECREATE")
file_out = rt.TFile("output_neg0p3_neg0p32_charge_l200_nosmear.root",
"RECREATE")
#file_out = rt.TFile("output_0_charge_ge200_nosmear.root", "RECREATE")
#file_out = rt.TFile("output_0p1_neg0p08_charge_ge200_nosmear.root", "RECREATE")
#file_out = rt.TFile("output_neg0p1_0p2_charge_ge200_nosmear.root", "RECREATE")
#file_out = rt.TFile("output_0p2_0p19_charge_ge200_nosmear.root", "RECREATE")
#file_out = rt.TFile("output_neg0p3_neg0p32_charge_ge200_nosmear.root", "RECREATE")
gr_phi.Write()
gr_z.Write()
gr_r3d.Write()
for hl in range(n_ladders):
gr_r_hl[hl].Write()
gr_z_hl[hl].Write()
for ring in range(n_rings):
gr_phi_ring[ring].Write()
file_out.Close()
def plot_likelihood(plcInterval_1sd,
Yat_Xmax_1sd,
min_1sd,
max_1sd,
Yat_Xmax_2sd,
min_2sd,
max_2sd,
x_min=0.8,
x_max=1.2,
x_SM=1.0,
NPoints=20,
xlabel='R'):
plccanvas = rt.TCanvas('fig_PL', 'PL', 800, 600)
plcplot = rt.RooStats.LikelihoodIntervalPlot(plcInterval_1sd)
plccanvas.cd()
pad = setup_pad()
pad.Draw()
pad.cd()
plcplot.SetRange(x_min, x_max)
plcplot.SetMaximum(10)
plcplot.SetLineColor(0)
plcplot.SetNPoints(NPoints)
plcplot.Draw("tf1")
#plcplot.Draw()
pad.cd()
'''
Yline_cutoff = rt.TLine(x_min,Yat_Xmax,x_max,Yat_Xmax);
Yline_min = rt.TLine(min_2sd,0.,min_2sd,Yat_Xmax);
Yline_max = rt.TLine(max_2sd,0.,max_2sd,Yat_Xmax);
Yline_cutoff.SetLineColor(8)
Yline_min.SetLineColor(8)
Yline_max.SetLineColor(8)
Yline_cutoff.Draw("same");
Yline_min.Draw("same");
Yline_max.Draw("same");
'''
hist = plcplot.GetPlottedObject()
frame = rt.TGraph(hist)
frame.GetYaxis().SetTitle('Profile of -log(L/L_{min})')
frame.GetXaxis().SetTitle(xlabel)
frame.GetYaxis().SetTitleOffset(0.9)
frame.GetYaxis().SetTitleFont(42)
frame.GetYaxis().SetTitleSize(0.04)
frame.GetYaxis().SetLabelSize(0.04)
frame.GetYaxis().SetLabelFont(42)
frame.GetXaxis().SetTitleOffset(0.9)
frame.GetXaxis().SetTitleFont(42)
frame.GetXaxis().SetTitleSize(0.04)
frame.GetXaxis().SetLabelSize(0.04)
frame.GetXaxis().SetLabelFont(42)
frame.SetMinimum(0)
frame.Draw()
pad.Update()
# plot 95% limit
hist_2sd = hist.Clone()
y_2sd, edge_2sd = root_numpy.hist2array(hist_2sd, return_edges=True)
edge_2sd = np.array(edge_2sd).flatten()
x_2sd = np.convolve(edge_2sd, np.ones(2), 'valid') / 2.0
tofill_2sd = [(x, y) for x, y in zip(x_2sd, y_2sd)
if min_2sd < x < max_2sd]
tg_2sd = rt.TGraph()
root_numpy.fill_graph(tg_2sd, tofill_2sd)
tg_2sd.SetPoint(tg_2sd.GetN(), min_2sd, Yat_Xmax_2sd)
tg_2sd.SetPoint(tg_2sd.GetN(), min_2sd, 0)
tg_2sd.SetPoint(tg_2sd.GetN(), max_2sd, 0)
tg_2sd.SetPoint(tg_2sd.GetN(), max_2sd, Yat_Xmax_2sd)
tg_2sd.Sort()
tg_2sd.SetFillColor(16)
tg_2sd.SetFillStyle(1001)
tg_2sd.Draw("F2 SAME")
pad.Update()
# plot 68.3% limit
hist_1sd = hist.Clone()
y_1sd, edge_1sd = root_numpy.hist2array(hist_1sd, return_edges=True)
edge_1sd = np.array(edge_1sd).flatten()
x_1sd = np.convolve(edge_1sd, np.ones(2), 'valid') / 2.0
tofill_1sd = [(x, y) for x, y in zip(x_1sd, y_1sd)
if min_1sd < x < max_1sd]
tg_1sd = rt.TGraph()
root_numpy.fill_graph(tg_1sd, tofill_1sd)
tg_1sd.SetPoint(tg_1sd.GetN(), min_1sd, Yat_Xmax_1sd)
tg_1sd.SetPoint(tg_1sd.GetN(), min_1sd, 0)
tg_1sd.SetPoint(tg_1sd.GetN(), max_1sd, 0)
tg_1sd.SetPoint(tg_1sd.GetN(), max_1sd, Yat_Xmax_1sd)
tg_1sd.Sort()
tg_1sd.SetFillColor(14)
tg_1sd.SetFillStyle(1001)
tg_1sd.Draw("F2 SAME")
pad.Update()
frame.Draw("same")
pad.Update()
uymax = rt.gPad.GetUymax()
uymin = rt.gPad.GetUymin()
if x_SM is not None:
pad.cd()
l = rt.TLine(x_SM, uymin, x_SM, uymax)
l.SetLineColor(2)
l.SetLineWidth(2)
l.Draw("same")
pad.cd()
CMS_lumi(False)
plccanvas.cd()
plccanvas.Update()
# save canvases
plccanvas.Draw()
plccanvas.SaveAs('.pdf')
return plccanvas
def fillgraph(graph, arrx, arry):
arrxy = combinevectors(arrx, arry)
root_numpy.fill_graph(graph, arrxy)
def _roc_graph(data, classes, prelim=False):
# pylint: disable=too-many-locals
pos, neg = classes
canvas = ROOT.TCanvas('c_{}vs{}.format(pos, neg)', '', 0, 0, 800, 600)
canvas.SetLogx()
graphs = ROOT.TMultiGraph()
leg = ROOT.TLegend(0.63, 0.7, 0.9, 0.88)
for layer in data:
if pos == 3:
pos_sel = data[layer]['Output_number_true'] >= pos
else:
pos_sel = data[layer]['Output_number_true'] == pos
if neg == 3:
neg_sel = data[layer]['Output_number_true'] >= neg
else:
neg_sel = data[layer]['Output_number_true'] == neg
isel = np.where(
np.logical_or(
pos_sel,
neg_sel,
)
)[0]
fpr, tpr, _ = sklearn.metrics.roc_curve(
data[layer]['Output_number_true'][isel],
data[layer]['Output_number'][isel][:, pos - 1],
pos_label=pos
)
auc = sklearn.metrics.auc(fpr, tpr)
graph = ROOT.TGraph(fpr.size)
_set_graph_style(graph, layer)
root_numpy.fill_graph(graph, np.column_stack((fpr, tpr)))
graphs.Add(graph)
leg.AddEntry(graph, '{}, AUC: {:.2f}'.format(layer, auc), 'L')
graphs.SetTitle(
';Pr(Estimated: {pos}-particle{ps} | True: {neg}-particle{ns});Pr(Estimated: {pos}-particle{ps} | True: {pos}-particle{ps})'.format( # noqa
pos=pos,
neg=neg,
ps=('' if pos == 1 else 's'),
ns=('' if neg == 1 else 's')
)
)
graphs.SetMaximum(1.5)
graphs.Draw('AL')
line = ROOT.TF1("line", "x", 0, 1)
line.SetLineStyle(3)
line.SetLineColor(ROOT.kGray + 2)
line.Draw("same")
leg.AddEntry(line, 'Random, AUC: 0.50', 'L')
leg.SetTextSize(leg.GetTextSize() * 0.65)
leg.SetBorderSize(0)
leg.Draw()
figures.draw_atlas_label(prelim)
txt = ROOT.TLatex()
txt.SetNDC()
txt.SetTextSize(txt.GetTextSize() * 0.75)
txt.DrawLatex(0.2, 0.82, 'PYTHIA8 dijet, 1.8 < p_{T}^{jet} < 2.5 TeV')
canvas.SaveAs('ROC_{}vs{}.pdf'.format(pos, neg))
zdist=np.zeros([6,90])
abins=np.arange(0,90)
abins_rad=np.radians(abins)
for k in range(5,6):
print(pfiles[k])
name='{0}_sn.out'.format(pfiles[k])
f=open(name,'r')
j=0
for line in f:
theta[k,j]=np.float(line.split()[2])
j+=1
theta[k,:]=np.degrees(np.arccos(theta[k,:]))
angraph=ROOT.TGraph()
ang_hist,bin=np.histogram(theta[k,:],bins=abins,density=True)
angT=np.transpose(np.array([abins_rad[:-1],ang_hist]))
rnp.fill_graph(angraph,angT)
if pfiles[k]=='muon':
afun=ROOT.TF1('angular','[0]*sin(x)*TMath::Power(cos(x),[1])',0,np.pi/2.0)
else:
afun=ROOT.TF1('angular','[0]*sin(x)*(1.0+[1]*TMath::Power(cos(x),[2]))',0,np.pi/2.0)
afun.SetParLimits(2,0.5,4.0)
angraph.Fit(afun,'R')
p=afun.GetParameters()
e=afun.GetParError(0)
if pfiles[k]=='muon':
zdist[k,:]=p[0]*np.sin(abins_rad)*(np.power(np.cos(abins_rad),p[1]))
print(p[0],p[1])
else:
zdist[k,:]=p[0]*np.sin(abins_rad)*(1.0+p[1]*np.power(np.cos(abins_rad),p[2]))
print(p[0],p[1],p[2])
fig,ax=plt.subplots(nrows=1,ncols=1,sharex=False,sharey=False)
def save(self):
# Save the toy-model source distributions in custom NumPy-oriented format.
if self.sourceMode == "Mixture":
self.sourceKinematicsDistribution.save(
f"{self.directory}/numpy/sourceKinematicsDistribution")
self.sourceTimeDistribution.save(
f"{self.directory}/numpy/sourceTimeDistribution")
np.savez(f"{self.directory}/numpy/sourceCorrelation",
sourceCorrelation=self.sourceCorrelation)
# Save the source distributions in ROOT format.
else:
# Open a ROOT file to contain the source information.
sourceFile = root.TFile(f"{self.directory}/source.root",
"RECREATE")
if self.sourceMode == "Histogram1D":
# Write the kinematics and injection time histograms.
self.sourceKinematicsHistogram.Write()
self.sourceTimeHistogram.Write()
# Write the correlation polynomial coefficients as entries in a single-branched TTree.
rnp.array2tree(np.array(self.sourceCorrelation,
dtype=[("sourceCorrelation",
np.float32)]),
name="sourceCorrelation").Write()
else:
# Write the joint kinematics and injection time histogram.
self.sourceJointHistogram.Write()
sourceFile.Close()
# Save simulation histograms in NumPy formats.
self.frequencies.save(f"{self.directory}/numpy/frequencies")
self.profile.save(f"{self.directory}/numpy/profile")
self.joint.save(f"{self.directory}/numpy/joint")
self.signal.save(f"{self.directory}/numpy/signal")
# Prepare the truth-level radial TGraph.
radial = root.TGraph()
radial.SetName("radial")
rnp.fill_graph(
radial,
np.stack((utilities.frequencyToRadius(
self.frequencies.xCenters), self.frequencies.heights),
axis=-1))
# Save simulation histograms in ROOT format.
rootFile = root.TFile(f"{self.directory}/simulation.root", "RECREATE")
self.frequencies.toRoot("frequencies",
";Cyclotron Frequency (kHz);Entries").Write()
self.profile.toRoot("profile", ";Injection Time (ns);Entries").Write()
self.joint.toRoot(
"joint", ";Injection Time (ns);Cyclotron Frequency (kHz)").Write()
self.signal.toRoot("signal",
";Time (us);Arbitrary Units",
xRescale=1E-3).Write()
radial.Write()
rootFile.Close()
def find_best_working_point(effs, signal_efficiencies, background_efficiencies,
signal_probabilities, background_probabilities):
# Compute ratios of background and signal probabilities and truncate the array
# to match the gradient array size
probability_ratios = background_probabilities / signal_probabilities
probability_ratios = probability_ratios[1:]
# Compute efficiency gradients
effs_diff = np.ediff1d(effs)
signal_efficiencies_diff = np.ediff1d(signal_efficiencies)
background_efficiencies_diff = np.ediff1d(background_efficiencies)
signal_efficiencies_diff = np.divide(signal_efficiencies_diff, effs_diff)
background_efficiencies_diff = np.divide(background_efficiencies_diff,
effs_diff)
# Apply averaging over 3 or 2 values in order to smooth the gradients
signal_efficiencies_diff_3 = np.convolve(signal_efficiencies_diff,
np.repeat(1.0, 3.) / 3., 'valid')
signal_efficiencies_diff_2 = np.convolve(signal_efficiencies_diff,
np.repeat(1.0, 2.) / 2., 'valid')
signal_efficiencies_diff = np.append(
signal_efficiencies_diff_3,
[signal_efficiencies_diff_2[-1], signal_efficiencies_diff[-1]])
background_efficiencies_diff_3 = np.convolve(background_efficiencies_diff,
np.repeat(1.0, 3.) / 3.,
'valid')
background_efficiencies_diff_2 = np.convolve(background_efficiencies_diff,
np.repeat(1.0, 2.) / 2.,
'valid')
background_efficiencies_diff = np.append(
background_efficiencies_diff_3,
[background_efficiencies_diff_2[-1], background_efficiencies_diff[-1]])
# Apply the signal and background probabilities in order to weight the efficiency gradients
# If it is more likely to have background than signal in this bin, then the background efficiency gradient
# will be increased accordingly
background_efficiencies_diff = background_efficiencies_diff * probability_ratios
# Interpolate and find points where background efficiency gradient > signal efficiency gradient (with some tolerance)
interp_x = np.linspace(np.amin(effs[1:]), np.amax(effs[1:]), 1000)
interp_signal = np.interp(interp_x, effs[1:], signal_efficiencies_diff)
interp_background = np.interp(interp_x, effs[1:],
background_efficiencies_diff)
optimal_points = np.argwhere(
np.greater(interp_background - 0.05, interp_signal)).ravel(
) # Use a tolerance of 0.02 in case of fluctuations
if len(optimal_points) == 0:
print 'WARNING: no working point found where the efficiency gradient is larger for background than for signal'
# Find optimal point with smallest efficiency
## Compute spacing between points, and select those with an efficiency separation > 2%
optimal_discontinuities = np.argwhere(
np.ediff1d(interp_x[optimal_points]) > 0.02).ravel()
## Select the point with the largest efficiency
optimal_index = np.amax(optimal_discontinuities) + 1 if len(
optimal_discontinuities) > 0 else 0
optimal_point = interp_x[optimal_points[optimal_index]]
# Create graphs
signal_efficiencies_diff_graph = Graph(len(effs) - 1)
background_efficiencies_diff_graph = Graph(len(effs) - 1)
optimal_points_graph = Graph(len(optimal_points))
fill_graph(signal_efficiencies_diff_graph,
np.column_stack((effs[1:], signal_efficiencies_diff)))
fill_graph(background_efficiencies_diff_graph,
np.column_stack((effs[1:], background_efficiencies_diff)))
fill_graph(
optimal_points_graph,
np.column_stack(
(interp_x[optimal_points], interp_signal[optimal_points])))
signal_efficiencies_diff_graph.SetName('efficiencies_signal')
background_efficiencies_diff_graph.SetName('efficiencies_background')
optimal_points_graph.SetName('signal_background_optimal_points')
return signal_efficiencies_diff_graph, background_efficiencies_diff_graph, optimal_points_graph, optimal_point
