[PWGEM/PhotonMeson] fix in filterEoI.cxx (#12495)

Author: dsekihat

PWGEM/Dilepton/TableProducer/filterEoI.cxx

@@ -32,60 +32,70 @@ struct filterEoI {
     kElectron = 0x1,
     kFwdMuon = 0x2,
     kPCM = 0x4,
+    kElectronFromDalitz = 0x8,
   };
   Produces<o2::aod::EMEoIs> emeoi;
-  Configurable<int> minNElectrons{"minNElectrons", 1, "min number of e+ or e- at midrapidity"};
-  Configurable<int> minNMuons{"minNMuons", 1, "min number of mu+ or mu- at forward rapidity"};
-  Configurable<int> minNV0s{"minNV0s", 1, "min number of v0 photons at midrapidity"};
+  // Configurable<int> minNElectrons{"minNElectrons", 1, "min number of e+ or e- at midrapidity"};
+  // Configurable<int> minNMuons{"minNMuons", 1, "min number of mu+ or mu- at forward rapidity"};
+  // Configurable<int> minNV0s{"minNV0s", 1, "min number of v0 photons at midrapidity"};
 
   HistogramRegistry fRegistry{"output"};
   void init(o2::framework::InitContext&)
   {
-    auto hEventCounter = fRegistry.add<TH1>("hEventCounter", "hEventCounter", kTH1D, {{7, 0.5f, 7.5f}});
+    auto hEventCounter = fRegistry.add<TH1>("hEventCounter", "hEventCounter", kTH1D, {{8, 0.5f, 8.5f}});
     hEventCounter->GetXaxis()->SetBinLabel(1, "all");
     hEventCounter->GetXaxis()->SetBinLabel(2, "event with electron");
     hEventCounter->GetXaxis()->SetBinLabel(3, "event with forward muon");
     hEventCounter->GetXaxis()->SetBinLabel(4, "event with v0");
     hEventCounter->GetXaxis()->SetBinLabel(5, "event with electron or forward muon");
     hEventCounter->GetXaxis()->SetBinLabel(6, "event with electron and forward muon");
     hEventCounter->GetXaxis()->SetBinLabel(7, "event with electron or forward muon or v0");
+    hEventCounter->GetXaxis()->SetBinLabel(8, "event with v0 or electrons from dalitz");
   }
 
   SliceCache cache;
   Preslice<aod::EMPrimaryElectrons> perCollision_el = aod::emprimaryelectron::collisionId;
   Preslice<aod::EMPrimaryMuons> perCollision_mu = aod::emprimarymuon::collisionId;
   Preslice<aod::V0PhotonsKF> perCollision_v0 = aod::v0photonkf::collisionId;
+  Preslice<aod::EMPrimaryElectronsFromDalitz> perCollision_elda = aod::emprimaryelectron::collisionId;
 
-  template <uint8_t system, typename TCollisions, typename TElectrons, typename TMuons, typename TV0s>
-  void selectEoI(TCollisions const& collisions, TElectrons const& electrons, TMuons const& muons, TV0s const& v0s)
+  template <uint8_t system, typename TCollisions, typename TElectrons, typename TMuons, typename TV0s, typename TElectronsDA>
+  void selectEoI(TCollisions const& collisions, TElectrons const& electrons, TMuons const& muons, TV0s const& v0s, TElectronsDA const& electronsda)
   {
     for (const auto& collision : collisions) {
       bool does_electron_exist = false;
       bool does_fwdmuon_exist = false;
       bool does_pcm_exist = false;
+      bool does_electronda_exist = false;
       fRegistry.fill(HIST("hEventCounter"), 1);
 
       if constexpr (static_cast<bool>(system & kElectron)) {
         auto electrons_coll = electrons.sliceBy(perCollision_el, collision.globalIndex());
-        if (electrons_coll.size() >= minNElectrons) {
+        if (electrons_coll.size() >= 1) {
           does_electron_exist = true;
           fRegistry.fill(HIST("hEventCounter"), 2);
         }
       }
       if constexpr (static_cast<bool>(system & kFwdMuon)) {
         auto muons_coll = muons.sliceBy(perCollision_mu, collision.globalIndex());
-        if (muons_coll.size() >= minNMuons) {
+        if (muons_coll.size() >= 1) {
           does_fwdmuon_exist = true;
           fRegistry.fill(HIST("hEventCounter"), 3);
         }
       }
       if constexpr (static_cast<bool>(system & kPCM)) {
         auto v0s_coll = v0s.sliceBy(perCollision_v0, collision.globalIndex());
-        if (v0s_coll.size() >= minNV0s) {
+        if (v0s_coll.size() >= 1) {
           does_pcm_exist = true;
           fRegistry.fill(HIST("hEventCounter"), 4);
         }
       }
+      if constexpr (static_cast<bool>(system & kElectronFromDalitz)) {
+        auto electronsda_coll = electronsda.sliceBy(perCollision_elda, collision.globalIndex());
+        if (electronsda_coll.size() >= 2) {
+          does_electronda_exist = true;
+        }
+      }
 
       if (does_electron_exist || does_fwdmuon_exist) {
         fRegistry.fill(HIST("hEventCounter"), 5);
@@ -96,8 +106,11 @@ struct filterEoI {
       if (does_electron_exist || does_fwdmuon_exist || does_pcm_exist) {
         fRegistry.fill(HIST("hEventCounter"), 7);
       }
+      if (does_pcm_exist || does_electronda_exist) {
+        fRegistry.fill(HIST("hEventCounter"), 8);
+      }
 
-      emeoi(does_electron_exist || does_fwdmuon_exist || does_pcm_exist);
+      emeoi(does_electron_exist || does_fwdmuon_exist || does_pcm_exist || does_electronda_exist);
 
     } // end of collision loop
 
@@ -106,31 +119,37 @@ struct filterEoI {
   void process_Electron(aod::Collisions const& collisions, aod::EMPrimaryElectrons const& electrons)
   {
     const uint8_t sysflag = kElectron;
-    selectEoI<sysflag>(collisions, electrons, nullptr, nullptr);
+    selectEoI<sysflag>(collisions, electrons, nullptr, nullptr, nullptr);
   }
 
   void process_FwdMuon(aod::Collisions const& collisions, aod::EMPrimaryMuons const& muons)
   {
     const uint8_t sysflag = kFwdMuon;
-    selectEoI<sysflag>(collisions, nullptr, muons, nullptr);
+    selectEoI<sysflag>(collisions, nullptr, muons, nullptr, nullptr);
   }
 
   void process_Electron_FwdMuon(aod::Collisions const& collisions, aod::EMPrimaryElectrons const& electrons, aod::EMPrimaryMuons const& muons)
   {
     const uint8_t sysflag = kElectron | kFwdMuon;
-    selectEoI<sysflag>(collisions, electrons, muons, nullptr);
+    selectEoI<sysflag>(collisions, electrons, muons, nullptr, nullptr);
   }
 
   void process_PCM(aod::Collisions const& collisions, aod::V0PhotonsKF const& v0s)
   {
     const uint8_t sysflag = kPCM;
-    selectEoI<sysflag>(collisions, nullptr, nullptr, v0s);
+    selectEoI<sysflag>(collisions, nullptr, nullptr, v0s, nullptr);
   }
 
   void process_Electron_FwdMuon_PCM(aod::Collisions const& collisions, aod::EMPrimaryElectrons const& electrons, aod::EMPrimaryMuons const& muons, aod::V0PhotonsKF const& v0s)
   {
     const uint8_t sysflag = kElectron | kFwdMuon | kPCM;
-    selectEoI<sysflag>(collisions, electrons, muons, v0s);
+    selectEoI<sysflag>(collisions, electrons, muons, v0s, nullptr);
+  }
+
+  void process_PCM_ElectronFromDalitz(aod::Collisions const& collisions, aod::V0PhotonsKF const& v0s, aod::EMPrimaryElectronsFromDalitz const& electronsda)
+  {
+    const uint8_t sysflag = kPCM | kElectronFromDalitz;
+    selectEoI<sysflag>(collisions, nullptr, nullptr, v0s, electronsda);
   }
 
   void processDummy(aod::Collisions const& collisions)
@@ -145,6 +164,7 @@ struct filterEoI {
   PROCESS_SWITCH(filterEoI, process_PCM, "create filter bit for PCM", false);
   PROCESS_SWITCH(filterEoI, process_Electron_FwdMuon, "create filter bit for Electron, FwdMuon", false);
   PROCESS_SWITCH(filterEoI, process_Electron_FwdMuon_PCM, "create filter bit for Electron, FwdMuon, PCM", false);
+  PROCESS_SWITCH(filterEoI, process_PCM_ElectronFromDalitz, "create filter bit for PCM, ElectronFromDalitz", false);
   PROCESS_SWITCH(filterEoI, processDummy, "processDummy", true);
 };
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)