[PWGJE] adding mcCollision selections for TVX trigger (#15278)

Author: nzardosh

PWGJE/Core/JetDerivedDataUtilities.h

@@ -51,9 +51,9 @@ enum JCollisionSel {
   selIsGoodZvtxFT0vsPV = 7,
   selNoCollInTimeRangeStandard = 8,
   selNoCollInRofStandard = 9,
-  selUpcSingleGapA = 10,
-  selUpcSingleGapC = 11,
-  selUpcDoubleGap = 12,
+  selUPCSingleGapA = 10,
+  selUPCSingleGapC = 11,
+  selUPCDoubleGap = 12,
 };
 
 enum JCollisionSubGeneratorId {
@@ -62,8 +62,9 @@ enum JCollisionSubGeneratorId {
 };
 
 template <typename T>
-bool commonCollisionSelection(T const& collision, bool skipMBGapEvents = true, bool rctSelection = true, std::string rctLabel = "CBT_hadronPID", bool rejectLimitedAcceptanceRct = false, bool requireZDCRct = false)
+bool selectCollision(T const& collision, const std::vector<int>& eventSelectionMaskBits, bool skipMBGapEvents = true, bool rctSelection = true, std::string rctLabel = "CBT_hadronPID", bool rejectLimitedAcceptanceRct = false, bool requireZDCRct = false)
 {
+
   if (skipMBGapEvents && collision.getSubGeneratorId() == JCollisionSubGeneratorId::mbGap) {
     return false;
   }
@@ -72,22 +73,6 @@ bool commonCollisionSelection(T const& collision, bool skipMBGapEvents = true, b
   if (rctSelection && !rctChecker.checkTable(collision)) { // CBT_hadronPID given as default so that TOF is included in RCT selection to benefit from better timing for tracks. Impact of this for inclusive jets should be studied
     return false;
   }
-  return true;
-}
-
-template <typename T>
-bool selectMcCollision(T const& mcCollision, bool skipMBGapEvents = true, bool rctSelection = true, std::string rctLabel = "CBT_hadronPID", bool rejectLimitedAcceptanceRct = false, bool requireZDCRct = false)
-{
-  return commonCollisionSelection(mcCollision, skipMBGapEvents, rctSelection, rctLabel, rejectLimitedAcceptanceRct, requireZDCRct);
-}
-
-template <typename T>
-bool selectCollision(T const& collision, const std::vector<int>& eventSelectionMaskBits, bool skipMBGapEvents = true, bool rctSelection = true, std::string rctLabel = "CBT_hadronPID", bool rejectLimitedAcceptanceRct = false, bool requireZDCRct = false)
-{
-
-  if (!commonCollisionSelection(collision, skipMBGapEvents, rctSelection, rctLabel, rejectLimitedAcceptanceRct, requireZDCRct)) {
-    return false;
-  }
   if (eventSelectionMaskBits.size() == 0) {
     return true;
   }
@@ -192,13 +177,13 @@ std::vector<int> initialiseEventSelectionBits(const std::string& eventSelectionM
     eventSelectionMaskBits.push_back(JCollisionSel::selKINT7);
   }
   if (eventSelectionMasksContainSelection(eventSelectionMasks, "selUPCSingleGapA")) {
-    eventSelectionMaskBits.push_back(JCollisionSel::selUpcSingleGapA);
+    eventSelectionMaskBits.push_back(JCollisionSel::selUPCSingleGapA);
   }
   if (eventSelectionMasksContainSelection(eventSelectionMasks, "selUPCSingleGapC")) {
-    eventSelectionMaskBits.push_back(JCollisionSel::selUpcSingleGapC);
+    eventSelectionMaskBits.push_back(JCollisionSel::selUPCSingleGapC);
   }
   if (eventSelectionMasksContainSelection(eventSelectionMasks, "selUPCDoubleGap")) {
-    eventSelectionMaskBits.push_back(JCollisionSel::selUpcDoubleGap);
+    eventSelectionMaskBits.push_back(JCollisionSel::selUPCDoubleGap);
   }
 
   return eventSelectionMaskBits;
@@ -239,14 +224,37 @@ uint16_t setEventSelectionBit(T const& collision, int upcSelectionResult = o2::a
     SETBIT(bit, JCollisionSel::selNoCollInRofStandard);
   }
   if (upcSelectionResult == o2::aod::sgselector::SingleGapA) {
-    SETBIT(bit, JCollisionSel::selUpcSingleGapA);
+    SETBIT(bit, JCollisionSel::selUPCSingleGapA);
   }
   if (upcSelectionResult == o2::aod::sgselector::SingleGapC) {
-    SETBIT(bit, JCollisionSel::selUpcSingleGapC);
+    SETBIT(bit, JCollisionSel::selUPCSingleGapC);
   }
   if (upcSelectionResult == o2::aod::sgselector::DoubleGap) {
-    SETBIT(bit, JCollisionSel::selUpcDoubleGap);
+    SETBIT(bit, JCollisionSel::selUPCDoubleGap);
+  }
+
+  return bit;
+}
+
+template <typename T>
+uint16_t setMCEventSelectionBit(T const& bc)
+{
+  uint16_t bit = 0;
+  if (bc.selection_bit(o2::aod::evsel::kIsTriggerTVX)) {
+    SETBIT(bit, JCollisionSel::sel8);
+    SETBIT(bit, JCollisionSel::sel7);
+    SETBIT(bit, JCollisionSel::selKINT7);
+    SETBIT(bit, JCollisionSel::selTVX);
   }
+  SETBIT(bit, JCollisionSel::selNoTimeFrameBorder);
+  SETBIT(bit, JCollisionSel::selNoITSROFrameBorder);
+  SETBIT(bit, JCollisionSel::selNoSameBunchPileup);
+  SETBIT(bit, JCollisionSel::selIsGoodZvtxFT0vsPV);
+  SETBIT(bit, JCollisionSel::selNoCollInTimeRangeStandard);
+  SETBIT(bit, JCollisionSel::selNoCollInRofStandard);
+  SETBIT(bit, JCollisionSel::selUPCSingleGapA);
+  SETBIT(bit, JCollisionSel::selUPCSingleGapC);
+  SETBIT(bit, JCollisionSel::selUPCDoubleGap);
 
   return bit;
 }

PWGJE/DataModel/JetReducedData.h

@@ -219,6 +219,7 @@ DECLARE_SOA_COLUMN(XsectGen, xsectGen, float);
 DECLARE_SOA_COLUMN(XsectErr, xsectErr, float);
 DECLARE_SOA_COLUMN(PtHard, ptHard, float);
 DECLARE_SOA_COLUMN(IsOutlier, isOutlier, bool);
+DECLARE_SOA_COLUMN(EventSel, eventSel, uint16_t);
 DECLARE_SOA_BITMAP_COLUMN(Rct, rct, 32);
 DECLARE_SOA_COLUMN(GetGeneratorId, getGeneratorId, int);
 DECLARE_SOA_COLUMN(GetSubGeneratorId, getSubGeneratorId, int);
@@ -243,6 +244,7 @@ DECLARE_SOA_TABLE_STAGED(JMcCollisions, "JMCCOLLISION",
                          jmccollision::XsectGen,
                          jmccollision::XsectErr,
                          jmccollision::PtHard,
+                         jmccollision::EventSel,
                          jmccollision::Rct,
                          jmccollision::GetGeneratorId,
                          jmccollision::GetSubGeneratorId,

PWGJE/JetFinders/jetFinder.h

@@ -251,7 +251,7 @@ struct JetFinderTask {
 
   void processParticleLevelChargedJets(o2::soa::Filtered<o2::aod::JetMcCollisions>::iterator const& mcCollision, o2::soa::Filtered<o2::aod::JetParticles> const& particles)
   {
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections)) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections)) {
       return;
     }
     inputParticles.clear();
@@ -262,7 +262,7 @@ struct JetFinderTask {
 
   void processParticleLevelChargedEvtWiseSubJets(o2::soa::Filtered<o2::aod::JetMcCollisions>::iterator const& mcCollision, o2::soa::Filtered<o2::aod::JetParticlesSub> const& particles)
   {
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections)) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections)) {
       return;
     }
     inputParticles.clear();
