diff --git a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_1JET_13TEV_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_1JET_13TEV_DIF/filter.py index 8a098772c7..26e94a6437 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_1JET_13TEV_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_1JET_13TEV_DIF/filter.py @@ -1,13 +1,31 @@ -import yaml from math import sqrt -def se(delta_plus, delta_minus): - - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 + +import yaml + + +def symmetrize_errors(delta_plus, delta_minus): + r"""Compute the symmterized uncertainty and the shift in data point. + Parameters + ---------- + delta_plus : float + The top/plus uncertainty with sign + delta_minus : float + The bottom/minus uncertainty with sign + + Returns + ------- + se_delta : float + The value to be added to the data point + se_sigma : float + The symmetrized uncertainty to be used in commondata + """ + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -22,7 +40,7 @@ def processData(): kin_altcorr1 = [] error_altcorr1 = [] -# jet data + # jet data for i in tables: if i == 1: @@ -44,7 +62,7 @@ def processData(): y_min = 2.5 y_max = 3 y_central = None - hepdata_tables="rawdata/atlas_inclusive_jet2015_r04_eta"+str(i)+".yaml" + hepdata_tables = "rawdata/atlas_inclusive_jet2015_r04_eta" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -57,21 +75,32 @@ def processData(): value_delta = 0 error_value = {} for k in range(len(values[j]['errors'])): - se_delta, se_sigma = se(values[j]['errors'][k]['asymerror']['plus'], values[j]['errors'][k]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][k]['asymerror']['plus'], + values[j]['errors'][k]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_label = str(values[j]['errors'][k]['label']) error_value[error_label] = se_sigma data_central_value = values[j]['value'] + value_delta data_central.append(data_central_value) error.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, 'y': {'min': y_min, 'mid': y_central, 'max': y_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + 'y': {'min': y_min, 'mid': y_central, 'max': y_max}, + } kin.append(kin_value) - hepdata_tables="rawdata/atlas_inclusive_jet2015_r04_eta1.yaml" + hepdata_tables = "rawdata/atlas_inclusive_jet2015_r04_eta1.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) error_definition = {} - error_definition['stat'] = {'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + error_definition['stat'] = { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } for i in range(1, len(input['dependent_variables'][0]['values'][0]['errors'])): error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] error_definition[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} @@ -81,15 +110,15 @@ def processData(): uncertainties_yaml = {'definitions': error_definition, 'bins': error} with open('data.yaml', 'w') as file: - yaml.dump(data_central_yaml, file, sort_keys=False) + yaml.dump(data_central_yaml, file, sort_keys=False) with open('kinematics.yaml', 'w') as file: - yaml.dump(kinematics_yaml, file, sort_keys=False) + yaml.dump(kinematics_yaml, file, sort_keys=False) with open('uncertainties.yaml', 'w') as file: yaml.dump(uncertainties_yaml, file, sort_keys=False) -# jet altcorr1 data + # jet altcorr1 data for i in tables_altcorr1: if i == 1: @@ -111,7 +140,7 @@ def processData(): y_min = 2.5 y_max = 3 y_central = None - hepdata_tables="rawdata/atlas_inclusive_jet2015_r04_altcorr1_eta"+str(i)+".yaml" + hepdata_tables = "rawdata/atlas_inclusive_jet2015_r04_altcorr1_eta" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -124,36 +153,52 @@ def processData(): value_delta = 0 error_value = {} for k in range(len(values[j]['errors'])): - se_delta, se_sigma = se(values[j]['errors'][k]['asymerror']['plus'], values[j]['errors'][k]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][k]['asymerror']['plus'], + values[j]['errors'][k]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_label = str(values[j]['errors'][k]['label']) error_value[error_label] = se_sigma data_central_value = values[j]['value'] + value_delta data_central_altcorr1.append(data_central_value) error_altcorr1.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, 'y': {'min': y_min, 'mid': y_central, 'max': y_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + 'y': {'min': y_min, 'mid': y_central, 'max': y_max}, + } kin_altcorr1.append(kin_value) - hepdata_tables="rawdata/atlas_inclusive_jet2015_r04_altcorr1_eta1.yaml" + hepdata_tables = "rawdata/atlas_inclusive_jet2015_r04_altcorr1_eta1.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) error_definition_altcorr1 = {} - error_definition_altcorr1['stat'] = {'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + error_definition_altcorr1['stat'] = { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } for i in range(1, len(input['dependent_variables'][0]['values'][0]['errors'])): error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] - error_definition_altcorr1[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_altcorr1[error_name] = { + 'description': '', + 'treatment': 'MULT', + 'type': 'CORR', + } data_central_altcorr1_yaml = {'data_central': data_central_altcorr1} kinematics_altcorr1_yaml = {'bins': kin_altcorr1} uncertainties_altcorr1_yaml = {'definitions': error_definition_altcorr1, 'bins': error_altcorr1} with open('data_altcorr1.yaml', 'w') as file: - yaml.dump(data_central_altcorr1_yaml, file, sort_keys=False) + yaml.dump(data_central_altcorr1_yaml, file, sort_keys=False) with open('kinematics_altcorr1.yaml', 'w') as file: - yaml.dump(kinematics_altcorr1_yaml, file, sort_keys=False) + yaml.dump(kinematics_altcorr1_yaml, file, sort_keys=False) with open('uncertainties_altcorr1.yaml', 'w') as file: yaml.dump(uncertainties_altcorr1_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_2JET_13TEV_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_2JET_13TEV_DIF/filter.py index 5c993ce57e..25c4cd9e5a 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_2JET_13TEV_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_2JET_13TEV_DIF/filter.py @@ -1,14 +1,31 @@ -import yaml from math import sqrt -def se(delta_plus, delta_minus): - - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 +import yaml + + +def symmetrize_errors(delta_plus, delta_minus): + r"""Compute the symmterized uncertainty and the shift in data point. + Parameters + ---------- + delta_plus : float + The top/plus uncertainty with sign + delta_minus : float + The bottom/minus uncertainty with sign + + Returns + ------- + se_delta : float + The value to be added to the data point + se_sigma : float + The symmetrized uncertainty to be used in commondata + """ + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -39,7 +56,7 @@ def processData(): y_min = 2.5 y_max = 3 y_central = None - hepdata_tables="rawdata/atlas_mjj_jet2015_r04_ystar"+str(i)+".yaml" + hepdata_tables = "rawdata/atlas_mjj_jet2015_r04_ystar" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -52,21 +69,32 @@ def processData(): value_delta = 0 error_value = {} for k in range(len(values[j]['errors'])): - se_delta, se_sigma = se(values[j]['errors'][k]['asymerror']['plus'], values[j]['errors'][k]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][k]['asymerror']['plus'], + values[j]['errors'][k]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_label = str(values[j]['errors'][k]['label']) error_value[error_label] = se_sigma data_central_value = values[j]['value'] + value_delta data_central.append(data_central_value) error.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_jj': {'min': m_jj_min, 'mid': None, 'max': m_jj_max}, 'ystar': {'min': y_min, 'mid': y_central, 'max': y_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_jj': {'min': m_jj_min, 'mid': None, 'max': m_jj_max}, + 'ystar': {'min': y_min, 'mid': y_central, 'max': y_max}, + } kin.append(kin_value) - hepdata_tables="rawdata/atlas_mjj_jet2015_r04_ystar1.yaml" + hepdata_tables = "rawdata/atlas_mjj_jet2015_r04_ystar1.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) error_definition = {} - error_definition['stat'] = {'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + error_definition['stat'] = { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } for i in range(1, len(input['dependent_variables'][0]['values'][0]['errors'])): error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] error_definition[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} @@ -76,12 +104,13 @@ def processData(): uncertainties_yaml = {'definitions': error_definition, 'bins': error} with open('data.yaml', 'w') as file: - yaml.dump(data_central_yaml, file, sort_keys=False) + yaml.dump(data_central_yaml, file, sort_keys=False) with open('kinematics.yaml', 'w') as file: - yaml.dump(kinematics_yaml, file, sort_keys=False) + yaml.dump(kinematics_yaml, file, sort_keys=False) with open('uncertainties.yaml', 'w') as file: yaml.dump(uncertainties_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_13TEV_LJ_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_13TEV_LJ_DIF/filter.py index 46f688a787..b9f78bafd1 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_13TEV_LJ_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_13TEV_LJ_DIF/filter.py @@ -1,30 +1,100 @@ -import yaml -import numpy as np - from math import sqrt + +import numpy as np from numpy.linalg import eig +import yaml + + +def symmetrize_errors(delta_plus, delta_minus): + r"""Compute the symmterized uncertainty and the shift in data point. + Parameters + ---------- + delta_plus : float + The top/plus uncertainty with sign + delta_minus : float + The bottom/minus uncertainty with sign -def se(delta_plus, delta_minus): - - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 + Returns + ------- + se_delta : float + The value to be added to the data point + se_sigma : float + The symmetrized uncertainty to be used in commondata + + """ + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma -def pta(percentage, value): - + +def percentage_to_absolute(percentage, value): + r"""Compute the absolute value of uncertainty from percentage. + + Parameters + ---------- + percentage : string/float + Experimental datasets can provide the percentage + uncertainties with a % sign or without one. + The function will autostrip % sign and convert to + a float type in case the percentage uncertainty + comes with a % sign. Else, it will directly perform + the computation. + value : float + The data point + + Returns + ------- + absolute : float + The absolute value of the uncertainty + + """ if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute -def cta(ndata, covmat_list, no_of_norm_mat=0): - + +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + r"""Convert the covariance matrix to a matrix of + artificial uncertainties. + + Parameters + ---------- + ndata : integer + Number of data points + covmat_list : list + A one dimensional list which contains the elements of + the covariance matrix row by row. Since experimental + datasets provide these matrices in a list form, this + simplifies the implementation for the user. + no_of_norm_mat : int + Normalized covariance matrices may have an eigenvalue + of 0 due to the last data point not being linearly + independent. To allow for this, the user should input + the number of normalized matrices that are being treated + in an instance. For example, if a single covariance matrix + of a normalized distribution is being processed, the input + would be 1. If a covariance matrix contains pertains to + 3 normalized datasets (i.e. cross covmat for 3 + distributions), the input would be 3. The default value is + 0 for when the covariance matrix pertains to an absolute + distribution. + + Returns + ------- + artunc : list + A two dimensional matrix (given as a list of lists) + which contains artificial uncertainties to be added + to the commondata. i^th row (or list) contains the + artificial uncertainties of the i^th data point. + + """ epsilon = -0.0000000001 neg_eval_count = 0 psd_check = True @@ -52,9 +122,10 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -102,18 +173,18 @@ def processData(): covMatArray_dSig_dyttBar = [] covMatArray_dSig_dyttBar_norm = [] -# dSig_dmttBar data - hepdata_tables="rawdata/Table618.yaml" + # dSig_dmttBar data + hepdata_tables = "rawdata/Table618.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - - covariance_matrix="rawdata/Table619.yaml" + + covariance_matrix = "rawdata/Table619.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dmttBar*ndata_dSig_dmttBar): + for i in range(ndata_dSig_dmttBar * ndata_dSig_dmttBar): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dmttBar.append(covMatEl) - artUncMat_dSig_dmttBar = cta(ndata_dSig_dmttBar, covMatArray_dSig_dmttBar) + artUncMat_dSig_dmttBar = covmat_to_artunc(ndata_dSig_dmttBar, covMatArray_dSig_dmttBar) sqrts = float(input['dependent_variables'][0]['qualifiers'][0]['value']) m_t2 = 29756.25 @@ -125,20 +196,24 @@ def processData(): value_delta = 0 error_value = {} # error_label = str(values[i]['errors'][0]['label']) - # error_value[error_label] = pta(values[i]['errors'][0]['symerror'], values[i]['value']) + # error_value[error_label] = percentage_to_absolute(values[i]['errors'][0]['symerror'], values[i]['value']) # for j in range(1, len(values[i]['errors'])): - # plus = pta(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) - # minus = pta(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) - # se_delta, se_sigma = se(plus, minus) + # plus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) + # minus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) + # se_delta, se_sigma = symmetrize_errors(plus, minus) # value_delta = value_delta + se_delta # error_label = values[i]['errors'][j]['label'] # error_value[error_label] = se_sigma - data_central_value = values[i]['value'] # + value_delta + data_central_value = values[i]['value'] # + value_delta data_central_dSig_dmttBar.append(data_central_value) for j in range(ndata_dSig_dmttBar): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dmttBar[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dmttBar[i][j]) error_dSig_dmttBar.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } kin_dSig_dmttBar.append(kin_value) error_definition_dSig_dmttBar = {} @@ -147,33 +222,42 @@ def processData(): # error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] # error_definition_dSig_dmttBar[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dmttBar): - error_definition_dSig_dmttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dmttBar_yaml = {'data_central': data_central_dSig_dmttBar} kinematics_dSig_dmttBar_yaml = {'bins': kin_dSig_dmttBar} - uncertainties_dSig_dmttBar_yaml = {'definitions': error_definition_dSig_dmttBar, 'bins': error_dSig_dmttBar} + uncertainties_dSig_dmttBar_yaml = { + 'definitions': error_definition_dSig_dmttBar, + 'bins': error_dSig_dmttBar, + } with open('data_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_yaml, file, sort_keys=False) -# dSig_dmttBar_norm data - hepdata_tables="rawdata/Table616.yaml" + # dSig_dmttBar_norm data + hepdata_tables = "rawdata/Table616.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table617.yaml" + covariance_matrix = "rawdata/Table617.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dmttBar_norm*ndata_dSig_dmttBar_norm): + for i in range(ndata_dSig_dmttBar_norm * ndata_dSig_dmttBar_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dmttBar_norm.append(covMatEl) - artUncMat_dSig_dmttBar_norm = cta(ndata_dSig_dmttBar_norm, covMatArray_dSig_dmttBar_norm) + artUncMat_dSig_dmttBar_norm = covmat_to_artunc( + ndata_dSig_dmttBar_norm, covMatArray_dSig_dmttBar_norm + ) sqrts = float(input['dependent_variables'][0]['qualifiers'][0]['value']) m_t2 = 29756.25 @@ -185,20 +269,24 @@ def processData(): value_delta = 0 error_value = {} # error_label = str(values[i]['errors'][0]['label']) - # error_value[error_label] = pta(values[i]['errors'][0]['symerror'], values[i]['value']) + # error_value[error_label] = percentage_to_absolute(values[i]['errors'][0]['symerror'], values[i]['value']) # for j in range(1, len(values[i]['errors'])): - # plus = pta(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) - # minus = pta(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) - # se_delta, se_sigma = se(plus, minus) + # plus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) + # minus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) + # se_delta, se_sigma = symmetrize_errors(plus, minus) # value_delta = value_delta + se_delta # error_label = values[i]['errors'][j]['label'] # error_value[error_label] = se_sigma - data_central_value = values[i]['value'] # + value_delta + data_central_value = values[i]['value'] # + value_delta data_central_dSig_dmttBar_norm.append(data_central_value) for j in range(ndata_dSig_dmttBar_norm): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dmttBar_norm[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dmttBar_norm[i][j]) error_dSig_dmttBar_norm.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } kin_dSig_dmttBar_norm.append(kin_value) error_definition_dSig_dmttBar_norm = {} @@ -207,33 +295,40 @@ def processData(): # error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] # error_definition_dSig_dmttBar_norm[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dmttBar_norm): - error_definition_dSig_dmttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dmttBar_norm_yaml = {'data_central': data_central_dSig_dmttBar_norm} kinematics_dSig_dmttBar_norm_yaml = {'bins': kin_dSig_dmttBar_norm} - uncertainties_dSig_dmttBar_norm_yaml = {'definitions': error_definition_dSig_dmttBar_norm, 'bins': error_dSig_dmttBar_norm} + uncertainties_dSig_dmttBar_norm_yaml = { + 'definitions': error_definition_dSig_dmttBar_norm, + 'bins': error_dSig_dmttBar_norm, + } with open('data_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_norm_yaml, file, sort_keys=False) -# dSig_dpTt data - hepdata_tables="rawdata/Table610.yaml" + # dSig_dpTt data + hepdata_tables = "rawdata/Table610.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table611.yaml" + covariance_matrix = "rawdata/Table611.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dpTt*ndata_dSig_dpTt): + for i in range(ndata_dSig_dpTt * ndata_dSig_dpTt): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dpTt.append(covMatEl) - artUncMat_dSig_dpTt = cta(ndata_dSig_dpTt, covMatArray_dSig_dpTt) + artUncMat_dSig_dpTt = covmat_to_artunc(ndata_dSig_dpTt, covMatArray_dSig_dpTt) sqrts = float(input['dependent_variables'][0]['qualifiers'][0]['value']) m_t2 = 29756.25 @@ -245,20 +340,24 @@ def processData(): value_delta = 0 error_value = {} # error_label = str(values[i]['errors'][0]['label']) - # error_value[error_label] = pta(values[i]['errors'][0]['symerror'], values[i]['value']) + # error_value[error_label] = percentage_to_absolute(values[i]['errors'][0]['symerror'], values[i]['value']) # for j in range(1, len(values[i]['errors'])): - # plus = pta(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) - # minus = pta(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) - # se_delta, se_sigma = se(plus, minus) + # plus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) + # minus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) + # se_delta, se_sigma = symmetrize_errors(plus, minus) # value_delta = value_delta + se_delta # error_label = values[i]['errors'][j]['label'] # error_value[error_label] = se_sigma - data_central_value = values[i]['value'] # + value_delta + data_central_value = values[i]['value'] # + value_delta data_central_dSig_dpTt.append(data_central_value) for j in range(ndata_dSig_dpTt): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dpTt[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dpTt[i][j]) error_dSig_dpTt.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } kin_dSig_dpTt.append(kin_value) error_definition_dSig_dpTt = {} @@ -267,33 +366,40 @@ def processData(): # error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] # error_definition_dSig_dpTt[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dpTt): - error_definition_dSig_dpTt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dpTt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dpTt_yaml = {'data_central': data_central_dSig_dpTt} kinematics_dSig_dpTt_yaml = {'bins': kin_dSig_dpTt} - uncertainties_dSig_dpTt_yaml = {'definitions': error_definition_dSig_dpTt, 'bins': error_dSig_dpTt} + uncertainties_dSig_dpTt_yaml = { + 'definitions': error_definition_dSig_dpTt, + 'bins': error_dSig_dpTt, + } with open('data_dSig_dpTt.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_yaml, file, sort_keys=False) -# dSig_dpTt_norm data - hepdata_tables="rawdata/Table608.yaml" + # dSig_dpTt_norm data + hepdata_tables = "rawdata/Table608.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table609.yaml" + covariance_matrix = "rawdata/Table609.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dpTt_norm*ndata_dSig_dpTt_norm): + for i in range(ndata_dSig_dpTt_norm * ndata_dSig_dpTt_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dpTt_norm.append(covMatEl) - artUncMat_dSig_dpTt_norm = cta(ndata_dSig_dpTt_norm, covMatArray_dSig_dpTt_norm) + artUncMat_dSig_dpTt_norm = covmat_to_artunc(ndata_dSig_dpTt_norm, covMatArray_dSig_dpTt_norm) sqrts = float(input['dependent_variables'][0]['qualifiers'][0]['value']) m_t2 = 29756.25 @@ -305,20 +411,24 @@ def processData(): value_delta = 0 error_value = {} # error_label = str(values[i]['errors'][0]['label']) - # error_value[error_label] = pta(values[i]['errors'][0]['symerror'], values[i]['value']) + # error_value[error_label] = percentage_to_absolute(values[i]['errors'][0]['symerror'], values[i]['value']) # for j in range(1, len(values[i]['errors'])): - # plus = pta(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) - # minus = pta(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) - # se_delta, se_sigma = se(plus, minus) + # plus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) + # minus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) + # se_delta, se_sigma = symmetrize_errors(plus, minus) # value_delta = value_delta + se_delta # error_label = values[i]['errors'][j]['label'] # error_value[error_label] = se_sigma - data_central_value = values[i]['value'] # + value_delta + data_central_value = values[i]['value'] # + value_delta data_central_dSig_dpTt_norm.append(data_central_value) for j in range(ndata_dSig_dpTt_norm): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dpTt_norm[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dpTt_norm[i][j]) error_dSig_dpTt_norm.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } kin_dSig_dpTt_norm.append(kin_value) error_definition_dSig_dpTt_norm = {} @@ -327,33 +437,40 @@ def processData(): # error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] # error_definition_dSig_dpTt_norm[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dpTt_norm): - error_definition_dSig_dpTt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dpTt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dpTt_norm_yaml = {'data_central': data_central_dSig_dpTt_norm} kinematics_dSig_dpTt_norm_yaml = {'bins': kin_dSig_dpTt_norm} - uncertainties_dSig_dpTt_norm_yaml = {'definitions': error_definition_dSig_dpTt_norm, 'bins': error_dSig_dpTt_norm} + uncertainties_dSig_dpTt_norm_yaml = { + 'definitions': error_definition_dSig_dpTt_norm, + 'bins': error_dSig_dpTt_norm, + } with open('data_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_norm_yaml, file, sort_keys=False) -# dSig_dyt data - hepdata_tables="rawdata/Table614.yaml" + # dSig_dyt data + hepdata_tables = "rawdata/Table614.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table615.yaml" + covariance_matrix = "rawdata/Table615.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dyt*ndata_dSig_dyt): + for i in range(ndata_dSig_dyt * ndata_dSig_dyt): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyt.append(covMatEl) - artUncMat_dSig_dyt = cta(ndata_dSig_dyt, covMatArray_dSig_dyt) + artUncMat_dSig_dyt = covmat_to_artunc(ndata_dSig_dyt, covMatArray_dSig_dyt) sqrts = float(input['dependent_variables'][0]['qualifiers'][0]['value']) m_t2 = 29756.25 @@ -365,20 +482,24 @@ def processData(): value_delta = 0 error_value = {} # error_label = str(values[i]['errors'][0]['label']) - # error_value[error_label] = pta(values[i]['errors'][0]['symerror'], values[i]['value']) + # error_value[error_label] = percentage_to_absolute(values[i]['errors'][0]['symerror'], values[i]['value']) # for j in range(1, len(values[i]['errors'])): - # plus = pta(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) - # minus = pta(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) - # se_delta, se_sigma = se(plus, minus) + # plus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) + # minus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) + # se_delta, se_sigma = symmetrize_errors(plus, minus) # value_delta = value_delta + se_delta # error_label = values[i]['errors'][j]['label'] # error_value[error_label] = se_sigma - data_central_value = values[i]['value'] # + value_delta + data_central_value = values[i]['value'] # + value_delta data_central_dSig_dyt.append(data_central_value) for j in range(ndata_dSig_dyt): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyt[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyt[i][j]) error_dSig_dyt.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + } kin_dSig_dyt.append(kin_value) error_definition_dSig_dyt = {} @@ -387,33 +508,37 @@ def processData(): # error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] # error_definition_dSig_dyt[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dyt): - error_definition_dSig_dyt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyt_yaml = {'data_central': data_central_dSig_dyt} kinematics_dSig_dyt_yaml = {'bins': kin_dSig_dyt} uncertainties_dSig_dyt_yaml = {'definitions': error_definition_dSig_dyt, 'bins': error_dSig_dyt} with open('data_dSig_dyt.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_yaml, file, sort_keys=False) -# dSig_dyt_norm data - hepdata_tables="rawdata/Table612.yaml" + # dSig_dyt_norm data + hepdata_tables = "rawdata/Table612.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table613.yaml" + covariance_matrix = "rawdata/Table613.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dyt_norm*ndata_dSig_dyt_norm): + for i in range(ndata_dSig_dyt_norm * ndata_dSig_dyt_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyt_norm.append(covMatEl) - artUncMat_dSig_dyt_norm = cta(ndata_dSig_dyt_norm, covMatArray_dSig_dyt_norm) + artUncMat_dSig_dyt_norm = covmat_to_artunc(ndata_dSig_dyt_norm, covMatArray_dSig_dyt_norm) sqrts = float(input['dependent_variables'][0]['qualifiers'][0]['value']) m_t2 = 29756.25 @@ -425,20 +550,24 @@ def processData(): value_delta = 0 error_value = {} # error_label = str(values[i]['errors'][0]['label']) - # error_value[error_label] = pta(values[i]['errors'][0]['symerror'], values[i]['value']) + # error_value[error_label] = percentage_to_absolute(values[i]['errors'][0]['symerror'], values[i]['value']) # for j in range(1, len(values[i]['errors'])): - # plus = pta(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) - # minus = pta(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) - # se_delta, se_sigma = se(plus, minus) + # plus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) + # minus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) + # se_delta, se_sigma = symmetrize_errors(plus, minus) # value_delta = value_delta + se_delta # error_label = values[i]['errors'][j]['label'] # error_value[error_label] = se_sigma - data_central_value = values[i]['value'] # + value_delta + data_central_value = values[i]['value'] # + value_delta data_central_dSig_dyt_norm.append(data_central_value) for j in range(ndata_dSig_dyt_norm): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyt_norm[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyt_norm[i][j]) error_dSig_dyt_norm.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + } kin_dSig_dyt_norm.append(kin_value) error_definition_dSig_dyt_norm = {} @@ -447,33 +576,40 @@ def processData(): # error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] # error_definition_dSig_dyt_norm[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dyt_norm): - error_definition_dSig_dyt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyt_norm_yaml = {'data_central': data_central_dSig_dyt_norm} kinematics_dSig_dyt_norm_yaml = {'bins': kin_dSig_dyt_norm} - uncertainties_dSig_dyt_norm_yaml = {'definitions': error_definition_dSig_dyt_norm, 'bins': error_dSig_dyt_norm} + uncertainties_dSig_dyt_norm_yaml = { + 'definitions': error_definition_dSig_dyt_norm, + 'bins': error_dSig_dyt_norm, + } with open('data_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_norm_yaml, file, sort_keys=False) -# dSig_dyttBar data - hepdata_tables="rawdata/Table626.yaml" + # dSig_dyttBar data + hepdata_tables = "rawdata/Table626.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table627.yaml" + covariance_matrix = "rawdata/Table627.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dyttBar*ndata_dSig_dyttBar): + for i in range(ndata_dSig_dyttBar * ndata_dSig_dyttBar): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyttBar.append(covMatEl) - artUncMat_dSig_dyttBar = cta(ndata_dSig_dyttBar, covMatArray_dSig_dyttBar) + artUncMat_dSig_dyttBar = covmat_to_artunc(ndata_dSig_dyttBar, covMatArray_dSig_dyttBar) sqrts = float(input['dependent_variables'][0]['qualifiers'][0]['value']) m_t2 = 29756.25 @@ -485,20 +621,24 @@ def processData(): value_delta = 0 error_value = {} # error_label = str(values[i]['errors'][0]['label']) - # error_value[error_label] = pta(values[i]['errors'][0]['symerror'], values[i]['value']) + # error_value[error_label] = percentage_to_absolute(values[i]['errors'][0]['symerror'], values[i]['value']) # for j in range(1, len(values[i]['errors'])): - # plus = pta(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) - # minus = pta(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) - # se_delta, se_sigma = se(plus, minus) + # plus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) + # minus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) + # se_delta, se_sigma = symmetrize_errors(plus, minus) # value_delta = value_delta + se_delta # error_label = values[i]['errors'][j]['label'] # error_value[error_label] = se_sigma - data_central_value = values[i]['value'] # + value_delta + data_central_value = values[i]['value'] # + value_delta data_central_dSig_dyttBar.append(data_central_value) for j in range(ndata_dSig_dyttBar): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyttBar[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyttBar[i][j]) error_dSig_dyttBar.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } kin_dSig_dyttBar.append(kin_value) error_definition_dSig_dyttBar = {} @@ -507,33 +647,42 @@ def processData(): # error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] # error_definition_dSig_dyttBar[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dyttBar): - error_definition_dSig_dyttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyttBar_yaml = {'data_central': data_central_dSig_dyttBar} kinematics_dSig_dyttBar_yaml = {'bins': kin_dSig_dyttBar} - uncertainties_dSig_dyttBar_yaml = {'definitions': error_definition_dSig_dyttBar, 'bins': error_dSig_dyttBar} + uncertainties_dSig_dyttBar_yaml = { + 'definitions': error_definition_dSig_dyttBar, + 'bins': error_dSig_dyttBar, + } with open('data_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_yaml, file, sort_keys=False) -# dSig_dyttBar_norm data - hepdata_tables="rawdata/Table624.yaml" + # dSig_dyttBar_norm data + hepdata_tables = "rawdata/Table624.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table625.yaml" + covariance_matrix = "rawdata/Table625.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dyttBar_norm*ndata_dSig_dyttBar_norm): + for i in range(ndata_dSig_dyttBar_norm * ndata_dSig_dyttBar_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyttBar_norm.append(covMatEl) - artUncMat_dSig_dyttBar_norm = cta(ndata_dSig_dyttBar_norm, covMatArray_dSig_dyttBar_norm) + artUncMat_dSig_dyttBar_norm = covmat_to_artunc( + ndata_dSig_dyttBar_norm, covMatArray_dSig_dyttBar_norm + ) sqrts = float(input['dependent_variables'][0]['qualifiers'][0]['value']) m_t2 = 29756.25 @@ -545,20 +694,24 @@ def processData(): value_delta = 0 error_value = {} # error_label = str(values[i]['errors'][0]['label']) - # error_value[error_label] = pta(values[i]['errors'][0]['symerror'], values[i]['value']) + # error_value[error_label] = percentage_to_absolute(values[i]['errors'][0]['symerror'], values[i]['value']) # for j in range(1, len(values[i]['errors'])): - # plus = pta(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) - # minus = pta(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) - # se_delta, se_sigma = se(plus, minus) + # plus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['plus'], values[i]['value']) + # minus = percentage_to_absolute(values[i]['errors'][j]['asymerror']['minus'], values[i]['value']) + # se_delta, se_sigma = symmetrize_errors(plus, minus) # value_delta = value_delta + se_delta # error_label = values[i]['errors'][j]['label'] # error_value[error_label] = se_sigma - data_central_value = values[i]['value'] # + value_delta + data_central_value = values[i]['value'] # + value_delta data_central_dSig_dyttBar_norm.append(data_central_value) for j in range(ndata_dSig_dyttBar_norm): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyttBar_norm[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyttBar_norm[i][j]) error_dSig_dyttBar_norm.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } kin_dSig_dyttBar_norm.append(kin_value) error_definition_dSig_dyttBar_norm = {} @@ -567,19 +720,27 @@ def processData(): # error_name = input['dependent_variables'][0]['values'][0]['errors'][i]['label'] # error_definition_dSig_dyttBar_norm[error_name] = {'description': '', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dyttBar_norm): - error_definition_dSig_dyttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyttBar_norm_yaml = {'data_central': data_central_dSig_dyttBar_norm} kinematics_dSig_dyttBar_norm_yaml = {'bins': kin_dSig_dyttBar_norm} - uncertainties_dSig_dyttBar_norm_yaml = {'definitions': error_definition_dSig_dyttBar_norm, 'bins': error_dSig_dyttBar_norm} + uncertainties_dSig_dyttBar_norm_yaml = { + 'definitions': error_definition_dSig_dyttBar_norm, + 'bins': error_dSig_dyttBar_norm, + } with open('data_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_norm_yaml, file, sort_keys=False) - + + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_2L_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_2L_DIF/filter.py index a83f9d3d0a..1ebcf20957 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_2L_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_2L_DIF/filter.py @@ -1,10 +1,45 @@ -import yaml from math import sqrt + import numpy as np from numpy.linalg import eig +import yaml + -def cta(ndata, covmat_list, no_of_norm_mat=0): - +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + r"""Convert the covariance matrix to a matrix of + artificial uncertainties. + + Parameters + ---------- + ndata : integer + Number of data points + covmat_list : list + A one dimensional list which contains the elements of + the covariance matrix row by row. Since experimental + datasets provide these matrices in a list form, this + simplifies the implementation for the user. + no_of_norm_mat : int + Normalized covariance matrices may have an eigenvalue + of 0 due to the last data point not being linearly + independent. To allow for this, the user should input + the number of normalized matrices that are being treated + in an instance. For example, if a single covariance matrix + of a normalized distribution is being processed, the input + would be 1. If a covariance matrix contains pertains to + 3 normalized datasets (i.e. cross covmat for 3 + distributions), the input would be 3. The default value is + 0 for when the covariance matrix pertains to an absolute + distribution. + + Returns + ------- + artunc : list + A two dimensional matrix (given as a list of lists) + which contains artificial uncertainties to be added + to the commondata. i^th row (or list) contains the + artificial uncertainties of the i^th data point. + + """ epsilon = -0.0000000001 neg_eval_count = 0 psd_check = True @@ -32,9 +67,10 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -57,192 +93,239 @@ def processData(): covMatArray_dSig_dyttBar = [] covMatArray_dSig_dyttBar_norm = [] -# dSig_dmttBar data + # dSig_dmttBar data - hepdata_tables="rawdata/Table_10.yaml" + hepdata_tables = "rawdata/Table_10.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table_22.yaml" + covariance_matrix = "rawdata/Table_22.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) - + sqrts = float(input['dependent_variables'][0]['qualifiers'][1]['value']) m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - - for i in range(len(values)*len(values)): + + for i in range(len(values) * len(values)): covMatArray_dSig_dmttBar.append(input2['dependent_variables'][0]['values'][i]['value']) - artUnc_dSig_dmttBar = cta(len(values), covMatArray_dSig_dmttBar) + artUnc_dSig_dmttBar = covmat_to_artunc(len(values), covMatArray_dSig_dmttBar) for i in range(len(values)): m_ttBar_min = input['independent_variables'][0]['values'][i]['low'] m_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(len(values)): - error_value['ArtUnc_'+str(j+1)] = artUnc_dSig_dmttBar[i][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc_dSig_dmttBar[i][j] data_central_value = values[i]['value'] data_central_dSig_dmttBar.append(data_central_value) error_dSig_dmttBar.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } kin_dSig_dmttBar.append(kin_value) error_definition_dSig_dmttBar = {} for i in range(len(values)): - error_definition_dSig_dmttBar['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dmttBar_yaml = {'data_central': data_central_dSig_dmttBar} kinematics_dSig_dmttBar_yaml = {'bins': kin_dSig_dmttBar} - uncertainties_dSig_dmttBar_yaml = {'definitions': error_definition_dSig_dmttBar, 'bins': error_dSig_dmttBar} + uncertainties_dSig_dmttBar_yaml = { + 'definitions': error_definition_dSig_dmttBar, + 'bins': error_dSig_dmttBar, + } with open('data_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_yaml, file, sort_keys=False) -# dSig_dmttBar_norm data + # dSig_dmttBar_norm data - hepdata_tables="rawdata/Table_4.yaml" + hepdata_tables = "rawdata/Table_4.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table_16.yaml" + covariance_matrix = "rawdata/Table_16.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) - + sqrts = float(input['dependent_variables'][0]['qualifiers'][1]['value']) m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - - for i in range(len(values)*len(values)): - covMatArray_dSig_dmttBar_norm.append(input2['dependent_variables'][0]['values'][i]['value']*1e-6) - artUnc_dSig_dmttBar_norm = cta(len(values), covMatArray_dSig_dmttBar_norm, 1) + + for i in range(len(values) * len(values)): + covMatArray_dSig_dmttBar_norm.append( + input2['dependent_variables'][0]['values'][i]['value'] * 1e-6 + ) + artUnc_dSig_dmttBar_norm = covmat_to_artunc(len(values), covMatArray_dSig_dmttBar_norm, 1) for i in range(len(values)): m_ttBar_min = input['independent_variables'][0]['values'][i]['low'] m_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(len(values)): - error_value['ArtUnc_'+str(j+1)] = artUnc_dSig_dmttBar_norm[i][j] - data_central_value = values[i]['value']*1e-3 + error_value['ArtUnc_' + str(j + 1)] = artUnc_dSig_dmttBar_norm[i][j] + data_central_value = values[i]['value'] * 1e-3 data_central_dSig_dmttBar_norm.append(data_central_value) error_dSig_dmttBar_norm.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } kin_dSig_dmttBar_norm.append(kin_value) error_definition_dSig_dmttBar_norm = {} for i in range(len(values)): - error_definition_dSig_dmttBar_norm['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar_norm['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dmttBar_norm_yaml = {'data_central': data_central_dSig_dmttBar_norm} kinematics_dSig_dmttBar_norm_yaml = {'bins': kin_dSig_dmttBar_norm} - uncertainties_dSig_dmttBar_norm_yaml = {'definitions': error_definition_dSig_dmttBar_norm, 'bins': error_dSig_dmttBar_norm} + uncertainties_dSig_dmttBar_norm_yaml = { + 'definitions': error_definition_dSig_dmttBar_norm, + 'bins': error_dSig_dmttBar_norm, + } with open('data_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_norm_yaml, file, sort_keys=False) -# dSig_dyttBar data + # dSig_dyttBar data - hepdata_tables="rawdata/Table_12.yaml" + hepdata_tables = "rawdata/Table_12.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table_24.yaml" + covariance_matrix = "rawdata/Table_24.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) - + sqrts = float(input['dependent_variables'][0]['qualifiers'][1]['value']) m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - - for i in range(len(values)*len(values)): + + for i in range(len(values) * len(values)): covMatArray_dSig_dyttBar.append(input2['dependent_variables'][0]['values'][i]['value']) - artUnc_dSig_dyttBar = cta(len(values), covMatArray_dSig_dyttBar) + artUnc_dSig_dyttBar = covmat_to_artunc(len(values), covMatArray_dSig_dyttBar) for i in range(len(values)): y_ttBar_min = input['independent_variables'][0]['values'][i]['low'] y_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(len(values)): - error_value['ArtUnc_'+str(j+1)] = artUnc_dSig_dyttBar[i][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc_dSig_dyttBar[i][j] data_central_value = values[i]['value'] data_central_dSig_dyttBar.append(data_central_value) error_dSig_dyttBar.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } kin_dSig_dyttBar.append(kin_value) error_definition_dSig_dyttBar = {} for i in range(len(values)): - error_definition_dSig_dyttBar['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyttBar_yaml = {'data_central': data_central_dSig_dyttBar} kinematics_dSig_dyttBar_yaml = {'bins': kin_dSig_dyttBar} - uncertainties_dSig_dyttBar_yaml = {'definitions': error_definition_dSig_dyttBar, 'bins': error_dSig_dyttBar} + uncertainties_dSig_dyttBar_yaml = { + 'definitions': error_definition_dSig_dyttBar, + 'bins': error_dSig_dyttBar, + } with open('data_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_yaml, file, sort_keys=False) -# dSig_dyttBar_norm data + # dSig_dyttBar_norm data - hepdata_tables="rawdata/Table_6.yaml" + hepdata_tables = "rawdata/Table_6.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table_18.yaml" + covariance_matrix = "rawdata/Table_18.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) - + sqrts = float(input['dependent_variables'][0]['qualifiers'][1]['value']) m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - - for i in range(len(values)*len(values)): + + for i in range(len(values) * len(values)): covMatArray_dSig_dyttBar_norm.append(input2['dependent_variables'][0]['values'][i]['value']) - artUnc_dSig_dyttBar_norm = cta(len(values), covMatArray_dSig_dyttBar_norm, 1) + artUnc_dSig_dyttBar_norm = covmat_to_artunc(len(values), covMatArray_dSig_dyttBar_norm, 1) for i in range(len(values)): y_ttBar_min = input['independent_variables'][0]['values'][i]['low'] y_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(len(values)): - error_value['ArtUnc_'+str(j+1)] = artUnc_dSig_dyttBar_norm[i][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc_dSig_dyttBar_norm[i][j] data_central_value = values[i]['value'] data_central_dSig_dyttBar_norm.append(data_central_value) error_dSig_dyttBar_norm.append(error_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } kin_dSig_dyttBar_norm.append(kin_value) error_definition_dSig_dyttBar_norm = {} for i in range(len(values)): - error_definition_dSig_dyttBar_norm['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar_norm['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyttBar_norm_yaml = {'data_central': data_central_dSig_dyttBar_norm} kinematics_dSig_dyttBar_norm_yaml = {'bins': kin_dSig_dyttBar_norm} - uncertainties_dSig_dyttBar_norm_yaml = {'definitions': error_definition_dSig_dyttBar_norm, 'bins': error_dSig_dyttBar_norm} + uncertainties_dSig_dyttBar_norm_yaml = { + 'definitions': error_definition_dSig_dyttBar_norm, + 'bins': error_dSig_dyttBar_norm, + } with open('data_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_norm_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_LJ_DIF/artunc.py b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_LJ_DIF/artunc.py index df10182dba..4afeb24568 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_LJ_DIF/artunc.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_LJ_DIF/artunc.py @@ -1,11 +1,32 @@ -import yaml from math import sqrt + import numpy as np from numpy.linalg import eig +import yaml + +def cormat_to_covmat(err_list, cormat_list): + r"""Convert correlation matrix elements to covariance + matrix elements. -def ctc(err_list, cormat_list): - + Parameters + ---------- + err_list : list + A one dimensional list which contains the uncertainty + associated to each data point in order. + cormat_list : list + A one dimensional list which contains the elements of + the correlation matrix row by row. Since experimental + datasets provide these matrices in a list form, this + simplifies the implementation for the user. + + Returns + ------- + covmat_list : list + A one dimensional list which contains the elements of + the covariance matrix row by row. + + """ covmat_list = [] for i in range(len(cormat_list)): a = i // len(err_list) @@ -13,8 +34,42 @@ def ctc(err_list, cormat_list): covmat_list.append(cormat_list[i] * err_list[a] * err_list[b]) return covmat_list -def cta(ndata, covmat_list, no_of_norm_mat=0): - + +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + r"""Convert the covariance matrix to a matrix of + artificial uncertainties. + + Parameters + ---------- + ndata : integer + Number of data points + covmat_list : list + A one dimensional list which contains the elements of + the covariance matrix row by row. Since experimental + datasets provide these matrices in a list form, this + simplifies the implementation for the user. + no_of_norm_mat : int + Normalized covariance matrices may have an eigenvalue + of 0 due to the last data point not being linearly + independent. To allow for this, the user should input + the number of normalized matrices that are being treated + in an instance. For example, if a single covariance matrix + of a normalized distribution is being processed, the input + would be 1. If a covariance matrix contains pertains to + 3 normalized datasets (i.e. cross covmat for 3 + distributions), the input would be 3. The default value is + 0 for when the covariance matrix pertains to an absolute + distribution. + + Returns + ------- + artunc : list + A two dimensional matrix (given as a list of lists) + which contains artificial uncertainties to be added + to the commondata. i^th row (or list) contains the + artificial uncertainties of the i^th data point. + + """ epsilon = -0.0000000001 neg_eval_count = 0 psd_check = True @@ -42,21 +97,77 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() -def pta(percentage, value): - + +def percentage_to_absolute(percentage, value): + r"""Compute the absolute value of uncertainty from percentage. + + Parameters + ---------- + percentage : string/float + Experimental datasets can provide the percentage + uncertainties with a % sign or without one. + The function will autostrip % sign and convert to + a float type in case the percentage uncertainty + comes with a % sign. Else, it will directly perform + the computation. + value : float + The data point + + Returns + ------- + absolute : float + The absolute value of the uncertainty + + """ if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute -def cm(rows, columns, list_of_matrices): - + +def concat_matrices(rows, columns, list_of_matrices): + r"""Join smaller matrices into a large matrix. + + This function aims to simplify the process of joining multiple + smaller matrices into one large matrix. Such a need could arise, + for instance, when cross variable covariance matrices are provided + but the user needs to join all the matrices to generate the full + covariance matrix corresponding to the entire dataset. + + Parameters + ---------- + rows : int + No. of rows of matrices to be concatenated. E.g., if 6 + matrices: A, B, C, D, E, F need to be joined as + [[A, B, C], + [D, E, F]], + the number of rows would be 2. + columns : int + No. of columns of matrices to be concatenated. In the + above example, this would be 3. + list_of_matrices : list + A list of the matrices that have to concatenated row by + row. In the above example, this would be [A, B, C, D, E, F]. + The matrices themselves need to be provided as a list of lists, + or a numpy 2d array. If the user has the matrix in a 1d row by + row form, use matList_to_matrix() to convert it. It is assumed + the user verifies that all the input matrices have the correct + dimensions. Matrices with incompatible dimensions will lead to + undesired behavior. + + Returns + ------- + final_mat_list : list + A one dimensional list which contains the elements of + the final, fully concatenated matrix row by row. + + """ for i in range(len(list_of_matrices)): list_of_matrices[i] = np.array(list_of_matrices[i]) col_list = [] @@ -72,8 +183,34 @@ def cm(rows, columns, list_of_matrices): final_mat_list.append(final_mat[i][j]) return final_mat_list -def mtm(rows, columns, mat_list): - + +def matlist_to_matrix(rows, columns, mat_list): + r"""Convert a 1d list to a 2d matrix. + + Note: This utils function is not strictly needed for + data implementation, however, it is provided for + the aid of the user due to how matrices are treated + throughout all the other functions. This function + allows the user to convert a list that contains the + elemnets of matrix row by row to a proper matrix, if + need be for any reason. + + Parameters + ---------- + rows : int + No. of rows in the matrix + columns : int + No. of columns in the matrix + mat_list : list + A one dimensional list which contains the elements of + the matrix row by row. + + Returns + ------- + matrix : numpy.ndarray + The matrix as a numpy 2d array. + + """ if rows * columns == len(mat_list): matrix = np.zeros((rows, columns)) for i in range(rows): @@ -84,185 +221,226 @@ def mtm(rows, columns, mat_list): else: raise Exception('rows * columns != len(mat_list)') + def artunc(): statArr = [] for i in [23, 29, 31, 27]: - with open('rawdata/Table_'+str(i)+'.yaml', 'r') as file: + with open('rawdata/Table_' + str(i) + '.yaml', 'r') as file: input = yaml.safe_load(file) for j in range(len(input['dependent_variables'][0]['values'])): datval = input['dependent_variables'][0]['values'][j]['value'] statperc = input['dependent_variables'][0]['values'][j]['errors'][0]['symerror'] - statArr.append(pta(statperc, datval)) - -# mttbar(7)| pTt (8)| yt(5)| yttbar(5) -# mttbar| 179 174t 170t 177t -# pTt | 174 172 168t 173 -# yt | 170 168 167 169 -# yttbar| 177 173t 169t 176 + statArr.append(percentage_to_absolute(statperc, datval)) + + # mttbar(7)| pTt (8)| yt(5)| yttbar(5) + # mttbar| 179 174t 170t 177t + # pTt | 174 172 168t 173 + # yt | 170 168 167 169 + # yttbar| 177 173t 169t 176 ml179, ml174, ml170, ml177, ml172, ml168, ml167, ml173, ml169, ml176 = ([] for i in range(10)) - + with open('rawdata/Table_179.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml179.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_174.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml174.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_170.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml170.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_177.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml177.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_172.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml172.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_168.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml168.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_167.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml167.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_173.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml173.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_169.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml169.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_176.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml176.append(input['dependent_variables'][0]['values'][i]['value']) - - mat179 = mtm(7, 7, ml179) - mat174 = mtm(8, 7, ml174) + + mat179 = matlist_to_matrix(7, 7, ml179) + mat174 = matlist_to_matrix(8, 7, ml174) mat174t = mat174.transpose() - mat170 = mtm(5, 7, ml170) + mat170 = matlist_to_matrix(5, 7, ml170) mat170t = mat170.transpose() - mat177 = mtm(5, 7, ml177) + mat177 = matlist_to_matrix(5, 7, ml177) mat177t = mat177.transpose() - mat172 = mtm(8, 8, ml172) - mat168 = mtm(5, 8, ml168) + mat172 = matlist_to_matrix(8, 8, ml172) + mat168 = matlist_to_matrix(5, 8, ml168) mat168t = mat168.transpose() - mat167 = mtm(5, 5, ml167) - mat173 = mtm(8, 5, ml173) + mat167 = matlist_to_matrix(5, 5, ml167) + mat173 = matlist_to_matrix(8, 5, ml173) mat173t = mat173.transpose() - mat169 = mtm(5, 5, ml169) + mat169 = matlist_to_matrix(5, 5, ml169) mat169t = mat169.transpose() - mat176 = mtm(5, 5, ml176) + mat176 = matlist_to_matrix(5, 5, ml176) - cormatlist = cm(4, 4, [mat179, mat174t, mat170t, mat177t, mat174, mat172, mat168t, mat173, - mat170, mat168, mat167, mat169, mat177, mat173t, mat169t, mat176]) + cormatlist = concat_matrices( + 4, + 4, + [ + mat179, + mat174t, + mat170t, + mat177t, + mat174, + mat172, + mat168t, + mat173, + mat170, + mat168, + mat167, + mat169, + mat177, + mat173t, + mat169t, + mat176, + ], + ) - covmatlist = ctc(statArr, cormatlist) - artunc = cta(25, covmatlist) + covmatlist = cormat_to_covmat(statArr, cormatlist) + artunc = covmat_to_artunc(25, covmatlist) return artunc def artunc_norm(): statArr = [] for i in [24, 30, 32, 28]: - with open('rawdata/Table_'+str(i)+'.yaml', 'r') as file: + with open('rawdata/Table_' + str(i) + '.yaml', 'r') as file: input = yaml.safe_load(file) for j in range(len(input['dependent_variables'][0]['values'])): datval = input['dependent_variables'][0]['values'][j]['value'] statperc = input['dependent_variables'][0]['values'][j]['errors'][0]['symerror'] - statArr.append(pta(statperc, datval)) - -# mttbar(7)| pTt (8)| yt(5)| yttbar(5) -# mttbar| 234 229t 225t 232t -# pTt | 229 227 223t 228 -# yt | 225 223 222 224 -# yttbar| 232 228t 224t 231 + statArr.append(percentage_to_absolute(statperc, datval)) + + # mttbar(7)| pTt (8)| yt(5)| yttbar(5) + # mttbar| 234 229t 225t 232t + # pTt | 229 227 223t 228 + # yt | 225 223 222 224 + # yttbar| 232 228t 224t 231 ml234, ml229, ml225, ml232, ml227, ml223, ml222, ml228, ml224, ml231 = ([] for i in range(10)) - + with open('rawdata/Table_234.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml234.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_229.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml229.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_225.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml225.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_232.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml232.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_227.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml227.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_223.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml223.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_222.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml222.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_228.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml228.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_224.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml224.append(input['dependent_variables'][0]['values'][i]['value']) - + with open('rawdata/Table_231.yaml', 'r') as file: input = yaml.safe_load(file) for i in range(len(input['dependent_variables'][0]['values'])): ml231.append(input['dependent_variables'][0]['values'][i]['value']) - - mat234 = mtm(7, 7, ml234) - mat229 = mtm(8, 7, ml229) + + mat234 = matlist_to_matrix(7, 7, ml234) + mat229 = matlist_to_matrix(8, 7, ml229) mat229t = mat229.transpose() - mat225 = mtm(5, 7, ml225) + mat225 = matlist_to_matrix(5, 7, ml225) mat225t = mat225.transpose() - mat232 = mtm(5, 7, ml232) + mat232 = matlist_to_matrix(5, 7, ml232) mat232t = mat232.transpose() - mat227 = mtm(8, 8, ml227) - mat223 = mtm(5, 8, ml223) + mat227 = matlist_to_matrix(8, 8, ml227) + mat223 = matlist_to_matrix(5, 8, ml223) mat223t = mat223.transpose() - mat222 = mtm(5, 5, ml222) - mat228 = mtm(8, 5, ml228) + mat222 = matlist_to_matrix(5, 5, ml222) + mat228 = matlist_to_matrix(8, 5, ml228) mat228t = mat228.transpose() - mat224 = mtm(5, 5, ml224) + mat224 = matlist_to_matrix(5, 5, ml224) mat224t = mat224.transpose() - mat231 = mtm(5, 5, ml231) + mat231 = matlist_to_matrix(5, 5, ml231) - cormatlist = cm(4, 4, [mat234, mat229t, mat225t, mat232t, mat229, mat227, mat223t, mat228, - mat225, mat223, mat222, mat224, mat232, mat228t, mat224t, mat231]) + cormatlist = concat_matrices( + 4, + 4, + [ + mat234, + mat229t, + mat225t, + mat232t, + mat229, + mat227, + mat223t, + mat228, + mat225, + mat223, + mat222, + mat224, + mat232, + mat228t, + mat224t, + mat231, + ], + ) - covmatlist = ctc(statArr, cormatlist) - artunc = cta(25, covmatlist, 4) + covmatlist = cormat_to_covmat(statArr, cormatlist) + artunc = covmat_to_artunc(25, covmatlist, 4) return artunc diff --git a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_LJ_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_LJ_DIF/filter.py index 52cb35b39a..7a7c83d896 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_LJ_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ATLAS_TTBAR_8TEV_LJ_DIF/filter.py @@ -1,28 +1,66 @@ +from math import sqrt +from pathlib import Path +import re + import artunc import yaml -import re -from pathlib import Path -from math import sqrt -def pta(percentage, value): - +def percentage_to_absolute(percentage, value): + r"""Compute the absolute value of uncertainty from percentage. + + Parameters + ---------- + percentage : string/float + Experimental datasets can provide the percentage + uncertainties with a % sign or without one. + The function will autostrip % sign and convert to + a float type in case the percentage uncertainty + comes with a % sign. Else, it will directly perform + the computation. + value : float + The data point + + Returns + ------- + absolute : float + The absolute value of the uncertainty + + """ if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute -def se(delta_plus, delta_minus): - - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 + +def symmetrize_errors(delta_plus, delta_minus): + r"""Compute the symmterized uncertainty and the shift in data point. + + Parameters + ---------- + delta_plus : float + The top/plus uncertainty with sign + delta_minus : float + The bottom/minus uncertainty with sign + + Returns + ------- + se_delta : float + The value to be added to the data point + se_sigma : float + The symmetrized uncertainty to be used in commondata + + """ + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -54,12 +92,12 @@ def processData(): artUnc = artunc.artunc() artUnc_norm = artunc.artunc_norm() -# dSig_dmttBar + # dSig_dmttBar - hepdata_tables='rawdata/Table_23.yaml' + hepdata_tables = 'rawdata/Table_23.yaml' with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = 8000.0 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] @@ -70,48 +108,91 @@ def processData(): m_ttbar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(25): - error_value['ArtUnc_'+str(j+1)] = artUnc[i][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc[i][j] value_delta = 0 - for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors'])-1): + for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors']) - 1): if 'symerror' in input['dependent_variables'][1]['values'][i]['errors'][j]: - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = pta(input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], data_central_value) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], + data_central_value, + ) else: - se_delta, se_sigma = se(pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['plus'], data_central_value), pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['minus'], data_central_value)) - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = se_sigma + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'plus' + ], + data_central_value, + ), + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'minus' + ], + data_central_value, + ), + ) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = se_sigma value_delta = value_delta + se_delta - error_value['lumi'] = pta(values[i]['errors'][2]['symerror'], data_central_value) + error_value['lumi'] = percentage_to_absolute( + values[i]['errors'][2]['symerror'], data_central_value + ) data_central_value = data_central_value + value_delta - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttbar_min, 'mid': None, 'max': m_ttbar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttbar_min, 'mid': None, 'max': m_ttbar_max}, + } data_central_dSig_dmttBar.append(data_central_value) kin_dSig_dmttBar.append(kin_value) error_dSig_dmttBar.append(error_value) error_definition_dSig_dmttBar = {} for i in range(25): - error_definition_dSig_dmttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'ATLAS8TEVTTB151104716unc'+str(i+1)} - for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors'])-1): - error_definition_dSig_dmttBar[input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "")] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} - error_definition_dSig_dmttBar['lumi'] = {'definition': 'luminosity uncertainty', 'treatment': 'MULT', 'type': 'ATLASLUMI8'} + error_definition_dSig_dmttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'ATLAS8TEVTTB151104716unc' + str(i + 1), + } + for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors']) - 1): + error_definition_dSig_dmttBar[ + input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "") + ] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dmttBar['lumi'] = { + 'definition': 'luminosity uncertainty', + 'treatment': 'MULT', + 'type': 'ATLASLUMI8', + } data_central_dSig_dmttBar_yaml = {'data_central': data_central_dSig_dmttBar} kinematics_dSig_dmttBar_yaml = {'bins': kin_dSig_dmttBar} - uncertainties_dSig_dmttBar_yaml = {'definitions': error_definition_dSig_dmttBar, 'bins': error_dSig_dmttBar} + uncertainties_dSig_dmttBar_yaml = { + 'definitions': error_definition_dSig_dmttBar, + 'bins': error_dSig_dmttBar, + } with open('data_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_yaml, file, sort_keys=False) - -# dSig_dmttBar_norm - hepdata_tables='rawdata/Table_24.yaml' + # dSig_dmttBar_norm + + hepdata_tables = 'rawdata/Table_24.yaml' with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = 8000.0 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] @@ -122,46 +203,83 @@ def processData(): m_ttbar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(25): - error_value['ArtUnc_'+str(j+1)] = artUnc_norm[i][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc_norm[i][j] value_delta = 0 for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors'])): if 'symerror' in input['dependent_variables'][1]['values'][i]['errors'][j]: - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = pta(input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], data_central_value) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], + data_central_value, + ) else: - se_delta, se_sigma = se(pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['plus'], data_central_value), pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['minus'], data_central_value)) - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = se_sigma + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'plus' + ], + data_central_value, + ), + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'minus' + ], + data_central_value, + ), + ) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = se_sigma value_delta = value_delta + se_delta data_central_value = data_central_value + value_delta - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttbar_min, 'mid': None, 'max': m_ttbar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttbar_min, 'mid': None, 'max': m_ttbar_max}, + } data_central_dSig_dmttBar_norm.append(data_central_value) kin_dSig_dmttBar_norm.append(kin_value) error_dSig_dmttBar_norm.append(error_value) error_definition_dSig_dmttBar_norm = {} for i in range(25): - error_definition_dSig_dmttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'ATLAS8TEVTTB151104716unc'+str(i+1)} + error_definition_dSig_dmttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'ATLAS8TEVTTB151104716unc' + str(i + 1), + } for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors'])): - error_definition_dSig_dmttBar_norm[input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "")] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dmttBar_norm[ + input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "") + ] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} data_central_dSig_dmttBar_norm_yaml = {'data_central': data_central_dSig_dmttBar_norm} kinematics_dSig_dmttBar_norm_yaml = {'bins': kin_dSig_dmttBar_norm} - uncertainties_dSig_dmttBar_norm_yaml = {'definitions': error_definition_dSig_dmttBar_norm, 'bins': error_dSig_dmttBar_norm} + uncertainties_dSig_dmttBar_norm_yaml = { + 'definitions': error_definition_dSig_dmttBar_norm, + 'bins': error_dSig_dmttBar_norm, + } with open('data_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_norm_yaml, file, sort_keys=False) -# dSig_dpTt + # dSig_dpTt - hepdata_tables='rawdata/Table_29.yaml' + hepdata_tables = 'rawdata/Table_29.yaml' with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = 8000.0 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] @@ -172,48 +290,91 @@ def processData(): pT_t_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(25): - error_value['ArtUnc_'+str(j+1)] = artUnc[i+7][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc[i + 7][j] value_delta = 0 - for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors'])-1): + for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors']) - 1): if 'symerror' in input['dependent_variables'][1]['values'][i]['errors'][j]: - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = pta(input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], data_central_value) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], + data_central_value, + ) else: - se_delta, se_sigma = se(pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['plus'], data_central_value), pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['minus'], data_central_value)) - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = se_sigma + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'plus' + ], + data_central_value, + ), + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'minus' + ], + data_central_value, + ), + ) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = se_sigma value_delta = value_delta + se_delta - error_value['lumi'] = pta(values[i]['errors'][2]['symerror'], data_central_value) + error_value['lumi'] = percentage_to_absolute( + values[i]['errors'][2]['symerror'], data_central_value + ) data_central_value = data_central_value + value_delta - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } data_central_dSig_dpTt.append(data_central_value) kin_dSig_dpTt.append(kin_value) error_dSig_dpTt.append(error_value) error_definition_dSig_dpTt = {} for i in range(25): - error_definition_dSig_dpTt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'ATLAS8TEVTTB151104716unc'+str(i+1)} - for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors'])-1): - error_definition_dSig_dpTt[input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "")] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} - error_definition_dSig_dpTt['lumi'] = {'definition': 'luminosity uncertainty', 'treatment': 'MULT', 'type': 'ATLASLUMI8'} + error_definition_dSig_dpTt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'ATLAS8TEVTTB151104716unc' + str(i + 1), + } + for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors']) - 1): + error_definition_dSig_dpTt[ + input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "") + ] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dpTt['lumi'] = { + 'definition': 'luminosity uncertainty', + 'treatment': 'MULT', + 'type': 'ATLASLUMI8', + } data_central_dSig_dpTt_yaml = {'data_central': data_central_dSig_dpTt} kinematics_dSig_dpTt_yaml = {'bins': kin_dSig_dpTt} - uncertainties_dSig_dpTt_yaml = {'definitions': error_definition_dSig_dpTt, 'bins': error_dSig_dpTt} + uncertainties_dSig_dpTt_yaml = { + 'definitions': error_definition_dSig_dpTt, + 'bins': error_dSig_dpTt, + } with open('data_dSig_dpTt.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_yaml, file, sort_keys=False) -# dSig_dpTt_norm + # dSig_dpTt_norm - hepdata_tables='rawdata/Table_30.yaml' + hepdata_tables = 'rawdata/Table_30.yaml' with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = 8000.0 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] @@ -224,46 +385,83 @@ def processData(): pT_t_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(25): - error_value['ArtUnc_'+str(j+1)] = artUnc_norm[i+7][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc_norm[i + 7][j] value_delta = 0 for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors'])): if 'symerror' in input['dependent_variables'][1]['values'][i]['errors'][j]: - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = pta(input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], data_central_value) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], + data_central_value, + ) else: - se_delta, se_sigma = se(pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['plus'], data_central_value), pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['minus'], data_central_value)) - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = se_sigma + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'plus' + ], + data_central_value, + ), + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'minus' + ], + data_central_value, + ), + ) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = se_sigma value_delta = value_delta + se_delta data_central_value = data_central_value + value_delta - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } data_central_dSig_dpTt_norm.append(data_central_value) kin_dSig_dpTt_norm.append(kin_value) error_dSig_dpTt_norm.append(error_value) error_definition_dSig_dpTt_norm = {} for i in range(25): - error_definition_dSig_dpTt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'ATLAS8TEVTTB151104716unc'+str(i+1)} + error_definition_dSig_dpTt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'ATLAS8TEVTTB151104716unc' + str(i + 1), + } for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors'])): - error_definition_dSig_dpTt_norm[input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "")] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dpTt_norm[ + input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "") + ] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} data_central_dSig_dpTt_norm_yaml = {'data_central': data_central_dSig_dpTt_norm} kinematics_dSig_dpTt_norm_yaml = {'bins': kin_dSig_dpTt_norm} - uncertainties_dSig_dpTt_norm_yaml = {'definitions': error_definition_dSig_dpTt_norm, 'bins': error_dSig_dpTt_norm} + uncertainties_dSig_dpTt_norm_yaml = { + 'definitions': error_definition_dSig_dpTt_norm, + 'bins': error_dSig_dpTt_norm, + } with open('data_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_norm_yaml, file, sort_keys=False) -# dSig_dyt + # dSig_dyt - hepdata_tables='rawdata/Table_31.yaml' + hepdata_tables = 'rawdata/Table_31.yaml' with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = 8000.0 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] @@ -274,48 +472,88 @@ def processData(): y_t_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(25): - error_value['ArtUnc_'+str(j+1)] = artUnc[i+15][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc[i + 15][j] value_delta = 0 - for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors'])-1): + for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors']) - 1): if 'symerror' in input['dependent_variables'][1]['values'][i]['errors'][j]: - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = pta(input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], data_central_value) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], + data_central_value, + ) else: - se_delta, se_sigma = se(pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['plus'], data_central_value), pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['minus'], data_central_value)) - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = se_sigma + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'plus' + ], + data_central_value, + ), + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'minus' + ], + data_central_value, + ), + ) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = se_sigma value_delta = value_delta + se_delta - error_value['lumi'] = pta(values[i]['errors'][2]['symerror'], data_central_value) + error_value['lumi'] = percentage_to_absolute( + values[i]['errors'][2]['symerror'], data_central_value + ) data_central_value = data_central_value + value_delta - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + } data_central_dSig_dyt.append(data_central_value) kin_dSig_dyt.append(kin_value) error_dSig_dyt.append(error_value) error_definition_dSig_dyt = {} for i in range(25): - error_definition_dSig_dyt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'ATLAS8TEVTTB151104716unc'+str(i+1)} - for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors'])-1): - error_definition_dSig_dyt[input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "")] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} - error_definition_dSig_dyt['lumi'] = {'definition': 'luminosity uncertainty', 'treatment': 'MULT', 'type': 'ATLASLUMI8'} + error_definition_dSig_dyt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'ATLAS8TEVTTB151104716unc' + str(i + 1), + } + for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors']) - 1): + error_definition_dSig_dyt[ + input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "") + ] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyt['lumi'] = { + 'definition': 'luminosity uncertainty', + 'treatment': 'MULT', + 'type': 'ATLASLUMI8', + } data_central_dSig_dyt_yaml = {'data_central': data_central_dSig_dyt} kinematics_dSig_dyt_yaml = {'bins': kin_dSig_dyt} uncertainties_dSig_dyt_yaml = {'definitions': error_definition_dSig_dyt, 'bins': error_dSig_dyt} with open('data_dSig_dyt.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_yaml, file, sort_keys=False) -# dSig_dyt_norm + # dSig_dyt_norm - hepdata_tables='rawdata/Table_32.yaml' + hepdata_tables = 'rawdata/Table_32.yaml' with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = 8000.0 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] @@ -326,46 +564,83 @@ def processData(): y_t_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(25): - error_value['ArtUnc_'+str(j+1)] = artUnc_norm[i+15][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc_norm[i + 15][j] value_delta = 0 for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors'])): if 'symerror' in input['dependent_variables'][1]['values'][i]['errors'][j]: - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = pta(input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], data_central_value) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], + data_central_value, + ) else: - se_delta, se_sigma = se(pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['plus'], data_central_value), pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['minus'], data_central_value)) - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = se_sigma + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'plus' + ], + data_central_value, + ), + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'minus' + ], + data_central_value, + ), + ) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = se_sigma value_delta = value_delta + se_delta data_central_value = data_central_value + value_delta - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + } data_central_dSig_dyt_norm.append(data_central_value) kin_dSig_dyt_norm.append(kin_value) error_dSig_dyt_norm.append(error_value) error_definition_dSig_dyt_norm = {} for i in range(25): - error_definition_dSig_dyt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'ATLAS8TEVTTB151104716unc'+str(i+1)} + error_definition_dSig_dyt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'ATLAS8TEVTTB151104716unc' + str(i + 1), + } for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors'])): - error_definition_dSig_dyt_norm[input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "")] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyt_norm[ + input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "") + ] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} data_central_dSig_dyt_norm_yaml = {'data_central': data_central_dSig_dyt_norm} kinematics_dSig_dyt_norm_yaml = {'bins': kin_dSig_dyt_norm} - uncertainties_dSig_dyt_norm_yaml = {'definitions': error_definition_dSig_dyt_norm, 'bins': error_dSig_dyt_norm} + uncertainties_dSig_dyt_norm_yaml = { + 'definitions': error_definition_dSig_dyt_norm, + 'bins': error_dSig_dyt_norm, + } with open('data_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_norm_yaml, file, sort_keys=False) -# dSig_dyttBar + # dSig_dyttBar - hepdata_tables='rawdata/Table_27.yaml' + hepdata_tables = 'rawdata/Table_27.yaml' with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = 8000.0 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] @@ -376,48 +651,91 @@ def processData(): y_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(25): - error_value['ArtUnc_'+str(j+1)] = artUnc[i+20][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc[i + 20][j] value_delta = 0 - for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors'])-1): + for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors']) - 1): if 'symerror' in input['dependent_variables'][1]['values'][i]['errors'][j]: - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = pta(input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], data_central_value) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], + data_central_value, + ) else: - se_delta, se_sigma = se(pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['plus'], data_central_value), pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['minus'], data_central_value)) - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = se_sigma + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'plus' + ], + data_central_value, + ), + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'minus' + ], + data_central_value, + ), + ) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = se_sigma value_delta = value_delta + se_delta - error_value['lumi'] = pta(values[i]['errors'][2]['symerror'], data_central_value) + error_value['lumi'] = percentage_to_absolute( + values[i]['errors'][2]['symerror'], data_central_value + ) data_central_value = data_central_value + value_delta - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } data_central_dSig_dyttBar.append(data_central_value) kin_dSig_dyttBar.append(kin_value) error_dSig_dyttBar.append(error_value) error_definition_dSig_dyttBar = {} for i in range(25): - error_definition_dSig_dyttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'ATLAS8TEVTTB151104716unc'+str(i+1)} - for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors'])-1): - error_definition_dSig_dyttBar[input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "")] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} - error_definition_dSig_dyttBar['lumi'] = {'definition': 'luminosity uncertainty', 'treatment': 'MULT', 'type': 'ATLASLUMI8'} + error_definition_dSig_dyttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'ATLAS8TEVTTB151104716unc' + str(i + 1), + } + for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors']) - 1): + error_definition_dSig_dyttBar[ + input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "") + ] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyttBar['lumi'] = { + 'definition': 'luminosity uncertainty', + 'treatment': 'MULT', + 'type': 'ATLASLUMI8', + } data_central_dSig_dyttBar_yaml = {'data_central': data_central_dSig_dyttBar} kinematics_dSig_dyttBar_yaml = {'bins': kin_dSig_dyttBar} - uncertainties_dSig_dyttBar_yaml = {'definitions': error_definition_dSig_dyttBar, 'bins': error_dSig_dyttBar} + uncertainties_dSig_dyttBar_yaml = { + 'definitions': error_definition_dSig_dyttBar, + 'bins': error_dSig_dyttBar, + } with open('data_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_yaml, file, sort_keys=False) -# dSig_dyttBar_norm + # dSig_dyttBar_norm - hepdata_tables='rawdata/Table_28.yaml' + hepdata_tables = 'rawdata/Table_28.yaml' with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = 8000.0 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] @@ -428,40 +746,78 @@ def processData(): y_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(25): - error_value['ArtUnc_'+str(j+1)] = artUnc_norm[i+20][j] + error_value['ArtUnc_' + str(j + 1)] = artUnc_norm[i + 20][j] value_delta = 0 for j in range(1, len(input['dependent_variables'][1]['values'][i]['errors'])): if 'symerror' in input['dependent_variables'][1]['values'][i]['errors'][j]: - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = pta(input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], data_central_value) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['symerror'], + data_central_value, + ) else: - se_delta, se_sigma = se(pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['plus'], data_central_value), pta(input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror']['minus'], data_central_value)) - error_value[input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace(" ", "")] = se_sigma + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'plus' + ], + data_central_value, + ), + percentage_to_absolute( + input['dependent_variables'][1]['values'][i]['errors'][j]['asymerror'][ + 'minus' + ], + data_central_value, + ), + ) + error_value[ + input['dependent_variables'][1]['values'][i]['errors'][j]['label'].replace( + " ", "" + ) + ] = se_sigma value_delta = value_delta + se_delta data_central_value = data_central_value + value_delta - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } data_central_dSig_dyttBar_norm.append(data_central_value) kin_dSig_dyttBar_norm.append(kin_value) error_dSig_dyttBar_norm.append(error_value) error_definition_dSig_dyttBar_norm = {} for i in range(25): - error_definition_dSig_dyttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'ATLAS8TEVTTB151104716unc'+str(i+1)} + error_definition_dSig_dyttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'ATLAS8TEVTTB151104716unc' + str(i + 1), + } for i in range(1, len(input['dependent_variables'][1]['values'][0]['errors'])): - error_definition_dSig_dyttBar_norm[input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "")] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyttBar_norm[ + input['dependent_variables'][1]['values'][0]['errors'][i]['label'].replace(" ", "") + ] = {'definition': '', 'treatment': 'MULT', 'type': 'CORR'} data_central_dSig_dyttBar_norm_yaml = {'data_central': data_central_dSig_dyttBar_norm} kinematics_dSig_dyttBar_norm_yaml = {'bins': kin_dSig_dyttBar_norm} - uncertainties_dSig_dyttBar_norm_yaml = {'definitions': error_definition_dSig_dyttBar_norm, 'bins': error_dSig_dyttBar_norm} + uncertainties_dSig_dyttBar_norm_yaml = { + 'definitions': error_definition_dSig_dyttBar_norm, + 'bins': error_dSig_dyttBar_norm, + } with open('data_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_norm_yaml, file, sort_keys=False) + def remove_commas(): pattern = "uncertainties*.yaml" reg = re.compile(fr'({"sys,"})') @@ -469,5 +825,6 @@ def remove_commas(): new_text = reg.sub("syst_", file.read_text()) file.write_text(new_text) + processData() -remove_commas() \ No newline at end of file +remove_commas() diff --git a/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_13TEV_2L_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_13TEV_2L_DIF/filter.py index 4f618ec2b7..f252a5b517 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_13TEV_2L_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_13TEV_2L_DIF/filter.py @@ -1,12 +1,45 @@ -import yaml +from math import sqrt import numpy as np - -from math import sqrt from numpy.linalg import eig +import yaml + -def cta(ndata, covmat_list, no_of_norm_mat=0): - +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + r"""Convert the covariance matrix to a matrix of + artificial uncertainties. + + Parameters + ---------- + ndata : integer + Number of data points + covmat_list : list + A one dimensional list which contains the elements of + the covariance matrix row by row. Since experimental + datasets provide these matrices in a list form, this + simplifies the implementation for the user. + no_of_norm_mat : int + Normalized covariance matrices may have an eigenvalue + of 0 due to the last data point not being linearly + independent. To allow for this, the user should input + the number of normalized matrices that are being treated + in an instance. For example, if a single covariance matrix + of a normalized distribution is being processed, the input + would be 1. If a covariance matrix contains pertains to + 3 normalized datasets (i.e. cross covmat for 3 + distributions), the input would be 3. The default value is + 0 for when the covariance matrix pertains to an absolute + distribution. + + Returns + ------- + artunc : list + A two dimensional matrix (given as a list of lists) + which contains artificial uncertainties to be added + to the commondata. i^th row (or list) contains the + artificial uncertainties of the i^th data point. + + """ epsilon = -0.0000000001 neg_eval_count = 0 psd_check = True @@ -34,9 +67,10 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -75,18 +109,17 @@ def processData(): covmat_dSig_dyttBar = [] covmat_dSig_dyttBar_norm = [] -# dSig_dpTt + # dSig_dpTt - hepdata_tables="rawdata/d01-x01-y01.yaml" + hepdata_tables = "rawdata/d01-x01-y01.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/d01-x01-y01_cov.yaml" + covariance_matrix = "rawdata/d01-x01-y01_cov.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) for i in range(36): covmat_dSig_dpTt.append(input2['dependent_variables'][0]['values'][i]['value']) - artunc_dSig_dpTt = cta(6, covmat_dSig_dpTt, 0) - + artunc_dSig_dpTt = covmat_to_artunc(6, covmat_dSig_dpTt, 0) sqrts = 13000.0 m_t2 = 29756.25 @@ -98,41 +131,51 @@ def processData(): pT_t_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(6): - error_value['ArtUnc_'+str(j+1)] = artunc_dSig_dpTt[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc_dSig_dpTt[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } data_central_dSig_dpTt.append(data_central_value) kin_dSig_dpTt.append(kin_value) error_dSig_dpTt.append(error_value) error_definition_dSig_dpTt = {} for i in range(6): - error_definition_dSig_dpTt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dpTt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dpTt_yaml = {'data_central': data_central_dSig_dpTt} kinematics_dSig_dpTt_yaml = {'bins': kin_dSig_dpTt} - uncertainties_dSig_dpTt_yaml = {'definitions': error_definition_dSig_dpTt, 'bins': error_dSig_dpTt} + uncertainties_dSig_dpTt_yaml = { + 'definitions': error_definition_dSig_dpTt, + 'bins': error_dSig_dpTt, + } with open('data_dSig_dpTt.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_yaml, file, sort_keys=False) -# dSig_dpTt_norm + # dSig_dpTt_norm - hepdata_tables="rawdata/d02-x01-y01.yaml" + hepdata_tables = "rawdata/d02-x01-y01.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/d02-x01-y01_cov.yaml" + covariance_matrix = "rawdata/d02-x01-y01_cov.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) for i in range(25): covmat_dSig_dpTt_norm.append(input2['dependent_variables'][0]['values'][i]['value']) - artunc_dSig_dpTt_norm = cta(5, covmat_dSig_dpTt_norm, 1) - + artunc_dSig_dpTt_norm = covmat_to_artunc(5, covmat_dSig_dpTt_norm, 1) sqrts = 13000.0 m_t2 = 29756.25 @@ -144,41 +187,51 @@ def processData(): pT_t_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(5): - error_value['ArtUnc_'+str(j+1)] = artunc_dSig_dpTt_norm[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc_dSig_dpTt_norm[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } data_central_dSig_dpTt_norm.append(data_central_value) kin_dSig_dpTt_norm.append(kin_value) error_dSig_dpTt_norm.append(error_value) error_definition_dSig_dpTt_norm = {} for i in range(5): - error_definition_dSig_dpTt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dpTt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dpTt_norm_yaml = {'data_central': data_central_dSig_dpTt_norm} kinematics_dSig_dpTt_norm_yaml = {'bins': kin_dSig_dpTt_norm} - uncertainties_dSig_dpTt_norm_yaml = {'definitions': error_definition_dSig_dpTt_norm, 'bins': error_dSig_dpTt_norm} + uncertainties_dSig_dpTt_norm_yaml = { + 'definitions': error_definition_dSig_dpTt_norm, + 'bins': error_dSig_dpTt_norm, + } with open('data_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_norm_yaml, file, sort_keys=False) -# dSig_dmttBar + # dSig_dmttBar - hepdata_tables="rawdata/d045-x01-y01.yaml" + hepdata_tables = "rawdata/d045-x01-y01.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/d045-x01-y01_cov.yaml" + covariance_matrix = "rawdata/d045-x01-y01_cov.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) for i in range(49): covmat_dSig_dmttBar.append(input2['dependent_variables'][0]['values'][i]['value']) - artunc_dSig_dmttBar = cta(7, covmat_dSig_dmttBar, 0) - + artunc_dSig_dmttBar = covmat_to_artunc(7, covmat_dSig_dmttBar, 0) sqrts = 13000.0 m_t2 = 29756.25 @@ -190,41 +243,51 @@ def processData(): m_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(7): - error_value['ArtUnc_'+str(j+1)] = artunc_dSig_dmttBar[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc_dSig_dmttBar[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } data_central_dSig_dmttBar.append(data_central_value) kin_dSig_dmttBar.append(kin_value) error_dSig_dmttBar.append(error_value) error_definition_dSig_dmttBar = {} for i in range(7): - error_definition_dSig_dmttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dmttBar_yaml = {'data_central': data_central_dSig_dmttBar} kinematics_dSig_dmttBar_yaml = {'bins': kin_dSig_dmttBar} - uncertainties_dSig_dmttBar_yaml = {'definitions': error_definition_dSig_dmttBar, 'bins': error_dSig_dmttBar} + uncertainties_dSig_dmttBar_yaml = { + 'definitions': error_definition_dSig_dmttBar, + 'bins': error_dSig_dmttBar, + } with open('data_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_yaml, file, sort_keys=False) -# dSig_dmttBar_norm + # dSig_dmttBar_norm - hepdata_tables="rawdata/d046-x01-y01.yaml" + hepdata_tables = "rawdata/d046-x01-y01.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/d046-x01-y01_cov.yaml" + covariance_matrix = "rawdata/d046-x01-y01_cov.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) for i in range(36): covmat_dSig_dmttBar_norm.append(input2['dependent_variables'][0]['values'][i]['value']) - artunc_dSig_dmttBar_norm = cta(6, covmat_dSig_dmttBar_norm, 1) - + artunc_dSig_dmttBar_norm = covmat_to_artunc(6, covmat_dSig_dmttBar_norm, 1) sqrts = 13000.0 m_t2 = 29756.25 @@ -236,41 +299,51 @@ def processData(): m_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(6): - error_value['ArtUnc_'+str(j+1)] = artunc_dSig_dmttBar_norm[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc_dSig_dmttBar_norm[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } data_central_dSig_dmttBar_norm.append(data_central_value) kin_dSig_dmttBar_norm.append(kin_value) error_dSig_dmttBar_norm.append(error_value) error_definition_dSig_dmttBar_norm = {} for i in range(6): - error_definition_dSig_dmttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dmttBar_norm_yaml = {'data_central': data_central_dSig_dmttBar_norm} kinematics_dSig_dmttBar_norm_yaml = {'bins': kin_dSig_dmttBar_norm} - uncertainties_dSig_dmttBar_norm_yaml = {'definitions': error_definition_dSig_dmttBar_norm, 'bins': error_dSig_dmttBar_norm} + uncertainties_dSig_dmttBar_norm_yaml = { + 'definitions': error_definition_dSig_dmttBar_norm, + 'bins': error_dSig_dmttBar_norm, + } with open('data_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_norm_yaml, file, sort_keys=False) -# dSig_dyt + # dSig_dyt - hepdata_tables="rawdata/d021-x01-y01.yaml" + hepdata_tables = "rawdata/d021-x01-y01.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/d021-x01-y01_cov.yaml" + covariance_matrix = "rawdata/d021-x01-y01_cov.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) for i in range(100): covmat_dSig_dyt.append(input2['dependent_variables'][0]['values'][i]['value']) - artunc_dSig_dyt = cta(10, covmat_dSig_dyt, 0) - + artunc_dSig_dyt = covmat_to_artunc(10, covmat_dSig_dyt, 0) sqrts = 13000.0 m_t2 = 29756.25 @@ -282,41 +355,48 @@ def processData(): y_t_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(10): - error_value['ArtUnc_'+str(j+1)] = artunc_dSig_dyt[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc_dSig_dyt[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + } data_central_dSig_dyt.append(data_central_value) kin_dSig_dyt.append(kin_value) error_dSig_dyt.append(error_value) error_definition_dSig_dyt = {} for i in range(10): - error_definition_dSig_dyt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyt_yaml = {'data_central': data_central_dSig_dyt} kinematics_dSig_dyt_yaml = {'bins': kin_dSig_dyt} uncertainties_dSig_dyt_yaml = {'definitions': error_definition_dSig_dyt, 'bins': error_dSig_dyt} with open('data_dSig_dyt.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_yaml, file, sort_keys=False) -# dSig_dyt_norm + # dSig_dyt_norm - hepdata_tables="rawdata/d022-x01-y01.yaml" + hepdata_tables = "rawdata/d022-x01-y01.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/d022-x01-y01_cov.yaml" + covariance_matrix = "rawdata/d022-x01-y01_cov.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) for i in range(81): covmat_dSig_dyt_norm.append(input2['dependent_variables'][0]['values'][i]['value']) - artunc_dSig_dyt_norm = cta(9, covmat_dSig_dyt_norm, 1) - + artunc_dSig_dyt_norm = covmat_to_artunc(9, covmat_dSig_dyt_norm, 1) sqrts = 13000.0 m_t2 = 29756.25 @@ -328,41 +408,51 @@ def processData(): y_t_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(9): - error_value['ArtUnc_'+str(j+1)] = artunc_dSig_dyt_norm[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc_dSig_dyt_norm[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + } data_central_dSig_dyt_norm.append(data_central_value) kin_dSig_dyt_norm.append(kin_value) error_dSig_dyt_norm.append(error_value) error_definition_dSig_dyt_norm = {} for i in range(9): - error_definition_dSig_dyt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyt_norm_yaml = {'data_central': data_central_dSig_dyt_norm} kinematics_dSig_dyt_norm_yaml = {'bins': kin_dSig_dyt_norm} - uncertainties_dSig_dyt_norm_yaml = {'definitions': error_definition_dSig_dyt_norm, 'bins': error_dSig_dyt_norm} + uncertainties_dSig_dyt_norm_yaml = { + 'definitions': error_definition_dSig_dyt_norm, + 'bins': error_dSig_dyt_norm, + } with open('data_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_norm_yaml, file, sort_keys=False) -# dSig_dyttBar + # dSig_dyttBar - hepdata_tables="rawdata/d041-x01-y01.yaml" + hepdata_tables = "rawdata/d041-x01-y01.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/d041-x01-y01_cov.yaml" + covariance_matrix = "rawdata/d041-x01-y01_cov.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) for i in range(100): covmat_dSig_dyttBar.append(input2['dependent_variables'][0]['values'][i]['value']) - artunc_dSig_dyttBar = cta(10, covmat_dSig_dyttBar, 0) - + artunc_dSig_dyttBar = covmat_to_artunc(10, covmat_dSig_dyttBar, 0) sqrts = 13000.0 m_t2 = 29756.25 @@ -374,41 +464,51 @@ def processData(): y_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(10): - error_value['ArtUnc_'+str(j+1)] = artunc_dSig_dyttBar[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc_dSig_dyttBar[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } data_central_dSig_dyttBar.append(data_central_value) kin_dSig_dyttBar.append(kin_value) error_dSig_dyttBar.append(error_value) error_definition_dSig_dyttBar = {} for i in range(10): - error_definition_dSig_dyttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyttBar_yaml = {'data_central': data_central_dSig_dyttBar} kinematics_dSig_dyttBar_yaml = {'bins': kin_dSig_dyttBar} - uncertainties_dSig_dyttBar_yaml = {'definitions': error_definition_dSig_dyttBar, 'bins': error_dSig_dyttBar} + uncertainties_dSig_dyttBar_yaml = { + 'definitions': error_definition_dSig_dyttBar, + 'bins': error_dSig_dyttBar, + } with open('data_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_yaml, file, sort_keys=False) -# dSig_dyttBar_norm + # dSig_dyttBar_norm - hepdata_tables="rawdata/d042-x01-y01.yaml" + hepdata_tables = "rawdata/d042-x01-y01.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/d042-x01-y01_cov.yaml" + covariance_matrix = "rawdata/d042-x01-y01_cov.yaml" with open(covariance_matrix, 'r') as file: input2 = yaml.safe_load(file) for i in range(81): covmat_dSig_dyttBar_norm.append(input2['dependent_variables'][0]['values'][i]['value']) - artunc_dSig_dyttBar_norm = cta(9, covmat_dSig_dyttBar_norm, 1) - + artunc_dSig_dyttBar_norm = covmat_to_artunc(9, covmat_dSig_dyttBar_norm, 1) sqrts = 13000.0 m_t2 = 29756.25 @@ -420,27 +520,39 @@ def processData(): y_ttBar_max = input['independent_variables'][0]['values'][i]['high'] error_value = {} for j in range(9): - error_value['ArtUnc_'+str(j+1)] = artunc_dSig_dyttBar_norm[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc_dSig_dyttBar_norm[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } data_central_dSig_dyttBar_norm.append(data_central_value) kin_dSig_dyttBar_norm.append(kin_value) error_dSig_dyttBar_norm.append(error_value) error_definition_dSig_dyttBar_norm = {} for i in range(9): - error_definition_dSig_dyttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyttBar_norm_yaml = {'data_central': data_central_dSig_dyttBar_norm} kinematics_dSig_dyttBar_norm_yaml = {'bins': kin_dSig_dyttBar_norm} - uncertainties_dSig_dyttBar_norm_yaml = {'definitions': error_definition_dSig_dyttBar_norm, 'bins': error_dSig_dyttBar_norm} + uncertainties_dSig_dyttBar_norm_yaml = { + 'definitions': error_definition_dSig_dyttBar_norm, + 'bins': error_dSig_dyttBar_norm, + } with open('data_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_norm_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_13TEV_LJ_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_13TEV_LJ_DIF/filter.py index 0f771e9c93..4a5ee5fb5b 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_13TEV_LJ_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_13TEV_LJ_DIF/filter.py @@ -1,11 +1,12 @@ -import yaml -import numpy as np - from math import sqrt + +import numpy as np from numpy.linalg import eig +import yaml + -def cta(ndata, covmat_list, no_of_norm_mat=0): - r"""Convert the covariance matrix to a matrix of +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + r"""Convert the covariance matrix to a matrix of artificial uncertainties. Parameters @@ -15,7 +16,7 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): covmat_list : list A one dimensional list which contains the elements of the covariance matrix row by row. Since experimental - datasets provide these matrices in a list form, this + datasets provide these matrices in a list form, this simplifies the implementation for the user. no_of_norm_mat : int Normalized covariance matrices may have an eigenvalue @@ -25,19 +26,19 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): in an instance. For example, if a single covariance matrix of a normalized distribution is being processed, the input would be 1. If a covariance matrix contains pertains to - 3 normalized datasets (i.e. cross covmat for 3 + 3 normalized datasets (i.e. cross covmat for 3 distributions), the input would be 3. The default value is - 0 for when the covariance matrix pertains to an absolute + 0 for when the covariance matrix pertains to an absolute distribution. Returns ------- artunc : list A two dimensional matrix (given as a list of lists) - which contains artificial uncertainties to be added - to the commondata. i^th row (or list) contains the + which contains artificial uncertainties to be added + to the commondata. i^th row (or list) contains the artificial uncertainties of the i^th data point. - + """ epsilon = -0.0000000001 neg_eval_count = 0 @@ -66,9 +67,10 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -137,69 +139,89 @@ def processData(): covMatArray_dSig_dyt = [] covMatArray_dSig_dyt_norm = [] -# dSig_dmttBar data + # dSig_dmttBar data - hepdata_tables="rawdata/"+tables_dSig_dmttBar[0]+".yaml" + hepdata_tables = "rawdata/" + tables_dSig_dmttBar[0] + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - - covariance_matrix="rawdata/parton_abs_ttm_covariance.yaml" + + covariance_matrix = "rawdata/parton_abs_ttm_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dmttBar*ndata_dSig_dmttBar): + for i in range(ndata_dSig_dmttBar * ndata_dSig_dmttBar): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dmttBar.append(covMatEl) - artUncMat_dSig_dmttBar = cta(ndata_dSig_dmttBar, covMatArray_dSig_dmttBar, 0) + artUncMat_dSig_dmttBar = covmat_to_artunc(ndata_dSig_dmttBar, covMatArray_dSig_dmttBar, 0) sqrts = 13000 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - + for i in range(len(values)): data_central_value = values[i]['value'] data_central_dSig_dmttBar.append(data_central_value) m_ttBar_min = input['independent_variables'][0]['values'][i]['low'] m_ttBar_max = input['independent_variables'][0]['values'][i]['high'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } kin_dSig_dmttBar.append(kin_value) error_value = {} error_value['stat'] = values[i]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[i]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dmttBar): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dmttBar[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dmttBar[i][j]) error_dSig_dmttBar.append(error_value) - + error_definition_dSig_dmttBar = {} - error_definition_dSig_dmttBar['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_dSig_dmttBar['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dmttBar['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_dSig_dmttBar['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_dSig_dmttBar): - error_definition_dSig_dmttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dmttBar_yaml = {'data_central': data_central_dSig_dmttBar} kinematics_dSig_dmttBar_yaml = {'bins': kin_dSig_dmttBar} - uncertainties_dSig_dmttBar_yaml = {'definitions': error_definition_dSig_dmttBar, 'bins': error_dSig_dmttBar} + uncertainties_dSig_dmttBar_yaml = { + 'definitions': error_definition_dSig_dmttBar, + 'bins': error_dSig_dmttBar, + } with open('data_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_yaml, file, sort_keys=False) - -# dSig_dmttBar_norm data + # dSig_dmttBar_norm data - hepdata_tables="rawdata/"+tables_dSig_dmttBar_norm[0]+".yaml" + hepdata_tables = "rawdata/" + tables_dSig_dmttBar_norm[0] + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/parton_norm_ttm_covariance.yaml" + covariance_matrix = "rawdata/parton_norm_ttm_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dmttBar_norm*ndata_dSig_dmttBar_norm): + for i in range(ndata_dSig_dmttBar_norm * ndata_dSig_dmttBar_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dmttBar_norm.append(covMatEl) - artUncMat_dSig_dmttBar_norm = cta(ndata_dSig_dmttBar_norm, covMatArray_dSig_dmttBar_norm, 1) + artUncMat_dSig_dmttBar_norm = covmat_to_artunc( + ndata_dSig_dmttBar_norm, covMatArray_dSig_dmttBar_norm, 1 + ) sqrts = 13000 m_t2 = 29756.25 @@ -210,47 +232,66 @@ def processData(): data_central_dSig_dmttBar_norm.append(data_central_value) m_ttBar_min = input['independent_variables'][0]['values'][i]['low'] m_ttBar_max = input['independent_variables'][0]['values'][i]['high'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } kin_dSig_dmttBar_norm.append(kin_value) error_value = {} error_value['stat'] = values[i]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[i]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dmttBar_norm): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dmttBar_norm[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dmttBar_norm[i][j]) error_dSig_dmttBar_norm.append(error_value) - + error_definition_dSig_dmttBar_norm = {} - error_definition_dSig_dmttBar_norm['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_dSig_dmttBar_norm['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dmttBar_norm['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_dSig_dmttBar_norm['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_dSig_dmttBar_norm): - error_definition_dSig_dmttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dmttBar_norm_yaml = {'data_central': data_central_dSig_dmttBar_norm} kinematics_dSig_dmttBar_norm_yaml = {'bins': kin_dSig_dmttBar_norm} - uncertainties_dSig_dmttBar_norm_yaml = {'definitions': error_definition_dSig_dmttBar_norm, 'bins': error_dSig_dmttBar_norm} + uncertainties_dSig_dmttBar_norm_yaml = { + 'definitions': error_definition_dSig_dmttBar_norm, + 'bins': error_dSig_dmttBar_norm, + } with open('data_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_norm_yaml, file, sort_keys=False) -# dSig_dyttBar data + # dSig_dyttBar data - hepdata_tables="rawdata/"+tables_dSig_dyttBar[0]+".yaml" + hepdata_tables = "rawdata/" + tables_dSig_dyttBar[0] + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - - covariance_matrix="rawdata/parton_abs_tty_covariance.yaml" + + covariance_matrix = "rawdata/parton_abs_tty_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dyttBar*ndata_dSig_dyttBar): + for i in range(ndata_dSig_dyttBar * ndata_dSig_dyttBar): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyttBar.append(covMatEl) - artUncMat_dSig_dyttBar = cta(ndata_dSig_dyttBar, covMatArray_dSig_dyttBar, 0) + artUncMat_dSig_dyttBar = covmat_to_artunc(ndata_dSig_dyttBar, covMatArray_dSig_dyttBar, 0) sqrts = 13000 m_t2 = 29756.25 @@ -261,47 +302,68 @@ def processData(): data_central_dSig_dyttBar.append(data_central_value) y_ttBar_min = input['independent_variables'][0]['values'][i]['low'] y_ttBar_max = input['independent_variables'][0]['values'][i]['high'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } kin_dSig_dyttBar.append(kin_value) error_value = {} error_value['stat'] = values[i]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[i]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dyttBar): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyttBar[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyttBar[i][j]) error_dSig_dyttBar.append(error_value) - + error_definition_dSig_dyttBar = {} - error_definition_dSig_dyttBar['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_dSig_dyttBar['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyttBar['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_dSig_dyttBar['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_dSig_dyttBar): - error_definition_dSig_dyttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyttBar_yaml = {'data_central': data_central_dSig_dyttBar} kinematics_dSig_dyttBar_yaml = {'bins': kin_dSig_dyttBar} - uncertainties_dSig_dyttBar_yaml = {'definitions': error_definition_dSig_dyttBar, 'bins': error_dSig_dyttBar} + uncertainties_dSig_dyttBar_yaml = { + 'definitions': error_definition_dSig_dyttBar, + 'bins': error_dSig_dyttBar, + } with open('data_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_yaml, file, sort_keys=False) -# dSig_dyttBar_norm data + # dSig_dyttBar_norm data - hepdata_tables="rawdata/"+tables_dSig_dyttBar_norm[0]+".yaml" + hepdata_tables = "rawdata/" + tables_dSig_dyttBar_norm[0] + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - - covariance_matrix="rawdata/parton_norm_tty_covariance.yaml" + + covariance_matrix = "rawdata/parton_norm_tty_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dyttBar_norm*ndata_dSig_dyttBar_norm): + for i in range(ndata_dSig_dyttBar_norm * ndata_dSig_dyttBar_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyttBar_norm.append(covMatEl) - artUncMat_dSig_dyttBar_norm = cta(ndata_dSig_dyttBar_norm, covMatArray_dSig_dyttBar_norm, 1) + artUncMat_dSig_dyttBar_norm = covmat_to_artunc( + ndata_dSig_dyttBar_norm, covMatArray_dSig_dyttBar_norm, 1 + ) sqrts = 13000 m_t2 = 29756.25 @@ -312,46 +374,67 @@ def processData(): data_central_dSig_dyttBar_norm.append(data_central_value) y_ttBar_min = input['independent_variables'][0]['values'][i]['low'] y_ttBar_max = input['independent_variables'][0]['values'][i]['high'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } kin_dSig_dyttBar_norm.append(kin_value) error_value = {} error_value['stat'] = values[i]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[i]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dyttBar_norm): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyttBar_norm[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyttBar_norm[i][j]) error_dSig_dyttBar_norm.append(error_value) - + error_definition_dSig_dyttBar_norm = {} - error_definition_dSig_dyttBar_norm['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_dSig_dyttBar_norm['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyttBar_norm['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_dSig_dyttBar_norm['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_dSig_dyttBar_norm): - error_definition_dSig_dyttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyttBar_norm_yaml = {'data_central': data_central_dSig_dyttBar_norm} kinematics_dSig_dyttBar_norm_yaml = {'bins': kin_dSig_dyttBar_norm} - uncertainties_dSig_dyttBar_norm_yaml = {'definitions': error_definition_dSig_dyttBar_norm, 'bins': error_dSig_dyttBar_norm} + uncertainties_dSig_dyttBar_norm_yaml = { + 'definitions': error_definition_dSig_dyttBar_norm, + 'bins': error_dSig_dyttBar_norm, + } with open('data_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_norm_yaml, file, sort_keys=False) -# d2Sig_dyttBar_dmttBar data + # d2Sig_dyttBar_dmttBar data - covariance_matrix="rawdata/parton_abs_ttm+tty_covariance.yaml" + covariance_matrix = "rawdata/parton_abs_ttm+tty_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_d2Sig_dyttbar_dmttbar*ndata_d2Sig_dyttbar_dmttbar): + for i in range(ndata_d2Sig_dyttbar_dmttbar * ndata_d2Sig_dyttbar_dmttbar): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_d2Sig_dyttbar_dmttbar.append(covMatEl) - artUncMat_d2Sig_dyttbar_dmttbar = cta(ndata_d2Sig_dyttbar_dmttbar, covMatArray_d2Sig_dyttbar_dmttbar, 0) + artUncMat_d2Sig_dyttbar_dmttbar = covmat_to_artunc( + ndata_d2Sig_dyttbar_dmttbar, covMatArray_d2Sig_dyttbar_dmttbar, 0 + ) for i in tables_d2Sig_dyttbar_dmttbar: - hepdata_tables="rawdata/parton_abs_ttm+tty_"+str(i)+".yaml" + hepdata_tables = "rawdata/parton_abs_ttm+tty_" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -359,53 +442,75 @@ def processData(): m_t2 = 29756.25 m_ttBar_min = input['dependent_variables'][0]['qualifiers'][0]['value'] m_ttBar_max = input['dependent_variables'][0]['qualifiers'][1]['value'] - values = input ['dependent_variables'][0]['values'] + values = input['dependent_variables'][0]['values'] for j in range(len(values)): data_central_value = values[j]['value'] data_central_d2Sig_dyttbar_dmttbar.append(data_central_value) y_ttBar_min = input['independent_variables'][0]['values'][j]['low'] y_ttBar_max = input['independent_variables'][0]['values'][j]['high'] - kin_value = {'sqrts':{'min': None,'mid': sqrts,'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar':{'min': m_ttBar_min,'mid': None,'max': m_ttBar_max}, 'y_ttBar':{'min': y_ttBar_min,'mid': None,'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } kin_d2Sig_dyttbar_dmttbar.append(kin_value) error_value = {} error_value['stat'] = values[j]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[j]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[j]['errors'][1]['symerror'] for k in range(ndata_d2Sig_dyttbar_dmttbar): - error_value['ArtUnc_'+str(k+1)] = float(artUncMat_d2Sig_dyttbar_dmttbar[j][k]) + error_value['ArtUnc_' + str(k + 1)] = float(artUncMat_d2Sig_dyttbar_dmttbar[j][k]) error_d2Sig_dyttbar_dmttbar.append(error_value) error_definition_d2Sig_dyttbar_dmttbar = {} - error_definition_d2Sig_dyttbar_dmttbar['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_d2Sig_dyttbar_dmttbar['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_d2Sig_dyttbar_dmttbar['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_d2Sig_dyttbar_dmttbar['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_d2Sig_dyttbar_dmttbar): - error_definition_d2Sig_dyttbar_dmttbar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_d2Sig_dyttbar_dmttbar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_d2Sig_dyttbar_dmttbar_yaml = {'data_central': data_central_d2Sig_dyttbar_dmttbar} kinematics_d2Sig_dyttbar_dmttbar_yaml = {'bins': kin_d2Sig_dyttbar_dmttbar} - uncertainties_d2Sig_dyttbar_dmttbar_yaml = {'definitions': error_definition_d2Sig_dyttbar_dmttbar, 'bins': error_d2Sig_dyttbar_dmttbar} + uncertainties_d2Sig_dyttbar_dmttbar_yaml = { + 'definitions': error_definition_d2Sig_dyttbar_dmttbar, + 'bins': error_d2Sig_dyttbar_dmttbar, + } with open('data_d2Sig_dyttBar_dmttBar.yaml', 'w') as file: - yaml.dump(data_central_d2Sig_dyttbar_dmttbar_yaml, file, sort_keys=False) + yaml.dump(data_central_d2Sig_dyttbar_dmttbar_yaml, file, sort_keys=False) with open('kinematics_d2Sig_dyttBar_dmttBar.yaml', 'w') as file: - yaml.dump(kinematics_d2Sig_dyttbar_dmttbar_yaml, file, sort_keys=False) + yaml.dump(kinematics_d2Sig_dyttbar_dmttbar_yaml, file, sort_keys=False) with open('uncertainties_d2Sig_dyttBar_dmttBar.yaml', 'w') as file: yaml.dump(uncertainties_d2Sig_dyttbar_dmttbar_yaml, file, sort_keys=False) -# d2Sig_dyttBar_dmttBar_norm data + # d2Sig_dyttBar_dmttBar_norm data - covariance_matrix="rawdata/parton_norm_ttm+tty_covariance.yaml" + covariance_matrix = "rawdata/parton_norm_ttm+tty_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_d2Sig_dyttbar_dmttbar_norm*ndata_d2Sig_dyttbar_dmttbar_norm): + for i in range(ndata_d2Sig_dyttbar_dmttbar_norm * ndata_d2Sig_dyttbar_dmttbar_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_d2Sig_dyttbar_dmttbar_norm.append(covMatEl) - artUncMat_d2Sig_dyttbar_dmttbar_norm = cta(ndata_d2Sig_dyttbar_dmttbar_norm, covMatArray_d2Sig_dyttbar_dmttbar_norm, 1) + artUncMat_d2Sig_dyttbar_dmttbar_norm = covmat_to_artunc( + ndata_d2Sig_dyttbar_dmttbar_norm, covMatArray_d2Sig_dyttbar_dmttbar_norm, 1 + ) for i in tables_d2Sig_dyttBar_dmttBar_norm: - hepdata_tables="rawdata/parton_norm_ttm+tty_"+str(i)+".yaml" + hepdata_tables = "rawdata/parton_norm_ttm+tty_" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -413,237 +518,333 @@ def processData(): m_t2 = 29756.25 m_ttBar_min = input['dependent_variables'][0]['qualifiers'][0]['value'] m_ttBar_max = input['dependent_variables'][0]['qualifiers'][1]['value'] - values = input ['dependent_variables'][0]['values'] + values = input['dependent_variables'][0]['values'] for j in range(len(values)): data_central_value = values[j]['value'] data_central_d2Sig_dyttbar_dmttbar_norm.append(data_central_value) y_ttBar_min = input['independent_variables'][0]['values'][j]['low'] y_ttBar_max = input['independent_variables'][0]['values'][j]['high'] - kin_value = {'sqrts':{'min': None,'mid': sqrts,'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar':{'min': m_ttBar_min,'mid': None,'max': m_ttBar_max}, 'y_ttBar':{'min': y_ttBar_min,'mid': None,'max': y_ttBar_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + } kin_d2Sig_dyttbar_dmttbar_norm.append(kin_value) error_value = {} error_value['stat'] = values[j]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[j]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[j]['errors'][1]['symerror'] for k in range(ndata_d2Sig_dyttbar_dmttbar_norm): - error_value['ArtUnc_'+str(k+1)] = float(artUncMat_d2Sig_dyttbar_dmttbar_norm[j][k]) + error_value['ArtUnc_' + str(k + 1)] = float( + artUncMat_d2Sig_dyttbar_dmttbar_norm[j][k] + ) error_d2Sig_dyttbar_dmttbar_norm.append(error_value) error_definition_d2Sig_dyttbar_dmttbar_norm = {} - error_definition_d2Sig_dyttbar_dmttbar_norm['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_d2Sig_dyttbar_dmttbar_norm['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_d2Sig_dyttbar_dmttbar_norm['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_d2Sig_dyttbar_dmttbar_norm['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_d2Sig_dyttbar_dmttbar_norm): - error_definition_d2Sig_dyttbar_dmttbar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} - - data_central_d2Sig_dyttbar_dmttbar_norm_yaml = {'data_central': data_central_d2Sig_dyttbar_dmttbar_norm} + error_definition_d2Sig_dyttbar_dmttbar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } + + data_central_d2Sig_dyttbar_dmttbar_norm_yaml = { + 'data_central': data_central_d2Sig_dyttbar_dmttbar_norm + } kinematics_d2Sig_dyttbar_dmttbar_norm_yaml = {'bins': kin_d2Sig_dyttbar_dmttbar_norm} - uncertainties_d2Sig_dyttbar_dmttbar_norm_yaml = {'definitions': error_definition_d2Sig_dyttbar_dmttbar_norm, 'bins': error_d2Sig_dyttbar_dmttbar_norm} + uncertainties_d2Sig_dyttbar_dmttbar_norm_yaml = { + 'definitions': error_definition_d2Sig_dyttbar_dmttbar_norm, + 'bins': error_d2Sig_dyttbar_dmttbar_norm, + } with open('data_d2Sig_dyttBar_dmttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_d2Sig_dyttbar_dmttbar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_d2Sig_dyttbar_dmttbar_norm_yaml, file, sort_keys=False) with open('kinematics_d2Sig_dyttBar_dmttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_d2Sig_dyttbar_dmttbar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_d2Sig_dyttbar_dmttbar_norm_yaml, file, sort_keys=False) with open('uncertainties_d2Sig_dyttBar_dmttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_d2Sig_dyttbar_dmttbar_norm_yaml, file, sort_keys=False) -# dSig_dpTt data + # dSig_dpTt data - hepdata_tables="rawdata/"+tables_dSig_dpTt[0]+".yaml" + hepdata_tables = "rawdata/" + tables_dSig_dpTt[0] + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - - covariance_matrix="rawdata/parton_abs_tleppt_covariance.yaml" + + covariance_matrix = "rawdata/parton_abs_tleppt_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dpTt*ndata_dSig_dpTt): + for i in range(ndata_dSig_dpTt * ndata_dSig_dpTt): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dpTt.append(covMatEl) - artUncMat_dSig_dpTt = cta(ndata_dSig_dpTt, covMatArray_dSig_dpTt, 0) + artUncMat_dSig_dpTt = covmat_to_artunc(ndata_dSig_dpTt, covMatArray_dSig_dpTt, 0) sqrts = 13000 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - + for i in range(len(values)): data_central_value = values[i]['value'] data_central_dSig_dpTt.append(data_central_value) pT_t_min = input['independent_variables'][0]['values'][i]['low'] pT_t_max = input['independent_variables'][0]['values'][i]['high'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } kin_dSig_dpTt.append(kin_value) error_value = {} error_value['stat'] = values[i]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[i]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dpTt): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dpTt[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dpTt[i][j]) error_dSig_dpTt.append(error_value) - + error_definition_dSig_dpTt = {} - error_definition_dSig_dpTt['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_dSig_dpTt['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dpTt['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_dSig_dpTt['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_dSig_dpTt): - error_definition_dSig_dpTt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dpTt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dpTt_yaml = {'data_central': data_central_dSig_dpTt} kinematics_dSig_dpTt_yaml = {'bins': kin_dSig_dpTt} - uncertainties_dSig_dpTt_yaml = {'definitions': error_definition_dSig_dpTt, 'bins': error_dSig_dpTt} + uncertainties_dSig_dpTt_yaml = { + 'definitions': error_definition_dSig_dpTt, + 'bins': error_dSig_dpTt, + } with open('data_dSig_dpTt.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_yaml, file, sort_keys=False) + # dSig_dpTt_norm data -# dSig_dpTt_norm data - - hepdata_tables="rawdata/"+tables_dSig_dpTt_norm[0]+".yaml" + hepdata_tables = "rawdata/" + tables_dSig_dpTt_norm[0] + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - - covariance_matrix="rawdata/parton_norm_tleppt_covariance.yaml" + + covariance_matrix = "rawdata/parton_norm_tleppt_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dpTt_norm*ndata_dSig_dpTt_norm): + for i in range(ndata_dSig_dpTt_norm * ndata_dSig_dpTt_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dpTt_norm.append(covMatEl) - artUncMat_dSig_dpTt_norm = cta(ndata_dSig_dpTt_norm, covMatArray_dSig_dpTt_norm, 1) + artUncMat_dSig_dpTt_norm = covmat_to_artunc(ndata_dSig_dpTt_norm, covMatArray_dSig_dpTt_norm, 1) sqrts = 13000 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - + for i in range(len(values)): data_central_value = values[i]['value'] data_central_dSig_dpTt_norm.append(data_central_value) pT_t_min = input['independent_variables'][0]['values'][i]['low'] pT_t_max = input['independent_variables'][0]['values'][i]['high'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } kin_dSig_dpTt_norm.append(kin_value) error_value = {} error_value['stat'] = values[i]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[i]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dpTt_norm): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dpTt_norm[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dpTt_norm[i][j]) error_dSig_dpTt_norm.append(error_value) - + error_definition_dSig_dpTt_norm = {} - error_definition_dSig_dpTt_norm['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_dSig_dpTt_norm['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dpTt_norm['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_dSig_dpTt_norm['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_dSig_dpTt_norm): - error_definition_dSig_dpTt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dpTt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dpTt_norm_yaml = {'data_central': data_central_dSig_dpTt_norm} kinematics_dSig_dpTt_norm_yaml = {'bins': kin_dSig_dpTt_norm} - uncertainties_dSig_dpTt_norm_yaml = {'definitions': error_definition_dSig_dpTt_norm, 'bins': error_dSig_dpTt_norm} + uncertainties_dSig_dpTt_norm_yaml = { + 'definitions': error_definition_dSig_dpTt_norm, + 'bins': error_dSig_dpTt_norm, + } with open('data_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_norm_yaml, file, sort_keys=False) + # dSig_dyt data -# dSig_dyt data - - hepdata_tables="rawdata/"+tables_dSig_dyt[0]+".yaml" + hepdata_tables = "rawdata/" + tables_dSig_dyt[0] + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - - covariance_matrix="rawdata/parton_abs_tlepy_covariance.yaml" + + covariance_matrix = "rawdata/parton_abs_tlepy_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dyt*ndata_dSig_dyt): + for i in range(ndata_dSig_dyt * ndata_dSig_dyt): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyt.append(covMatEl) - artUncMat_dSig_dyt = cta(ndata_dSig_dyt, covMatArray_dSig_dyt, 0) + artUncMat_dSig_dyt = covmat_to_artunc(ndata_dSig_dyt, covMatArray_dSig_dyt, 0) sqrts = 13000 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - + for i in range(len(values)): data_central_value = values[i]['value'] data_central_dSig_dyt.append(data_central_value) y_t_min = input['independent_variables'][0]['values'][i]['low'] y_t_max = input['independent_variables'][0]['values'][i]['high'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + } kin_dSig_dyt.append(kin_value) error_value = {} error_value['stat'] = values[i]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[i]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dyt): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyt[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyt[i][j]) error_dSig_dyt.append(error_value) - + error_definition_dSig_dyt = {} - error_definition_dSig_dyt['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_dSig_dyt['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyt['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_dSig_dyt['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_dSig_dyt): - error_definition_dSig_dyt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyt_yaml = {'data_central': data_central_dSig_dyt} kinematics_dSig_dyt_yaml = {'bins': kin_dSig_dyt} uncertainties_dSig_dyt_yaml = {'definitions': error_definition_dSig_dyt, 'bins': error_dSig_dyt} with open('data_dSig_dyt.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_yaml, file, sort_keys=False) -# dSig_dyt_norm data + # dSig_dyt_norm data - hepdata_tables="rawdata/"+tables_dSig_dyt_norm[0]+".yaml" + hepdata_tables = "rawdata/" + tables_dSig_dyt_norm[0] + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - - covariance_matrix="rawdata/parton_norm_tlepy_covariance.yaml" + + covariance_matrix = "rawdata/parton_norm_tlepy_covariance.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - for i in range(ndata_dSig_dyt_norm*ndata_dSig_dyt_norm): + for i in range(ndata_dSig_dyt_norm * ndata_dSig_dyt_norm): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyt_norm.append(covMatEl) - artUncMat_dSig_dyt_norm = cta(ndata_dSig_dyt_norm, covMatArray_dSig_dyt_norm, 1) + artUncMat_dSig_dyt_norm = covmat_to_artunc(ndata_dSig_dyt_norm, covMatArray_dSig_dyt_norm, 1) sqrts = 13000 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] - + for i in range(len(values)): data_central_value = values[i]['value'] data_central_dSig_dyt_norm.append(data_central_value) y_t_min = input['independent_variables'][0]['values'][i]['low'] y_t_max = input['independent_variables'][0]['values'][i]['high'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + } kin_dSig_dyt_norm.append(kin_value) error_value = {} error_value['stat'] = values[i]['errors'][0]['symerror'] - error_value['sys'] = 0 #values[i]['errors'][1]['symerror'] + error_value['sys'] = 0 # values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dyt_norm): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyt_norm[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyt_norm[i][j]) error_dSig_dyt_norm.append(error_value) - + error_definition_dSig_dyt_norm = {} - error_definition_dSig_dyt_norm['stat'] = {'definition': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} - error_definition_dSig_dyt_norm['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyt_norm['stat'] = { + 'definition': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } + error_definition_dSig_dyt_norm['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(ndata_dSig_dyt_norm): - error_definition_dSig_dyt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } data_central_dSig_dyt_norm_yaml = {'data_central': data_central_dSig_dyt_norm} kinematics_dSig_dyt_norm_yaml = {'bins': kin_dSig_dyt_norm} - uncertainties_dSig_dyt_norm_yaml = {'definitions': error_definition_dSig_dyt_norm, 'bins': error_dSig_dyt_norm} + uncertainties_dSig_dyt_norm_yaml = { + 'definitions': error_definition_dSig_dyt_norm, + 'bins': error_dSig_dyt_norm, + } with open('data_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_norm_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_8TEV_2L_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_8TEV_2L_DIF/filter.py index 5f99aaddbc..47fe718be2 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_8TEV_2L_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_8TEV_2L_DIF/filter.py @@ -1,30 +1,87 @@ -import yaml -import numpy as np - from math import sqrt + +import numpy as np from numpy.linalg import eig +import yaml -def se(delta_plus, delta_minus): - - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 +def symmetrize_errors(delta_plus, delta_minus): + r"""Compute the symmterized uncertainty and the shift in data point. + + Parameters + ---------- + delta_plus : float + The top/plus uncertainty with sign + delta_minus : float + The bottom/minus uncertainty with sign + + Returns + ------- + se_delta : float + The value to be added to the data point + se_sigma : float + The symmetrized uncertainty to be used in commondata + + """ + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma -def pta(percentage, value): - + +def percentage_to_absolute(percentage, value): + r"""Compute the absolute value of uncertainty from percentage. + + Parameters + ---------- + percentage : string/float + Experimental datasets can provide the percentage + uncertainties with a % sign or without one. + The function will autostrip % sign and convert to + a float type in case the percentage uncertainty + comes with a % sign. Else, it will directly perform + the computation. + value : float + The data point + + Returns + ------- + absolute : float + The absolute value of the uncertainty + + """ if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute -def ctc(err_list, cormat_list): - + +def cormat_to_covmat(err_list, cormat_list): + r"""Convert correlation matrix elements to covariance + matrix elements. + + Parameters + ---------- + err_list : list + A one dimensional list which contains the uncertainty + associated to each data point in order. + cormat_list : list + A one dimensional list which contains the elements of + the correlation matrix row by row. Since experimental + datasets provide these matrices in a list form, this + simplifies the implementation for the user. + + Returns + ------- + covmat_list : list + A one dimensional list which contains the elements of + the covariance matrix row by row. + + """ covmat_list = [] for i in range(len(cormat_list)): a = i // len(err_list) @@ -32,8 +89,42 @@ def ctc(err_list, cormat_list): covmat_list.append(cormat_list[i] * err_list[a] * err_list[b]) return covmat_list -def cta(ndata, covmat_list, no_of_norm_mat=0): - + +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + r"""Convert the covariance matrix to a matrix of + artificial uncertainties. + + Parameters + ---------- + ndata : integer + Number of data points + covmat_list : list + A one dimensional list which contains the elements of + the covariance matrix row by row. Since experimental + datasets provide these matrices in a list form, this + simplifies the implementation for the user. + no_of_norm_mat : int + Normalized covariance matrices may have an eigenvalue + of 0 due to the last data point not being linearly + independent. To allow for this, the user should input + the number of normalized matrices that are being treated + in an instance. For example, if a single covariance matrix + of a normalized distribution is being processed, the input + would be 1. If a covariance matrix contains pertains to + 3 normalized datasets (i.e. cross covmat for 3 + distributions), the input would be 3. The default value is + 0 for when the covariance matrix pertains to an absolute + distribution. + + Returns + ------- + artunc : list + A two dimensional matrix (given as a list of lists) + which contains artificial uncertainties to be added + to the commondata. i^th row (or list) contains the + artificial uncertainties of the i^th data point. + + """ epsilon = -0.0000000001 neg_eval_count = 0 psd_check = True @@ -61,17 +152,58 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() -def ttf(mode, tri_mat_list): - - dim = int((np.sqrt(1 + 8*len(tri_mat_list)) - 1)/2) + +def trimat_to_fullmat(mode, tri_mat_list): + r"""Convert a list of values of a triangular matrix + to a symmetric matrix. + + Experimental datasets can provide the entries of + correlation or covariance matrices as a triangular + matrix, as these matrices are symmetric by their + very nature. This function can convert these list to + a complete symmetric matrix, that can be used for the + dataset implementation. + + mode : bool + Enter 0 or 1 based on the following scenarios: + Use mode 0 if matrix entries are given row by + row such as: + 0 1 2 3 + 4 5 6 + 7 8 + 9 + Use mode 1 if the matrix entries are given column + by column such as: + 0 1 3 6 + 2 4 7 + 5 8 + 9 + Please note that the numbers above (0-9) are not + entries of the matrix but rather the index of the + entries of the list which contains the elements of + the triangular matrix. + tri_mat_list : list + A list containing the elements of the triangular matrix, + for example, for a 4*4 matrix, the list of + triangular matrix entries could be: + [a, b, c, d, e, f, g, h, i, j] + + Returns + ------- + mat_list : list + A one dimensional list which contains the elements of + the fully populated, symmetric matrix row by row. + + """ + dim = int((np.sqrt(1 + 8 * len(tri_mat_list)) - 1) / 2) matrix = np.zeros((dim, dim)) if mode == 0: for i in range(dim): for j in range(i + 1): - list_el = len(tri_mat_list) - 1 - ((i*(i + 1))//2 + j) + list_el = len(tri_mat_list) - 1 - ((i * (i + 1)) // 2 + j) if i == j: matrix[dim - 1 - i][dim - 1 - j] = tri_mat_list[list_el] else: @@ -80,7 +212,7 @@ def ttf(mode, tri_mat_list): elif mode == 1: for i in range(dim): for j in range(i + 1): - list_el = (i*(i + 1))//2 + j + list_el = (i * (i + 1)) // 2 + j if i == j: matrix[i][j] = tri_mat_list[list_el] else: @@ -94,6 +226,7 @@ def ttf(mode, tri_mat_list): mat_list.append(matrix[i][j]) return mat_list + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -108,31 +241,32 @@ def processData(): kin_d2Sig_dmttBar_dyttBar_norm = [] error_d2Sig_dmttBar_dyttBar_norm = [] -# d2Sig_dyt_dpTt_norm + # d2Sig_dyt_dpTt_norm - hepdata_tables="rawdata/CMS_8TeV_ttbar_DoubleDiff_yt_ptt.yaml" + hepdata_tables = "rawdata/CMS_8TeV_ttbar_DoubleDiff_yt_ptt.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - correlation_matrix="rawdata/CMS_8TeV_ttbar_DoubleDiff_yt_ptt_statcorr.yaml" + correlation_matrix = "rawdata/CMS_8TeV_ttbar_DoubleDiff_yt_ptt_statcorr.yaml" with open(correlation_matrix, 'r') as file: input2 = yaml.safe_load(file) -# systematics_breakdown="rawdata/CMS_8TeV_ttbar_DoubleDiff_yt_ptt_syst.yaml" -# with open(systematics_breakdown, 'r') as file: -# input3 = yaml.safe_load(file) + # systematics_breakdown="rawdata/CMS_8TeV_ttbar_DoubleDiff_yt_ptt_syst.yaml" + # with open(systematics_breakdown, 'r') as file: + # input3 = yaml.safe_load(file) sqrts = 8000 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] statlist1 = [] for i in range(len(values)): - statlist1.append(pta(str(values[i]['errors'][0]['symerror']), values[i]['value'])) + statlist1.append( + percentage_to_absolute(str(values[i]['errors'][0]['symerror']), values[i]['value']) + ) trimatlist1 = [] for i in range(len(input2['dependent_variables'][0]['values'])): trimatlist1.append(input2['dependent_variables'][0]['values'][i]['value']) - cormatlist1 = ttf(0, trimatlist1) - covmatlist1 = ctc(statlist1, cormatlist1) - artunc1 = cta(len(values), covmatlist1, 1) - + cormatlist1 = trimat_to_fullmat(0, trimatlist1) + covmatlist1 = cormat_to_covmat(statlist1, cormatlist1) + artunc1 = covmat_to_artunc(len(values), covmatlist1, 1) for i in range(len(values)): data_central_value = values[i]['value'] @@ -141,61 +275,82 @@ def processData(): pT_t_min = input['independent_variables'][1]['values'][i]['low'] pT_t_max = input['independent_variables'][1]['values'][i]['high'] error_value = {} - plus = pta(str(values[i]['errors'][1]['asymerror']['plus']), data_central_value) - minus = pta(str(values[i]['errors'][1]['asymerror']['minus']), data_central_value) - se_delta, se_sigma = se(plus, minus) + plus = percentage_to_absolute( + str(values[i]['errors'][1]['asymerror']['plus']), data_central_value + ) + minus = percentage_to_absolute( + str(values[i]['errors'][1]['asymerror']['minus']), data_central_value + ) + se_delta, se_sigma = symmetrize_errors(plus, minus) data_central_value = data_central_value + se_delta error_value['sys'] = se_sigma for j in range(len(values)): - error_value['ArtUnc_'+str(j+1)] = artunc1[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc1[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + 'pT_t': {'min': pT_t_min, 'mid': None, 'max': pT_t_max}, + } data_central_d2Sig_dyt_dpTt_norm.append(data_central_value) kin_d2Sig_dyt_dpTt_norm.append(kin_value) error_d2Sig_dyt_dpTt_norm.append(error_value) error_definition_d2Sig_dyt_dpTt_norm = {} - error_definition_d2Sig_dyt_dpTt_norm['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_d2Sig_dyt_dpTt_norm['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(16): - error_definition_d2Sig_dyt_dpTt_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} - + error_definition_d2Sig_dyt_dpTt_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } + data_central_d2Sig_dyt_dpTt_norm_yaml = {'data_central': data_central_d2Sig_dyt_dpTt_norm} kinematics_d2Sig_dyt_dpTt_norm_yaml = {'bins': kin_d2Sig_dyt_dpTt_norm} - uncertainties_d2Sig_dyt_dpTt_norm_yaml = {'definitions': error_definition_d2Sig_dyt_dpTt_norm, 'bins': error_d2Sig_dyt_dpTt_norm} + uncertainties_d2Sig_dyt_dpTt_norm_yaml = { + 'definitions': error_definition_d2Sig_dyt_dpTt_norm, + 'bins': error_d2Sig_dyt_dpTt_norm, + } with open('data_d2Sig_dyt_dpTt_norm.yaml', 'w') as file: - yaml.dump(data_central_d2Sig_dyt_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_d2Sig_dyt_dpTt_norm_yaml, file, sort_keys=False) with open('kinematics_d2Sig_dyt_dpTt_norm.yaml', 'w') as file: - yaml.dump(kinematics_d2Sig_dyt_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_d2Sig_dyt_dpTt_norm_yaml, file, sort_keys=False) with open('uncertainties_d2Sig_dyt_dpTt_norm.yaml', 'w') as file: yaml.dump(uncertainties_d2Sig_dyt_dpTt_norm_yaml, file, sort_keys=False) -# d2Sig_dyt_dmttBar_norm + # d2Sig_dyt_dmttBar_norm - hepdata_tables="rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_yt.yaml" + hepdata_tables = "rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_yt.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - correlation_matrix="rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_yt_statcorr.yaml" + correlation_matrix = "rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_yt_statcorr.yaml" with open(correlation_matrix, 'r') as file: input2 = yaml.safe_load(file) -# systematics_breakdown="rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_yt_syst.yaml" -# with open(systematics_breakdown, 'r') as file: -# input3 = yaml.safe_load(file) + # systematics_breakdown="rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_yt_syst.yaml" + # with open(systematics_breakdown, 'r') as file: + # input3 = yaml.safe_load(file) sqrts = 8000 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] statlist2 = [] for i in range(len(values)): - statlist2.append(pta(str(values[i]['errors'][0]['symerror']), values[i]['value'])) + statlist2.append( + percentage_to_absolute(str(values[i]['errors'][0]['symerror']), values[i]['value']) + ) trimatlist2 = [] for i in range(len(input2['dependent_variables'][0]['values'])): trimatlist2.append(input2['dependent_variables'][0]['values'][i]['value']) - cormatlist2 = ttf(0, trimatlist2) - covmatlist2 = ctc(statlist2, cormatlist2) - artunc2 = cta(len(values), covmatlist2, 1) - + cormatlist2 = trimat_to_fullmat(0, trimatlist2) + covmatlist2 = cormat_to_covmat(statlist2, cormatlist2) + artunc2 = covmat_to_artunc(len(values), covmatlist2, 1) for i in range(len(values)): data_central_value = values[i]['value'] @@ -204,61 +359,82 @@ def processData(): y_t_min = input['independent_variables'][1]['values'][i]['low'] y_t_max = input['independent_variables'][1]['values'][i]['high'] error_value = {} - plus = pta(str(values[i]['errors'][1]['asymerror']['plus']), data_central_value) - minus = pta(str(values[i]['errors'][1]['asymerror']['minus']), data_central_value) - se_delta, se_sigma = se(plus, minus) + plus = percentage_to_absolute( + str(values[i]['errors'][1]['asymerror']['plus']), data_central_value + ) + minus = percentage_to_absolute( + str(values[i]['errors'][1]['asymerror']['minus']), data_central_value + ) + se_delta, se_sigma = symmetrize_errors(plus, minus) data_central_value = data_central_value + se_delta error_value['sys'] = se_sigma for j in range(len(values)): - error_value['ArtUnc_'+str(j+1)] = artunc2[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc2[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': None, 'max': y_t_max}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } data_central_d2Sig_dyt_dmttBar_norm.append(data_central_value) kin_d2Sig_dyt_dmttBar_norm.append(kin_value) error_d2Sig_dyt_dmttBar_norm.append(error_value) error_definition_d2Sig_dyt_dmttBar_norm = {} - error_definition_d2Sig_dyt_dmttBar_norm['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_d2Sig_dyt_dmttBar_norm['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(16): - error_definition_d2Sig_dyt_dmttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} - + error_definition_d2Sig_dyt_dmttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } + data_central_d2Sig_dyt_dmttBar_norm_yaml = {'data_central': data_central_d2Sig_dyt_dmttBar_norm} kinematics_d2Sig_dyt_dmttBar_norm_yaml = {'bins': kin_d2Sig_dyt_dmttBar_norm} - uncertainties_d2Sig_dyt_dmttBar_norm_yaml = {'definitions': error_definition_d2Sig_dyt_dmttBar_norm, 'bins': error_d2Sig_dyt_dmttBar_norm} + uncertainties_d2Sig_dyt_dmttBar_norm_yaml = { + 'definitions': error_definition_d2Sig_dyt_dmttBar_norm, + 'bins': error_d2Sig_dyt_dmttBar_norm, + } with open('data_d2Sig_dyt_dmttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_d2Sig_dyt_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_d2Sig_dyt_dmttBar_norm_yaml, file, sort_keys=False) with open('kinematics_d2Sig_dyt_dmttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_d2Sig_dyt_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_d2Sig_dyt_dmttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_d2Sig_dyt_dmttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_d2Sig_dyt_dmttBar_norm_yaml, file, sort_keys=False) -# d2Sig_dmttBar_dyttBar_norm + # d2Sig_dmttBar_dyttBar_norm - hepdata_tables="rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_ytt.yaml" + hepdata_tables = "rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_ytt.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - correlation_matrix="rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_ytt_statcorr.yaml" + correlation_matrix = "rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_ytt_statcorr.yaml" with open(correlation_matrix, 'r') as file: input2 = yaml.safe_load(file) -# systematics_breakdown="rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_ytt_syst.yaml" -# with open(systematics_breakdown, 'r') as file: -# input3 = yaml.safe_load(file) + # systematics_breakdown="rawdata/CMS_8TeV_ttbar_DoubleDiff_mtt_ytt_syst.yaml" + # with open(systematics_breakdown, 'r') as file: + # input3 = yaml.safe_load(file) sqrts = 8000 m_t2 = 29756.25 values = input['dependent_variables'][0]['values'] statlist3 = [] for i in range(len(values)): - statlist3.append(pta(str(values[i]['errors'][0]['symerror']), values[i]['value'])) + statlist3.append( + percentage_to_absolute(str(values[i]['errors'][0]['symerror']), values[i]['value']) + ) trimatlist3 = [] for i in range(len(input2['dependent_variables'][0]['values'])): trimatlist3.append(input2['dependent_variables'][0]['values'][i]['value']) - cormatlist3 = ttf(0, trimatlist3) - covmatlist3 = ctc(statlist3, cormatlist3) - artunc3 = cta(len(values), covmatlist3, 1) - + cormatlist3 = trimat_to_fullmat(0, trimatlist3) + covmatlist3 = cormat_to_covmat(statlist3, cormatlist3) + artunc3 = covmat_to_artunc(len(values), covmatlist3, 1) for i in range(len(values)): data_central_value = values[i]['value'] @@ -267,34 +443,57 @@ def processData(): y_ttBar_min = input['independent_variables'][1]['values'][i]['low'] y_ttBar_max = input['independent_variables'][1]['values'][i]['high'] error_value = {} - plus = pta(str(values[i]['errors'][1]['asymerror']['plus']), data_central_value) - minus = pta(str(values[i]['errors'][1]['asymerror']['minus']), data_central_value) - se_delta, se_sigma = se(plus, minus) + plus = percentage_to_absolute( + str(values[i]['errors'][1]['asymerror']['plus']), data_central_value + ) + minus = percentage_to_absolute( + str(values[i]['errors'][1]['asymerror']['minus']), data_central_value + ) + se_delta, se_sigma = symmetrize_errors(plus, minus) data_central_value = data_central_value + se_delta error_value['sys'] = se_sigma for j in range(len(values)): - error_value['ArtUnc_'+str(j+1)] = artunc3[i][j] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}} + error_value['ArtUnc_' + str(j + 1)] = artunc3[i][j] + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': None, 'max': y_ttBar_max}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': None, 'max': m_ttBar_max}, + } data_central_d2Sig_dmttBar_dyttBar_norm.append(data_central_value) kin_d2Sig_dmttBar_dyttBar_norm.append(kin_value) error_d2Sig_dmttBar_dyttBar_norm.append(error_value) error_definition_d2Sig_dmttBar_dyttBar_norm = {} - error_definition_d2Sig_dmttBar_dyttBar_norm['sys'] = {'definition': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + error_definition_d2Sig_dmttBar_dyttBar_norm['sys'] = { + 'definition': 'total systematic uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + } for i in range(16): - error_definition_d2Sig_dmttBar_dyttBar_norm['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} - - data_central_d2Sig_dmttBar_dyttBar_norm_yaml = {'data_central': data_central_d2Sig_dmttBar_dyttBar_norm} + error_definition_d2Sig_dmttBar_dyttBar_norm['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } + + data_central_d2Sig_dmttBar_dyttBar_norm_yaml = { + 'data_central': data_central_d2Sig_dmttBar_dyttBar_norm + } kinematics_d2Sig_dmttBar_dyttBar_norm_yaml = {'bins': kin_d2Sig_dmttBar_dyttBar_norm} - uncertainties_d2Sig_dmttBar_dyttBar_norm_yaml = {'definitions': error_definition_d2Sig_dmttBar_dyttBar_norm, 'bins': error_d2Sig_dmttBar_dyttBar_norm} + uncertainties_d2Sig_dmttBar_dyttBar_norm_yaml = { + 'definitions': error_definition_d2Sig_dmttBar_dyttBar_norm, + 'bins': error_d2Sig_dmttBar_dyttBar_norm, + } with open('data_d2Sig_dmttBar_dyttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_d2Sig_dmttBar_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_d2Sig_dmttBar_dyttBar_norm_yaml, file, sort_keys=False) with open('kinematics_d2Sig_dmttBar_dyttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_d2Sig_dmttBar_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_d2Sig_dmttBar_dyttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_d2Sig_dmttBar_dyttBar_norm.yaml', 'w') as file: - yaml.dump(uncertainties_d2Sig_dmttBar_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(uncertainties_d2Sig_dmttBar_dyttBar_norm_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_8TEV_LJ_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_8TEV_LJ_DIF/filter.py index 92d524ea5b..4ac580504d 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_8TEV_LJ_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/CMS_TTBAR_8TEV_LJ_DIF/filter.py @@ -1,21 +1,75 @@ -import yaml -import numpy as np - from math import sqrt + +import numpy as np from numpy.linalg import eig +import yaml + -def pta(percentage, value): - +def percentage_to_absolute(percentage, value): + r"""Compute the absolute value of uncertainty from percentage. + + Parameters + ---------- + percentage : string/float + Experimental datasets can provide the percentage + uncertainties with a % sign or without one. + The function will autostrip % sign and convert to + a float type in case the percentage uncertainty + comes with a % sign. Else, it will directly perform + the computation. + value : float + The data point + + Returns + ------- + absolute : float + The absolute value of the uncertainty + + """ if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute -def cta(ndata, covmat_list, no_of_norm_mat=0): - + +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + r"""Convert the covariance matrix to a matrix of + artificial uncertainties. + + Parameters + ---------- + ndata : integer + Number of data points + covmat_list : list + A one dimensional list which contains the elements of + the covariance matrix row by row. Since experimental + datasets provide these matrices in a list form, this + simplifies the implementation for the user. + no_of_norm_mat : int + Normalized covariance matrices may have an eigenvalue + of 0 due to the last data point not being linearly + independent. To allow for this, the user should input + the number of normalized matrices that are being treated + in an instance. For example, if a single covariance matrix + of a normalized distribution is being processed, the input + would be 1. If a covariance matrix contains pertains to + 3 normalized datasets (i.e. cross covmat for 3 + distributions), the input would be 3. The default value is + 0 for when the covariance matrix pertains to an absolute + distribution. + + Returns + ------- + artunc : list + A two dimensional matrix (given as a list of lists) + which contains artificial uncertainties to be added + to the commondata. i^th row (or list) contains the + artificial uncertainties of the i^th data point. + + """ epsilon = -0.0000000001 neg_eval_count = 0 psd_check = True @@ -43,9 +97,10 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -73,24 +128,24 @@ def processData(): covMatArray_dSig_dyttBar = [] covMatArray_dSig_dmttBar = [] -# dSig_dpTt data + # dSig_dpTt data - hepdata_tables="rawdata/Table15.yaml" + hepdata_tables = "rawdata/Table15.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table16.yaml" + covariance_matrix = "rawdata/Table16.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - systematics_breakdown="rawdata/Table17.yaml" + systematics_breakdown = "rawdata/Table17.yaml" with open(systematics_breakdown, 'r') as file3: input3 = yaml.safe_load(file3) - for i in range(ndata_dSig_dpTt*ndata_dSig_dpTt): + for i in range(ndata_dSig_dpTt * ndata_dSig_dpTt): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dpTt.append(covMatEl) - artUncMat_dSig_dpTt = cta(ndata_dSig_dpTt, covMatArray_dSig_dpTt, 1) + artUncMat_dSig_dpTt = covmat_to_artunc(ndata_dSig_dpTt, covMatArray_dSig_dpTt, 1) sqrts = float(input['dependent_variables'][0]['qualifiers'][2]['value']) m_t2 = 29756.25 @@ -104,54 +159,78 @@ def processData(): error_value['stat'] = 0 # error_value['sys'] = values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dpTt): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dpTt[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dpTt[i][j]) data_central_value = values[i]['value'] for j in range(11): - error_value[input3['independent_variables'][0]['values'][j]['value']] = pta(str(input3['dependent_variables'][i]['values'][j]['value']), data_central_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'pT_t': {'min': pT_t_min, 'mid': pT_t_mid, 'max': pT_t_max}} + error_value[input3['independent_variables'][0]['values'][j]['value']] = ( + percentage_to_absolute( + str(input3['dependent_variables'][i]['values'][j]['value']), data_central_value + ) + ) + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'pT_t': {'min': pT_t_min, 'mid': pT_t_mid, 'max': pT_t_max}, + } data_central_dSig_dpTt.append(data_central_value) kin_dSig_dpTt.append(kin_value) error_dSig_dpTt.append(error_value) error_definition_dSig_dpTt = {} - error_definition_dSig_dpTt['stat'] = {'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + error_definition_dSig_dpTt['stat'] = { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } # error_definition_dSig_dpTt['sys'] = {'description': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dpTt): - error_definition_dSig_dpTt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dpTt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } for i in range(11): - error_definition_dSig_dpTt[input3['independent_variables'][0]['values'][i]['value']] = {'definition': 'systematic uncertainty- '+str(input3['independent_variables'][0]['values'][i]['value']), 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dpTt[input3['independent_variables'][0]['values'][i]['value']] = { + 'definition': 'systematic uncertainty- ' + + str(input3['independent_variables'][0]['values'][i]['value']), + 'treatment': 'MULT', + 'type': 'CORR', + } data_central_dSig_dpTt_norm_yaml = {'data_central': data_central_dSig_dpTt} kinematics_dSig_dpTt_norm_yaml = {'bins': kin_dSig_dpTt} - uncertainties_dSig_dpTt_norm_yaml = {'definitions': error_definition_dSig_dpTt, 'bins': error_dSig_dpTt} + uncertainties_dSig_dpTt_norm_yaml = { + 'definitions': error_definition_dSig_dpTt, + 'bins': error_dSig_dpTt, + } with open('data_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dpTt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dpTt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dpTt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dpTt_norm_yaml, file, sort_keys=False) -# dSig_dyt data + # dSig_dyt data - hepdata_tables="rawdata/Table21.yaml" + hepdata_tables = "rawdata/Table21.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table22.yaml" + covariance_matrix = "rawdata/Table22.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - systematics_breakdown="rawdata/Table23.yaml" + systematics_breakdown = "rawdata/Table23.yaml" with open(systematics_breakdown, 'r') as file3: input3 = yaml.safe_load(file3) - for i in range(ndata_dSig_dyt*ndata_dSig_dyt): + for i in range(ndata_dSig_dyt * ndata_dSig_dyt): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyt.append(covMatEl) - artUncMat_dSig_dyt = cta(ndata_dSig_dyt, covMatArray_dSig_dyt, 1) + artUncMat_dSig_dyt = covmat_to_artunc(ndata_dSig_dyt, covMatArray_dSig_dyt, 1) sqrts = float(input['dependent_variables'][0]['qualifiers'][2]['value']) m_t2 = 29756.25 @@ -165,54 +244,78 @@ def processData(): error_value['stat'] = 0 # error_value['sys'] = values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dyt): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyt[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyt[i][j]) data_central_value = values[i]['value'] for j in range(11): - error_value[input3['independent_variables'][0]['values'][j]['value']] = pta(str(input3['dependent_variables'][i]['values'][j]['value']), data_central_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_t': {'min': y_t_min, 'mid': y_t_mid, 'max': y_t_max}} + error_value[input3['independent_variables'][0]['values'][j]['value']] = ( + percentage_to_absolute( + str(input3['dependent_variables'][i]['values'][j]['value']), data_central_value + ) + ) + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_t': {'min': y_t_min, 'mid': y_t_mid, 'max': y_t_max}, + } data_central_dSig_dyt.append(data_central_value) kin_dSig_dyt.append(kin_value) error_dSig_dyt.append(error_value) error_definition_dSig_dyt = {} - error_definition_dSig_dyt['stat'] = {'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + error_definition_dSig_dyt['stat'] = { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } # error_definition_dSig_dyt['sys'] = {'description': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dyt): - error_definition_dSig_dyt['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyt['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } for i in range(11): - error_definition_dSig_dyt[input3['independent_variables'][0]['values'][i]['value']] = {'definition': 'systematic uncertainty- '+str(input3['independent_variables'][0]['values'][i]['value']), 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyt[input3['independent_variables'][0]['values'][i]['value']] = { + 'definition': 'systematic uncertainty- ' + + str(input3['independent_variables'][0]['values'][i]['value']), + 'treatment': 'MULT', + 'type': 'CORR', + } data_central_dSig_dyt_norm_yaml = {'data_central': data_central_dSig_dyt} kinematics_dSig_dyt_norm_yaml = {'bins': kin_dSig_dyt} - uncertainties_dSig_dyt_norm_yaml = {'definitions': error_definition_dSig_dyt, 'bins': error_dSig_dyt} + uncertainties_dSig_dyt_norm_yaml = { + 'definitions': error_definition_dSig_dyt, + 'bins': error_dSig_dyt, + } with open('data_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyt_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyt_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyt_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyt_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyt_norm_yaml, file, sort_keys=False) -# dSig_dyttBar data + # dSig_dyttBar data - hepdata_tables="rawdata/Table36.yaml" + hepdata_tables = "rawdata/Table36.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table37.yaml" + covariance_matrix = "rawdata/Table37.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - systematics_breakdown="rawdata/Table38.yaml" + systematics_breakdown = "rawdata/Table38.yaml" with open(systematics_breakdown, 'r') as file3: input3 = yaml.safe_load(file3) - for i in range(ndata_dSig_dyttBar*ndata_dSig_dyttBar): + for i in range(ndata_dSig_dyttBar * ndata_dSig_dyttBar): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dyttBar.append(covMatEl) - artUncMat_dSig_dyttBar = cta(ndata_dSig_dyttBar, covMatArray_dSig_dyttBar, 1) + artUncMat_dSig_dyttBar = covmat_to_artunc(ndata_dSig_dyttBar, covMatArray_dSig_dyttBar, 1) sqrts = float(input['dependent_variables'][0]['qualifiers'][2]['value']) m_t2 = 29756.25 @@ -226,54 +329,78 @@ def processData(): error_value['stat'] = 0 # error_value['sys'] = values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dyttBar): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dyttBar[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dyttBar[i][j]) data_central_value = values[i]['value'] for j in range(11): - error_value[input3['independent_variables'][0]['values'][j]['value']] = pta(str(input3['dependent_variables'][i]['values'][j]['value']), data_central_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'y_ttBar': {'min': y_ttBar_min, 'mid': y_ttBar_mid, 'max': y_ttBar_max}} + error_value[input3['independent_variables'][0]['values'][j]['value']] = ( + percentage_to_absolute( + str(input3['dependent_variables'][i]['values'][j]['value']), data_central_value + ) + ) + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'y_ttBar': {'min': y_ttBar_min, 'mid': y_ttBar_mid, 'max': y_ttBar_max}, + } data_central_dSig_dyttBar.append(data_central_value) kin_dSig_dyttBar.append(kin_value) error_dSig_dyttBar.append(error_value) error_definition_dSig_dyttBar = {} - error_definition_dSig_dyttBar['stat'] = {'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + error_definition_dSig_dyttBar['stat'] = { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } # error_definition_dSig_dyttBar['sys'] = {'description': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dyttBar): - error_definition_dSig_dyttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dyttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } for i in range(11): - error_definition_dSig_dyttBar[input3['independent_variables'][0]['values'][i]['value']] = {'definition': 'systematic uncertainty- '+str(input3['independent_variables'][0]['values'][i]['value']), 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dyttBar[input3['independent_variables'][0]['values'][i]['value']] = { + 'definition': 'systematic uncertainty- ' + + str(input3['independent_variables'][0]['values'][i]['value']), + 'treatment': 'MULT', + 'type': 'CORR', + } data_central_dSig_dyttBar_norm_yaml = {'data_central': data_central_dSig_dyttBar} kinematics_dSig_dyttBar_norm_yaml = {'bins': kin_dSig_dyttBar} - uncertainties_dSig_dyttBar_norm_yaml = {'definitions': error_definition_dSig_dyttBar, 'bins': error_dSig_dyttBar} + uncertainties_dSig_dyttBar_norm_yaml = { + 'definitions': error_definition_dSig_dyttBar, + 'bins': error_dSig_dyttBar, + } with open('data_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dyttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dyttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dyttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dyttBar_norm_yaml, file, sort_keys=False) -# dSig_dmttBar data + # dSig_dmttBar data - hepdata_tables="rawdata/Table39.yaml" + hepdata_tables = "rawdata/Table39.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - covariance_matrix="rawdata/Table40.yaml" + covariance_matrix = "rawdata/Table40.yaml" with open(covariance_matrix, 'r') as file2: input2 = yaml.safe_load(file2) - systematics_breakdown="rawdata/Table41.yaml" + systematics_breakdown = "rawdata/Table41.yaml" with open(systematics_breakdown, 'r') as file3: input3 = yaml.safe_load(file3) - for i in range(ndata_dSig_dmttBar*ndata_dSig_dmttBar): + for i in range(ndata_dSig_dmttBar * ndata_dSig_dmttBar): covMatEl = input2['dependent_variables'][0]['values'][i]['value'] covMatArray_dSig_dmttBar.append(covMatEl) - artUncMat_dSig_dmttBar = cta(ndata_dSig_dmttBar, covMatArray_dSig_dmttBar, 1) + artUncMat_dSig_dmttBar = covmat_to_artunc(ndata_dSig_dmttBar, covMatArray_dSig_dmttBar, 1) sqrts = float(input['dependent_variables'][0]['qualifiers'][2]['value']) m_t2 = 29756.25 @@ -287,34 +414,59 @@ def processData(): error_value['stat'] = 0 # error_value['sys'] = values[i]['errors'][1]['symerror'] for j in range(ndata_dSig_dmttBar): - error_value['ArtUnc_'+str(j+1)] = float(artUncMat_dSig_dmttBar[i][j]) + error_value['ArtUnc_' + str(j + 1)] = float(artUncMat_dSig_dmttBar[i][j]) data_central_value = values[i]['value'] for j in range(11): - error_value[input3['independent_variables'][0]['values'][j]['value']] = pta(str(input3['dependent_variables'][i]['values'][j]['value']), data_central_value) - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, 'm_ttBar': {'min': m_ttBar_min, 'mid': m_ttBar_mid, 'max': m_ttBar_max}} + error_value[input3['independent_variables'][0]['values'][j]['value']] = ( + percentage_to_absolute( + str(input3['dependent_variables'][i]['values'][j]['value']), data_central_value + ) + ) + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'm_t2': {'min': None, 'mid': m_t2, 'max': None}, + 'm_ttBar': {'min': m_ttBar_min, 'mid': m_ttBar_mid, 'max': m_ttBar_max}, + } data_central_dSig_dmttBar.append(data_central_value) kin_dSig_dmttBar.append(kin_value) error_dSig_dmttBar.append(error_value) error_definition_dSig_dmttBar = {} - error_definition_dSig_dmttBar['stat'] = {'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + error_definition_dSig_dmttBar['stat'] = { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + } # error_definition_dSig_dmttBar['sys'] = {'description': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'} for i in range(ndata_dSig_dmttBar): - error_definition_dSig_dmttBar['ArtUnc_'+str(i+1)] = {'definition': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'CORR'} + error_definition_dSig_dmttBar['ArtUnc_' + str(i + 1)] = { + 'definition': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'CORR', + } for i in range(11): - error_definition_dSig_dmttBar[input3['independent_variables'][0]['values'][i]['value']] = {'definition': 'systematic uncertainty- '+str(input3['independent_variables'][0]['values'][i]['value']), 'treatment': 'MULT', 'type': 'CORR'} + error_definition_dSig_dmttBar[input3['independent_variables'][0]['values'][i]['value']] = { + 'definition': 'systematic uncertainty- ' + + str(input3['independent_variables'][0]['values'][i]['value']), + 'treatment': 'MULT', + 'type': 'CORR', + } data_central_dSig_dmttBar_norm_yaml = {'data_central': data_central_dSig_dmttBar} kinematics_dSig_dmttBar_norm_yaml = {'bins': kin_dSig_dmttBar} - uncertainties_dSig_dmttBar_norm_yaml = {'definitions': error_definition_dSig_dmttBar, 'bins': error_dSig_dmttBar} + uncertainties_dSig_dmttBar_norm_yaml = { + 'definitions': error_definition_dSig_dmttBar, + 'bins': error_dSig_dmttBar, + } with open('data_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('kinematics_dSig_dmttBar_norm.yaml', 'w') as file: - yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_dSig_dmttBar_norm_yaml, file, sort_keys=False) with open('uncertainties_dSig_dmttBar_norm.yaml', 'w') as file: yaml.dump(uncertainties_dSig_dmttBar_norm_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_290PB-1_DIF/artUnc.py b/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_290PB-1_DIF/artUnc.py index ebb4dcbc8f..706e17dd90 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_290PB-1_DIF/artUnc.py +++ b/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_290PB-1_DIF/artUnc.py @@ -1,21 +1,23 @@ -import yaml -import numpy as np - from math import sqrt + +import numpy as np from numpy.linalg import eig +import yaml + + +def percentage_to_absolute(percentage, value): -def pta(percentage, value): - if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute -def cta(ndata, covmat_list, no_of_norm_mat=0): - + +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + epsilon = -0.0000000001 neg_eval_count = 0 psd_check = True @@ -43,9 +45,10 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() + def artunc(): with open('rawdata/data49.yaml', 'r') as file: @@ -58,7 +61,7 @@ def artunc(): errPercArr = [] dataArr = [] for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]: - hepdata_tables="rawdata/data"+str(i)+".yaml" + hepdata_tables = "rawdata/data" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) values = input['dependent_variables'][0]['values'] @@ -67,17 +70,16 @@ def artunc(): errPercArr.append(errPerc) dataArr.append(float(values[j]['value'])) - errArr = [] for i in range(96): - errArr.append(pta(errPercArr[i], dataArr[i])) + errArr.append(percentage_to_absolute(errPercArr[i], dataArr[i])) covMat = np.zeros((96, 96)) artUnc = np.zeros((96, 96)) for i in range(96): - for j in range(i+1): - cmhap = (i * (i+1)) // 2 + j + for j in range(i + 1): + cmhap = (i * (i + 1)) // 2 + j if i == j: covMat[i][j] = corMatHalfArr[cmhap] * errArr[i] * errArr[j] else: @@ -88,12 +90,13 @@ def artunc(): for i in range(96): for j in range(96): covMatList.append(covMat[i][j]) - artUnc = cta(96, covMatList, 0) + artUnc = covmat_to_artunc(96, covMatList, 0) return artUnc + def artunc_norm(): - + with open('rawdata/data50.yaml', 'r') as file: corMatFile = yaml.safe_load(file) @@ -104,7 +107,7 @@ def artunc_norm(): errPercArr = [] dataArr = [] for i in [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]: - hepdata_tables="rawdata/data"+str(i)+".yaml" + hepdata_tables = "rawdata/data" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) values = input['dependent_variables'][0]['values'] @@ -115,14 +118,14 @@ def artunc_norm(): errArr = [] for i in range(96): - errArr.append(pta(errPercArr[i], dataArr[i])) + errArr.append(percentage_to_absolute(errPercArr[i], dataArr[i])) covMat = np.zeros((96, 96)) artUnc = np.zeros((96, 96)) for i in range(96): - for j in range(i+1): - cmhap = (i * (i+1)) // 2 + j + for j in range(i + 1): + cmhap = (i * (i + 1)) // 2 + j if i == j: covMat[i][j] = corMatHalfArr[cmhap] * errArr[i] * errArr[j] else: @@ -133,6 +136,6 @@ def artunc_norm(): for i in range(96): for j in range(96): covMatList.append(covMat[i][j]) - artUnc = cta(96, covMatList, 1) + artUnc = covmat_to_artunc(96, covMatList, 1) return artUnc diff --git a/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_290PB-1_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_290PB-1_DIF/filter.py index 0cca31b201..2ac801f886 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_290PB-1_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_290PB-1_DIF/filter.py @@ -1,25 +1,29 @@ +from math import sqrt + import artUnc import yaml -from math import sqrt -def se(delta_plus, delta_minus): - - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 + +def symmetrize_errors(delta_plus, delta_minus): + + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma -def pta(percentage, value): - + +def percentage_to_absolute(percentage, value): + if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -45,7 +49,7 @@ def processData(): artUncMatr = artUnc.artunc() artUncMatr_norm = artUnc.artunc_norm() -# jet data + # jet data for i in tables: if i == 1: @@ -73,7 +77,7 @@ def processData(): Q2_min = 60 Q2_max = 80 - hepdata_tables="rawdata/data"+str(i)+".yaml" + hepdata_tables = "rawdata/data" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -84,53 +88,107 @@ def processData(): data_central_value = float(values[j]['value']) pT_max = input['independent_variables'][0]['values'][j]['high'] pT_min = input['independent_variables'][0]['values'][j]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max},'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin.append(kin_value) value_delta = 0 error_value = {} for k in 0, 1, 5, 6, 7, 8, 9, 10, 11: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']] = pta(values[j]['errors'][k]['symerror'], data_central_value) + error_value[values[j]['errors'][k]['label']] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ), + ) value_delta = value_delta + se_delta error_value[values[j]['errors'][k]['label']] = se_sigma for k in 2, 3, 4: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']+'_1'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) - error_value[values[j]['errors'][k]['label']+'_2'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_1'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_2'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value)/sqrt(2), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)/sqrt(2)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ) + / sqrt(2), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ) + / sqrt(2), + ) value_delta = value_delta + se_delta + se_delta - error_value[values[j]['errors'][k]['label']+'_1'] = se_sigma - error_value[values[j]['errors'][k]['label']+'_2'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_1'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_2'] = se_sigma data_central_value = data_central_value + value_delta data_central.append(data_central_value) for k in range(96): - error_value['ArtUnc_'+str(k+1)] = float(artUncMatr[j][k]) + error_value['ArtUnc_' + str(k + 1)] = float(artUncMatr[j][k]) error_value['stat'] = 0 error.append(error_value) error_definition = { - 'stat':{'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Uncorr':{'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Model_1':{'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Model_2':{'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ModelRW_1':{'description': 'reweighting uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'ModelRW_2':{'description': 'reweighting uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'JES_1':{'description': 'jet energy scale uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'JES_2':{'description': 'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'RCES':{'description': 'remaining cluster energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ElEn':{'description': 'electron energy uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ElTh':{'description': 'electron theta uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'Lumi':{'description': 'luminosity', 'treatment': 'MULT', 'type': 'CORR'}, - 'LArN':{'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, - 'StatMC':{'description': 'MC statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'RadErr':{'description': 'radiative uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Uncorr': {'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_1': {'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_2': {'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'ModelRW_1': { + 'description': 'reweighting uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'ModelRW_2': { + 'description': 'reweighting uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'JES_1': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'JES_2': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'RCES': { + 'description': 'remaining cluster energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'ElEn': {'description': 'electron energy uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'ElTh': {'description': 'electron theta uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'Lumi': {'description': 'luminosity', 'treatment': 'MULT', 'type': 'CORR'}, + 'LArN': {'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, + 'StatMC': { + 'description': 'MC statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'RadErr': {'description': 'radiative uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, } for i in range(96): - error_definition['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'H1JETS161103421unc'+str(i+1)} + error_definition['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'H1JETS161103421unc' + str(i + 1), + } data_central_yaml = {'data_central': data_central} kinematics_yaml = {'bins': kin} @@ -145,7 +203,7 @@ def processData(): with open('uncertainties.yaml', 'w') as file: yaml.dump(uncertainties_yaml, file, sort_keys=False) -# jet_norm data + # jet_norm data for i in tables_norm: if i == 25: @@ -173,7 +231,7 @@ def processData(): Q2_min = 60 Q2_max = 80 - hepdata_tables="rawdata/data"+str(i)+".yaml" + hepdata_tables = "rawdata/data" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -184,53 +242,107 @@ def processData(): data_central_value = float(values[j]['value']) pT_max = input['independent_variables'][0]['values'][j]['high'] pT_min = input['independent_variables'][0]['values'][j]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max},'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin_norm.append(kin_value) value_delta = 0 error_value = {} for k in 0, 1, 5, 6, 7, 8, 9, 10, 11: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']] = pta(values[j]['errors'][k]['symerror'], data_central_value) + error_value[values[j]['errors'][k]['label']] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ), + ) value_delta = value_delta + se_delta error_value[values[j]['errors'][k]['label']] = se_sigma for k in 2, 3, 4: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']+'_1'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) - error_value[values[j]['errors'][k]['label']+'_2'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_1'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_2'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value)/sqrt(2), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)/sqrt(2)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ) + / sqrt(2), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ) + / sqrt(2), + ) value_delta = value_delta + se_delta + se_delta - error_value[values[j]['errors'][k]['label']+'_1'] = se_sigma - error_value[values[j]['errors'][k]['label']+'_2'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_1'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_2'] = se_sigma data_central_value = data_central_value + value_delta data_central_norm.append(data_central_value) for k in range(96): - error_value['ArtUnc_'+str(k+1)] = float(artUncMatr_norm[j][k]) + error_value['ArtUnc_' + str(k + 1)] = float(artUncMatr_norm[j][k]) error_value['stat'] = 0 error_norm.append(error_value) error_definition_norm = { - 'stat':{'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Uncorr':{'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Model_1':{'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Model_2':{'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ModelRW_1':{'description': 'reweighting uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'ModelRW_2':{'description': 'reweighting uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'JES_1':{'description': 'jet energy scale uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'JES_2':{'description': 'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'RCES':{'description': 'remaining cluster energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ElEn':{'description': 'electron energy uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ElTh':{'description': 'electron theta uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'Lumi':{'description': 'luminosity', 'treatment': 'MULT', 'type': 'CORR'}, - 'LArN':{'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, - 'StatMC':{'description': 'MC statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'RadErr':{'description': 'radiative uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Uncorr': {'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_1': {'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_2': {'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'ModelRW_1': { + 'description': 'reweighting uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'ModelRW_2': { + 'description': 'reweighting uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'JES_1': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'JES_2': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'RCES': { + 'description': 'remaining cluster energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'ElEn': {'description': 'electron energy uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'ElTh': {'description': 'electron theta uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'Lumi': {'description': 'luminosity', 'treatment': 'MULT', 'type': 'CORR'}, + 'LArN': {'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, + 'StatMC': { + 'description': 'MC statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'RadErr': {'description': 'radiative uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, } for i in range(96): - error_definition_norm['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'H1JETS161103421NORMunc'+str(i+1)} + error_definition_norm['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'H1JETS161103421NORMunc' + str(i + 1), + } data_central_norm_yaml = {'data_central': data_central_norm} kinematics_norm_yaml = {'bins': kin_norm} @@ -245,12 +357,12 @@ def processData(): with open('uncertainties_norm.yaml', 'w') as file: yaml.dump(uncertainties_norm_yaml, file, sort_keys=False) -# jet_highQ2 data + # jet_highQ2 data - hepdata_tables="rawdata/data51.yaml" + hepdata_tables = "rawdata/data51.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = float(input['dependent_variables'][0]['qualifiers'][2]['value']) pT_min = 5 pT_max = 7 @@ -260,49 +372,90 @@ def processData(): data_central_value = float(values[i]['value']) Q2_max = input['independent_variables'][0]['values'][i]['high'] Q2_min = input['independent_variables'][0]['values'][i]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max},'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin_highQ2.append(kin_value) value_delta = 0 error_value = {} for k in 0, 3, 4, 5, 6, 7, 8: - if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']] = pta(values[j]['errors'][k]['symerror'], data_central_value) - else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)) - value_delta = value_delta + se_delta - error_value[values[j]['errors'][k]['label']] = se_sigma + if 'symerror' in values[j]['errors'][k]: + error_value[values[j]['errors'][k]['label']] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) + else: + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ), + ) + value_delta = value_delta + se_delta + error_value[values[j]['errors'][k]['label']] = se_sigma for k in 1, 2: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']+'_1'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) - error_value[values[j]['errors'][k]['label']+'_2'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_1'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_2'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value)/sqrt(2), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)/sqrt(2)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ) + / sqrt(2), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ) + / sqrt(2), + ) value_delta = value_delta + se_delta + se_delta - error_value[values[j]['errors'][k]['label']+'_1'] = se_sigma - error_value[values[j]['errors'][k]['label']+'_2'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_1'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_2'] = se_sigma data_central_value = data_central_value + value_delta data_central_highQ2.append(data_central_value) error_highQ2.append(error_value) - + error_definition_highQ2 = { - 'stat':{'description':'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR' }, - 'Model_1':{'description':'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR' }, - 'Model_2':{'description':'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR' }, - 'JES_1':{'description':'jet energy scale uncertainty', 'treatment': 'ADD', 'type': 'UNCORR' }, - 'JES_2':{'description':'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR' }, - 'RCES':{'description':'remaining cluster energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR' }, - '$E_{e^\prime}$':{'description':'electron energy', 'treatment': 'MULT', 'type': 'CORR' }, - '$\theta_{e^\prime}$':{'description':'electron theta', 'treatment': 'MULT', 'type': 'CORR' }, - 'ID(e)':{'description': 'electron identification', 'treatment': 'MULT', 'type': 'CORR'}, - 'LArNoise':{'description':'lar noice', 'treatment': 'MULT', 'type': 'CORR' }, - 'Norm':{'description': 'normalization uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_1': {'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_2': {'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'JES_1': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'JES_2': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'RCES': { + 'description': 'remaining cluster energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + '$E_{e^\prime}$': {'description': 'electron energy', 'treatment': 'MULT', 'type': 'CORR'}, + '$\theta_{e^\prime}$': { + 'description': 'electron theta', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'ID(e)': {'description': 'electron identification', 'treatment': 'MULT', 'type': 'CORR'}, + 'LArNoise': {'description': 'lar noice', 'treatment': 'MULT', 'type': 'CORR'}, + 'Norm': {'description': 'normalization uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, } data_central_highQ2_yaml = {'data_central': data_central_highQ2} kinematics_highQ2_yaml = {'bins': kin_highQ2} uncertainties_highQ2_yaml = {'definitions': error_definition_highQ2, 'bins': error_highQ2} - with open('data_highQ2.yaml', 'w') as file: yaml.dump(data_central_highQ2_yaml, file, sort_keys=False) @@ -312,12 +465,12 @@ def processData(): with open('uncertainties_highQ2.yaml', 'w') as file: yaml.dump(uncertainties_highQ2_yaml, file, sort_keys=False) -# jet_highQ2_norm data + # jet_highQ2_norm data - hepdata_tables="rawdata/data52.yaml" + hepdata_tables = "rawdata/data52.yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) - + sqrts = float(input['dependent_variables'][0]['qualifiers'][2]['value']) pT_min = 5 pT_max = 7 @@ -327,46 +480,90 @@ def processData(): data_central_value = float(values[i]['value']) Q2_max = input['independent_variables'][0]['values'][i]['high'] Q2_min = input['independent_variables'][0]['values'][i]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max},'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin_highQ2_norm.append(kin_value) value_delta = 0 error_value = {} for k in 0, 3, 4, 5, 6: - if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']] = pta(values[j]['errors'][k]['symerror'], data_central_value) - else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)) - value_delta = value_delta + se_delta - error_value[values[j]['errors'][k]['label']] = se_sigma + if 'symerror' in values[j]['errors'][k]: + error_value[values[j]['errors'][k]['label']] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) + else: + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ), + ) + value_delta = value_delta + se_delta + error_value[values[j]['errors'][k]['label']] = se_sigma for k in 1, 2: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']+'_1'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) - error_value[values[j]['errors'][k]['label']+'_2'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_1'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_2'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value)/sqrt(2), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)/sqrt(2)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ) + / sqrt(2), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ) + / sqrt(2), + ) value_delta = value_delta + se_delta + se_delta - error_value[values[j]['errors'][k]['label']+'_1'] = se_sigma - error_value[values[j]['errors'][k]['label']+'_2'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_1'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_2'] = se_sigma data_central_value = data_central_value + value_delta data_central_highQ2_norm.append(data_central_value) error_highQ2_norm.append(error_value) - + error_definition_highQ2_norm = { - 'stat':{'description':'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR' }, - 'Model_1':{'description':'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR' }, - 'Model_2':{'description':'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR' }, - 'JES_1':{'description':'jet energy scale uncertainty', 'treatment': 'ADD', 'type': 'UNCORR' }, - 'JES_2':{'description':'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR' }, - 'RCES':{'description':'remaining cluster energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR' }, - '$E_{e^\prime}$':{'description':'electron energy', 'treatment': 'MULT', 'type': 'CORR' }, - '$\theta_{e^\prime}$':{'description':'electron theta', 'treatment': 'MULT', 'type': 'CORR' }, - 'LArNoise':{'description':'lar noice', 'treatment': 'MULT', 'type': 'CORR' } + 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_1': {'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_2': {'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'JES_1': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'JES_2': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'RCES': { + 'description': 'remaining cluster energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + '$E_{e^\prime}$': {'description': 'electron energy', 'treatment': 'MULT', 'type': 'CORR'}, + '$\theta_{e^\prime}$': { + 'description': 'electron theta', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'LArNoise': {'description': 'lar noice', 'treatment': 'MULT', 'type': 'CORR'}, } data_central_highQ2_norm_yaml = {'data_central': data_central_highQ2_norm} kinematics_highQ2_norm_yaml = {'bins': kin_highQ2_norm} - uncertainties_highQ2_norm_yaml = {'definitions': error_definition_highQ2_norm, 'bins': error_highQ2_norm} - + uncertainties_highQ2_norm_yaml = { + 'definitions': error_definition_highQ2_norm, + 'bins': error_highQ2_norm, + } with open('data_highQ2_norm.yaml', 'w') as file: yaml.dump(data_central_highQ2_norm_yaml, file, sort_keys=False) @@ -377,4 +574,5 @@ def processData(): with open('uncertainties_highQ2_norm.yaml', 'w') as file: yaml.dump(uncertainties_highQ2_norm_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_351PB-1_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_351PB-1_DIF/filter.py index a12d070cd5..a4eed2bdfb 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_351PB-1_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_351PB-1_DIF/filter.py @@ -1,16 +1,18 @@ +from manual_impl import artunc, jet_data, jet_sys import yaml -from manual_impl import jet_data, jet_sys, artunc -def pta(percentage, value): - + +def percentage_to_absolute(percentage, value): + if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -28,9 +30,9 @@ def processData(): kin_norm = [] error_norm = [] -# jet data + # jet data - hepdata_tables="rawdata/Table"+str(tables[0])+".yaml" + hepdata_tables = "rawdata/Table" + str(tables[0]) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -45,49 +47,57 @@ def processData(): Q2_min = input['independent_variables'][0]['values'][i]['low'] pT_max = input['independent_variables'][1]['values'][i]['high'] pT_min = input['independent_variables'][1]['values'][i]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max},'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin.append(kin_value) error_value = {} - # error_value['stat'] = pta(values[i]['errors'][0]['symerror'], data_central_value) - # error_value['sys'] = pta(values[i]['errors'][1]['symerror'], data_central_value) + # error_value['stat'] = percentage_to_absolute(values[i]['errors'][0]['symerror'], data_central_value) + # error_value['sys'] = percentage_to_absolute(values[i]['errors'][1]['symerror'], data_central_value) for j in range(len(jet_sys[i])): - error_value['Syst_'+str(j+1)] = jet_sys[i][j] + error_value['Syst_' + str(j + 1)] = jet_sys[i][j] for j in range(len(artunc[i])): - error_value['ArtUnc_'+str(j+1)] = artunc[i][j] + error_value['ArtUnc_' + str(j + 1)] = artunc[i][j] error.append(error_value) # error_definition = {'stat':{'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, 'sys':{'description': 'total systematic uncertainty', 'treatment':'MULT' , 'type': 'CORR'}} - error_definition = {'Syst_1':{'description': 'model', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_2':{'description': 'jes', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_3':{'description': 'jes', 'treatment': 'MULT', 'type': 'CORR'}, - 'Syst_4':{'description': 'rces', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_5':{'description': 'rces', 'treatment': 'MULT', 'type': 'CORR'}, - 'Syst_6':{'description': 'e_e', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_7':{'description': 'theta_e', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_8':{'description': 'ID_e', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_9':{'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, - 'Syst_10':{'description': 'norm', 'treatment': 'MULT', 'type': 'CORR'}} + error_definition = { + 'Syst_1': {'description': 'model', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_2': {'description': 'jes', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_3': {'description': 'jes', 'treatment': 'MULT', 'type': 'CORR'}, + 'Syst_4': {'description': 'rces', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_5': {'description': 'rces', 'treatment': 'MULT', 'type': 'CORR'}, + 'Syst_6': {'description': 'e_e', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_7': {'description': 'theta_e', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_8': {'description': 'ID_e', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_9': {'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, + 'Syst_10': {'description': 'norm', 'treatment': 'MULT', 'type': 'CORR'}, + } for i in range(48): - error_definition['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty ' + str(i+1), 'treatment': 'ADD', 'type': 'H1JETS14064709unc'+str(i+1)} - - + error_definition['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'H1JETS14064709unc' + str(i + 1), + } data_central_yaml = {'data_central': data_central} kinematics_yaml = {'bins': kin} uncertainties_yaml = {'definitions': error_definition, 'bins': error} with open('data.yaml', 'w') as file: - yaml.dump(data_central_yaml, file, sort_keys=False) + yaml.dump(data_central_yaml, file, sort_keys=False) with open('kinematics.yaml', 'w') as file: - yaml.dump(kinematics_yaml, file, sort_keys=False) + yaml.dump(kinematics_yaml, file, sort_keys=False) with open('uncertainties.yaml', 'w') as file: yaml.dump(uncertainties_yaml, file, sort_keys=False) - # jet_norm data + # jet_norm data - hepdata_tables="rawdata/Table"+str(tables_norm[0])+".yaml" + hepdata_tables = "rawdata/Table" + str(tables_norm[0]) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -101,26 +111,42 @@ def processData(): Q2_min = input['independent_variables'][0]['values'][i]['low'] pT_max = input['independent_variables'][1]['values'][i]['high'] pT_min = input['independent_variables'][1]['values'][i]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max},'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin_norm.append(kin_value) error_value = {} - error_value['stat'] = pta(values[i]['errors'][0]['symerror'], data_central_value) - error_value['sys'] = pta(values[i]['errors'][1]['symerror'], data_central_value) + error_value['stat'] = percentage_to_absolute( + values[i]['errors'][0]['symerror'], data_central_value + ) + error_value['sys'] = percentage_to_absolute( + values[i]['errors'][1]['symerror'], data_central_value + ) error_norm.append(error_value) - error_definition_norm = {'stat':{'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, 'sys':{'description': 'total systematic uncertainty', 'treatment':'MULT' , 'type': 'CORR'}} + error_definition_norm = { + 'stat': { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'sys': {'description': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + } data_central_norm_yaml = {'data_central': data_central_norm} kinematics_norm_yaml = {'bins': kin_norm} uncertainties_norm_yaml = {'definitions': error_definition_norm, 'bins': error_norm} with open('data_norm.yaml', 'w') as file: - yaml.dump(data_central_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_norm_yaml, file, sort_keys=False) with open('kinematics_norm.yaml', 'w') as file: - yaml.dump(kinematics_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_norm_yaml, file, sort_keys=False) with open('uncertainties_norm.yaml', 'w') as file: yaml.dump(uncertainties_norm_yaml, file, sort_keys=False) -processData() \ No newline at end of file + +processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_351PB-1_DIF/manual_impl.py b/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_351PB-1_DIF/manual_impl.py index a0a0d280cd..aee379d2a1 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_351PB-1_DIF/manual_impl.py +++ b/nnpdf_data/nnpdf_data/new_commondata/H1_1JET_319GEV_351PB-1_DIF/manual_impl.py @@ -3,7 +3,7 @@ from math import sqrt from numpy.linalg import eig -def ctc(err_list, cormat_list): +def cormat_to_covmat(err_list, cormat_list): covmat_list = [] for i in range(len(cormat_list)): @@ -12,7 +12,7 @@ def ctc(err_list, cormat_list): covmat_list.append(cormat_list[i] * err_list[a] * err_list[b]) return covmat_list -def cta(ndata, covmat_list, no_of_norm_mat=0): +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): epsilon = -0.0000000001 neg_eval_count = 0 @@ -135,7 +135,7 @@ def stat_lists(): jet_sys = sys_breakdown(jet_old_impl_list, True) dijet_sys = sys_breakdown(dijet_old_impl_list, False) -covmat = ctc(jet_stat + dijet_stat, [a/100 for a in corMatArray]) +covmat = cormat_to_covmat(jet_stat + dijet_stat, [a/100 for a in corMatArray]) -artunc = cta(48, covmat, ) +artunc = covmat_to_artunc(48, covmat, ) diff --git a/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_290PB-1_DIF/artUnc.py b/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_290PB-1_DIF/artUnc.py index ebb4dcbc8f..706e17dd90 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_290PB-1_DIF/artUnc.py +++ b/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_290PB-1_DIF/artUnc.py @@ -1,21 +1,23 @@ -import yaml -import numpy as np - from math import sqrt + +import numpy as np from numpy.linalg import eig +import yaml + + +def percentage_to_absolute(percentage, value): -def pta(percentage, value): - if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute -def cta(ndata, covmat_list, no_of_norm_mat=0): - + +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): + epsilon = -0.0000000001 neg_eval_count = 0 psd_check = True @@ -43,9 +45,10 @@ def cta(ndata, covmat_list, no_of_norm_mat=0): if eigval[j] < 0: continue else: - artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) + artunc[i][j] = eigvec[i][j] * sqrt(eigval[j]) return artunc.tolist() + def artunc(): with open('rawdata/data49.yaml', 'r') as file: @@ -58,7 +61,7 @@ def artunc(): errPercArr = [] dataArr = [] for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]: - hepdata_tables="rawdata/data"+str(i)+".yaml" + hepdata_tables = "rawdata/data" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) values = input['dependent_variables'][0]['values'] @@ -67,17 +70,16 @@ def artunc(): errPercArr.append(errPerc) dataArr.append(float(values[j]['value'])) - errArr = [] for i in range(96): - errArr.append(pta(errPercArr[i], dataArr[i])) + errArr.append(percentage_to_absolute(errPercArr[i], dataArr[i])) covMat = np.zeros((96, 96)) artUnc = np.zeros((96, 96)) for i in range(96): - for j in range(i+1): - cmhap = (i * (i+1)) // 2 + j + for j in range(i + 1): + cmhap = (i * (i + 1)) // 2 + j if i == j: covMat[i][j] = corMatHalfArr[cmhap] * errArr[i] * errArr[j] else: @@ -88,12 +90,13 @@ def artunc(): for i in range(96): for j in range(96): covMatList.append(covMat[i][j]) - artUnc = cta(96, covMatList, 0) + artUnc = covmat_to_artunc(96, covMatList, 0) return artUnc + def artunc_norm(): - + with open('rawdata/data50.yaml', 'r') as file: corMatFile = yaml.safe_load(file) @@ -104,7 +107,7 @@ def artunc_norm(): errPercArr = [] dataArr = [] for i in [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]: - hepdata_tables="rawdata/data"+str(i)+".yaml" + hepdata_tables = "rawdata/data" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) values = input['dependent_variables'][0]['values'] @@ -115,14 +118,14 @@ def artunc_norm(): errArr = [] for i in range(96): - errArr.append(pta(errPercArr[i], dataArr[i])) + errArr.append(percentage_to_absolute(errPercArr[i], dataArr[i])) covMat = np.zeros((96, 96)) artUnc = np.zeros((96, 96)) for i in range(96): - for j in range(i+1): - cmhap = (i * (i+1)) // 2 + j + for j in range(i + 1): + cmhap = (i * (i + 1)) // 2 + j if i == j: covMat[i][j] = corMatHalfArr[cmhap] * errArr[i] * errArr[j] else: @@ -133,6 +136,6 @@ def artunc_norm(): for i in range(96): for j in range(96): covMatList.append(covMat[i][j]) - artUnc = cta(96, covMatList, 1) + artUnc = covmat_to_artunc(96, covMatList, 1) return artUnc diff --git a/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_290PB-1_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_290PB-1_DIF/filter.py index f02422ab0e..8b231f11b7 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_290PB-1_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_290PB-1_DIF/filter.py @@ -1,25 +1,29 @@ +from math import sqrt + import artUnc import yaml -from math import sqrt -def se(delta_plus, delta_minus): - - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 + +def symmetrize_errors(delta_plus, delta_minus): + + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma -def pta(percentage, value): - + +def percentage_to_absolute(percentage, value): + if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -37,7 +41,7 @@ def processData(): artUncMatr = artUnc.artunc() artUncMatr_norm = artUnc.artunc_norm() -# dijet data + # dijet data for i in tables: if i == 9: @@ -65,7 +69,7 @@ def processData(): Q2_min = 60 Q2_max = 80 - hepdata_tables="rawdata/data"+str(i)+".yaml" + hepdata_tables = "rawdata/data" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -76,53 +80,107 @@ def processData(): data_central_value = float(values[j]['value']) pT_max = input['independent_variables'][0]['values'][j]['high'] pT_min = input['independent_variables'][0]['values'][j]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max},'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin.append(kin_value) value_delta = 0 error_value = {} for k in 0, 1, 5, 6, 7, 8, 9, 10, 11: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']] = pta(values[j]['errors'][k]['symerror'], data_central_value) + error_value[values[j]['errors'][k]['label']] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ), + ) value_delta = value_delta + se_delta error_value[values[j]['errors'][k]['label']] = se_sigma for k in 2, 3, 4: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']+'_1'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) - error_value[values[j]['errors'][k]['label']+'_2'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_1'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_2'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value)/sqrt(2), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)/sqrt(2)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ) + / sqrt(2), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ) + / sqrt(2), + ) value_delta = value_delta + se_delta + se_delta - error_value[values[j]['errors'][k]['label']+'_1'] = se_sigma - error_value[values[j]['errors'][k]['label']+'_2'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_1'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_2'] = se_sigma data_central_value = data_central_value + value_delta data_central.append(data_central_value) for k in range(96): - error_value['ArtUnc_'+str(k+1)] = float(artUncMatr[j + 48][k]) + error_value['ArtUnc_' + str(k + 1)] = float(artUncMatr[j + 48][k]) error_value['stat'] = 0 error.append(error_value) error_definition = { - 'stat':{'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Uncorr':{'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Model_1':{'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Model_2':{'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ModelRW_1':{'description': 'reweighting uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'ModelRW_2':{'description': 'reweighting uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'JES_1':{'description': 'jet energy scale uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'JES_2':{'description': 'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'RCES':{'description': 'remaining cluster energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ElEn':{'description': 'electron energy uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ElTh':{'description': 'electron theta uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'Lumi':{'description': 'luminosity', 'treatment': 'MULT', 'type': 'CORR'}, - 'LArN':{'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, - 'StatMC':{'description': 'MC statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'RadErr':{'description': 'radiative uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Uncorr': {'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_1': {'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_2': {'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'ModelRW_1': { + 'description': 'reweighting uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'ModelRW_2': { + 'description': 'reweighting uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'JES_1': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'JES_2': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'RCES': { + 'description': 'remaining cluster energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'ElEn': {'description': 'electron energy uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'ElTh': {'description': 'electron theta uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'Lumi': {'description': 'luminosity', 'treatment': 'MULT', 'type': 'CORR'}, + 'LArN': {'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, + 'StatMC': { + 'description': 'MC statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'RadErr': {'description': 'radiative uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, } for i in range(96): - error_definition['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'H1JETS161103421unc'+str(i+1)} + error_definition['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'H1JETS161103421unc' + str(i + 1), + } data_central_yaml = {'data_central': data_central} kinematics_yaml = {'bins': kin} @@ -137,7 +195,7 @@ def processData(): with open('uncertainties.yaml', 'w') as file: yaml.dump(uncertainties_yaml, file, sort_keys=False) -# dijet_norm data + # dijet_norm data for i in tables_norm: if i == 33: @@ -165,7 +223,7 @@ def processData(): Q2_min = 60 Q2_max = 80 - hepdata_tables="rawdata/data"+str(i)+".yaml" + hepdata_tables = "rawdata/data" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -176,52 +234,106 @@ def processData(): data_central_value = float(values[j]['value']) pT_max = input['independent_variables'][0]['values'][j]['high'] pT_min = input['independent_variables'][0]['values'][j]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max},'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin_norm.append(kin_value) value_delta = 0 error_value = {} for k in 0, 1, 5, 6, 7, 8, 9, 10, 11: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']] = pta(values[j]['errors'][k]['symerror'], data_central_value) + error_value[values[j]['errors'][k]['label']] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ), + ) value_delta = value_delta + se_delta error_value[values[j]['errors'][k]['label']] = se_sigma for k in 2, 3, 4: if 'symerror' in values[j]['errors'][k]: - error_value[values[j]['errors'][k]['label']+'_1'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) - error_value[values[j]['errors'][k]['label']+'_2'] = pta(values[j]['errors'][k]['symerror'], data_central_value)/sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_1'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) + error_value[values[j]['errors'][k]['label'] + '_2'] = percentage_to_absolute( + values[j]['errors'][k]['symerror'], data_central_value + ) / sqrt(2) else: - se_delta, se_sigma = se(pta(values[j]['errors'][k]['asymerror']['plus'], data_central_value)/sqrt(2), pta(values[j]['errors'][k]['asymerror']['minus'], data_central_value)/sqrt(2)) + se_delta, se_sigma = symmetrize_errors( + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['plus'], data_central_value + ) + / sqrt(2), + percentage_to_absolute( + values[j]['errors'][k]['asymerror']['minus'], data_central_value + ) + / sqrt(2), + ) value_delta = value_delta + se_delta + se_delta - error_value[values[j]['errors'][k]['label']+'_1'] = se_sigma - error_value[values[j]['errors'][k]['label']+'_2'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_1'] = se_sigma + error_value[values[j]['errors'][k]['label'] + '_2'] = se_sigma data_central_value = data_central_value + value_delta data_central_norm.append(data_central_value) for k in range(96): - error_value['ArtUnc_'+str(k+1)] = float(artUncMatr_norm[j + 48][k]) + error_value['ArtUnc_' + str(k + 1)] = float(artUncMatr_norm[j + 48][k]) error_value['stat'] = 0 error_norm.append(error_value) error_definition_norm = { - 'stat':{'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Uncorr':{'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Model_1':{'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Model_2':{'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ModelRW_1':{'description': 'reweighting uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'ModelRW_2':{'description': 'reweighting uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'JES_1':{'description': 'jet energy scale uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'JES_2':{'description': 'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'RCES':{'description': 'remaining cluster energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ElEn':{'description': 'electron energy uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'ElTh':{'description': 'electron theta uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, - 'Lumi':{'description': 'luminosity', 'treatment': 'MULT', 'type': 'CORR'}, - 'LArN':{'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, - 'StatMC':{'description': 'MC statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'RadErr':{'description': 'radiative uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'} + 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Uncorr': {'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_1': {'description': 'MC model uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Model_2': {'description': 'MC model uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'ModelRW_1': { + 'description': 'reweighting uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'ModelRW_2': { + 'description': 'reweighting uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'JES_1': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'JES_2': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'RCES': { + 'description': 'remaining cluster energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, + 'ElEn': {'description': 'electron energy uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'ElTh': {'description': 'electron theta uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + 'Lumi': {'description': 'luminosity', 'treatment': 'MULT', 'type': 'CORR'}, + 'LArN': {'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, + 'StatMC': { + 'description': 'MC statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'RadErr': {'description': 'radiative uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, } for i in range(96): - error_definition_norm['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty '+str(i+1), 'treatment': 'ADD', 'type': 'H1JETS161103421NORMunc'+str(i+1)} + error_definition_norm['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'H1JETS161103421NORMunc' + str(i + 1), + } data_central_norm_yaml = {'data_central': data_central_norm} kinematics_norm_yaml = {'bins': kin_norm} @@ -236,4 +348,5 @@ def processData(): with open('uncertainties_norm.yaml', 'w') as file: yaml.dump(uncertainties_norm_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_351PB-1_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_351PB-1_DIF/filter.py index ab835eae19..cf6210f643 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_351PB-1_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_351PB-1_DIF/filter.py @@ -1,16 +1,18 @@ +from manual_impl import artunc, dijet_data, dijet_sys import yaml -from manual_impl import dijet_data, dijet_sys, artunc -def pta(percentage, value): - + +def percentage_to_absolute(percentage, value): + if type(percentage) is str: percentage = float(percentage.replace("%", "")) absolute = percentage * value * 0.01 - return absolute + return absolute else: absolute = percentage * value * 0.01 return absolute + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -28,9 +30,9 @@ def processData(): kin_norm = [] error_norm = [] -# dijet data + # dijet data - hepdata_tables="rawdata/Table"+str(tables[0])+".yaml" + hepdata_tables = "rawdata/Table" + str(tables[0]) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -45,48 +47,57 @@ def processData(): Q2_min = input['independent_variables'][0]['values'][i]['low'] pT_max = input['independent_variables'][1]['values'][i]['high'] pT_min = input['independent_variables'][1]['values'][i]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin.append(kin_value) error_value = {} - # error_value['stat'] = pta(values[i]['errors'][0]['symerror'], data_central_value) - # error_value['sys'] = pta(values[i]['errors'][1]['symerror'], data_central_value) + # error_value['stat'] = percentage_to_absolute(values[i]['errors'][0]['symerror'], data_central_value) + # error_value['sys'] = percentage_to_absolute(values[i]['errors'][1]['symerror'], data_central_value) for j in range(len(dijet_sys[i])): - error_value['Syst_'+str(j+1)] = dijet_sys[i][j] - for j in range(len(artunc[i+24])): - error_value['ArtUnc_'+str(j+1)] = artunc[i+24][j] + error_value['Syst_' + str(j + 1)] = dijet_sys[i][j] + for j in range(len(artunc[i + 24])): + error_value['ArtUnc_' + str(j + 1)] = artunc[i + 24][j] error.append(error_value) # error_definition = {'stat':{'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, 'sys':{'description': 'total systematic uncertainty', 'treatment':'MULT' , 'type': 'CORR'}} - error_definition = {'Syst_1':{'description': 'model', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_2':{'description': 'jes', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_3':{'description': 'jes', 'treatment': 'MULT', 'type': 'CORR'}, - 'Syst_4':{'description': 'rces', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_5':{'description': 'rces', 'treatment': 'MULT', 'type': 'CORR'}, - 'Syst_6':{'description': 'e_e', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_7':{'description': 'theta_e', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_8':{'description': 'ID_e', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'Syst_9':{'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, - 'Syst_10':{'description': 'norm', 'treatment': 'MULT', 'type': 'CORR'}} + error_definition = { + 'Syst_1': {'description': 'model', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_2': {'description': 'jes', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_3': {'description': 'jes', 'treatment': 'MULT', 'type': 'CORR'}, + 'Syst_4': {'description': 'rces', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_5': {'description': 'rces', 'treatment': 'MULT', 'type': 'CORR'}, + 'Syst_6': {'description': 'e_e', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_7': {'description': 'theta_e', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_8': {'description': 'ID_e', 'treatment': 'ADD', 'type': 'UNCORR'}, + 'Syst_9': {'description': 'lar noise', 'treatment': 'MULT', 'type': 'CORR'}, + 'Syst_10': {'description': 'norm', 'treatment': 'MULT', 'type': 'CORR'}, + } for i in range(48): - error_definition['ArtUnc_'+str(i+1)] = {'description': 'artificial uncertainty ' + str(i+1), 'treatment': 'ADD', 'type': 'H1JETS14064709unc'+str(i+1)} - + error_definition['ArtUnc_' + str(i + 1)] = { + 'description': 'artificial uncertainty ' + str(i + 1), + 'treatment': 'ADD', + 'type': 'H1JETS14064709unc' + str(i + 1), + } data_central_yaml = {'data_central': data_central} kinematics_yaml = {'bins': kin} uncertainties_yaml = {'definitions': error_definition, 'bins': error} with open('data.yaml', 'w') as file: - yaml.dump(data_central_yaml, file, sort_keys=False) + yaml.dump(data_central_yaml, file, sort_keys=False) with open('kinematics.yaml', 'w') as file: - yaml.dump(kinematics_yaml, file, sort_keys=False) + yaml.dump(kinematics_yaml, file, sort_keys=False) with open('uncertainties.yaml', 'w') as file: yaml.dump(uncertainties_yaml, file, sort_keys=False) -# dijet_norm data + # dijet_norm data - hepdata_tables="rawdata/Table"+str(tables_norm[0])+".yaml" + hepdata_tables = "rawdata/Table" + str(tables_norm[0]) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -100,26 +111,42 @@ def processData(): Q2_min = input['independent_variables'][0]['values'][i]['low'] pT_max = input['independent_variables'][1]['values'][i]['high'] pT_min = input['independent_variables'][1]['values'][i]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'pT': {'min': pT_min, 'mid': None, 'max': pT_max}, + } kin_norm.append(kin_value) error_value = {} - error_value['stat'] = pta(values[i]['errors'][0]['symerror'], data_central_value) - error_value['sys'] = pta(values[i]['errors'][1]['symerror'], data_central_value) + error_value['stat'] = percentage_to_absolute( + values[i]['errors'][0]['symerror'], data_central_value + ) + error_value['sys'] = percentage_to_absolute( + values[i]['errors'][1]['symerror'], data_central_value + ) error_norm.append(error_value) - error_definition_norm = {'stat':{'description': 'total statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, 'sys':{'description': 'total systematic uncertainty', 'treatment':'MULT' , 'type': 'CORR'}} + error_definition_norm = { + 'stat': { + 'description': 'total statistical uncertainty', + 'treatment': 'ADD', + 'type': 'UNCORR', + }, + 'sys': {'description': 'total systematic uncertainty', 'treatment': 'MULT', 'type': 'CORR'}, + } data_central_norm_yaml = {'data_central': data_central_norm} kinematics_norm_yaml = {'bins': kin_norm} uncertainties_norm_yaml = {'definitions': error_definition_norm, 'bins': error_norm} with open('data_norm.yaml', 'w') as file: - yaml.dump(data_central_norm_yaml, file, sort_keys=False) + yaml.dump(data_central_norm_yaml, file, sort_keys=False) with open('kinematics_norm.yaml', 'w') as file: - yaml.dump(kinematics_norm_yaml, file, sort_keys=False) + yaml.dump(kinematics_norm_yaml, file, sort_keys=False) with open('uncertainties_norm.yaml', 'w') as file: yaml.dump(uncertainties_norm_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_351PB-1_DIF/manual_impl.py b/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_351PB-1_DIF/manual_impl.py index a0a0d280cd..4bb958d5da 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_351PB-1_DIF/manual_impl.py +++ b/nnpdf_data/nnpdf_data/new_commondata/H1_2JET_319GEV_351PB-1_DIF/manual_impl.py @@ -1,9 +1,10 @@ -import numpy as np - from math import sqrt + +import numpy as np from numpy.linalg import eig -def ctc(err_list, cormat_list): + +def cormat_to_covmat(err_list, cormat_list): covmat_list = [] for i in range(len(cormat_list)): @@ -12,7 +13,7 @@ def ctc(err_list, cormat_list): covmat_list.append(cormat_list[i] * err_list[a] * err_list[b]) return covmat_list -def cta(ndata, covmat_list, no_of_norm_mat=0): +def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0): epsilon = -0.0000000001 neg_eval_count = 0 @@ -135,7 +136,7 @@ def stat_lists(): jet_sys = sys_breakdown(jet_old_impl_list, True) dijet_sys = sys_breakdown(dijet_old_impl_list, False) -covmat = ctc(jet_stat + dijet_stat, [a/100 for a in corMatArray]) +covmat = cormat_to_covmat(jet_stat + dijet_stat, [a/100 for a in corMatArray]) -artunc = cta(48, covmat, ) +artunc = covmat_to_artunc(48, covmat, ) diff --git a/nnpdf_data/nnpdf_data/new_commondata/ZEUS_1JET_300GEV_38P6PB-1_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/ZEUS_1JET_300GEV_38P6PB-1_DIF/filter.py index ce482d047e..a4a25e1b9e 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ZEUS_1JET_300GEV_38P6PB-1_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ZEUS_1JET_300GEV_38P6PB-1_DIF/filter.py @@ -1,7 +1,9 @@ -import yaml from math import sqrt -def se(delta_plus, delta_minus): +import yaml + + +def symmetrize_errors(delta_plus, delta_minus): r"""Compute the symmterized uncertainty and the shift in data point. Parameters @@ -10,7 +12,7 @@ def se(delta_plus, delta_minus): The top/plus uncertainty with sign delta_minus : float The bottom/minus uncertainty with sign - + Returns ------- se_delta : float @@ -19,12 +21,13 @@ def se(delta_plus, delta_minus): The symmetrized uncertainty to be used in commondata """ - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -35,11 +38,11 @@ def processData(): kin_q2_et = [] error_q2_et = [] -# q2_et data + # q2_et data for i in tables_q2_et: - hepdata_tables="rawdata/Table"+str(i)+".yaml" + hepdata_tables = "rawdata/Table" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -73,26 +76,39 @@ def processData(): data_central_value = values[k]['value'] ET_max = input['independent_variables'][0]['values'][k]['high'] ET_min = input['independent_variables'][0]['values'][k]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, 'ET': {'min': ET_min, 'mid': None, 'max': ET_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'ET': {'min': ET_min, 'mid': None, 'max': ET_max}, + } kin_q2_et.append(kin_value) value_delta = 0 error_value = {} if 'symerror' in values[k]['errors'][0]: error_value['stat'] = values[k]['errors'][0]['symerror'] else: - se_delta, se_sigma = se(values[k]['errors'][0]['asymerror']['plus'], values[k]['errors'][0]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[k]['errors'][0]['asymerror']['plus'], + values[k]['errors'][0]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['stat'] = se_sigma if 'symerror' in values[k]['errors'][1]: error_value['sys'] = values[k]['errors'][1]['symerror'] else: - se_delta, se_sigma = se(values[k]['errors'][1]['asymerror']['plus'], values[k]['errors'][1]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[k]['errors'][1]['asymerror']['plus'], + values[k]['errors'][1]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['sys'] = se_sigma if 'symerror' in values[k]['errors'][2]: error_value['jet_es'] = values[k]['errors'][2]['symerror'] else: - se_delta, se_sigma = se(values[k]['errors'][2]['asymerror']['plus'], values[k]['errors'][2]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[k]['errors'][2]['asymerror']['plus'], + values[k]['errors'][2]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['jet_es'] = se_sigma data_central_value = data_central_value + value_delta @@ -102,7 +118,11 @@ def processData(): error_definition_q2_et = { 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, 'sys': {'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'jet_es': {'description': 'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + 'jet_es': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, } data_central_q2_et_yaml = {'data_central': data_central_q2_et} @@ -118,4 +138,5 @@ def processData(): with open('uncertainties_q2_et.yaml', 'w') as file: yaml.dump(uncertainties_q2_et_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/ZEUS_1JET_319GEV_82PB-1_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/ZEUS_1JET_319GEV_82PB-1_DIF/filter.py index c292084054..d791f9ae38 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ZEUS_1JET_319GEV_82PB-1_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ZEUS_1JET_319GEV_82PB-1_DIF/filter.py @@ -1,7 +1,9 @@ -import yaml from math import sqrt -def se(delta_plus, delta_minus): +import yaml + + +def symmetrize_errors(delta_plus, delta_minus): r"""Compute the symmterized uncertainty and the shift in data point. Parameters @@ -10,7 +12,7 @@ def se(delta_plus, delta_minus): The top/plus uncertainty with sign delta_minus : float The bottom/minus uncertainty with sign - + Returns ------- se_delta : float @@ -19,10 +21,10 @@ def se(delta_plus, delta_minus): The symmetrized uncertainty to be used in commondata """ - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma @@ -36,7 +38,7 @@ def processData(): kin_q2_et = [] error_q2_et = [] -# q2_et data + # q2_et data for i in tables_q2_et: if i == 12: @@ -58,7 +60,7 @@ def processData(): Q2_min = 5000 Q2_max = 10000 - hepdata_tables="rawdata/Table"+str(i)+".yaml" + hepdata_tables = "rawdata/Table" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -69,26 +71,39 @@ def processData(): data_central_value = values[j]['value'] ET_max = input['independent_variables'][0]['values'][j]['high'] ET_min = input['independent_variables'][0]['values'][j]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, 'ET': {'min': ET_min, 'mid': None, 'max': ET_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'ET': {'min': ET_min, 'mid': None, 'max': ET_max}, + } kin_q2_et.append(kin_value) value_delta = 0 error_value = {} if 'symerror' in values[j]['errors'][0]: error_value['stat'] = values[j]['errors'][0]['symerror'] else: - se_delta, se_sigma = se(values[j]['errors'][0]['asymerror']['plus'], values[j]['errors'][0]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][0]['asymerror']['plus'], + values[j]['errors'][0]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['stat'] = se_sigma if 'symerror' in values[j]['errors'][1]: error_value['sys'] = values[j]['errors'][1]['symerror'] else: - se_delta, se_sigma = se(values[j]['errors'][1]['asymerror']['plus'], values[j]['errors'][1]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][1]['asymerror']['plus'], + values[j]['errors'][1]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['sys'] = se_sigma if 'symerror' in values[j]['errors'][2]: error_value['jet_es'] = values[j]['errors'][2]['symerror'] else: - se_delta, se_sigma = se(values[j]['errors'][2]['asymerror']['plus'], values[j]['errors'][2]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][2]['asymerror']['plus'], + values[j]['errors'][2]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['jet_es'] = se_sigma data_central_value = data_central_value + value_delta @@ -98,7 +113,11 @@ def processData(): error_definition_q2_et = { 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, 'sys': {'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'jet_es': {'description': 'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + 'jet_es': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, } data_central_q2_et_yaml = {'data_central': data_central_q2_et} @@ -114,4 +133,5 @@ def processData(): with open('uncertainties_q2_et.yaml', 'w') as file: yaml.dump(uncertainties_q2_et_yaml, file, sort_keys=False) + processData() diff --git a/nnpdf_data/nnpdf_data/new_commondata/ZEUS_2JET_319GEV_374PB-1_DIF/filter.py b/nnpdf_data/nnpdf_data/new_commondata/ZEUS_2JET_319GEV_374PB-1_DIF/filter.py index dcbd5cbc91..e562d26090 100644 --- a/nnpdf_data/nnpdf_data/new_commondata/ZEUS_2JET_319GEV_374PB-1_DIF/filter.py +++ b/nnpdf_data/nnpdf_data/new_commondata/ZEUS_2JET_319GEV_374PB-1_DIF/filter.py @@ -1,7 +1,9 @@ -import yaml from math import sqrt -def se(delta_plus, delta_minus): +import yaml + + +def symmetrize_errors(delta_plus, delta_minus): r"""Compute the symmterized uncertainty and the shift in data point. Parameters @@ -10,7 +12,7 @@ def se(delta_plus, delta_minus): The top/plus uncertainty with sign delta_minus : float The bottom/minus uncertainty with sign - + Returns ------- se_delta : float @@ -19,12 +21,13 @@ def se(delta_plus, delta_minus): The symmetrized uncertainty to be used in commondata """ - semi_diff = (delta_plus + delta_minus)/2 - average = (delta_plus - delta_minus)/2 + semi_diff = (delta_plus + delta_minus) / 2 + average = (delta_plus - delta_minus) / 2 se_delta = semi_diff - se_sigma = sqrt(average*average + 2*semi_diff*semi_diff) + se_sigma = sqrt(average * average + 2 * semi_diff * semi_diff) return se_delta, se_sigma + def processData(): with open('metadata.yaml', 'r') as file: metadata = yaml.safe_load(file) @@ -35,7 +38,7 @@ def processData(): kin_q2_et = [] error_q2_et = [] -# q2_et data + # q2_et data for i in tables_q2_et: if i == 13: @@ -57,7 +60,7 @@ def processData(): Q2_min = 5000 Q2_max = 20000 - hepdata_tables="rawdata/Table"+str(i)+".yaml" + hepdata_tables = "rawdata/Table" + str(i) + ".yaml" with open(hepdata_tables, 'r') as file: input = yaml.safe_load(file) @@ -68,26 +71,39 @@ def processData(): data_central_value = values[j]['value'] ET_max = input['independent_variables'][0]['values'][j]['high'] ET_min = input['independent_variables'][0]['values'][j]['low'] - kin_value = {'sqrts': {'min': None, 'mid': sqrts, 'max': None}, 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, 'ET': {'min': ET_min, 'mid': None, 'max': ET_max}} + kin_value = { + 'sqrts': {'min': None, 'mid': sqrts, 'max': None}, + 'Q2': {'min': Q2_min, 'mid': None, 'max': Q2_max}, + 'ET': {'min': ET_min, 'mid': None, 'max': ET_max}, + } kin_q2_et.append(kin_value) value_delta = 0 error_value = {} if 'symerror' in values[j]['errors'][0]: error_value['stat'] = values[j]['errors'][0]['symerror'] else: - se_delta, se_sigma = se(values[j]['errors'][0]['asymerror']['plus'], values[j]['errors'][0]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][0]['asymerror']['plus'], + values[j]['errors'][0]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['stat'] = se_sigma if 'symerror' in values[j]['errors'][1]: error_value['sys'] = values[j]['errors'][1]['symerror'] else: - se_delta, se_sigma = se(values[j]['errors'][1]['asymerror']['plus'], values[j]['errors'][1]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][1]['asymerror']['plus'], + values[j]['errors'][1]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['sys'] = se_sigma if 'symerror' in values[j]['errors'][2]: error_value['jet_es'] = values[j]['errors'][2]['symerror'] else: - se_delta, se_sigma = se(values[j]['errors'][2]['asymerror']['plus'], values[j]['errors'][2]['asymerror']['minus']) + se_delta, se_sigma = symmetrize_errors( + values[j]['errors'][2]['asymerror']['plus'], + values[j]['errors'][2]['asymerror']['minus'], + ) value_delta = value_delta + se_delta error_value['jet_es'] = se_sigma data_central_value = data_central_value + value_delta @@ -97,7 +113,11 @@ def processData(): error_definition_q2_et = { 'stat': {'description': 'statistical uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, 'sys': {'description': 'systematic uncertainty', 'treatment': 'ADD', 'type': 'UNCORR'}, - 'jet_es': {'description': 'jet energy scale uncertainty', 'treatment': 'MULT', 'type': 'CORR'} + 'jet_es': { + 'description': 'jet energy scale uncertainty', + 'treatment': 'MULT', + 'type': 'CORR', + }, } data_central_q2_et_yaml = {'data_central': data_central_q2_et} @@ -113,4 +133,5 @@ def processData(): with open('uncertainties_q2_et.yaml', 'w') as file: yaml.dump(uncertainties_q2_et_yaml, file, sort_keys=False) + processData()