[PWGEM/Dilepton] add a task for dilepton-hadron 2PC

PWGEM/Dilepton/Core/CMakeLists.txt

@@ -13,10 +13,12 @@ o2physics_add_library(PWGEMDileptonCore
                SOURCES  EMEventCut.cxx
                         DielectronCut.cxx
                         DimuonCut.cxx
+                        EMTrackCut.cxx
                PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::MLCore)
 
 o2physics_target_root_dictionary(PWGEMDileptonCore
               HEADERS   EMEventCut.h
                         DielectronCut.h
                         DimuonCut.h
+                        EMTrackCut.h
               LINKDEF PWGEMDileptonCoreLinkDef.h)

PWGEM/Dilepton/Core/Dilepton.h

@@ -60,14 +60,14 @@
 #include <utility>
 #include <vector>
 
 using namespace o2;
 using namespace o2::aod;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 using namespace o2::soa;
 using namespace o2::aod::pwgem::dilepton::utils;
 using namespace o2::aod::pwgem::dilepton::utils::emtrackutil;
 using namespace o2::aod::pwgem::dilepton::utils::pairutil;
 
 using MyCollisions = soa::Join<aod::EMEvents, aod::EMEventsMult, aod::EMEventsCent, aod::EMEventsQvec>;
 using MyCollision = MyCollisions::iterator;
@@ -110,10 +110,10 @@
   Configurable<float> cfgCentMax{"cfgCentMax", 999.f, "max. centrality"};
   Configurable<bool> cfgDoMix{"cfgDoMix", true, "flag for event mixing"};
   Configurable<int> ndepth{"ndepth", 100, "depth for event mixing"};
-  Configurable<uint64_t> ndiff_bc_mix{"ndiff_bc_mix", 5, "difference in global BC required in mixed events"};
+  Configurable<uint64_t> ndiff_bc_mix{"ndiff_bc_mix", 594, "difference in global BC required in mixed events"};
   ConfigurableAxis ConfVtxBins{"ConfVtxBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"};
   ConfigurableAxis ConfCentBins{"ConfCentBins", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.f, 999.f}, "Mixing bins - centrality"};
   ConfigurableAxis ConfEPBins{"ConfEPBins", {16, -M_PI / 2, +M_PI / 2}, "Mixing bins - event plane angle"};
   ConfigurableAxis ConfOccupancyBins{"ConfOccupancyBins", {VARIABLE_WIDTH, -1, 1e+10}, "Mixing bins - occupancy"};
   Configurable<std::string> cfg_swt_name{"cfg_swt_name", "fHighTrackMult", "desired software trigger name"}; // 1 trigger name per 1 task. fHighTrackMult, fHighFt0Mult
   // Configurable<int> cfgNtracksPV08Min{"cfgNtracksPV08Min", -1, "min. multNTracksPV"};
@@ -157,7 +157,7 @@
     Configurable<bool> cfgRequireGoodITSLayersAll{"cfgRequireGoodITSLayersAll", false, "number of inactive chips on all ITS layers are below threshold "};
     // for RCT
     Configurable<bool> cfgRequireGoodRCT{"cfgRequireGoodRCT", false, "require good detector flag in run condtion table"};
-    Configurable<std::string> cfgRCTLabel{"cfgRCTLabel", "CBT_hadronPID", "select 1 [CBT, CBT_hadron, CBT_muon_glo] see O2Physics/Common/CCDB/RCTSelectionFlags.h"};
+    Configurable<std::string> cfgRCTLabel{"cfgRCTLabel", "CBT_hadronPID", "select 1 [CBT, CBT_hadronPID, CBT_muon_glo] see O2Physics/Common/CCDB/RCTSelectionFlags.h"};
     Configurable<bool> cfgCheckZDC{"cfgCheckZDC", false, "set ZDC flag for PbPb"};
     Configurable<bool> cfgTreatLimitedAcceptanceAsBad{"cfgTreatLimitedAcceptanceAsBad", false, "reject all events where the detectors relevant for the specified Runlist are flagged as LimitedAcceptance"};
   } eventcuts;
