signal loss in mult processer

Author: Luigi Dello Stritto

machine_learning_hep/analysis/analyzerdhadrons_mult.py

@@ -51,6 +51,7 @@ def __init__(self, datap, case, typean, period):
         self.p_nptbins = len(self.lpt_finbinmin)
         self.lpt_probcutfin = datap["mlapplication"]["probcutoptimal"]
 
+        self.signal_loss = datap["analysis"][self.typean].get("signal_loss", "")
         self.lvar2_binmin = datap["analysis"][self.typean]["sel_binmin2"]
         self.lvar2_binmax = datap["analysis"][self.typean]["sel_binmax2"]
         self.v_var2_binning = datap["analysis"][self.typean]["var_binning2"]
@@ -421,35 +422,90 @@ def efficiency(self):
         cEff.SetWindowSize(500, 500)
         cEff.SetLogy()
 
-        legeff = TLegend(.5, .25, .7, .45)
+        legeff = TLegend(.5, .20, .7, .45)
         legeff.SetBorderSize(0)
         legeff.SetFillColor(0)
         legeff.SetFillStyle(0)
         legeff.SetTextFont(42)
         legeff.SetTextSize(0.035)
 
+        if self.signal_loss:
+            cSl = TCanvas('cSl', 'The Fit Canvas')
+            cSl.SetCanvasSize(1900, 1500)
+            cSl.SetWindowSize(500, 500)
+            legsl = TLegend(.5, .20, .7, .45)
+            legsl.SetBorderSize(0)
+            legsl.SetFillColor(0)
+            legsl.SetFillStyle(0)
+            legsl.SetTextFont(42)
+            legsl.SetTextSize(0.035)
+
         for imult in range(self.p_nbin2):
