示例#1
0
    def fill_nsubjettiness(self, jet, jetR, R_max=None, label=''):

        # Compute N-subjettiness
        axis_definition = fjcontrib.KT_Axes()
        for i, N in enumerate(self.N_list):
            beta = self.beta_list[i]

            measure_definition = fjcontrib.UnnormalizedMeasure(beta)
            n_subjettiness_calculator = fjcontrib.Nsubjettiness(
                N, axis_definition, measure_definition)
            n_subjettiness = n_subjettiness_calculator.result(jet) / jet.pt()
            self.jet_variables[label][f'R{jetR}'][f'Rmax{R_max}'][
                f'n_subjettiness_N{N}_beta{beta}'].append(n_subjettiness)
示例#2
0
    def analyze_event(self, fj_particles):
        
        # Cluster each jet with R=infinity
        jetR = fj.JetDefinition.max_allowable_R
        jet_def = fj.JetDefinition(fj.antikt_algorithm, jetR)
        cs = fj.ClusterSequence(fj_particles, jet_def)
        jet = fj.sorted_by_pt(cs.inclusive_jets())[0]

        # Compute N-subjetiness
        axis_definition = fjcontrib.KT_Axes()
        for i,N in enumerate(self.N_list):
            beta = self.beta_list[i]
        
            measure_definition = fjcontrib.UnnormalizedMeasure(beta)
            n_subjettiness_calculator = fjcontrib.Nsubjettiness(N, axis_definition, measure_definition)
            n_subjettiness = n_subjettiness_calculator.result(jet)/jet.pt()
            self.jet_variables['n_subjettiness_N{}_beta{}'.format(N, beta)].append(n_subjettiness)
    def fill_semi_inclusive_chjet_histograms(self, jets_selected, fj_hadrons_positive_charged, fj_hadrons_negative_charged, jetR):

        if self.sqrts == 2760:
        
            # Define trigger classes for both traditional h-jet analysis and Nsubjettiness analysis
            hjet_low_trigger_range = self.semi_inclusive_chjet_observables['IAA_alice']['low_trigger_range']
            hjet_high_trigger_range = self.semi_inclusive_chjet_observables['IAA_alice']['high_trigger_range']
            nsubjettiness_low_trigger_range = self.semi_inclusive_chjet_observables['nsubjettiness_alice']['low_trigger_range']
            nsubjettiness_high_trigger_range = self.semi_inclusive_chjet_observables['nsubjettiness_alice']['high_trigger_range']
            
            pt_IAA = self.semi_inclusive_chjet_observables['IAA_alice']['pt_ch']
            pt_dphi = self.semi_inclusive_chjet_observables['dphi_alice']['pt_ch']
            pt_nsubjettiness = self.semi_inclusive_chjet_observables['nsubjettiness_alice']['pt_ch']
            
            # Define Nsubjettiness calculators
            axis_definition = fjcontrib.KT_Axes()
            measure_definition = fjcontrib.UnnormalizedMeasure(1)
            n_subjettiness_calculator1 = fjcontrib.Nsubjettiness(1, axis_definition, measure_definition)
            n_subjettiness_calculator2 = fjcontrib.Nsubjettiness(2, axis_definition, measure_definition)

            for hadron in fj_hadrons_positive_charged:
            
                if abs(hadron.eta()) < self.semi_inclusive_chjet_observables['IAA_alice']['hadron_eta_cut']:

                    # Search for hadron trigger
                    hjet_found_low = False
                    hjet_found_high = False
                    nsubjettiness_found_low = False
                    nsubjettiness_found_high = False

                    if hjet_low_trigger_range[0] < hadron.pt() < hjet_low_trigger_range[1]:
                        hjet_found_low = True
                    if hjet_high_trigger_range[0] < hadron.pt() < hjet_high_trigger_range[1]:
                        hjet_found_high = True
                    if nsubjettiness_low_trigger_range[0] < hadron.pt() < nsubjettiness_low_trigger_range[1]:
                        nsubjettiness_found_low = True
                    if nsubjettiness_high_trigger_range[0] < hadron.pt() < nsubjettiness_high_trigger_range[1]:
                        nsubjettiness_found_high = True
                    found_trigger =  hjet_found_low or hjet_found_high or nsubjettiness_found_low or nsubjettiness_found_high
            
                    if found_trigger:
                    
                        # Record hadron pt for trigger normalization
                        if jetR == min(self.semi_inclusive_chjet_observables['IAA_alice']['jet_R']):
                            self.observable_dict_event[f'semi_inclusive_chjet_alice_trigger_pt'].append(hadron.pt())
                    
                        # Search for recoil jets
                        for jet in jets_selected:
                            if abs(jet.eta()) < (self.semi_inclusive_chjet_observables['IAA_alice']['eta_cut_R'] - jetR):
                                            
                                # Get the corrected jet pt: shower+recoil-holes
                                jet_pt = jet.pt()
                                for temp_hadron in fj_hadrons_negative_charged:
                                    if jet.delta_R(temp_hadron) < jetR:
                                        jet_pt -= temp_hadron.pt()

                                # Jet yield and Delta phi
                                if jetR in self.semi_inclusive_chjet_observables['IAA_alice']['jet_R']:
                                    if hjet_found_low:
                                        if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                            if pt_IAA[0] < jet_pt < pt_IAA[1]:
                                                self.observable_dict_event[f'semi_inclusive_chjet_IAA_alice_R{jetR}_lowTrigger'].append(jet_pt)

                                        if pt_dphi[0] < jet_pt < pt_dphi[1]:
                                            self.observable_dict_event[f'semi_inclusive_chjet_dphi_alice_R{jetR}_lowTrigger'].append(np.abs(hadron.delta_phi_to(jet)))
                                            
                                    if hjet_found_high:
                                        if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                            if pt_IAA[0] < jet_pt < pt_IAA[1]:
                                                self.observable_dict_event[f'semi_inclusive_chjet_IAA_alice_R{jetR}_highTrigger'].append(jet_pt)

                                        if pt_dphi[0] < jet_pt < pt_dphi[1]:
                                            self.observable_dict_event[f'semi_inclusive_chjet_dphi_alice_R{jetR}_highTrigger'].append(np.abs(hadron.delta_phi_to(jet)))

                                # Nsubjettiness
                                if jetR in self.semi_inclusive_chjet_observables['nsubjettiness_alice']['jet_R']:
                                    if nsubjettiness_found_low:
                                        if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                            if pt_nsubjettiness[0] < jet_pt < pt_nsubjettiness[1]:
                                                tau1 = n_subjettiness_calculator1.result(jet)/jet.pt()
                                                tau2 = n_subjettiness_calculator2.result(jet)/jet.pt()
                                                if tau1 > 1e-3:
                                                    self.observable_dict_event[f'semi_inclusive_chjet_nsubjettiness_alice_R{jetR}_lowTrigger'].append(tau2/tau1)
                                                    
                                    if nsubjettiness_found_high:
                                        if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                            if pt_nsubjettiness[0] < jet_pt < pt_nsubjettiness[1]:
                                                tau1 = n_subjettiness_calculator1.result(jet)/jet.pt()
                                                tau2 = n_subjettiness_calculator2.result(jet)/jet.pt()
                                                if tau1 > 1e-3:
                                                    self.observable_dict_event[f'semi_inclusive_chjet_nsubjettiness_alice_R{jetR}_highTrigger'].append(tau2/tau1)

        if self.sqrts == 200:
        
            hjet_trigger_range = self.semi_inclusive_chjet_observables['IAA_star']['trigger_range']
            pt_IAA = self.semi_inclusive_chjet_observables['IAA_star']['pt_ch']
            pt_dphi = self.semi_inclusive_chjet_observables['dphi_star']['pt_ch']
            
            for hadron in fj_hadrons_positive_charged:
            
                if abs(hadron.eta()) < self.semi_inclusive_chjet_observables['IAA_star']['hadron_eta_cut']:

                    # Search for hadron trigger
                    found_trigger = False
                    if hjet_trigger_range[0] < hadron.pt() < hjet_trigger_range[1]:
                        found_trigger = True
            
                    if found_trigger:
                    
                        # Record hadron pt for trigger normalization
                        if jetR == min(self.semi_inclusive_chjet_observables['IAA_star']['jet_R']):
                            self.observable_dict_event[f'semi_inclusive_chjet_star_trigger_pt'].append(hadron.pt())
                    
                        # Search for recoil jets
                        for jet in jets_selected:
                            if abs(jet.eta()) < (self.semi_inclusive_chjet_observables['IAA_star']['eta_cut_R'] - jetR):
                                            
                                # Get the corrected jet pt: shower+recoil-holes
                                jet_pt = jet.pt()
                                for temp_hadron in fj_hadrons_negative_charged:
                                    if jet.delta_R(temp_hadron) < jetR:
                                        jet_pt -= temp_hadron.pt()

                                # Jet yield and Delta phi
                                if jetR in self.semi_inclusive_chjet_observables['IAA_star']['jet_R']:

                                        if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                            if pt_IAA[0] < jet_pt < pt_IAA[1]:
                                                self.observable_dict_event[f'semi_inclusive_chjet_IAA_star_R{jetR}'].append(jet_pt)

                                        if pt_dphi[0] < jet_pt < pt_dphi[1]:
                                            self.observable_dict_event[f'semi_inclusive_chjet_dphi_star_R{jetR}'].append(np.abs(hadron.delta_phi_to(jet)))
    def fill_semi_inclusive_chjet_histograms(self, jets_selected, fj_hadrons_positive_charged,
                                             fj_hadrons_negative_charged, jetR, constituent_threshold):

        # Define trigger classes for both traditional h-jet analysis and Nsubjettiness analysis
        hjet_low_trigger_range_276 = self.semi_inclusive_chjet_observables['hjet_alice']['low_trigger_range_276']
        hjet_low_trigger_range_502 = self.semi_inclusive_chjet_observables['hjet_alice']['low_trigger_range_502']
        hjet_high_trigger_range = self.semi_inclusive_chjet_observables['hjet_alice']['high_trigger_range']
        nsubjettiness_low_trigger_range = self.semi_inclusive_chjet_observables['nsubjettiness_alice']['low_trigger_range']
        nsubjettiness_high_trigger_range = self.semi_inclusive_chjet_observables['nsubjettiness_alice']['high_trigger_range']
        
        # Define Nsubjettiness calculators
        axis_definition = fjcontrib.KT_Axes()
        measure_definition = fjcontrib.UnnormalizedMeasure(1)
        n_subjettiness_calculator1 = fjcontrib.Nsubjettiness(1, axis_definition, measure_definition)
        n_subjettiness_calculator2 = fjcontrib.Nsubjettiness(2, axis_definition, measure_definition)

        for hadron in fj_hadrons_positive_charged:
        
            if abs(hadron.eta()) < self.semi_inclusive_chjet_observables['hjet_alice']['hadron_eta_cut']:

                # Search for hadron trigger
                hjet_found_low_276 = False
                hjet_found_low_502 = False
                hjet_found_high = False
                nsubjettiness_found_low = False
                nsubjettiness_found_high = False

                if hjet_low_trigger_range_276[0] < hadron.pt() < hjet_low_trigger_range_276[1]:
                    hjet_found_low_276 = True
                if hjet_low_trigger_range_502[0] < hadron.pt() < hjet_low_trigger_range_502[1]:
                    hjet_found_low_502 = True
                if hjet_high_trigger_range[0] < hadron.pt() < hjet_high_trigger_range[1]:
                    hjet_found_high = True
                if nsubjettiness_low_trigger_range[0] < hadron.pt() < nsubjettiness_low_trigger_range[1]:
                    nsubjettiness_found_low = True
                if nsubjettiness_high_trigger_range[0] < hadron.pt() < nsubjettiness_high_trigger_range[1]:
                    nsubjettiness_found_high = True
                found_trigger =  hjet_found_low_276 or hjet_found_low_502 or hjet_found_high or nsubjettiness_found_low or nsubjettiness_found_high

                # Record N triggers
                getattr(self, f'h_semi_inclusive_chjet_hjet_ntrigger_alice_R{jetR}_pt{constituent_threshold}').Fill(hadron.pt())
                getattr(self, f'h_semi_inclusive_chjet_nsubjettiness_ntrigger_alice_R{jetR}_pt{constituent_threshold}').Fill(hadron.pt())
                
                # Search for recoil jets
                if found_trigger:
                    for jet in jets_selected:
                        if abs(jet.eta()) < (self.inclusive_chjet_observables['eta_cut_alice_R'] - jetR):
                                        
                            # Get the corrected jet pt: shower+recoil-holes
                            jet_pt = jet.pt()
                            for temp_hadron in fj_hadrons_negative_charged:
                                if jet.delta_R(temp_hadron) < jetR:
                                    jet_pt -= temp_hadron.pt()

                            # Jet yield and Delta phi
                            if hjet_found_low_276:
                                if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                    getattr(self, f'h_semi_inclusive_chjet_IAA_lowTrigger_alice_R{jetR}_276_pt{constituent_threshold}').Fill(jet_pt)

                                if 40 < jet_pt < 60:
                                    getattr(self, f'h_semi_inclusive_chjet_dphi_lowTrigger_alice_R{jetR}_276_pt{constituent_threshold}').Fill(np.abs(hadron.delta_phi_to(jet)))

                            if hjet_found_low_502:
                                getattr(self, f'h_semi_inclusive_chjet_IAA_dphi_lowTrigger_alice_R{jetR}_502_pt{constituent_threshold}').Fill(jet_pt, np.abs(hadron.delta_phi_to(jet)))
                                    
                            if hjet_found_high:
                                if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                    getattr(self, f'h_semi_inclusive_chjet_IAA_highTrigger_alice_R{jetR}_276_pt{constituent_threshold}').Fill(jet_pt)

                                if 40 < jet_pt < 60:
                                    getattr(self, f'h_semi_inclusive_chjet_dphi_highTrigger_alice_R{jetR}_276_pt{constituent_threshold}').Fill(np.abs(hadron.delta_phi_to(jet)))

                                getattr(self, f'h_semi_inclusive_chjet_IAA_dphi_highTrigger_alice_R{jetR}_502_pt{constituent_threshold}').Fill(jet_pt, np.abs(hadron.delta_phi_to(jet)))

                            # Nsubjettiness
                            # We use the jet pt including recoils here, since the Nsubjettiness is calculated
                            # including recoils (but without hole subtraction).
                            # Not ideal but not sure of an immediate better solution.
                            if nsubjettiness_found_low:
                                if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                    if 40 < jet_pt < 60:
                                        tau1 = n_subjettiness_calculator1.result(jet)/jet.pt()
                                        tau2 = n_subjettiness_calculator2.result(jet)/jet.pt()
                                        if tau1 > 1e-3:
                                            getattr(self, f'h_semi_inclusive_chjet_nsubjettiness_lowTrigger_alice_R{jetR}_pt{constituent_threshold}').Fill(tau2/tau1)

                            if nsubjettiness_found_high:
                                if np.abs(jet.delta_phi_to(hadron)) > (np.pi - 0.6):
                                    if 40 < jet_pt < 60:
                                        tau1 = n_subjettiness_calculator1.result(jet)/jet.pt()
                                        tau2 = n_subjettiness_calculator2.result(jet)/jet.pt()
                                        if tau1 > 1e-3:
                                            getattr(self, f'h_semi_inclusive_chjet_nsubjettiness_highTrigger_alice_R{jetR}_pt{constituent_threshold}').Fill(tau2/tau1)