@@ -547,7 +547,7 @@
 
     if (cfgAnalysisType == static_cast<int>(o2::aod::pwgem::dilepton::utils::pairutil::DileptonAnalysisType::kQC)) {
       fRegistry.add("Pair/same/uls/hs", "dilepton", kTHnSparseD, {axis_mass, axis_pt, axis_dca}, true);
       fRegistry.add("Pair/same/uls/hDeltaEtaDeltaPhi", "#Delta#eta-#Delta#varphi between 2 tracks;#Delta#varphi (rad.);#Delta#eta;", kTH2D, {{180, -M_PI, M_PI}, {400, -2, +2}}, true);
       if constexpr (pairtype == o2::aod::pwgem::dilepton::utils::pairutil::DileptonPairType::kDielectron) {
         fRegistry.add("Pair/same/uls/hMvsPhiV", "m_{ee} vs. #varphi_{V};#varphi_{V} (rad.);m_{ee} (GeV/c^{2})", kTH2D, {{90, 0, M_PI}, {100, 0.0f, 1.0f}}, true); // phiv is only for dielectron
         fRegistry.add("Pair/same/uls/hMvsOpAng", "m_{ee} vs. angle between 2 tracks;#omega (rad.);m_{ee} (GeV/c^{2})", kTH2D, {{90, 0, M_PI}, {100, 0.0f, 1.0f}}, true);

PWGEM/Dilepton/Core/DileptonMC.h

@@ -151,7 +151,7 @@ struct DileptonMC {
     Configurable<bool> cfgRequireGoodITSLayersAll{"cfgRequireGoodITSLayersAll", false, "number of inactive chips on all ITS layers are below threshold "};
     // for RCT
     Configurable<bool> cfgRequireGoodRCT{"cfgRequireGoodRCT", false, "require good detector flag in run condtion table"};
-    Configurable<std::string> cfgRCTLabel{"cfgRCTLabel", "CBT_hadronPID", "select 1 [CBT, CBT_hadron, CBT_muon_glo] see O2Physics/Common/CCDB/RCTSelectionFlags.h"};
+    Configurable<std::string> cfgRCTLabel{"cfgRCTLabel", "CBT_hadronPID", "select 1 [CBT, CBT_hadronPID, CBT_muon_glo] see O2Physics/Common/CCDB/RCTSelectionFlags.h"};
     Configurable<bool> cfgCheckZDC{"cfgCheckZDC", false, "set ZDC flag for PbPb"};
     Configurable<bool> cfgTreatLimitedAcceptanceAsBad{"cfgTreatLimitedAcceptanceAsBad", false, "reject all events where the detectors relevant for the specified Runlist are flagged as LimitedAcceptance"};
   } eventcuts;

PWGEM/Dilepton/Core/EMTrackCut.cxx

@@ -0,0 +1,113 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+//
+// Class for track Cut
+//
+
+#include "PWGEM/Dilepton/Core/EMTrackCut.h"
+
+#include "Framework/Logger.h"
+
+#include <set>
+#include <utility>
+
+ClassImp(EMTrackCut);
+
+const std::pair<int8_t, std::set<uint8_t>> EMTrackCut::its_ib_any_Requirement = {1, {0, 1, 2}}; // hits on any ITS ib layers.
+const std::pair<int8_t, std::set<uint8_t>> EMTrackCut::its_ib_1st_Requirement = {1, {0}};       // hit on 1st ITS ib layers.
+
+void EMTrackCut::SetTrackPtRange(float minPt, float maxPt)
+{
+  mMinTrackPt = minPt;
+  mMaxTrackPt = maxPt;
+  LOG(info) << "EMTrack Cut, set track pt range: " << mMinTrackPt << " - " << mMaxTrackPt;
+}
+void EMTrackCut::SetTrackEtaRange(float minEta, float maxEta)
+{
+  mMinTrackEta = minEta;
+  mMaxTrackEta = maxEta;
+  LOG(info) << "EMTrack Cut, set track eta range: " << mMinTrackEta << " - " << mMaxTrackEta;
+}
+void EMTrackCut::SetTrackPhiRange(float minPhi, float maxPhi)
+{
+  mMinTrackPhi = minPhi;
+  mMaxTrackPhi = maxPhi;
+  LOG(info) << "EMTrack Cut, set track phi range (rad.): " << mMinTrackPhi << " - " << mMaxTrackPhi;
+}
+void EMTrackCut::SetMinNClustersTPC(int minNClustersTPC)
+{
+  mMinNClustersTPC = minNClustersTPC;
+  LOG(info) << "EMTrack Cut, set min N clusters TPC: " << mMinNClustersTPC;
+}
+void EMTrackCut::SetMinNCrossedRowsTPC(int minNCrossedRowsTPC)
+{
+  mMinNCrossedRowsTPC = minNCrossedRowsTPC;
+  LOG(info) << "EMTrack Cut, set min N crossed rows TPC: " << mMinNCrossedRowsTPC;
+}
+void EMTrackCut::SetMinNCrossedRowsOverFindableClustersTPC(float minNCrossedRowsOverFindableClustersTPC)
+{
+  mMinNCrossedRowsOverFindableClustersTPC = minNCrossedRowsOverFindableClustersTPC;
+  LOG(info) << "EMTrack Cut, set min N crossed rows over findable clusters TPC: " << mMinNCrossedRowsOverFindableClustersTPC;
+}
+void EMTrackCut::SetMaxFracSharedClustersTPC(float max)
+{
+  mMaxFracSharedClustersTPC = max;
+  LOG(info) << "EMTrack Cut, set max fraction of shared clusters in  TPC: " << mMaxFracSharedClustersTPC;
+}
+void EMTrackCut::SetChi2PerClusterTPC(float min, float max)
+{
+  mMinChi2PerClusterTPC = min;
+  mMaxChi2PerClusterTPC = max;
+  LOG(info) << "EMTrack Cut, set chi2 per cluster TPC range: " << mMinChi2PerClusterTPC << " - " << mMaxChi2PerClusterTPC;
+}
+
+void EMTrackCut::SetNClustersITS(int min, int max)
+{
+  mMinNClustersITS = min;
+  mMaxNClustersITS = max;
+  LOG(info) << "EMTrack Cut, set N clusters ITS range: " << mMinNClustersITS << " - " << mMaxNClustersITS;
+}
+void EMTrackCut::SetChi2PerClusterITS(float min, float max)
+{
+  mMinChi2PerClusterITS = min;
+  mMaxChi2PerClusterITS = max;
+  LOG(info) << "EMTrack Cut, set chi2 per cluster ITS range: " << mMinChi2PerClusterITS << " - " << mMaxChi2PerClusterITS;
+}
+
+void EMTrackCut::SetTrackMaxDcaXY(float maxDcaXY)
+{
+  mMaxDcaXY = maxDcaXY;
+  LOG(info) << "EMTrack Cut, set max DCA xy: " << mMaxDcaXY;
+}
+void EMTrackCut::SetTrackMaxDcaZ(float maxDcaZ)
+{
+  mMaxDcaZ = maxDcaZ;
+  LOG(info) << "EMTrack Cut, set max DCA z: " << mMaxDcaZ;
+}
+
+void EMTrackCut::SetTrackMaxDcaXYPtDep(std::function<float(float)> ptDepCut)
+{
+  mMaxDcaXYPtDep = ptDepCut;
+  LOG(info) << "EMTrack Cut, set max DCA xy pt dep: " << mMaxDcaXYPtDep(1.0);
+}
+
+void EMTrackCut::RequireITSibAny(bool flag)
+{
+  mRequireITSibAny = flag;
+  LOG(info) << "EMTrack Cut, require ITS ib any: " << mRequireITSibAny;
+}
+
+void EMTrackCut::RequireITSib1st(bool flag)
+{
+  mRequireITSib1st = flag;
+  LOG(info) << "EMTrack Cut, require ITS ib 1st: " << mRequireITSib1st;
+}

PWGEM/Dilepton/Core/EMTrackCut.h

@@ -0,0 +1,217 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+//
+// Class for track selection
+//
+
+#ifndef PWGEM_DILEPTON_CORE_EMTRACKCUT_H_
+#define PWGEM_DILEPTON_CORE_EMTRACKCUT_H_
+
+// #include "PWGEM/Dilepton/Utils/EMTrackUtilities.h"
+
+#include "CommonConstants/PhysicsConstants.h"
+#include "Framework/DataTypes.h"
+#include "Framework/Logger.h"
+
+#include "Math/Vector4D.h"
+#include "TNamed.h"
+
+#include <algorithm>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+// using namespace o2::aod::pwgem::dilepton::utils::emtrackutil;
+
+class EMTrackCut : public TNamed
+{
+ public:
+  EMTrackCut() = default;
+  EMTrackCut(const char* name, const char* title) : TNamed(name, title) {}
+  ~EMTrackCut() {}
+
+  enum class EMTrackCuts : int {
+    // track cut
+    kTrackPtRange,
+    kTrackEtaRange,
+    kTrackPhiRange,
+    kTPCNCls,
+    kTPCCrossedRows,
+    kTPCCrossedRowsOverNCls,
+    kTPCFracSharedClusters,
+    kTPCChi2NDF,
+    kDCAxy,
+    kDCAz,
+    kITSNCls,
+    kITSChi2NDF,
+    kNCuts
+  };
+
+  template <typename TTrack>
+  bool IsSelected(TTrack const& track) const
+  {
+    if (!track.hasITS() || !track.hasTPC()) {
+      return false;
+    }
+
+    if (!IsSelectedTrack(track, EMTrackCuts::kTrackPtRange)) {
+      return false;
+    }
+    if (!IsSelectedTrack(track, EMTrackCuts::kTrackEtaRange)) {
+      return false;
+    }
+
+    if (!IsSelectedTrack(track, EMTrackCuts::kTrackPhiRange)) {
+      return false;
+    }
+    if (!IsSelectedTrack(track, EMTrackCuts::kDCAxy)) {
+      return false;
+    }
+    if (!IsSelectedTrack(track, EMTrackCuts::kDCAz)) {
+      return false;
+    }
+
+    // ITS cuts
+    if (!IsSelectedTrack(track, EMTrackCuts::kITSNCls)) {
+      return false;
+    }
+    if (!IsSelectedTrack(track, EMTrackCuts::kITSChi2NDF)) {
+      return false;
+    }
+
+    if (mRequireITSibAny) {
+      auto hits_ib = std::count_if(its_ib_any_Requirement.second.begin(), its_ib_any_Requirement.second.end(), [&](auto&& requiredLayer) { return track.itsClusterMap() & (1 << requiredLayer); });
+      if (hits_ib < its_ib_any_Requirement.first) {
+        return false;
+      }
+    }
+
+    if (mRequireITSib1st) {
+      auto hits_ib = std::count_if(its_ib_1st_Requirement.second.begin(), its_ib_1st_Requirement.second.end(), [&](auto&& requiredLayer) { return track.itsClusterMap() & (1 << requiredLayer); });
+      if (hits_ib < its_ib_1st_Requirement.first) {
+        return false;
+      }
+    }
+
+    // TPC cuts
+    if (!IsSelectedTrack(track, EMTrackCuts::kTPCNCls)) {
+      return false;
+    }
+    if (!IsSelectedTrack(track, EMTrackCuts::kTPCCrossedRows)) {
+      return false;
+    }
+    if (!IsSelectedTrack(track, EMTrackCuts::kTPCCrossedRowsOverNCls)) {
+      return false;
+    }
+    if (!IsSelectedTrack(track, EMTrackCuts::kTPCFracSharedClusters)) {
+      return false;
+    }
+    if (!IsSelectedTrack(track, EMTrackCuts::kTPCChi2NDF)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  template <typename T>
+  bool IsSelectedTrack(T const& track, const EMTrackCuts& cut) const
+  {
+    switch (cut) {
+      case EMTrackCuts::kTrackPtRange:
+        return track.pt() > mMinTrackPt && track.pt() < mMaxTrackPt;
+
+      case EMTrackCuts::kTrackEtaRange:
+        return track.eta() > mMinTrackEta && track.eta() < mMaxTrackEta;
+
+      case EMTrackCuts::kTrackPhiRange:
+        return track.phi() > mMinTrackPhi && track.phi() < mMaxTrackPhi;
+
+      case EMTrackCuts::kTPCNCls:
+        return track.tpcNClsFound() >= mMinNClustersTPC;
+
+      case EMTrackCuts::kTPCCrossedRows:
+        return track.tpcNClsCrossedRows() >= mMinNCrossedRowsTPC;
+
+      case EMTrackCuts::kTPCCrossedRowsOverNCls:
+        return track.tpcCrossedRowsOverFindableCls() > mMinNCrossedRowsOverFindableClustersTPC;
+
+      case EMTrackCuts::kTPCFracSharedClusters:
+        return track.tpcFractionSharedCls() < mMaxFracSharedClustersTPC;
+
+      case EMTrackCuts::kTPCChi2NDF:
+        return mMinChi2PerClusterTPC < track.tpcChi2NCl() && track.tpcChi2NCl() < mMaxChi2PerClusterTPC;
+
+      case EMTrackCuts::kDCAxy:
+        return std::fabs(track.dcaXY()) < ((mMaxDcaXYPtDep) ? mMaxDcaXYPtDep(track.pt()) : mMaxDcaXY);
+
+      case EMTrackCuts::kDCAz:
+        return std::fabs(track.dcaZ()) < mMaxDcaZ;
+
+      case EMTrackCuts::kITSNCls:
+        return mMinNClustersITS <= track.itsNCls() && track.itsNCls() <= mMaxNClustersITS;
+
+      case EMTrackCuts::kITSChi2NDF:
+        return mMinChi2PerClusterITS < track.itsChi2NCl() && track.itsChi2NCl() < mMaxChi2PerClusterITS;
+
+      default:
+        return false;
+    }
+  }
+
+  // Setters
+  void SetTrackPtRange(float minPt = 0.f, float maxPt = 1e10f);
+  void SetTrackEtaRange(float minEta = -1e10f, float maxEta = 1e10f);
+  void SetTrackPhiRange(float minPhi = 0.f, float maxPhi = 6.3f);
+  void SetMinNClustersTPC(int minNClustersTPC);
+  void SetMinNCrossedRowsTPC(int minNCrossedRowsTPC);
+  void SetMinNCrossedRowsOverFindableClustersTPC(float minNCrossedRowsOverFindableClustersTPC);
+  void SetMaxFracSharedClustersTPC(float max);
+  void SetChi2PerClusterTPC(float min, float max);
+  void SetNClustersITS(int min, int max);
+  void SetChi2PerClusterITS(float min, float max);
+
+  void SetTrackDca3DRange(float min, float max); // in sigma
+  void SetTrackMaxDcaXY(float maxDcaXY);         // in cm
+  void SetTrackMaxDcaZ(float maxDcaZ);           // in cm
+  void SetTrackMaxDcaXYPtDep(std::function<float(float)> ptDepCut);
+  void RequireITSibAny(bool flag);
+  void RequireITSib1st(bool flag);
+
+ private:
+  static const std::pair<int8_t, std::set<uint8_t>> its_ib_any_Requirement;
+  static const std::pair<int8_t, std::set<uint8_t>> its_ib_1st_Requirement;
+
+  // kinematic cuts
+  float mMinTrackPt{0.f}, mMaxTrackPt{1e10f};      // range in pT
+  float mMinTrackEta{-1e10f}, mMaxTrackEta{1e10f}; // range in eta
+  float mMinTrackPhi{0.f}, mMaxTrackPhi{6.3};      // range in phi
+
+  // track quality cuts
+  int mMinNClustersTPC{0};                                        // min number of TPC clusters
+  int mMinNCrossedRowsTPC{0};                                     // min number of crossed rows in TPC
+  float mMinChi2PerClusterTPC{0.f}, mMaxChi2PerClusterTPC{1e10f}; // max tpc fit chi2 per TPC cluster
+  float mMinNCrossedRowsOverFindableClustersTPC{0.f};             // min ratio crossed rows / findable clusters
+  float mMaxFracSharedClustersTPC{999.f};                         // max ratio shared clusters / clusters in TPC
+  int mMinNClustersITS{0}, mMaxNClustersITS{7};                   // range in number of ITS clusters
+  float mMinChi2PerClusterITS{0.f}, mMaxChi2PerClusterITS{1e10f}; // max its fit chi2 per ITS cluster
+  bool mRequireITSibAny{true};
+  bool mRequireITSib1st{false};
+
+  float mMaxDcaXY{1.0f};                        // max dca in xy plane
+  float mMaxDcaZ{1.0f};                         // max dca in z direction
+  std::function<float(float)> mMaxDcaXYPtDep{}; // max dca in xy plane as function of pT
+
+  ClassDef(EMTrackCut, 1);
+};
+
+#endif // PWGEM_DILEPTON_CORE_EMTRACKCUT_H_

PWGEM/Dilepton/Core/PWGEMDileptonCoreLinkDef.h

@@ -19,5 +19,6 @@
 #pragma link C++ class EMEventCut + ;
 #pragma link C++ class DielectronCut + ;
 #pragma link C++ class DimuonCut + ;
+#pragma link C++ class EMTrackCut + ;
 
 #endif // PWGEM_DILEPTON_CORE_PWGEMDILEPTONCORELINKDEF_H_

PWGEM/Dilepton/Core/SingleTrackQC.h

@@ -114,7 +114,7 @@ struct SingleTrackQC {
     Configurable<bool> cfgRequireGoodITSLayersAll{"cfgRequireGoodITSLayersAll", false, "number of inactive chips on all ITS layers are below threshold "};
     // for RCT
     Configurable<bool> cfgRequireGoodRCT{"cfgRequireGoodRCT", false, "require good detector flag in run condtion table"};
-    Configurable<std::string> cfgRCTLabel{"cfgRCTLabel", "CBT_hadronPID", "select 1 [CBT, CBT_hadron, CBT_muon_glo] see O2Physics/Common/CCDB/RCTSelectionFlags.h"};
+    Configurable<std::string> cfgRCTLabel{"cfgRCTLabel", "CBT_hadronPID", "select 1 [CBT, CBT_hadronPID, CBT_muon_glo] see O2Physics/Common/CCDB/RCTSelectionFlags.h"};
     Configurable<bool> cfgCheckZDC{"cfgCheckZDC", false, "set ZDC flag for PbPb"};
     Configurable<bool> cfgTreatLimitedAcceptanceAsBad{"cfgTreatLimitedAcceptanceAsBad", false, "reject all events where the detectors relevant for the specified Runlist are flagged as LimitedAcceptance"};
   } eventcuts;

PWGEM/Dilepton/Core/SingleTrackQCMC.h

@@ -122,7 +122,7 @@ struct SingleTrackQCMC {
     Configurable<bool> cfgRequireGoodITSLayersAll{"cfgRequireGoodITSLayersAll", false, "number of inactive chips on all ITS layers are below threshold "};
     // for RCT
     Configurable<bool> cfgRequireGoodRCT{"cfgRequireGoodRCT", false, "require good detector flag in run condtion table"};
-    Configurable<std::string> cfgRCTLabel{"cfgRCTLabel", "CBT_hadronPID", "select 1 [CBT, CBT_hadron, CBT_muon_glo] see O2Physics/Common/CCDB/RCTSelectionFlags.h"};
+    Configurable<std::string> cfgRCTLabel{"cfgRCTLabel", "CBT_hadronPID", "select 1 [CBT, CBT_hadronPID, CBT_muon_glo] see O2Physics/Common/CCDB/RCTSelectionFlags.h"};
     Configurable<bool> cfgCheckZDC{"cfgCheckZDC", false, "set ZDC flag for PbPb"};
     Configurable<bool> cfgTreatLimitedAcceptanceAsBad{"cfgTreatLimitedAcceptanceAsBad", false, "reject all events where the detectors relevant for the specified Runlist are flagged as LimitedAcceptance"};
   } eventcuts;