@@ -273,7 +273,7 @@ struct JetFinderTask {
 
   void processParticleLevelNeutralJets(o2::soa::Filtered<o2::aod::JetMcCollisions>::iterator const& mcCollision, o2::soa::Filtered<o2::aod::JetParticles> const& particles)
   {
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections, "CBT_calo")) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections, "CBT_calo")) {
       return;
     }
     inputParticles.clear();
@@ -284,7 +284,7 @@ struct JetFinderTask {
 
   void processParticleLevelFullJets(o2::soa::Filtered<o2::aod::JetMcCollisions>::iterator const& mcCollision, o2::soa::Filtered<o2::aod::JetParticles> const& particles)
   {
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections, "CBT_calo")) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections, "CBT_calo")) {
       return;
     }
     inputParticles.clear();

PWGJE/JetFinders/jetFinderHF.h

@@ -239,7 +239,7 @@ struct JetFinderHFTask {
   template <bool isEvtWiseSub, typename T, typename U, typename V, typename M, typename N>
   void analyseMCP(T const& mcCollision, U const& particles, V const& candidate, M& jetsTableInput, N& constituentsTableInput, int jetTypeParticleLevel, float minJetPt, float maxJetPt)
   {
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections)) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections)) {
       return;
     }
 

PWGJE/JetFinders/jetFinderHFHFBar.h

