def test_minus(self):
weight = [0.5, 1.0, 4.0, 10., 3., 1.5, 2.0, 5.0, 30., 5.]
bins = [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
axis = ['EPtBin']
data_raw = pd.DataFrame()
data_raw['Weight'], data_raw['WeightSquare'], data_raw['EPtBin'] = weight, list(np.array(weight) ** 2), bins
data_raw_2 = pd.DataFrame()
(data_raw_2['Weight'], data_raw_2['WeightSquare'], data_raw_2['EPtBin']) = (weight[:5],
list(np.array(weight) ** 2)[:5],
bins[:5])
h1 = Histogram.from_dataframe(data_raw, axis=axis)
h2 = Histogram.from_dataframe(data_raw_2, axis=axis)
pd.testing.assert_series_equal((h1 - h2).data['Content'], pd.Series([1.5, 2.0, 5.0, 30., 5.]),
check_names=False)
pd.testing.assert_series_equal((h1 - h2).data['SumWeightSquare'], pd.Series([0.5 ** 2 + 0.5 ** 2 + 1.5 ** 2,
1.0 ** 2 + 1.0 ** 2 + 2.0 ** 2,
4.0 ** 2 + 4.0 ** 2 + 5.0 ** 2,
10. ** 2 + 10. ** 2 + 30. ** 2,
3.0 ** 2 + 3.0 ** 2 + 5.0 ** 2]),
check_names=False)
pd.testing.assert_series_equal((h1 - h2).data['Error'], np.sqrt(pd.Series([0.5 ** 2 + 0.5 ** 2 + 1.5 ** 2,
1.0 ** 2 + 1.0 ** 2 + 2.0 ** 2,
4.0 ** 2 + 4.0 ** 2 + 5.0 ** 2,
10. ** 2 + 10. ** 2 + 30. ** 2,
3.0 ** 2 + 3.0 ** 2 + 5.0 ** 2])),
check_names=False)
def test_division(self):
weight = pd.Series([2., 3., 9., 40., 8.])
sum_weight_2 = pd.Series([2.5, 5.0, 41., 1000., 34.])
bins = [0, 1, 2, 3, 4]
data_raw = pd.DataFrame()
data_raw['Content'], data_raw['SumWeightSquare'], data_raw['EPtBin'] = weight, sum_weight_2, bins
data_raw.set_index('EPtBin')
h1 = Histogram(data_raw)
value_to_divide = 10.
# Test histogram/value
manual_result_c = weight / value_to_divide
manual_result_err = np.sqrt(sum_weight_2) / value_to_divide
manual_result_w2 = manual_result_err ** 2
result = h1 / value_to_divide
pd.testing.assert_series_equal(result.data['Content'], manual_result_c, check_names=False)
pd.testing.assert_series_equal(result.data['SumWeightSquare'], manual_result_w2, check_names=False)
pd.testing.assert_series_equal(result.data['Error'], manual_result_err, check_names=False)
# Test histogram * histogram
weight = pd.Series([5., 3., 8., 55., 8.])
sum_weight_2 = pd.Series([2.5, 45, 36., 544., 34.])
bins = [0, 1, 2, 3, 4]
data_raw = pd.DataFrame()
data_raw['Content'], data_raw['SumWeightSquare'], data_raw['EPtBin'] = weight, sum_weight_2, bins
data_raw.set_index('EPtBin')
h2 = Histogram(data_raw)
result_hh = h1 / h2
result_hh_manual = pd.Series([2. / 5., 1., 9. / 8, 40. / 55., 1.])
result_hh_w2 = pd.Series([0.11600000000000002, 5.555555555555555, 1.3525390625, 0.4256976982446554, 1.0625])
result_hh_err = np.sqrt(result_hh_w2)
pd.testing.assert_series_equal(result_hh.data['Content'],
result_hh_manual, check_names=False)
pd.testing.assert_series_equal(result_hh.data['SumWeightSquare'],
result_hh_w2, check_names=False)
pd.testing.assert_series_equal(result_hh.data['Error'],
result_hh_err, check_names=False)
def test_add(self):
# Pseudo data to test the addition
weight = [0.5, 1.0, 4.0, 10., 3., 1.5, 2.0, 5.0, 30., 5.]
bins = [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
axis = ['EPtBin']
data_raw = pd.DataFrame()
data_raw['Weight'], data_raw['WeightSquare'], data_raw['EPtBin'] = weight, list(np.array(weight) ** 2), bins
h1 = Histogram.from_dataframe(data_raw, axis=axis)
h2 = Histogram.from_dataframe(data_raw, axis=axis)
pd.testing.assert_series_equal((h1 + h2).data['Content'], h1.data['Content'] + h2.data['Content'])
pd.testing.assert_series_equal((h1 + h2).data['SumWeightSquare'], h1.data['SumWeightSquare'] +
h2.data['SumWeightSquare'])
pd.testing.assert_series_equal((h1 + h2).data['Error'], np.sqrt(h1.data['Error'] ** 2 + h2.data['Error'] ** 2))
def test_get_bin_center(self):
weight = [0.5, 1.0, 4.0, 10., 3., 1.5, 2.0, 5.0, 30., 5.]
bins = [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
data_raw = pd.DataFrame()
data_raw['Weight'], data_raw['WeightSquare'], data_raw['EPtBin'] = weight, list(np.array(weight) ** 2), bins
data_raw['EPtBin'] = pd.cut(data_raw['EPtBin'], [0, 1, 2, 3, 4])
h1 = Histogram.from_dataframe(data_raw, axis=['EPtBin'])
self.assertEqual(h1.get_bin_center('EPtBin'), [0.5, 1.5, 2.5, 3.5])
def correlation_signal_region(df, fit, n_sigma, suffix='_d', axis=()):
mean, sigma = (fit.GetMean(), fit.GetSigma())
signal = select_inv_mass(df,
mean - n_sigma * sigma,
mean + n_sigma * sigma,
suffix=suffix)
signal_corr = Histogram.from_dataframe(signal, axis)
return signal_corr
def test_multiply(self):
weight = [0.5, 1.0, 4.0, 10., 3., 1.5, 2.0, 5.0, 30., 5.]
bins = [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
axis = ['EPtBin']
data_raw = pd.DataFrame()
data_raw['Weight'], data_raw['WeightSquare'], data_raw['EPtBin'] = weight, list(np.array(weight) ** 2), bins
h1 = Histogram.from_dataframe(data_raw, axis=axis)
value_to_multiply = 10.
# Test histogram * value
manual_result = pd.Series([2., 3., 9., 40., 8.])
manual_result_w2 = pd.Series([2.5, 5.0, 41., 1000., 34.])
result = h1 * value_to_multiply
pd.testing.assert_series_equal(result.data['Content'],
manual_result * value_to_multiply, check_names=False)
pd.testing.assert_series_equal(result.data['SumWeightSquare'],
manual_result_w2 * (value_to_multiply ** 2), check_names=False)
pd.testing.assert_series_equal(result.data['Error'],
np.sqrt(manual_result_w2) * value_to_multiply, check_names=False)
# Test value * histogram
result_invert = value_to_multiply * h1
pd.testing.assert_series_equal(result_invert.data['Content'],
manual_result * value_to_multiply, check_names=False)
pd.testing.assert_series_equal(result_invert.data['SumWeightSquare'],
manual_result_w2 * (value_to_multiply ** 2), check_names=False)
pd.testing.assert_series_equal(result_invert.data['Error'],
np.sqrt(manual_result_w2) * value_to_multiply, check_names=False)
# Test histogram * histogram
result_hh = h1 * h1
result_hh_m = pd.Series([4.0, 9.0, 81.0, 1600.0, 64.0])
result_hh_err = pd.Series([4.47213595499958, 9.486832980505138, 81.49846624323675,
1788.8543819998317, 65.96969000988257])
pd.testing.assert_series_equal(result_hh.data['Content'],
result_hh_m, check_names=False)
pd.testing.assert_series_equal(result_hh.data['SumWeightSquare'],
result_hh_err ** 2, check_names=False)
pd.testing.assert_series_equal(result_hh.data['Error'],
result_hh_err, check_names=False)
def test_from_dataframe(self):
weight = [0.5, 1.0, 4.0, 10., 3., 1.5, 2.0, 5.0, 30., 5.]
bins = [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
axis = ['EPtBin']
data_raw = pd.DataFrame()
data_raw['Weight'], data_raw['WeightSquare'], data_raw['EPtBin'] = weight, list(np.array(weight) ** 2), bins
data_binned = pd.DataFrame()
data_binned['Content'] = [2.0, 3.0, 9.0, 40., 8.]
data_binned['SumWeightSquare'] = [2.5, 5.0, 41., 1000., 34.]
data_binned['Error'] = [1.58113883, 2.23606798, 6.40312424, 31.6227766, 5.83095189]
data_binned['EPtBin'] = [0, 1, 2, 3, 4]
data_binned.set_index('EPtBin', inplace=True)
histogram_to_test = Histogram.from_dataframe(data_raw, axis=axis)
pd.testing.assert_frame_equal(histogram_to_test.data, data_binned)
def correlation_background_region(df,
fit,
n_sigma_min,
n_sigma_max,
suffix='_d',
axis=()):
mean, sigma = (fit.GetMean(), fit.GetSigma())
right = select_inv_mass(df,
mean + n_sigma_min * sigma,
mean + n_sigma_max * sigma,
suffix=suffix)
left = select_inv_mass(df,
mean - n_sigma_max * sigma,
mean - n_sigma_min * sigma,
suffix=suffix)
bkg = pd.concat([right, left])
bkg_corr = Histogram.from_dataframe(bkg, axis)
return bkg_corr
def correlation_dmeson(df_pairs,
n_sigma_sig=2.,
n_sigma_bkg_min=4.,
n_sigma_bkg_max=8.,
suffixes=('_d', '_e'),
axis=('CentralityBin', 'VtxZBin', 'DPtBin', 'EPtBin',
'DeltaEtaBin', 'DeltaPhiBin'),
plot=False,
identifier=('RunNumber', 'EventNumber'),
mix=True,
subtract_non_hfe=False,
**kwargs):
d_in_this_pt = reduce_to_single_particle(df_pairs, suffixes[0])
e_in_this_pt = reduce_to_single_particle(df_pairs, suffixes[1])
try:
fit = make_histo_and_fit_inv_mass(d_in_this_pt, suffix=suffixes[0])
except RuntimeError:
warnings.warn("Skipping value due to fit failure.")
return pd.DataFrame(None,
columns=[
'InvMassFit', 'DMesonCorr', 'SignalRegCorr',
'NSignal', 'NSignalErr', 'SignalRegCorrMix',
'BkgRegCorr', 'NBkgSideBands',
'NBkgSideBandsErr', 'BkgRegCorrMix',
'NBkgSignalReg', 'NBkgSignalRegErr',
'Significance', 'Significance error'
])
n_signal, err_n_signal = get_n_signal(fit, n_sigma_sig)
n_bkg_sidebands, err_n_bkg_sb = get_n_bkg_sidebands(
fit, n_sigma_bkg_min, n_sigma_bkg_max)
n_bkg_signal_region, err_n_bkg_signal_region = get_n_bkg(fit, n_sigma_sig)
# Same Event
# Inclusive electron
signal_corr_inc = correlation_signal_region(
df_pairs,
fit,
n_sigma_sig,
axis=['DeltaEtaBin', 'DeltaPhiBin'],
suffix=suffixes[0])
bkg_corr_inc = correlation_background_region(
df_pairs,
fit,
n_sigma_bkg_min,
n_sigma_bkg_max,
suffix=suffixes[0],
axis=['DeltaEtaBin', 'DeltaPhiBin'])
if subtract_non_hfe:
# ULS electrons
signal_corr_uls = correlation_signal_region(
df_pairs.loc[df_pairs['NULS' + suffixes[1]] > 0],
fit,
n_sigma_sig,
axis=['DeltaEtaBin', 'DeltaPhiBin'],
suffix=suffixes[0])
bkg_corr_uls = correlation_background_region(
df_pairs.loc[df_pairs['NULS' + suffixes[1]] > 0],
fit,
n_sigma_bkg_min,
n_sigma_bkg_max,
suffix=suffixes[0],
axis=['DeltaEtaBin', 'DeltaPhiBin'])
# LS electrons
signal_corr_ls = correlation_signal_region(
df_pairs.loc[df_pairs['NLS' + suffixes[1]] > 0],
fit,
n_sigma_sig,
axis=['DeltaEtaBin', 'DeltaPhiBin'],
suffix=suffixes[0])
bkg_corr_ls = correlation_background_region(
df_pairs.loc[df_pairs['NLS' + suffixes[1]] > 0],
fit,
n_sigma_bkg_min,
n_sigma_bkg_max,
suffix=suffixes[0],
axis=['DeltaEtaBin', 'DeltaPhiBin'])
signal_corr = signal_corr_inc - signal_corr_uls + signal_corr_ls
bkg_corr = bkg_corr_inc - bkg_corr_uls + bkg_corr_ls
else:
signal_corr_uls = Histogram()
signal_corr_ls = Histogram()
bkg_corr_uls = Histogram()
bkg_corr_ls = Histogram()
signal_corr = signal_corr_inc
bkg_corr = bkg_corr_inc
if mix:
# Mixed event
df_mixed_pairs = build_pairs(d_in_this_pt,
e_in_this_pt,
suffixes=suffixes,
identifier=identifier,
is_mixed=True)
signal_corr_mix = correlation_signal_region(
df_mixed_pairs,
fit,
n_sigma_sig,
suffix=suffixes[0],
axis=['DeltaEtaBin', 'DeltaPhiBin'])
bkg_corr_mix = correlation_background_region(
df_mixed_pairs,
fit,
n_sigma_bkg_min,
n_sigma_bkg_max,
axis=['DeltaEtaBin', 'DeltaPhiBin'],
suffix=suffixes[0])
# Division by M(0,0)
signal_corr_mix = normalize_mixed_event(signal_corr_mix)
bkg_corr_mix = normalize_mixed_event(bkg_corr_mix)
# Same/mixed
corrected_signal_corr = (signal_corr /
signal_corr_mix).project('DeltaPhiBin')
corrected_bkg_corr = (bkg_corr / bkg_corr_mix).project('DeltaPhiBin')
corrected_bkg_corr = corrected_bkg_corr / n_bkg_sidebands * n_bkg_signal_region
else:
signal_corr_mix = Histogram()
bkg_corr_mix = Histogram()
corrected_signal_corr = signal_corr.project('DeltaPhiBin')
corrected_bkg_corr = bkg_corr.project('DeltaPhiBin')
# normalize the background correlation
bkg_corr = bkg_corr / n_bkg_sidebands * n_bkg_signal_region
if n_signal > 0:
d_meson_corr = (corrected_signal_corr - corrected_bkg_corr) / n_signal
else:
d_meson_corr = Histogram()
if plot:
fig, ax = plt.subplots()
plot_inv_mass_fit(fit, ax, **kwargs['correlation_qa_style'])
else:
ax = None
signif, err_signif = get_significance(fit, n_sigma_sig)
result = pd.DataFrame(
{
'InvMassFit': ax,
'DMesonCorr': d_meson_corr,
'SignalRegCorr': signal_corr,
'NSignal': n_signal,
'NSignalErr': err_n_signal,
'SignalRegCorrMix': signal_corr_mix,
'BkgRegCorr': bkg_corr,
'NBkgSideBands': n_bkg_sidebands,
'NBkgSideBandsErr': err_n_bkg_sb,
'BkgRegCorrMix': bkg_corr_mix,
'NBkgSignalReg': n_bkg_signal_region,
'NBkgSignalRegErr': err_n_bkg_signal_region,
'Significance': signif,
'Significance error': err_signif,
'SignalRegCorrInc': signal_corr_inc,
'SignalRegCorrULS': signal_corr_uls,
'SignalRegCorrLS': signal_corr_ls,
'BkgRegCorrInc': bkg_corr_inc,
'BkgRegCorrULS': bkg_corr_uls,
'BkgRegCorrLS': bkg_corr_ls
},
index=[0])
# Problem in the automatic python bindings: the destructor is called twice. Calling it manually fix it.
del fit
return result