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