@@ -250,7 +250,7 @@ struct JetFinderHFHFBarTask {
         return;
       }
     }
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections)) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections)) {
       return;
     }
 

PWGJE/JetFinders/jetFinderV0.h

@@ -206,7 +206,7 @@ struct JetFinderV0Task {
   void analyseMCP(T const& mcCollision, U const& particles, V const& candidates, int jetTypeParticleLevel, float minJetPt, float maxJetPt)
   {
 
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections)) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections)) {
       return;
     }
 

PWGJE/TableProducer/derivedDataProducer.cxx

@@ -193,6 +193,7 @@ struct JetDerivedDataProducerTask {
 
   std::vector<bool> trackMCSelection;
 
+  std::vector<uint16_t> bcSelMapping;
   std::vector<uint32_t> bcRctMapping;
 
   ctpRateFetcher rateFetcher;
@@ -267,18 +268,23 @@ struct JetDerivedDataProducerTask {
 
   void processBunchCrossings(soa::Join<aod::BCs, aod::Timestamps, aod::BcSels> const& bcs)
   {
+    bcSelMapping.clear();
+    bcSelMapping.resize(bcs.size(), ~uint16_t{0});
     bcRctMapping.clear();
     bcRctMapping.resize(bcs.size(), ~uint32_t{0});
     for (const auto& bc : bcs) {
       products.jBCsTable(bc.runNumber(), bc.globalBC(), bc.triggerMask(), bc.timestamp(), bc.alias_raw(), bc.selection_raw(), bc.rct_raw());
       products.jBCParentIndexTable(bc.globalIndex());
+      bcSelMapping[bc.globalIndex()] = jetderiveddatautilities::setMCEventSelectionBit(bc);
       bcRctMapping[bc.globalIndex()] = bc.rct_raw();
     }
   }
   PROCESS_SWITCH(JetDerivedDataProducerTask, processBunchCrossings, "produces derived bunch crossing table", true);
 
   void processBunchCrossingsWithoutSels(soa::Join<aod::BCs, aod::Timestamps> const& bcs)
   {
+    bcSelMapping.clear();
+    bcSelMapping.resize(bcs.size(), ~uint16_t{0});
     bcRctMapping.clear();
     bcRctMapping.resize(bcs.size(), ~uint32_t{0});
     for (const auto& bc : bcs) {
@@ -377,64 +383,73 @@ struct JetDerivedDataProducerTask {
 
   void processMcCollisions(soa::Join<aod::McCollisions, aod::HepMCXSections, aod::MultsExtraMC, aod::McCentFT0Ms>::iterator const& mcCollision)
   {
+    uint32_t selDecision = ~uint16_t{0};
     uint32_t rctDecision = ~uint32_t{0};
     int32_t bcId = -1;
     if (!config.isMCGenOnly) {
       bcId = mcCollision.bcId();
+      selDecision = bcSelMapping[bcId];
       rctDecision = bcRctMapping[bcId];
     } else {
       products.jBCsTable(-1, -1, -1, -1, ~uint32_t{0}, ~uint32_t{0}, ~uint32_t{0});
       bcId = products.jBCsTable.lastIndex();
     }
-    products.jMcCollisionsTable(bcId, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.multMCFV0A(), mcCollision.multMCFT0A(), mcCollision.multMCFT0C(), mcCollision.centFT0M(), mcCollision.weight(), mcCollision.accepted(), mcCollision.attempted(), mcCollision.xsectGen(), mcCollision.xsectErr(), mcCollision.ptHard(), rctDecision, mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
+    products.jMcCollisionsTable(bcId, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.multMCFV0A(), mcCollision.multMCFT0A(), mcCollision.multMCFT0C(), mcCollision.centFT0M(), mcCollision.weight(), mcCollision.accepted(), mcCollision.attempted(), mcCollision.xsectGen(), mcCollision.xsectErr(), mcCollision.ptHard(), selDecision, rctDecision, mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
     products.jMcCollisionsParentIndexTable(mcCollision.globalIndex());
   }
   PROCESS_SWITCH(JetDerivedDataProducerTask, processMcCollisions, "produces derived MC collision table", false);
 
   void processMcCollisionsWithoutCentralityAndMultiplicity(soa::Join<aod::McCollisions, aod::HepMCXSections>::iterator const& mcCollision)
   {
+
+    uint32_t selDecision = ~uint16_t{0};
     uint32_t rctDecision = ~uint32_t{0};
     int32_t bcId = -1;
     if (!config.isMCGenOnly) {
       bcId = mcCollision.bcId();
+      selDecision = bcSelMapping[bcId];
       rctDecision = bcRctMapping[bcId];
     } else {
       products.jBCsTable(-1, -1, -1, -1, ~uint32_t{0}, ~uint32_t{0}, ~uint32_t{0});
       bcId = products.jBCsTable.lastIndex();
     }
-    products.jMcCollisionsTable(bcId, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), -1.0, -1.0, -1.0, -1.0, mcCollision.weight(), mcCollision.accepted(), mcCollision.attempted(), mcCollision.xsectGen(), mcCollision.xsectErr(), mcCollision.ptHard(), rctDecision, mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
+    products.jMcCollisionsTable(bcId, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), -1.0, -1.0, -1.0, -1.0, mcCollision.weight(), mcCollision.accepted(), mcCollision.attempted(), mcCollision.xsectGen(), mcCollision.xsectErr(), mcCollision.ptHard(), selDecision, rctDecision, mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
     products.jMcCollisionsParentIndexTable(mcCollision.globalIndex());
   }
   PROCESS_SWITCH(JetDerivedDataProducerTask, processMcCollisionsWithoutCentralityAndMultiplicity, "produces derived MC collision table without centraility and multiplicity", false);
 
   void processMcCollisionsWithoutXsection(soa::Join<aod::McCollisions, aod::MultsExtraMC, aod::McCentFT0Ms>::iterator const& mcCollision)
   {
+    uint32_t selDecision = ~uint16_t{0};
     uint32_t rctDecision = ~uint32_t{0};
     int32_t bcId = -1;
     if (!config.isMCGenOnly) {
       bcId = mcCollision.bcId();
+      selDecision = bcSelMapping[bcId];
       rctDecision = bcRctMapping[bcId];
     } else {
       products.jBCsTable(-1, -1, -1, -1, ~uint32_t{0}, ~uint32_t{0}, ~uint32_t{0});
       bcId = products.jBCsTable.lastIndex();
     }
-    products.jMcCollisionsTable(bcId, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.multMCFV0A(), mcCollision.multMCFT0A(), mcCollision.multMCFT0C(), mcCollision.centFT0M(), mcCollision.weight(), 1, 1, 1.0, 1.0, 999.0, rctDecision, mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
+    products.jMcCollisionsTable(bcId, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.multMCFV0A(), mcCollision.multMCFT0A(), mcCollision.multMCFT0C(), mcCollision.centFT0M(), mcCollision.weight(), 1, 1, 1.0, 1.0, 999.0, selDecision, rctDecision, mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
     products.jMcCollisionsParentIndexTable(mcCollision.globalIndex());
   }
   PROCESS_SWITCH(JetDerivedDataProducerTask, processMcCollisionsWithoutXsection, "produces derived MC collision table without cross section information", false);
 
   void processMcCollisionsWithoutCentralityAndMultiplicityAndXsection(aod::McCollision const& mcCollision)
   {
+    uint32_t selDecision = ~uint16_t{0};
     uint32_t rctDecision = ~uint32_t{0};
     int32_t bcId = -1;
     if (!config.isMCGenOnly) {
       bcId = mcCollision.bcId();
+      selDecision = bcSelMapping[bcId];
       rctDecision = bcRctMapping[bcId];
     } else {
       products.jBCsTable(-1, -1, -1, -1, ~uint32_t{0}, ~uint32_t{0}, ~uint32_t{0});
       bcId = products.jBCsTable.lastIndex();
     }
-    products.jMcCollisionsTable(bcId, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), -1.0, -1.0, -1.0, -1.0, mcCollision.weight(), 1, 1, 1.0, 1.0, 999.0, rctDecision, mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
+    products.jMcCollisionsTable(bcId, mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), -1.0, -1.0, -1.0, -1.0, mcCollision.weight(), 1, 1, 1.0, 1.0, 999.0, selDecision, rctDecision, mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
     products.jMcCollisionsParentIndexTable(mcCollision.globalIndex());
   }
   PROCESS_SWITCH(JetDerivedDataProducerTask, processMcCollisionsWithoutCentralityAndMultiplicityAndXsection, "produces derived MC collision table without centrality, multiplicity and cross section information", false);

PWGJE/TableProducer/derivedDataWriter.cxx

@@ -685,7 +685,7 @@ struct JetDerivedDataWriter {
     mcCollisionMapping.resize(mcCollisions.size(), -1);
     for (auto const& mcCollision : mcCollisions) {
       if (mcCollision.isMcCollisionSelected()) {
-        products.storedJMcCollisionsTable(bcMapping[mcCollision.bcId()], mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.multFV0A(), mcCollision.multFT0A(), mcCollision.multFT0C(), mcCollision.centFT0M(), mcCollision.weight(), mcCollision.accepted(), mcCollision.attempted(), mcCollision.xsectGen(), mcCollision.xsectErr(), mcCollision.ptHard(), mcCollision.rct_raw(), mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
+        products.storedJMcCollisionsTable(bcMapping[mcCollision.bcId()], mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.multFV0A(), mcCollision.multFT0A(), mcCollision.multFT0C(), mcCollision.centFT0M(), mcCollision.weight(), mcCollision.accepted(), mcCollision.attempted(), mcCollision.xsectGen(), mcCollision.xsectErr(), mcCollision.ptHard(), mcCollision.eventSel(), mcCollision.rct_raw(), mcCollision.getGeneratorId(), mcCollision.getSubGeneratorId(), mcCollision.getSourceId(), mcCollision.impactParameter(), mcCollision.eventPlaneAngle());
         products.storedJMcCollisionsParentIndexTable(mcCollision.mcCollisionId());
         mcCollisionMapping[mcCollision.globalIndex()] = products.storedJMcCollisionsTable.lastIndex();
       }

PWGJE/TableProducer/eventwiseConstituentSubtractor.cxx

@@ -141,7 +141,7 @@ struct eventWiseConstituentSubtractorTask {
   template <typename T, typename U, typename V, typename M>
   void analyseHFMc(T const& mcCollision, U const& particles, V const& candidates, M& particleSubTable)
   {
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections) || std::abs(mcCollision.posZ()) > vertexZCut) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections) || std::abs(mcCollision.posZ()) > vertexZCut) {
       return;
     }
     for (auto& candidate : candidates) {
@@ -178,7 +178,7 @@ struct eventWiseConstituentSubtractorTask {
 
   void processMcCollisions(soa::Join<aod::JetMcCollisions, aod::BkgChargedMcRhos>::iterator const& mcCollision, soa::Filtered<aod::JetParticles> const& particles)
   {
-    if (!jetderiveddatautilities::selectMcCollision(mcCollision, skipMBGapEvents, applyRCTSelections) || std::abs(mcCollision.posZ()) > vertexZCut) {
+    if (!jetderiveddatautilities::selectCollision(mcCollision, eventSelectionBits, skipMBGapEvents, applyRCTSelections) || std::abs(mcCollision.posZ()) > vertexZCut) {
       return;
     }
     inputParticles.clear();