-            stringbin2 = "_%s_%.2f_%.2f" % (self.v_var2_binning_gen, \
+            stringbin2 = "_%s_%.2f_%.2f" % (self.v_var2_binning, \
                                             self.lvar2_binmin[imult], \
                                             self.lvar2_binmax[imult])
+            legeffstring = "%.1f #leq %s < %.1f" % \
+                    (self.lvar2_binmin[imult], self.p_latexbin2var, self.lvar2_binmax[imult])
+
+            if self.signal_loss:
+                h_gen_pr_sl = lfileeff.Get("h_signal_loss_gen_pr" + stringbin2)
+                h_sel_pr_sl = lfileeff.Get("h_signal_loss_rec_pr" + stringbin2)
+                h_sel_pr_sl.Divide(h_sel_pr_sl, h_gen_pr_sl, 1.0, 1.0, "B")
+                h_sel_pr_sl.SetLineColor(imult+1)
+                h_sel_pr_sl.SetMarkerColor(imult+1)
+                h_sel_pr_sl.SetMarkerStyle(21)
+                cSl.cd()
+                h_sel_pr_sl.Draw("same")
+                fileouteff.cd()
+                h_sel_pr_sl.SetName("signal_loss_pr_mult%d" % imult)
+                h_sel_pr_sl.Write()
+
+                legsl.AddEntry(h_sel_pr_sl, legeffstring, "LEP")
+                h_sel_pr_sl.GetXaxis().SetTitle("#it{p}_{T} (GeV/#it{c})")
+                h_sel_pr_sl.GetYaxis().SetTitle("Signal loss (prompt) %s" \
+                        % (self.p_latexnhadron))
+                h_sel_pr_sl.SetMinimum(0.7)
+                h_sel_pr_sl.SetMaximum(1.0)
+
             h_gen_pr = lfileeff.Get("h_gen_pr" + stringbin2)
             h_sel_pr = lfileeff.Get("h_sel_pr" + stringbin2)
             h_sel_pr.Divide(h_sel_pr, h_gen_pr, 1.0, 1.0, "B")
+
+            if self.signal_loss:
+                h_sel_pr.Multiply(h_sel_pr_sl)
+
             h_sel_pr.SetLineColor(imult+1)
             h_sel_pr.SetMarkerColor(imult+1)
             h_sel_pr.SetMarkerStyle(21)
+            cEff.cd()
             h_sel_pr.Draw("same")
             fileouteff.cd()
             h_sel_pr.SetName("eff_mult%d" % imult)
             h_sel_pr.Write()
-            legeffstring = "%.1f #leq %s < %.1f" % \
-                    (self.lvar2_binmin[imult], self.p_latexbin2var, self.lvar2_binmax[imult])
             legeff.AddEntry(h_sel_pr, legeffstring, "LEP")
             h_sel_pr.GetXaxis().SetTitle("#it{p}_{T} (GeV/#it{c})")
-            h_sel_pr.GetYaxis().SetTitle("Acc x efficiency (prompt) %s (1/GeV)" \
+            h_sel_pr.GetYaxis().SetTitle("Acc x efficiency (prompt) %s" \
                     % (self.p_latexnhadron))
             h_sel_pr.SetMinimum(0.0004)
             h_sel_pr.SetMaximum(0.4)
+
+        if self.signal_loss:
+            cSl.cd()
+            legsl.Draw()
+            cSl.SaveAs("%s/SignalLoss%s%s.eps" % (self.d_resultsallpmc,
+                                        self.case, self.typean))
+
+            cSlFD = TCanvas('cSlFD', 'The Fit Canvas')
+            cSlFD.SetCanvasSize(1900, 1500)
+            cSlFD.SetWindowSize(500, 500)
+            legslFD = TLegend(.5, .20, .7, .45)
+            legslFD.SetBorderSize(0)
+            legslFD.SetFillColor(0)
+            legslFD.SetFillStyle(0)
+            legslFD.SetTextFont(42)
+            legslFD.SetTextSize(0.035)
+
+        cEff.cd()
         legeff.Draw()
         cEff.SaveAs("%s/Eff%s%s.eps" % (self.d_resultsallpmc,
                                         self.case, self.typean))
@@ -458,38 +514,71 @@ def efficiency(self):
         cEffFD.SetCanvasSize(1900, 1500)
         cEffFD.SetWindowSize(500, 500)
         cEffFD.SetLogy()
-        legeffFD = TLegend(.5, .25, .7, .45)
+        legeffFD = TLegend(.5, .20, .7, .45)
         legeffFD.SetBorderSize(0)
         legeffFD.SetFillColor(0)
         legeffFD.SetFillStyle(0)
         legeffFD.SetTextFont(42)
         legeffFD.SetTextSize(0.035)
 
         for imult in range(self.p_nbin2):
-            stringbin2 = "_%s_%.2f_%.2f" % (self.v_var2_binning_gen, \
+            stringbin2 = "_%s_%.2f_%.2f" % (self.v_var2_binning, \
                                             self.lvar2_binmin[imult], \
                                             self.lvar2_binmax[imult])
+            legeffFDstring = "%.1f #leq %s < %.1f" % \
+                    (self.lvar2_binmin[imult], self.p_latexbin2var, self.lvar2_binmax[imult])
+
+            if self.signal_loss:
+                h_gen_fd_sl = lfileeff.Get("h_signal_loss_gen_fd" + stringbin2)
+                h_sel_fd_sl = lfileeff.Get("h_signal_loss_rec_fd" + stringbin2)
+                h_sel_fd_sl.Divide(h_sel_fd_sl, h_gen_fd_sl, 1.0, 1.0, "B")
+                h_sel_fd_sl.SetLineColor(imult+1)
+                h_sel_fd_sl.SetMarkerColor(imult+1)
+                h_sel_fd_sl.SetMarkerStyle(21)
+                cSlFD.cd()
+                h_sel_fd_sl.Draw("same")
+                fileouteff.cd()
+                h_sel_fd_sl.SetName("signal_loss_fd_mult%d" % imult)
+                h_sel_fd_sl.Write()
+
+                legslFD.AddEntry(h_sel_fd_sl, legeffstring, "LEP")
+                h_sel_fd_sl.GetXaxis().SetTitle("#it{p}_{T} (GeV/#it{c})")
+                h_sel_fd_sl.GetYaxis().SetTitle("Signal loss (feeddown) %s" \
+                        % (self.p_latexnhadron))
+                h_sel_fd_sl.SetMinimum(0.7)
+                h_sel_fd_sl.SetMaximum(1.0)
+
             h_gen_fd = lfileeff.Get("h_gen_fd" + stringbin2)
             h_sel_fd = lfileeff.Get("h_sel_fd" + stringbin2)
             h_sel_fd.Divide(h_sel_fd, h_gen_fd, 1.0, 1.0, "B")
+
+            if self.signal_loss:
+                h_sel_fd.Multiply(h_sel_fd_sl)
+
             h_sel_fd.SetLineColor(imult+1)
             h_sel_fd.SetMarkerColor(imult+1)
             h_sel_fd.SetMarkerStyle(21)
+            cEffFD.cd()
             h_sel_fd.Draw("same")
             fileouteff.cd()
             h_sel_fd.SetName("eff_fd_mult%d" % imult)
             h_sel_fd.Write()
-            legeffFDstring = "%.1f #leq %s < %.1f" % \
-                    (self.lvar2_binmin[imult], self.p_latexbin2var, self.lvar2_binmax[imult])
             legeffFD.AddEntry(h_sel_fd, legeffFDstring, "LEP")
             h_sel_fd.GetXaxis().SetTitle("#it{p}_{T} (GeV/#it{c})")
-            h_sel_fd.GetYaxis().SetTitle("Acc x efficiency feed-down %s (1/GeV)" \
+            h_sel_fd.GetYaxis().SetTitle("Acc x efficiency feed-down %s" \
                     % (self.p_latexnhadron))
             h_sel_fd.SetMinimum(0.0004)
             h_sel_fd.SetMaximum(0.4)
+
+        cEffFD.cd()
         legeffFD.Draw()
         cEffFD.SaveAs("%s/EffFD%s%s.eps" % (self.d_resultsallpmc,
                                             self.case, self.typean))
+        if self.signal_loss:
+            cSlFD.cd()
+            legslFD.Draw()
+            cSlFD.SaveAs("%s/SignalLossFD%s%s.eps" % (self.d_resultsallpmc,
+                                        self.case, self.typean))
 
 
     def plotter(self):

machine_learning_hep/data/data_run3/database_ml_parameters_LcToPKPi_newformat_mult_ana.yml

@@ -61,9 +61,10 @@ LcpKpi:
         level: gen
         index: fIndexHFLCMCCOLLBASES
         trees:
-          O2hflcmccollbase: [fPosX, fPosY, fPosZ]
+          O2hflcmccollbase: [fPosX, fPosY, fPosZ, fCentFT0M]
           O2hflcmcrcollid: [fIndexArrayHFLCCOLLBASES]
-          
+        rename: {old: fCentFT0M, new: fCentFT0Mmc}
+
       reco:
         level: all
         index: fIndexHfLcBases
@@ -107,7 +108,7 @@ LcpKpi:
     merge:
        - {base: reco, ref: evtorig , extra: {fMultZeqNTracksPV_sub: fMultZeqNTracksPV - fNProngsContributorsPV}}
        - {base: gen, ref: evtoriggen}
-       - {base: gen, ref: evtorig, left_on: fIndexArrayHFLCCOLLBASES}
+       - {base: gen, ref: evtorig, left_on: fIndexArrayHFLCCOLLBASES, out: genrec}
 
     write:
       evtorig:
@@ -117,10 +118,17 @@ LcpKpi:
         level: all
         source: evtorig
         file: AnalysisResultsEvt.parquet
+      evtmc:
+        level: mc
+        source: evtoriggen
+        file: AnalysisResultsEvtGen.parquet
       reco:
         level: all
         file: AnalysisResultsReco.parquet
       gen:
+        level: mc
+        file: AnalysisResultsGenSl.parquet
+      genrec:
         level: mc
         file: AnalysisResultsGen.parquet
 
@@ -398,9 +406,11 @@ LcpKpi:
       sel_binmin2: [0, 85, 70, 50, 30, 10, 1, 0] #list of var2 splittng nbins
       sel_binmax2: [100, 100, 85, 70, 50, 30, 10, 1]
       var_binning2: fCentFT0M
-      var_binning2_gen: fCentFT0M
+      var_binning2_gen: fCentFT0Mmc
       var_binning2_weights: fMultZeqNTracksPV
       mc_cut_on_binning2: false
+      signal_loss: true
+      signal_loss_idx: fIndexArrayHFLCCOLLBASES
       nbinshisto: 100
       minvaluehisto: -0.0005
       maxvaluehisto: 100.0005

machine_learning_hep/processer.py

@@ -115,6 +115,7 @@ def __init__(self, case, datap, run_param, mcordata, p_maxfiles, # pylint: disab
         self.n_evtorig = datap["files_names"].get("namefile_evtorig")
         self.n_evt_count_ml = datap["files_names"].get("namefile_evt_count", "evtcount.yaml")
         self.n_gen = datap["files_names"]["namefile_gen"]
+        self.n_gen_sl = datap["files_names"].get("namefile_gen_sl", "")
         self.n_filemass = datap["files_names"]["histofilename"]
         self.n_fileeff = datap["files_names"]["efffilename"]
         self.n_fileresp = datap["files_names"]["respfilename"]
@@ -170,7 +171,8 @@ def __init__(self, case, datap, run_param, mcordata, p_maxfiles, # pylint: disab
 
         if self.mcordata == "mc":
             self.l_gen = createlist(self.d_pkl, self.l_path, self.n_gen)
-
+            if self.n_gen_sl:
+                self.l_gen_sl = createlist(self.d_pkl, self.l_path, self.n_gen_sl)
         self.f_totevt = os.path.join(self.d_pkl, self.n_evt)
         self.f_totevtorig = os.path.join(self.d_pkl, self.n_evtorig)
 
@@ -232,6 +234,7 @@ def __init__(self, case, datap, run_param, mcordata, p_maxfiles, # pylint: disab
         self.d_pkl_dec = d_pkl_dec
         self.mptfiles_recosk = []
         self.mptfiles_gensk = []
+        self.mptfiles_gensk_sl = []
 
         self.d_pkl_decmerged = d_pkl_decmerged
         self.n_filemass = os.path.join(self.d_results, self.n_filemass)
@@ -249,6 +252,12 @@ def __init__(self, case, datap, run_param, mcordata, p_maxfiles, # pylint: disab
         self.lpt_gen_ml = [os.path.join(self.d_pkl_ml, self.lpt_gensk[ipt]) \
                             for ipt in range(self.p_nptbins)]
         self.f_evt_count_ml = os.path.join(self.d_pkl_ml, self.n_evt_count_ml)
+
+        if self.n_gen_sl:
+            self.lpt_gensk_sl = [self.n_gen_sl.replace(".p", "_%s%d_%d.p" % \
+                          (self.v_var_binning, self.lpt_anbinmin[i], self.lpt_anbinmax[i])) \
+                          for i in range(self.p_nptbins)]
+
         self.lpt_recodec = None
         if self.doml is True:
             if self.mltype == "MultiClassification":
@@ -277,6 +286,10 @@ def __init__(self, case, datap, run_param, mcordata, p_maxfiles, # pylint: disab
                                     self.lpt_gensk[ipt]) for ipt in range(self.p_nptbins)]
             self.lpt_gendecmerged = [os.path.join(self.d_pkl_decmerged, self.lpt_gensk[ipt])
                                      for ipt in range(self.p_nptbins)]
+            if self.n_gen_sl:
+                self.mptfiles_gensk_sl = [createlist(self.d_pklsk, self.l_path, \
+                                           self.lpt_gensk_sl[ipt]) for ipt in range(self.p_nptbins)]
+
         # self.triggerbit = datap["analysis"][self.typean]["triggerbit"]
         self.runlistrigger = runlisttrigger
 
@@ -405,6 +418,10 @@ def dfuse(df_spec):
                             dfs[df_name][var] = np.logical_and(dfs[df_name][var] == 1, swapped)
                 self.logger.debug(' %s -> done', df_name)
 
+                if 'rename' in df_spec:
+                    spec = df_spec['rename']
+                    dfs[df_name] = dfs[df_name].rename(columns={spec['old']: spec['new']})
+
 
         if self.df_merge:
             for m_spec in self.df_merge:
@@ -421,14 +438,9 @@ def dfuse(df_spec):
                         self.logger.info('merging %s with %s on %s into %s', base, ref, on, out)
                         if not is_numeric_dtype(dfs[base][on]):
                             self.logger.info('exploding dataframe %s on variable %s', base, on)
-                            dfs[base] = dfs[base].explode(on)
-                        dfs[out] = dfmerge(dfs[base], dfs[ref], left_on=['df', on], right_index=True)
-                        if not is_numeric_dtype(dfs[base][on]):
-                            dfs[out].index.name = 'MergedIndex'
-                            dfs[out] = dfs[out].reset_index()
-                            sorted_df = dfs[out].sort_values('fMultZeqNTracksPV', ascending=False)
-                            dfs[out] = sorted_df.drop_duplicates('MergedIndex')
-                            dfs[out] = dfs[out].sort_values('MergedIndex', ascending=True)
+                            dfs[out] = dfmerge(dfs[base].explode(on), dfs[ref], left_on=['df', on], right_index=True)
+                        else:
+                            dfs[out] = dfmerge(dfs[base], dfs[ref], left_on=['df', on], right_index=True)
                     else:
                         var = self.df_read[ref]['index']
                         self.logger.info('merging %s with %s on %s (default) into %s', base, ref, var, out)
@@ -451,6 +463,9 @@ def skim(self, file_index):
         dfreco = read_df(self.l_reco[file_index])
         dfgen = read_df(self.l_gen[file_index]) if self.mcordata == 'mc' else None
 
+        if self.n_gen_sl:
+            dfgen_sl = read_df(self.l_gen_sl[file_index]) if self.mcordata == 'mc' else None
+
         for ipt in range(self.p_nptbins):
             dfrecosk = seldf_singlevar(dfreco, self.v_var_binning,
                                        self.lpt_anbinmin[ipt], self.lpt_anbinmax[ipt])
@@ -463,6 +478,12 @@ def skim(self, file_index):
                 dfgensk = dfquery(dfgensk, self.s_gen_skim[ipt])
                 write_df(dfgensk, self.mptfiles_gensk[ipt][file_index])
 
+            if dfgen_sl is not None:
+                dfgensk_sl = seldf_singlevar(dfgen_sl, self.v_var_binning,
+                                          self.lpt_anbinmin[ipt], self.lpt_anbinmax[ipt])
+                dfgensk_sl = dfquery(dfgensk_sl, self.s_gen_skim[ipt])
+                write_df(dfgensk_sl, self.mptfiles_gensk_sl[ipt][file_index])
+
     def applymodel(self, file_index):
         for ipt in range(self.p_nptbins):
             if os.path.exists(self.mptfiles_recoskmldec[ipt][file_index]):