From 67a9056cc96cd103aa9bf47fa8b56d611026f586 Mon Sep 17 00:00:00 2001 From: nzardosh Date: Wed, 21 Aug 2024 22:39:45 +0200 Subject: [PATCH] PWGJE: Adding fixes to the track to collision associator and the derived data producer for memory --- PWGJE/Core/JetDerivedDataUtilities.h | 9 +- PWGJE/DataModel/JetReducedData.h | 70 +++-- PWGJE/DataModel/JetReducedDataDQ.h | 20 +- PWGJE/DataModel/JetReducedDataHF.h | 42 ++- PWGJE/DataModel/JetReducedDataV0.h | 24 +- .../TableProducer/jetderiveddataproducer.cxx | 65 +++-- PWGJE/TableProducer/jetderiveddatawriter.cxx | 256 +++++++++++------- PWGJE/Tasks/jetsubstructurehfoutput.cxx | 94 ++++++- PWGJE/Tasks/jetsubstructureoutput.cxx | 83 +++++- 9 files changed, 491 insertions(+), 172 deletions(-) diff --git a/PWGJE/Core/JetDerivedDataUtilities.h b/PWGJE/Core/JetDerivedDataUtilities.h index 82564e0df73..435a362e0db 100644 --- a/PWGJE/Core/JetDerivedDataUtilities.h +++ b/PWGJE/Core/JetDerivedDataUtilities.h @@ -35,8 +35,9 @@ enum JCollisionSel { selMCFull = 4, selMCFullPbPb = 5, selUnanchoredMC = 6, - sel7 = 7, - sel7KINT7 = 8 + selTVX = 7, + sel7 = 8, + sel7KINT7 = 9 }; template @@ -71,6 +72,9 @@ int initialiseEventSelection(std::string eventSelection) if (eventSelection == "selUnanchoredMC") { return JCollisionSel::selUnanchoredMC; } + if (eventSelection == "selTVX") { + return JCollisionSel::selTVX; + } if (eventSelection == "sel7") { return JCollisionSel::sel7; } @@ -100,6 +104,7 @@ uint16_t setEventSelectionBit(T const& collision) } } if (collision.selection_bit(o2::aod::evsel::kIsTriggerTVX)) { + SETBIT(bit, JCollisionSel::selTVX); SETBIT(bit, JCollisionSel::selUnanchoredMC); if (collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { SETBIT(bit, JCollisionSel::selMC); diff --git a/PWGJE/DataModel/JetReducedData.h b/PWGJE/DataModel/JetReducedData.h index 1b9a20557df..aedec0a9c3f 100644 --- a/PWGJE/DataModel/JetReducedData.h +++ b/PWGJE/DataModel/JetReducedData.h @@ -32,13 +32,20 @@ DECLARE_SOA_INDEX_COLUMN(BC, bc); DECLARE_SOA_COLUMN(RunNumber, runNumber, int); DECLARE_SOA_COLUMN(GlobalBC, globalBC, uint64_t); DECLARE_SOA_COLUMN(Timestamp, timestamp, uint64_t); +DECLARE_SOA_BITMAP_COLUMN(Alias, alias, 32); +DECLARE_SOA_BITMAP_COLUMN(Selection, selection, 64); +DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndITSROFBAndNoTFB, readCountsWithTVXAndITSROFBAndNoTFB, std::vector); } // namespace jbc DECLARE_SOA_TABLE(JBCs, "AOD", "JBC", o2::soa::Index<>, jbc::RunNumber, jbc::GlobalBC, - jbc::Timestamp); + jbc::Timestamp, + jbc::Alias, + jbc::Selection); using JBC = JBCs::iterator; @@ -47,6 +54,8 @@ DECLARE_SOA_TABLE(StoredJBCs, "AOD1", "JBC", jbc::RunNumber, jbc::GlobalBC, jbc::Timestamp, + jbc::Alias, + jbc::Selection, o2::soa::Marker<1>); using StoredJBC = StoredJBCs::iterator; @@ -58,6 +67,17 @@ DECLARE_SOA_TABLE(StoredJBCPIs, "AOD1", "JBCPI", jbc::BCId, o2::soa::Marker<1>); +DECLARE_SOA_TABLE(BCCounts, "AOD", "BCCOUNT", + jbc::ReadCounts, + jbc::ReadCountsWithTVX, + jbc::ReadCountsWithTVXAndITSROFBAndNoTFB); + +DECLARE_SOA_TABLE(StoredBCCounts, "AOD1", "BCCOUNT", + jbc::ReadCounts, + jbc::ReadCountsWithTVX, + jbc::ReadCountsWithTVXAndITSROFBAndNoTFB, + o2::soa::Marker<1>); + namespace jcollision { DECLARE_SOA_INDEX_COLUMN(Collision, collision); @@ -75,7 +95,9 @@ DECLARE_SOA_COLUMN(ChargedTriggerSel, chargedTriggerSel, uint8_t); DECLARE_SOA_COLUMN(FullTriggerSel, fullTriggerSel, uint32_t); DECLARE_SOA_COLUMN(ChargedHFTriggerSel, chargedHFTriggerSel, uint8_t); DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); -DECLARE_SOA_COLUMN(ReadSelectedCounts, readSelectedCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelection, readCountsWithTVXAndSelection, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelectionAndZVertex, readCountsWithTVXAndSelectionAndZVertex, std::vector); DECLARE_SOA_COLUMN(WrittenCounts, writtenCounts, std::vector); DECLARE_SOA_COLUMN(IsAmbiguous, isAmbiguous, bool); DECLARE_SOA_COLUMN(IsEMCALReadout, isEmcalReadout, bool); @@ -138,32 +160,24 @@ DECLARE_SOA_TABLE(StoredJCollisionBCs, "AOD1", "JCOLLISIONBC", DECLARE_SOA_TABLE(JChTrigSels, "AOD", "JCHTRIGSEL", jcollision::ChargedTriggerSel); -DECLARE_SOA_TABLE(StoredJChTrigSels, "AOD1", "JCHTRIGSEL", - jcollision::ChargedTriggerSel, - o2::soa::Marker<1>); - DECLARE_SOA_TABLE(JFullTrigSels, "AOD", "JFULLTRIGSEL", jcollision::FullTriggerSel); -DECLARE_SOA_TABLE(StoredJFullTrigSels, "AOD1", "JFULLTRIGSEL", - jcollision::FullTriggerSel, - o2::soa::Marker<1>); - DECLARE_SOA_TABLE(JChHFTrigSels, "AOD", "JCHHFTRIGSEL", jcollision::ChargedHFTriggerSel); -DECLARE_SOA_TABLE(StoredJChHFTrigSels, "AOD1", "JCHHFTRIGSEL", - jcollision::ChargedHFTriggerSel, - o2::soa::Marker<1>); - DECLARE_SOA_TABLE(CollisionCounts, "AOD", "COLLCOUNT", jcollision::ReadCounts, - jcollision::ReadSelectedCounts, + jcollision::ReadCountsWithTVX, + jcollision::ReadCountsWithTVXAndSelection, + jcollision::ReadCountsWithTVXAndSelectionAndZVertex, jcollision::WrittenCounts); DECLARE_SOA_TABLE(StoredCollisionCounts, "AOD1", "COLLCOUNT", jcollision::ReadCounts, - jcollision::ReadSelectedCounts, + jcollision::ReadCountsWithTVX, + jcollision::ReadCountsWithTVXAndSelection, + jcollision::ReadCountsWithTVXAndSelectionAndZVertex, jcollision::WrittenCounts, o2::soa::Marker<1>); @@ -220,8 +234,14 @@ DECLARE_SOA_INDEX_COLUMN(Track, track); DECLARE_SOA_COLUMN(Pt, pt, float); DECLARE_SOA_COLUMN(Eta, eta, float); DECLARE_SOA_COLUMN(Phi, phi, float); -DECLARE_SOA_COLUMN(DCAXY, dcaXY, float); +DECLARE_SOA_COLUMN(DCAX, dcaX, float); +DECLARE_SOA_COLUMN(DCAY, dcaY, float); DECLARE_SOA_COLUMN(DCAZ, dcaZ, float); +DECLARE_SOA_COLUMN(DCAXY, dcaXY, float); +DECLARE_SOA_COLUMN(DCAXYZ, dcaXYZ, float); +DECLARE_SOA_COLUMN(SigmaDCAZ, sigmadcaZ, float); +DECLARE_SOA_COLUMN(SigmaDCAXY, sigmadcaXY, float); +DECLARE_SOA_COLUMN(SigmaDCAXYZ, sigmadcaXYZ, float); DECLARE_SOA_COLUMN(Sigma1Pt, sigma1Pt, float); DECLARE_SOA_COLUMN(TrackSel, trackSel, uint8_t); DECLARE_SOA_DYNAMIC_COLUMN(Px, px, @@ -272,13 +292,25 @@ DECLARE_SOA_TABLE(StoredJTracks, "AOD1", "JTRACK", using StoredJTrack = StoredJTracks::iterator; DECLARE_SOA_TABLE(JTrackExtras, "AOD", "JTRACKEXTRA", - jtrack::DCAXY, + jtrack::DCAX, + jtrack::DCAY, jtrack::DCAZ, + jtrack::DCAXY, + jtrack::DCAXYZ, + jtrack::SigmaDCAZ, + jtrack::SigmaDCAXY, + jtrack::SigmaDCAXYZ, jtrack::Sigma1Pt); DECLARE_SOA_TABLE(StoredJTrackExtras, "AOD1", "JTRACKEXTRA", - jtrack::DCAXY, + jtrack::DCAX, + jtrack::DCAY, jtrack::DCAZ, + jtrack::DCAXY, + jtrack::DCAXYZ, + jtrack::SigmaDCAZ, + jtrack::SigmaDCAXY, + jtrack::SigmaDCAXYZ, jtrack::Sigma1Pt, o2::soa::Marker<1>); diff --git a/PWGJE/DataModel/JetReducedDataDQ.h b/PWGJE/DataModel/JetReducedDataDQ.h index 3a3cbd90c06..5b6be8d0dd9 100644 --- a/PWGJE/DataModel/JetReducedDataDQ.h +++ b/PWGJE/DataModel/JetReducedDataDQ.h @@ -52,10 +52,19 @@ DECLARE_SOA_INDEX_COLUMN(JMcCollision, mcCollision); DECLARE_SOA_INDEX_COLUMN(JMcParticle, mcParticle); } // namespace jdielectronindices +namespace dielectronbccounter +{ +DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndITSROFBAndNoTFB, readCountsWithTVXAndITSROFBAndNoTFB, std::vector); +} // namespace dielectronbccounter + namespace dielectroncollisioncounter { DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); -DECLARE_SOA_COLUMN(ReadSelectedCounts, readSelectedCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelection, readCountsWithTVXAndSelection, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelectionAndZVertex, readCountsWithTVXAndSelectionAndZVertex, std::vector); DECLARE_SOA_COLUMN(WrittenCounts, writtenCounts, std::vector); } // namespace dielectroncollisioncounter @@ -84,9 +93,16 @@ DECLARE_SOA_TABLE(StoredJDielectronIds, "AOD1", "JDIELID", jdielectronindices::Prong1Id, o2::soa::Marker<1>); +DECLARE_SOA_TABLE(DielectronBCCounts, "AOD", "DIELBCCOUNT", + dielectronbccounter::ReadCounts, + dielectronbccounter::ReadCountsWithTVX, + dielectronbccounter::ReadCountsWithTVXAndITSROFBAndNoTFB); + DECLARE_SOA_TABLE(DielectronCollisionCounts, "AOD", "DIELCOLLCOUNT", dielectroncollisioncounter::ReadCounts, - dielectroncollisioncounter::ReadSelectedCounts, + dielectroncollisioncounter::ReadCountsWithTVX, + dielectroncollisioncounter::ReadCountsWithTVXAndSelection, + dielectroncollisioncounter::ReadCountsWithTVXAndSelectionAndZVertex, dielectroncollisioncounter::WrittenCounts); namespace jdielectronmc diff --git a/PWGJE/DataModel/JetReducedDataHF.h b/PWGJE/DataModel/JetReducedDataHF.h index 83118732cd1..85e0f3f1013 100644 --- a/PWGJE/DataModel/JetReducedDataHF.h +++ b/PWGJE/DataModel/JetReducedDataHF.h @@ -35,10 +35,19 @@ DECLARE_SOA_INDEX_COLUMN(JMcCollision, mcCollision); DECLARE_SOA_INDEX_COLUMN(JMcParticle, mcParticle); } // namespace jd0indices +namespace d0bccounter +{ +DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndITSROFBAndNoTFB, readCountsWithTVXAndITSROFBAndNoTFB, std::vector); +} // namespace d0bccounter + namespace d0collisioncounter { DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); -DECLARE_SOA_COLUMN(ReadSelectedCounts, readSelectedCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelection, readCountsWithTVXAndSelection, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelectionAndZVertex, readCountsWithTVXAndSelectionAndZVertex, std::vector); DECLARE_SOA_COLUMN(WrittenCounts, writtenCounts, std::vector); } // namespace d0collisioncounter @@ -76,9 +85,16 @@ DECLARE_SOA_TABLE(StoredJD0PIds, "AOD1", "JD0PID", jd0indices::JMcParticleId, o2::soa::Marker<1>); +DECLARE_SOA_TABLE(D0BCCounts, "AOD", "D0BCCOUNT", + d0bccounter::ReadCounts, + d0bccounter::ReadCountsWithTVX, + d0bccounter::ReadCountsWithTVXAndITSROFBAndNoTFB); + DECLARE_SOA_TABLE(D0CollisionCounts, "AOD", "D0COLLCOUNT", d0collisioncounter::ReadCounts, - d0collisioncounter::ReadSelectedCounts, + d0collisioncounter::ReadCountsWithTVX, + d0collisioncounter::ReadCountsWithTVXAndSelection, + d0collisioncounter::ReadCountsWithTVXAndSelectionAndZVertex, d0collisioncounter::WrittenCounts); namespace jlcindices @@ -91,10 +107,19 @@ DECLARE_SOA_INDEX_COLUMN(JMcCollision, mcCollision); DECLARE_SOA_INDEX_COLUMN(JMcParticle, mcParticle); } // namespace jlcindices +namespace lcbccounter +{ +DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndITSROFBAndNoTFB, readCountsWithTVXAndITSROFBAndNoTFB, std::vector); +} // namespace lcbccounter + namespace lccollisioncounter { DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); -DECLARE_SOA_COLUMN(ReadSelectedCounts, readSelectedCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelection, readCountsWithTVXAndSelection, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelectionAndZVertex, readCountsWithTVXAndSelectionAndZVertex, std::vector); DECLARE_SOA_COLUMN(WrittenCounts, writtenCounts, std::vector); } // namespace lccollisioncounter @@ -134,9 +159,16 @@ DECLARE_SOA_TABLE(StoredJLcPIds, "AOD1", "JLCPID", jlcindices::JMcParticleId, o2::soa::Marker<1>); -DECLARE_SOA_TABLE(LcCollisionCounts, "AOD", "LcCOLLCOUNT", +DECLARE_SOA_TABLE(LcBCCounts, "AOD", "LCBCCOUNT", + lcbccounter::ReadCounts, + lcbccounter::ReadCountsWithTVX, + lcbccounter::ReadCountsWithTVXAndITSROFBAndNoTFB); + +DECLARE_SOA_TABLE(LcCollisionCounts, "AOD", "LCCOLLCOUNT", lccollisioncounter::ReadCounts, - lccollisioncounter::ReadSelectedCounts, + lccollisioncounter::ReadCountsWithTVX, + lccollisioncounter::ReadCountsWithTVXAndSelection, + lccollisioncounter::ReadCountsWithTVXAndSelectionAndZVertex, lccollisioncounter::WrittenCounts); } // namespace o2::aod diff --git a/PWGJE/DataModel/JetReducedDataV0.h b/PWGJE/DataModel/JetReducedDataV0.h index 8458d739cb9..24e09038ced 100644 --- a/PWGJE/DataModel/JetReducedDataV0.h +++ b/PWGJE/DataModel/JetReducedDataV0.h @@ -52,10 +52,19 @@ DECLARE_SOA_INDEX_COLUMN(JMcCollision, mcCollision); DECLARE_SOA_INDEX_COLUMN(JMcParticle, mcParticle); } // namespace jv0indices +namespace v0bccounter +{ +DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndITSROFBAndNoTFB, readCountsWithTVXAndITSROFBAndNoTFB, std::vector); +} // namespace v0bccounter + namespace v0collisioncounter { DECLARE_SOA_COLUMN(ReadCounts, readCounts, std::vector); -DECLARE_SOA_COLUMN(ReadSelectedCounts, readSelectedCounts, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVX, readCountsWithTVX, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelection, readCountsWithTVXAndSelection, std::vector); +DECLARE_SOA_COLUMN(ReadCountsWithTVXAndSelectionAndZVertex, readCountsWithTVXAndSelectionAndZVertex, std::vector); DECLARE_SOA_COLUMN(WrittenCounts, writtenCounts, std::vector); } // namespace v0collisioncounter @@ -78,15 +87,16 @@ DECLARE_SOA_TABLE(JV0Ids, "AOD", "JV0ID", jv0indices::PosTrackId, jv0indices::NegTrackId); -DECLARE_SOA_TABLE(StoredJV0Ids, "AOD1", "JV0ID", - jv0indices::JCollisionId, - jv0indices::PosTrackId, - jv0indices::NegTrackId, - o2::soa::Marker<1>); +DECLARE_SOA_TABLE(V0BCCounts, "AOD", "V0BCCOUNT", + v0bccounter::ReadCounts, + v0bccounter::ReadCountsWithTVX, + v0bccounter::ReadCountsWithTVXAndITSROFBAndNoTFB); DECLARE_SOA_TABLE(V0CollisionCounts, "AOD", "V0COLLCOUNT", v0collisioncounter::ReadCounts, - v0collisioncounter::ReadSelectedCounts, + v0collisioncounter::ReadCountsWithTVX, + v0collisioncounter::ReadCountsWithTVXAndSelection, + v0collisioncounter::ReadCountsWithTVXAndSelectionAndZVertex, v0collisioncounter::WrittenCounts); namespace jv0mc diff --git a/PWGJE/TableProducer/jetderiveddataproducer.cxx b/PWGJE/TableProducer/jetderiveddataproducer.cxx index e3d644c735e..bff1e239fe2 100644 --- a/PWGJE/TableProducer/jetderiveddataproducer.cxx +++ b/PWGJE/TableProducer/jetderiveddataproducer.cxx @@ -58,6 +58,7 @@ using namespace o2::framework; using namespace o2::framework::expressions; struct JetDerivedDataProducerTask { + Produces bcCountsTable; Produces collisionCountsTable; Produces jDummysTable; Produces jBCsTable; @@ -133,9 +134,15 @@ struct JetDerivedDataProducerTask { } } - void processBunchCrossings(soa::Join::iterator const& bc) + void processClearMaps(aod::Collisions const&) { - jBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp()); + trackCollisionMapping.clear(); + } + PROCESS_SWITCH(JetDerivedDataProducerTask, processClearMaps, "clears all maps", true); + + void processBunchCrossings(soa::Join::iterator const& bc) + { + jBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp(), bc.alias_raw(), bc.selection_raw()); jBCParentIndexTable(bc.globalIndex()); } PROCESS_SWITCH(JetDerivedDataProducerTask, processBunchCrossings, "produces derived bunch crossing table", false); @@ -214,34 +221,60 @@ struct JetDerivedDataProducerTask { } PROCESS_SWITCH(JetDerivedDataProducerTask, processMcCollisions, "produces derived MC collision table", false); - void processTracks(soa::Join::iterator const& track) + void processTracks(aod::Collision const& collision, soa::Join const& tracks) // we do not consider orphan tracks (tracks without a collision) in the JE framework { - jTracksTable(track.collisionId(), track.pt(), track.eta(), track.phi(), jetderiveddatautilities::setTrackSelectionBit(track, track.dcaZ(), dcaZMax)); - jTracksExtraTable(track.dcaXY(), track.dcaZ(), track.sigma1Pt()); // these need to be recalculated when we add the track to collision associator - jTracksParentIndexTable(track.globalIndex()); - trackCollisionMapping[{track.globalIndex(), track.collisionId()}] = jTracksTable.lastIndex(); + for (auto const& track : tracks) { + jTracksTable(collision.globalIndex(), track.pt(), track.eta(), track.phi(), jetderiveddatautilities::setTrackSelectionBit(track, track.dcaZ(), dcaZMax)); + auto trackParCov = getTrackParCov(track); + auto xyzTrack = trackParCov.getXYZGlo(); + float sigmaDCAXYZ; + float dcaXYZ = getDcaXYZ(track, &sigmaDCAXYZ); + jTracksExtraTable(xyzTrack.X() - collision.posX(), xyzTrack.Y() - collision.posY(), track.dcaZ(), track.dcaXY(), dcaXYZ, std::sqrt(track.sigmaDcaZ2()), std::sqrt(track.sigmaDcaXY2()), sigmaDCAXYZ, track.sigma1Pt()); // why is this getSigmaZY + jTracksParentIndexTable(track.globalIndex()); + trackCollisionMapping[{track.globalIndex(), collision.globalIndex()}] = jTracksTable.lastIndex(); + } } PROCESS_SWITCH(JetDerivedDataProducerTask, processTracks, "produces derived track table", true); - void processTracksWithCollisionAssociator(aod::Collisions const& collisions, soa::Join const&, soa::Join const&, aod::TrackAssoc const& assocCollisions) + void processTracksWithCollisionAssociator(aod::Collisions const& collisions, soa::Join const&, soa::Join const&, aod::TrackAssoc const& assocCollisions) { for (auto const& collision : collisions) { auto collisionTrackIndices = assocCollisions.sliceBy(perCollisionTrackIndices, collision.globalIndex()); for (auto const& collisionTrackIndex : collisionTrackIndices) { - auto track = collisionTrackIndex.track_as>(); + auto track = collisionTrackIndex.track_as>(); + auto trackParCov = getTrackParCov(track); if (track.collisionId() == collision.globalIndex()) { jTracksTable(collision.globalIndex(), track.pt(), track.eta(), track.phi(), jetderiveddatautilities::setTrackSelectionBit(track, track.dcaZ(), dcaZMax)); jTracksParentIndexTable(track.globalIndex()); - jTracksExtraTable(track.dcaXY(), track.dcaZ(), track.sigma1Pt()); + auto xyzTrack = trackParCov.getXYZGlo(); + float sigmaDCAXYZ; + float dcaXYZ = getDcaXYZ(track, &sigmaDCAXYZ); + jTracksExtraTable(xyzTrack.X() - collision.posX(), xyzTrack.Y() - collision.posY(), track.dcaZ(), track.dcaXY(), dcaXYZ, std::sqrt(track.sigmaDcaZ2()), std::sqrt(track.sigmaDcaXY2()), sigmaDCAXYZ, track.sigma1Pt()); // why is this getSigmaZY } else { auto bc = collision.bc_as>(); initCCDB(bc, runNumber, ccdb, doprocessCollisionsRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, doprocessCollisionsRun2); - auto trackPar = getTrackPar(track); - o2::gpu::gpustd::array dcaInfo{-999., -999.}; - o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, trackPar, 2.f, noMatCorr, &dcaInfo); - jTracksTable(collision.globalIndex(), trackPar.getPt(), trackPar.getEta(), trackPar.getPhi(), jetderiveddatautilities::setTrackSelectionBit(track, dcaInfo[1], dcaZMax)); // only qualitytracksWDCA are a reliable selection - jTracksParentIndexTable(-1); - jTracksExtraTable(dcaInfo[0], dcaInfo[1], track.sigma1Pt()); // sigma pT is not reliably updated! + o2::dataformats::DCA dcaCovInfo; + dcaCovInfo.set(-999., -999., -999., -999., -999.); + o2::dataformats::VertexBase collisionInfo; + collisionInfo.setPos({collision.posX(), collision.posY(), collision.posZ()}); + collisionInfo.setCov(collision.covXX(), collision.covXY(), collision.covYY(), collision.covXZ(), collision.covYZ(), collision.covZZ()); + o2::base::Propagator::Instance()->propagateToDCABxByBz(collisionInfo, trackParCov, 2.f, noMatCorr, &dcaCovInfo); + jTracksTable(collision.globalIndex(), trackParCov.getPt(), trackParCov.getEta(), trackParCov.getPhi(), jetderiveddatautilities::setTrackSelectionBit(track, dcaCovInfo.getZ(), dcaZMax)); // only qualitytracksWDCA are a reliable selection + jTracksParentIndexTable(track.globalIndex()); + auto xyzTrack = trackParCov.getXYZGlo(); + float dcaXY = dcaCovInfo.getY(); + float dcaZ = dcaCovInfo.getZ(); + float dcaXYZ = std::sqrt(dcaXY * dcaXY + dcaZ * dcaZ); + float covYY = dcaCovInfo.getSigmaY2(); + float covZZ = dcaCovInfo.getSigmaZ2(); + float covYZ = dcaCovInfo.getSigmaYZ(); + float sigmaDCAXYZ; + if (dcaXYZ < o2::constants::math::Almost0) { + sigmaDCAXYZ = o2::constants::math::VeryBig; // Protection against division by zero + } else { + sigmaDCAXYZ = covYY * (2.f * dcaXY / dcaXYZ) * (2.f * dcaXY / dcaXYZ) + covZZ * (2.f * dcaZ / dcaXYZ) * (2.f * dcaZ / dcaXYZ) + 2.f * covYZ * (2.f * dcaXY / dcaXYZ) * (2.f * dcaZ / dcaXYZ); + } + jTracksExtraTable(xyzTrack.X() - collision.posX(), xyzTrack.Y() - collision.posY(), dcaZ, dcaXY, dcaXYZ, std::sqrt(covZZ), std::sqrt(covYY), std::sqrt(sigmaDCAXYZ), std::sqrt(trackParCov.getSigma1Pt2())); } trackCollisionMapping[{track.globalIndex(), collision.globalIndex()}] = jTracksTable.lastIndex(); } diff --git a/PWGJE/TableProducer/jetderiveddatawriter.cxx b/PWGJE/TableProducer/jetderiveddatawriter.cxx index a5243216efb..84c1612de11 100644 --- a/PWGJE/TableProducer/jetderiveddatawriter.cxx +++ b/PWGJE/TableProducer/jetderiveddatawriter.cxx @@ -26,6 +26,7 @@ #include "Framework/ASoA.h" #include "Framework/runDataProcessing.h" +#include "Common/CCDB/EventSelectionParams.h" #include "PWGJE/Core/JetHFUtilities.h" #include "PWGJE/Core/JetDQUtilities.h" #include "PWGJE/DataModel/Jet.h" @@ -58,6 +59,7 @@ struct JetDerivedDataWriter { Configurable clusterEnergyMin{"clusterEnergyMin", 0.0, "Minimum cluster energy to accept event"}; Configurable downscaleFactor{"downscaleFactor", 1, "random downscale of selected events"}; + Configurable vertexZCut{"vertexZCut", 10.0, "z-vertex cut on event"}; Configurable centralityMin{"centralityMin", -999.0, "minimum centrality"}; Configurable centralityMax{"centralityMax", 999.0, "maximum centrality"}; Configurable trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range"}; @@ -65,16 +67,18 @@ struct JetDerivedDataWriter { Configurable trackPtSelectionMin{"trackPtSelectionMin", 0.15, "only save tracks that have a pT larger than this pT"}; Configurable trackEtaSelectionMax{"trackEtaSelectionMax", 0.9, "only save tracks that have an eta smaller than this eta"}; Configurable saveBCsTable{"saveBCsTable", true, "save the bunch crossing table to the output"}; - Configurable saveClustersTable{"saveClustersTable", true, "save the clusters table to the output"}; + Configurable saveClustersTable{"saveClustersTable", false, "save the clusters table to the output"}; Configurable saveD0Table{"saveD0Table", false, "save the D0 table to the output"}; Configurable saveLcTable{"saveLcTable", false, "save the Lc table to the output"}; Configurable saveDielectronTable{"saveDielectronTable", false, "save the Dielectron table to the output"}; + Configurable vertexZCutForCounting{"vertexZCutForCounting", 10.0, "choose z-vertex cut for collision counter"}; Configurable eventSelectionForCounting{"eventSelectionForCounting", "sel8", "choose event selection for collision counter"}; Configurable triggerMasks{"triggerMasks", "", "possible JE Trigger masks: fJetChLowPt,fJetChHighPt,fTrackLowPt,fTrackHighPt,fJetD0ChLowPt,fJetD0ChHighPt,fJetLcChLowPt,fJetLcChHighPt,fEMCALReadout,fJetFullHighPt,fJetFullLowPt,fJetNeutralHighPt,fJetNeutralLowPt,fGammaVeryHighPtEMCAL,fGammaVeryHighPtDCAL,fGammaHighPtEMCAL,fGammaHighPtDCAL,fGammaLowPtEMCAL,fGammaLowPtDCAL,fGammaVeryLowPtEMCAL,fGammaVeryLowPtDCAL"}; } config; struct : ProducesGroup { + Produces storedBCCountsTable; Produces storedCollisionCountsTable; Produces storedJDummysTable; Produces storedJBCsTable; @@ -178,21 +182,21 @@ struct JetDerivedDataWriter { return true; } - void processCollisions(aod::JCollisions const& collisions) + void processSetupCollisions(aod::JCollisions const& collisions) { collisionFlag.clear(); collisionFlag.resize(collisions.size()); std::fill(collisionFlag.begin(), collisionFlag.end(), false); } - void processMcCollisions(aod::JMcCollisions const& McCollisions) + void processSetupMcCollisions(aod::JMcCollisions const& McCollisions) { McCollisionFlag.clear(); McCollisionFlag.resize(McCollisions.size()); std::fill(McCollisionFlag.begin(), McCollisionFlag.end(), false); } - void processAllCollisionsWithDownscaling(aod::JCollisions const& collisions) + void processSetupAllCollisionsWithDownscaling(aod::JCollisions const& collisions) { collisionFlag.clear(); collisionFlag.resize(collisions.size()); @@ -205,7 +209,7 @@ struct JetDerivedDataWriter { } } - void processAllMcCollisionsWithDownscaling(aod::JMcCollisions const& McCollisions) + void processSetupAllMcCollisionsWithDownscaling(aod::JMcCollisions const& McCollisions) { McCollisionFlag.clear(); McCollisionFlag.resize(McCollisions.size()); @@ -219,7 +223,7 @@ struct JetDerivedDataWriter { } template - void processDownscaling(T const& collisions) + void processDoDownscaling(T const& collisions) { for (const auto& collision : collisions) { if constexpr (std::is_same_v, aod::JCollisions>) { @@ -235,170 +239,230 @@ struct JetDerivedDataWriter { } } - void processEventTriggers(aod::JCollision const& collision) + void processSetupEventTriggering(aod::JCollision const& collision) { if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { collisionFlag[collision.globalIndex()] = true; } } - void processCollisionSelections(aod::JCollision const& collision) + void processDoCollisionSelections(aod::JCollision const& collision) { // can also add event selection like sel8 but goes a little against the derived data idea - if (collision.centrality() < config.centralityMin || collision.centrality() >= config.centralityMax || collision.trackOccupancyInTimeRange() > config.trackOccupancyInTimeRangeMax) { + if (collision.centrality() < config.centralityMin || collision.centrality() >= config.centralityMax || collision.trackOccupancyInTimeRange() > config.trackOccupancyInTimeRangeMax || std::abs(collision.posZ()) > config.vertexZCut) { collisionFlag[collision.globalIndex()] = false; } } template - void processTriggerObjects(T& triggerObjects) + void processSelectionObjects(T& selectionObjects) { - float triggerObjectPtMin = 0.0; + float selectionObjectPtMin = 0.0; if constexpr (std::is_same_v, aod::ChargedJets> || std::is_same_v, aod::ChargedMCDetectorLevelJets>) { - triggerObjectPtMin = config.chargedJetPtMin; + selectionObjectPtMin = config.chargedJetPtMin; } else if constexpr (std::is_same_v, aod::ChargedEventWiseSubtractedJets> || std::is_same_v, aod::ChargedMCDetectorLevelEventWiseSubtractedJets>) { - triggerObjectPtMin = config.chargedEventWiseSubtractedJetPtMin; + selectionObjectPtMin = config.chargedEventWiseSubtractedJetPtMin; } else if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets>) { - triggerObjectPtMin = config.chargedMCPJetPtMin; + selectionObjectPtMin = config.chargedMCPJetPtMin; } else if constexpr (std::is_same_v, aod::NeutralJets> || std::is_same_v, aod::NeutralMCDetectorLevelJets>) { - triggerObjectPtMin = config.neutralJetPtMin; + selectionObjectPtMin = config.neutralJetPtMin; } else if constexpr (std::is_same_v, aod::NeutralMCParticleLevelJets>) { - triggerObjectPtMin = config.neutralMCPJetPtMin; + selectionObjectPtMin = config.neutralMCPJetPtMin; } else if constexpr (std::is_same_v, aod::FullJets> || std::is_same_v, aod::FullMCDetectorLevelJets>) { - triggerObjectPtMin = config.fullJetPtMin; + selectionObjectPtMin = config.fullJetPtMin; } else if constexpr (std::is_same_v, aod::FullMCParticleLevelJets>) { - triggerObjectPtMin = config.fullMCPJetPtMin; + selectionObjectPtMin = config.fullMCPJetPtMin; } else if constexpr (std::is_same_v, aod::D0ChargedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelJets>) { - triggerObjectPtMin = config.chargedD0JetPtMin; + selectionObjectPtMin = config.chargedD0JetPtMin; } else if constexpr (std::is_same_v, aod::D0ChargedEventWiseSubtractedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelEventWiseSubtractedJets>) { - triggerObjectPtMin = config.chargedEventWiseSubtractedD0JetPtMin; + selectionObjectPtMin = config.chargedEventWiseSubtractedD0JetPtMin; } else if constexpr (std::is_same_v, aod::D0ChargedMCParticleLevelJets>) { - triggerObjectPtMin = config.chargedD0MCPJetPtMin; + selectionObjectPtMin = config.chargedD0MCPJetPtMin; } else if constexpr (std::is_same_v, aod::LcChargedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelJets>) { - triggerObjectPtMin = config.chargedLcJetPtMin; + selectionObjectPtMin = config.chargedLcJetPtMin; } else if constexpr (std::is_same_v, aod::LcChargedEventWiseSubtractedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelEventWiseSubtractedJets>) { - triggerObjectPtMin = config.chargedEventWiseSubtractedLcJetPtMin; + selectionObjectPtMin = config.chargedEventWiseSubtractedLcJetPtMin; } else if constexpr (std::is_same_v, aod::LcChargedMCParticleLevelJets>) { - triggerObjectPtMin = config.chargedLcMCPJetPtMin; + selectionObjectPtMin = config.chargedLcMCPJetPtMin; } else if constexpr (std::is_same_v, aod::DielectronChargedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelJets>) { - triggerObjectPtMin = config.chargedDielectronJetPtMin; + selectionObjectPtMin = config.chargedDielectronJetPtMin; } else if constexpr (std::is_same_v, aod::DielectronChargedEventWiseSubtractedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelEventWiseSubtractedJets>) { - triggerObjectPtMin = config.chargedEventWiseSubtractedDielectronJetPtMin; + selectionObjectPtMin = config.chargedEventWiseSubtractedDielectronJetPtMin; } else if constexpr (std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { - triggerObjectPtMin = config.chargedDielectronMCPJetPtMin; + selectionObjectPtMin = config.chargedDielectronMCPJetPtMin; } else if constexpr (std::is_same_v, aod::JTracks>) { - triggerObjectPtMin = config.triggerTrackPtMin; + selectionObjectPtMin = config.triggerTrackPtMin; } else if constexpr (std::is_same_v, aod::JClusters>) { - triggerObjectPtMin = config.clusterEnergyMin; + selectionObjectPtMin = config.clusterEnergyMin; } else { - triggerObjectPtMin = 0.0; + selectionObjectPtMin = 0.0; } - for (const auto& triggerObject : triggerObjects) { + for (const auto& selectionObject : selectionObjects) { bool isTriggerObject = false; if constexpr (std::is_same_v, aod::JClusters>) { - if (triggerObject.energy() >= triggerObjectPtMin) { + if (selectionObject.energy() >= selectionObjectPtMin) { isTriggerObject = true; } } else { - if (triggerObject.pt() >= triggerObjectPtMin) { + if (selectionObject.pt() >= selectionObjectPtMin) { isTriggerObject = true; } } if (isTriggerObject) { if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets> || std::is_same_v, aod::NeutralMCParticleLevelJets> || std::is_same_v, aod::FullMCParticleLevelJets> || std::is_same_v, aod::D0ChargedMCParticleLevelJets> || std::is_same_v, aod::LcChargedMCParticleLevelJets> || std::is_same_v, aod::BplusChargedMCParticleLevelJets> || std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { - McCollisionFlag[triggerObject.mcCollisionId()] = true; + McCollisionFlag[selectionObject.mcCollisionId()] = true; } else { - collisionFlag[triggerObject.collisionId()] = true; + collisionFlag[selectionObject.collisionId()] = true; } } } } // Todo : Check memory consumption of having so many Process Switches - PROCESS_SWITCH(JetDerivedDataWriter, processCollisions, "setup the writing for data and MCD based on collisions", true); - PROCESS_SWITCH(JetDerivedDataWriter, processMcCollisions, "setup the writing for MCP based on mcCollisions", false); - PROCESS_SWITCH(JetDerivedDataWriter, processAllCollisionsWithDownscaling, "setup the writing of untriggered collisions with downscaling", false); - PROCESS_SWITCH(JetDerivedDataWriter, processAllMcCollisionsWithDownscaling, "setup the writing of untriggered mccollisions with downscaling", false); - PROCESS_SWITCH(JetDerivedDataWriter, processEventTriggers, "process software triggers", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processChargedJets, "process charged jets", true); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processChargedEventWiseSubtractedJets, "process charged event-wise subtracted jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processChargedMCDJets, "process charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processChargedMCDetectorLevelEventWiseSubtractedJets, "process charged event-wise subtracted mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processChargedMCPJets, "process charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processNeutralJets, "process neutral jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processNeutralMCDJets, "process neutral mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processNeutralMCPJets, "process neutral mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processFullJets, "process full jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processFullMCDJets, "process full mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processFullMCPJets, "process full mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processD0ChargedJets, "process D0 charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processD0ChargedEventWiseSubtractedJets, "process D0 event-wise subtracted charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processD0ChargedMCDJets, "process D0 charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processD0ChargedMCDetectorLevelEventWiseSubtractedJets, "process D0 event-wise subtracted charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processD0ChargedMCPJets, "process D0 charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processLcChargedJets, "process Lc charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processLcChargedEventWiseSubtractedJets, "process Lc event-wise subtracted charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processLcChargedMCDJets, "process Lc charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processLcChargedMCDetectorLevelEventWiseSubtractedJets, "process Lc event-wise subtracted charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processLcChargedMCPJets, "process Lc charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processDielectronChargedJets, "process Dielectron charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processDielectronChargedEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processDielectronChargedMCDJets, "process Dielectron charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processDielectronChargedMCDetectorLevelEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processDielectronChargedMCPJets, "process Dielectron charged mcp jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processClusters, "process EMCal clusters", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processTriggerObjects, processTriggerTracks, "process trigger tracks", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processDownscaling, processCollisionDownscaling, "process downsaling of triggered collisions", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processDownscaling, processMcCollisionDownscaling, "process downsaling of triggered mccollisions", false); - PROCESS_SWITCH(JetDerivedDataWriter, processCollisionSelections, "process event selections for saved events", false); - - void processDummyTable(aod::JDummys const&) + PROCESS_SWITCH(JetDerivedDataWriter, processSetupCollisions, "setup the writing for data and MCD based on collisions", true); + PROCESS_SWITCH(JetDerivedDataWriter, processSetupMcCollisions, "setup the writing for MCP based on mcCollisions", false); + PROCESS_SWITCH(JetDerivedDataWriter, processSetupAllCollisionsWithDownscaling, "setup the writing of untriggered collisions with downscaling", false); + PROCESS_SWITCH(JetDerivedDataWriter, processSetupAllMcCollisionsWithDownscaling, "setup the writing of untriggered mccollisions with downscaling", false); + PROCESS_SWITCH(JetDerivedDataWriter, processSetupEventTriggering, "process software triggers", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedJets, "process charged jets", true); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedEventWiseSubtractedJets, "process charged event-wise subtracted jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedMCDJets, "process charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedMCDetectorLevelEventWiseSubtractedJets, "process charged event-wise subtracted mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingChargedMCPJets, "process charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingNeutralJets, "process neutral jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingNeutralMCDJets, "process neutral mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingNeutralMCPJets, "process neutral mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingFullJets, "process full jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingFullMCDJets, "process full mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingFullMCPJets, "process full mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedJets, "process D0 charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedEventWiseSubtractedJets, "process D0 event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedMCDJets, "process D0 charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedMCDetectorLevelEventWiseSubtractedJets, "process D0 event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingD0ChargedMCPJets, "process D0 charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedJets, "process Lc charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedEventWiseSubtractedJets, "process Lc event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedMCDJets, "process Lc charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedMCDetectorLevelEventWiseSubtractedJets, "process Lc event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingLcChargedMCPJets, "process Lc charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedJets, "process Dielectron charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedMCDJets, "process Dielectron charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedMCDetectorLevelEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingDielectronChargedMCPJets, "process Dielectron charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingClusters, "process EMCal clusters", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingTracks, "process high pt tracks", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processDoDownscaling, processCollisionDownscaling, "process downsaling of triggered collisions", false); + PROCESS_SWITCH_FULL(JetDerivedDataWriter, processDoDownscaling, processMcCollisionDownscaling, "process downsaling of triggered mccollisions", false); + PROCESS_SWITCH(JetDerivedDataWriter, processDoCollisionSelections, "process event selections for saved events", false); + + void processStoreDummyTable(aod::JDummys const&) { products.storedJDummysTable(1); } - PROCESS_SWITCH(JetDerivedDataWriter, processDummyTable, "write out dummy output table", true); + PROCESS_SWITCH(JetDerivedDataWriter, processStoreDummyTable, "write out dummy output table", true); - void processCollisionCounting(aod::JCollisions const& collisions, aod::CollisionCounts const& collisionCounts) + void processStoreBCCounting(aod::JBCs const& bcs, aod::BCCounts const& bcCounts) + { + int readBCCounter = 0; + int readBCWithTVXCounter = 0; + int readBCWithTVXAndITSROFBAndNoTFBCounter = 0; + for (const auto& bc : bcs) { + readBCCounter++; + if (bc.selection_bit(aod::evsel::EventSelectionFlags::kIsTriggerTVX)) { + readBCWithTVXCounter++; + if (bc.selection_bit(aod::evsel::EventSelectionFlags::kNoITSROFrameBorder) && bc.selection_bit(aod::evsel::EventSelectionFlags::kNoTimeFrameBorder)) { + readBCWithTVXAndITSROFBAndNoTFBCounter++; + } + } + } + std::vector previousReadCounts; + std::vector previousReadCountsWithTVX; + std::vector previousReadCountsWithTVXAndITSROFBAndNoTFB; + int iPreviousDataFrame = 0; + for (const auto& bcCount : bcCounts) { + auto readBCCounterSpan = bcCount.readCounts(); + auto readBCWithTVXCounterSpan = bcCount.readCountsWithTVX(); + auto readBCWithTVXAndITSROFBAndNoTFBCounterSpan = bcCount.readCountsWithTVXAndITSROFBAndNoTFB(); + if (iPreviousDataFrame == 0) { + std::copy(readBCCounterSpan.begin(), readBCCounterSpan.end(), std::back_inserter(previousReadCounts)); + std::copy(readBCWithTVXCounterSpan.begin(), readBCWithTVXCounterSpan.end(), std::back_inserter(previousReadCountsWithTVX)); + std::copy(readBCWithTVXAndITSROFBAndNoTFBCounterSpan.begin(), readBCWithTVXAndITSROFBAndNoTFBCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndITSROFBAndNoTFB)); + } else { + for (unsigned int i = 0; i < previousReadCounts.size(); i++) { + previousReadCounts[i] += readBCCounterSpan[i]; + previousReadCountsWithTVX[i] += readBCWithTVXCounterSpan[i]; + previousReadCountsWithTVXAndITSROFBAndNoTFB[i] += readBCWithTVXAndITSROFBAndNoTFBCounterSpan[i]; + } + } + iPreviousDataFrame++; + } + previousReadCounts.push_back(readBCCounter); + previousReadCountsWithTVX.push_back(readBCWithTVXCounter); + previousReadCountsWithTVXAndITSROFBAndNoTFB.push_back(readBCWithTVXAndITSROFBAndNoTFBCounter); + products.storedBCCountsTable(previousReadCounts, previousReadCountsWithTVX, previousReadCountsWithTVXAndITSROFBAndNoTFB); + } + PROCESS_SWITCH(JetDerivedDataWriter, processStoreBCCounting, "write out bc counting output table", true); + + void processStoreCollisionCounting(aod::JCollisions const& collisions, aod::CollisionCounts const& collisionCounts) { int readCollisionCounter = 0; - int readSelectedCollisionCounter = 0; + int readCollisionWithTVXCounter = 0; + int readCollisionWithTVXAndSelectionCounter = 0; + int readCollisionWithTVXAndSelectionAndZVertexCounter = 0; int writtenCollisionCounter = 0; for (const auto& collision : collisions) { readCollisionCounter++; - if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { - readSelectedCollisionCounter++; - } if (collisionFlag[collision.globalIndex()]) { writtenCollisionCounter++; } + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selTVX)) { + readCollisionWithTVXCounter++; + if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { + readCollisionWithTVXAndSelectionCounter++; + if (std::abs(collision.posZ()) < config.vertexZCutForCounting) { + readCollisionWithTVXAndSelectionAndZVertexCounter++; + } + } + } } std::vector previousReadCounts; - std::vector previousReadSelectedCounts; + std::vector previousReadCountsWithTVX; + std::vector previousReadCountsWithTVXAndSelection; + std::vector previousReadCountsWithTVXAndSelectionAndZVertex; std::vector previousWrittenCounts; int iPreviousDataFrame = 0; for (const auto& collisionCount : collisionCounts) { auto readCollisionCounterSpan = collisionCount.readCounts(); - auto readSelectedCollisionCounterSpan = collisionCount.readSelectedCounts(); + auto readCollisionWithTVXCounterSpan = collisionCount.readCountsWithTVX(); + auto readCollisionWithTVXAndSelectionCounterSpan = collisionCount.readCountsWithTVXAndSelection(); + auto readCollisionWithTVXAndSelectionAndZVertexCounterSpan = collisionCount.readCountsWithTVXAndSelectionAndZVertex(); auto writtenCollisionCounterSpan = collisionCount.writtenCounts(); if (iPreviousDataFrame == 0) { std::copy(readCollisionCounterSpan.begin(), readCollisionCounterSpan.end(), std::back_inserter(previousReadCounts)); - std::copy(readSelectedCollisionCounterSpan.begin(), readSelectedCollisionCounterSpan.end(), std::back_inserter(previousReadSelectedCounts)); + std::copy(readCollisionWithTVXCounterSpan.begin(), readCollisionWithTVXCounterSpan.end(), std::back_inserter(previousReadCountsWithTVX)); + std::copy(readCollisionWithTVXAndSelectionCounterSpan.begin(), readCollisionWithTVXAndSelectionCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndSelection)); + std::copy(readCollisionWithTVXAndSelectionAndZVertexCounterSpan.begin(), readCollisionWithTVXAndSelectionAndZVertexCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndSelectionAndZVertex)); std::copy(writtenCollisionCounterSpan.begin(), writtenCollisionCounterSpan.end(), std::back_inserter(previousWrittenCounts)); } else { for (unsigned int i = 0; i < previousReadCounts.size(); i++) { previousReadCounts[i] += readCollisionCounterSpan[i]; - previousReadSelectedCounts[i] += readSelectedCollisionCounterSpan[i]; + previousReadCountsWithTVX[i] += readCollisionWithTVXCounterSpan[i]; + previousReadCountsWithTVXAndSelection[i] += readCollisionWithTVXAndSelectionCounterSpan[i]; + previousReadCountsWithTVXAndSelectionAndZVertex[i] += readCollisionWithTVXAndSelectionAndZVertexCounterSpan[i]; previousWrittenCounts[i] += writtenCollisionCounterSpan[i]; } } iPreviousDataFrame++; } previousReadCounts.push_back(readCollisionCounter); - previousReadSelectedCounts.push_back(readSelectedCollisionCounter); + previousReadCountsWithTVX.push_back(readCollisionWithTVXCounter); + previousReadCountsWithTVXAndSelection.push_back(readCollisionWithTVXAndSelectionCounter); + previousReadCountsWithTVXAndSelectionAndZVertex.push_back(readCollisionWithTVXAndSelectionAndZVertexCounter); previousWrittenCounts.push_back(writtenCollisionCounter); - products.storedCollisionCountsTable(previousReadCounts, previousReadSelectedCounts, previousWrittenCounts); + products.storedCollisionCountsTable(previousReadCounts, previousReadCountsWithTVX, previousReadCountsWithTVXAndSelection, previousReadCountsWithTVXAndSelectionAndZVertex, previousWrittenCounts); } - PROCESS_SWITCH(JetDerivedDataWriter, processCollisionCounting, "write out collision counting output table", false); + PROCESS_SWITCH(JetDerivedDataWriter, processStoreCollisionCounting, "write out collision counting output table", true); - void processData(soa::Join::iterator const& collision, soa::Join const&, soa::Join const& tracks, soa::Join const& clusters, CollisionsD0 const& D0Collisions, CandidatesD0Data const& D0s, CollisionsLc const& LcCollisions, CandidatesLcData const& Lcs, CollisionsDielectron const& DielectronCollisions, CandidatesDielectronData const& Dielectrons) + void processStoreData(soa::Join::iterator const& collision, soa::Join const&, soa::Join const& tracks, soa::Join const& clusters, CollisionsD0 const& D0Collisions, CandidatesD0Data const& D0s, CollisionsLc const& LcCollisions, CandidatesLcData const& Lcs, CollisionsDielectron const& DielectronCollisions, CandidatesDielectronData const& Dielectrons) { std::map bcMapping; std::map trackMapping; @@ -407,7 +471,7 @@ struct JetDerivedDataWriter { if (config.saveBCsTable) { auto bc = collision.bc_as>(); if (std::find(bcIndicies.begin(), bcIndicies.end(), bc.globalIndex()) == bcIndicies.end()) { - products.storedJBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp()); + products.storedJBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp(), bc.alias_raw(), bc.selection_raw()); products.storedJBCParentIndexTable(bc.bcId()); bcIndicies.push_back(bc.globalIndex()); bcMapping.insert(std::make_pair(bc.globalIndex(), products.storedJBCsTable.lastIndex())); @@ -436,7 +500,7 @@ struct JetDerivedDataWriter { continue; } products.storedJTracksTable(products.storedJCollisionsTable.lastIndex(), o2::math_utils::detail::truncateFloatFraction(track.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(track.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.phi(), precisionPositionMask), track.trackSel()); - products.storedJTracksExtraTable(o2::math_utils::detail::truncateFloatFraction(track.dcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigma1Pt(), precisionMomentumMask)); + products.storedJTracksExtraTable(o2::math_utils::detail::truncateFloatFraction(track.dcaX(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigma1Pt(), precisionMomentumMask)); products.storedJTracksParentIndexTable(track.trackId()); trackMapping.insert(std::make_pair(track.globalIndex(), products.storedJTracksTable.lastIndex())); } @@ -537,9 +601,9 @@ struct JetDerivedDataWriter { } // process switch for output writing must be last // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processData, "write out data output tables", false); + PROCESS_SWITCH(JetDerivedDataWriter, processStoreData, "write out data output tables", false); - void processMC(soa::Join const& mcCollisions, soa::Join const& collisions, soa::Join const&, soa::Join const& tracks, soa::Join const& clusters, soa::Join const& particles, CollisionsD0 const& D0Collisions, CandidatesD0MCD const& D0s, soa::Join const& D0McCollisions, CandidatesD0MCP const& D0Particles, CollisionsLc const& LcCollisions, CandidatesLcMCD const& Lcs, soa::Join const& LcMcCollisions, CandidatesLcMCP const& LcParticles, CollisionsDielectron const& DielectronCollisions, CandidatesDielectronMCD const& Dielectrons, McCollisionsDielectron const& DielectronMcCollisions, CandidatesDielectronMCP const& DielectronParticles) + void processStoreMC(soa::Join const& mcCollisions, soa::Join const& collisions, soa::Join const&, soa::Join const& tracks, soa::Join const& clusters, soa::Join const& particles, CollisionsD0 const& D0Collisions, CandidatesD0MCD const& D0s, soa::Join const& D0McCollisions, CandidatesD0MCP const& D0Particles, CollisionsLc const& LcCollisions, CandidatesLcMCD const& Lcs, soa::Join const& LcMcCollisions, CandidatesLcMCP const& LcParticles, CollisionsDielectron const& DielectronCollisions, CandidatesDielectronMCD const& Dielectrons, McCollisionsDielectron const& DielectronMcCollisions, CandidatesDielectronMCP const& DielectronParticles) { std::map bcMapping; std::map paticleMapping; @@ -696,7 +760,7 @@ struct JetDerivedDataWriter { if (config.saveBCsTable) { auto bc = collision.bc_as>(); if (std::find(bcIndicies.begin(), bcIndicies.end(), bc.globalIndex()) == bcIndicies.end()) { - products.storedJBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp()); + products.storedJBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp(), bc.alias_raw(), bc.selection_raw()); products.storedJBCParentIndexTable(bc.bcId()); bcIndicies.push_back(bc.globalIndex()); bcMapping.insert(std::make_pair(bc.globalIndex(), products.storedJBCsTable.lastIndex())); @@ -731,7 +795,7 @@ struct JetDerivedDataWriter { continue; } products.storedJTracksTable(products.storedJCollisionsTable.lastIndex(), o2::math_utils::detail::truncateFloatFraction(track.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(track.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.phi(), precisionPositionMask), track.trackSel()); - products.storedJTracksExtraTable(o2::math_utils::detail::truncateFloatFraction(track.dcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigma1Pt(), precisionMomentumMask)); + products.storedJTracksExtraTable(o2::math_utils::detail::truncateFloatFraction(track.dcaX(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.dcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXY(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigmadcaXYZ(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(track.sigma1Pt(), precisionMomentumMask)); products.storedJTracksParentIndexTable(track.trackId()); if (track.has_mcParticle()) { @@ -896,9 +960,9 @@ struct JetDerivedDataWriter { } // process switch for output writing must be last // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processMC, "write out data output tables for mc", false); + PROCESS_SWITCH(JetDerivedDataWriter, processStoreMC, "write out data output tables for mc", false); - void processMCP(soa::Join const& mcCollisions, soa::Join const& particles, McCollisionsD0 const& D0McCollisions, CandidatesD0MCP const& D0Particles, McCollisionsLc const& LcMcCollisions, CandidatesLcMCP const& LcParticles, McCollisionsDielectron const& DielectronMcCollisions, CandidatesDielectronMCP const& DielectronParticles) + void processStoreMCP(soa::Join const& mcCollisions, soa::Join const& particles, McCollisionsD0 const& D0McCollisions, CandidatesD0MCP const& D0Particles, McCollisionsLc const& LcMcCollisions, CandidatesLcMCP const& LcParticles, McCollisionsDielectron const& DielectronMcCollisions, CandidatesDielectronMCP const& DielectronParticles) { int particleTableIndex = 0; @@ -1025,7 +1089,7 @@ struct JetDerivedDataWriter { } // process switch for output writing must be last // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processMCP, "write out data output tables for mcp", false); + PROCESS_SWITCH(JetDerivedDataWriter, processStoreMCP, "write out data output tables for mcp", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) diff --git a/PWGJE/Tasks/jetsubstructurehfoutput.cxx b/PWGJE/Tasks/jetsubstructurehfoutput.cxx index dafa4d7bf1f..eeb0a388b81 100644 --- a/PWGJE/Tasks/jetsubstructurehfoutput.cxx +++ b/PWGJE/Tasks/jetsubstructurehfoutput.cxx @@ -23,6 +23,7 @@ #include "Common/Core/TrackSelection.h" #include "Common/Core/TrackSelectionDefaults.h" #include "Common/DataModel/EventSelection.h" +#include "Common/CCDB/EventSelectionParams.h" #include "Common/DataModel/TrackSelectionTables.h" #include "PWGHF/DataModel/CandidateReconstructionTables.h" @@ -41,8 +42,10 @@ using namespace o2::framework::expressions; // NB: runDataProcessing.h must be included after customize! #include "Framework/runDataProcessing.h" -template +template struct JetSubstructureHFOutputTask { + + Produces storedBCCountsTable; Produces storedCollisionCountsTable; Produces collisionOutputTableData; Produces jetOutputTableData; @@ -83,6 +86,7 @@ struct JetSubstructureHFOutputTask { Configurable trackEtaMax{"trackEtaMax", 0.9, "maximum track pseudorapidity"}; Configurable eventSelectionForCounting{"eventSelectionForCounting", "sel8", "choose event selection for collision counter"}; + Configurable vertexZCutForCounting{"vertexZCutForCounting", 10.0, "choose z-vertex cut for collision counter"}; std::map jetMappingData; std::map jetMappingDataSub; @@ -378,42 +382,102 @@ struct JetSubstructureHFOutputTask { } PROCESS_SWITCH(JetSubstructureHFOutputTask, processClearMaps, "process function that clears all the maps in each dataframe", true); + void processCountBCs(aod::JBCs const& bcs, aod::BCCounts const& bcCounts) + { + int readBCCounter = 0; + int readBCWithTVXCounter = 0; + int readBCWithTVXAndITSROFBAndNoTFBCounter = 0; + for (const auto& bc : bcs) { + readBCCounter++; + if (bc.selection_bit(aod::evsel::EventSelectionFlags::kIsTriggerTVX)) { + readBCWithTVXCounter++; + if (bc.selection_bit(aod::evsel::EventSelectionFlags::kNoITSROFrameBorder) && bc.selection_bit(aod::evsel::EventSelectionFlags::kNoTimeFrameBorder)) { + readBCWithTVXAndITSROFBAndNoTFBCounter++; + } + } + } + std::vector previousReadCounts; + std::vector previousReadCountsWithTVX; + std::vector previousReadCountsWithTVXAndITSROFBAndNoTFB; + int iPreviousDataFrame = 0; + for (const auto& bcCount : bcCounts) { + auto readBCCounterSpan = bcCount.readCounts(); + auto readBCWithTVXCounterSpan = bcCount.readCountsWithTVX(); + auto readBCWithTVXAndITSROFBAndNoTFBCounterSpan = bcCount.readCountsWithTVXAndITSROFBAndNoTFB(); + if (iPreviousDataFrame == 0) { + std::copy(readBCCounterSpan.begin(), readBCCounterSpan.end(), std::back_inserter(previousReadCounts)); + std::copy(readBCWithTVXCounterSpan.begin(), readBCWithTVXCounterSpan.end(), std::back_inserter(previousReadCountsWithTVX)); + std::copy(readBCWithTVXAndITSROFBAndNoTFBCounterSpan.begin(), readBCWithTVXAndITSROFBAndNoTFBCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndITSROFBAndNoTFB)); + } else { + for (unsigned int i = 0; i < previousReadCounts.size(); i++) { + previousReadCounts[i] += readBCCounterSpan[i]; + previousReadCountsWithTVX[i] += readBCWithTVXCounterSpan[i]; + previousReadCountsWithTVXAndITSROFBAndNoTFB[i] += readBCWithTVXAndITSROFBAndNoTFBCounterSpan[i]; + } + } + iPreviousDataFrame++; + } + previousReadCounts.push_back(readBCCounter); + previousReadCountsWithTVX.push_back(readBCWithTVXCounter); + previousReadCountsWithTVXAndITSROFBAndNoTFB.push_back(readBCWithTVXAndITSROFBAndNoTFBCounter); + storedBCCountsTable(previousReadCounts, previousReadCountsWithTVX, previousReadCountsWithTVXAndITSROFBAndNoTFB); + } + PROCESS_SWITCH(JetSubstructureHFOutputTask, processCountBCs, "write out bc counting output table", false); + void processCountCollisions(JetCollisions const& collisions, aod::CollisionCounts const& collisionCounts) { int readCollisionCounter = 0; - int readSelectedCollisionCounter = 0; + int readCollisionWithTVXCounter = 0; + int readCollisionWithTVXAndSelectionCounter = 0; + int readCollisionWithTVXAndSelectionAndZVertexCounter = 0; int writtenCollisionCounter = -1; - for (auto const& collision : collisions) { + for (const auto& collision : collisions) { readCollisionCounter++; - if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { - readSelectedCollisionCounter++; + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selTVX)) { + readCollisionWithTVXCounter++; + if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { + readCollisionWithTVXAndSelectionCounter++; + if (std::abs(collision.posZ()) < vertexZCutForCounting) { + readCollisionWithTVXAndSelectionAndZVertexCounter++; + } + } } } std::vector previousReadCounts; - std::vector previousReadSelectedCounts; + std::vector previousReadCountsWithTVX; + std::vector previousReadCountsWithTVXAndSelection; + std::vector previousReadCountsWithTVXAndSelectionAndZVertex; std::vector previousWrittenCounts; int iPreviousDataFrame = 0; for (const auto& collisionCount : collisionCounts) { auto readCollisionCounterSpan = collisionCount.readCounts(); - auto readSelectedCollisionCounterSpan = collisionCount.readSelectedCounts(); + auto readCollisionWithTVXCounterSpan = collisionCount.readCountsWithTVX(); + auto readCollisionWithTVXAndSelectionCounterSpan = collisionCount.readCountsWithTVXAndSelection(); + auto readCollisionWithTVXAndSelectionAndZVertexCounterSpan = collisionCount.readCountsWithTVXAndSelectionAndZVertex(); auto writtenCollisionCounterSpan = collisionCount.writtenCounts(); if (iPreviousDataFrame == 0) { std::copy(readCollisionCounterSpan.begin(), readCollisionCounterSpan.end(), std::back_inserter(previousReadCounts)); - std::copy(readSelectedCollisionCounterSpan.begin(), readSelectedCollisionCounterSpan.end(), std::back_inserter(previousReadSelectedCounts)); + std::copy(readCollisionWithTVXCounterSpan.begin(), readCollisionWithTVXCounterSpan.end(), std::back_inserter(previousReadCountsWithTVX)); + std::copy(readCollisionWithTVXAndSelectionCounterSpan.begin(), readCollisionWithTVXAndSelectionCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndSelection)); + std::copy(readCollisionWithTVXAndSelectionAndZVertexCounterSpan.begin(), readCollisionWithTVXAndSelectionAndZVertexCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndSelectionAndZVertex)); std::copy(writtenCollisionCounterSpan.begin(), writtenCollisionCounterSpan.end(), std::back_inserter(previousWrittenCounts)); } else { for (unsigned int i = 0; i < previousReadCounts.size(); i++) { previousReadCounts[i] += readCollisionCounterSpan[i]; - previousReadSelectedCounts[i] += readSelectedCollisionCounterSpan[i]; + previousReadCountsWithTVX[i] += readCollisionWithTVXCounterSpan[i]; + previousReadCountsWithTVXAndSelection[i] += readCollisionWithTVXAndSelectionCounterSpan[i]; + previousReadCountsWithTVXAndSelectionAndZVertex[i] += readCollisionWithTVXAndSelectionAndZVertexCounterSpan[i]; previousWrittenCounts[i] += writtenCollisionCounterSpan[i]; } } iPreviousDataFrame++; } previousReadCounts.push_back(readCollisionCounter); - previousReadSelectedCounts.push_back(readSelectedCollisionCounter); + previousReadCountsWithTVX.push_back(readCollisionWithTVXCounter); + previousReadCountsWithTVXAndSelection.push_back(readCollisionWithTVXAndSelectionCounter); + previousReadCountsWithTVXAndSelectionAndZVertex.push_back(readCollisionWithTVXAndSelectionAndZVertexCounter); previousWrittenCounts.push_back(writtenCollisionCounter); - storedCollisionCountsTable(previousReadCounts, previousReadSelectedCounts, previousWrittenCounts); + storedCollisionCountsTable(previousReadCounts, previousReadCountsWithTVX, previousReadCountsWithTVXAndSelection, previousReadCountsWithTVXAndSelectionAndZVertex, previousWrittenCounts); } PROCESS_SWITCH(JetSubstructureHFOutputTask, processCountCollisions, "process function that counts read in collisions", false); @@ -538,10 +602,10 @@ struct JetSubstructureHFOutputTask { } PROCESS_SWITCH(JetSubstructureHFOutputTask, processOutputMatchingMC, "jet matching output MC", false); }; -using JetSubstructureOutputD0 = JetSubstructureHFOutputTask, CandidatesD0Data, CandidatesD0MCD, CandidatesD0MCP, aod::JTrackD0Subs, soa::Join, soa::Join, aod::D0CJetCOs, aod::D0CJetOs, aod::D0CJetSSOs, aod::D0CJetMOs, soa::Join, aod::D0CMCDJetCOs, aod::D0CMCDJetOs, aod::D0CMCDJetSSOs, aod::D0CMCDJetMOs, soa::Join, aod::D0CMCPJetCOs, aod::D0CMCPJetOs, aod::D0CMCPJetSSOs, aod::D0CMCPJetMOs, soa::Join, aod::D0CEWSJetCOs, aod::D0CEWSJetOs, aod::D0CEWSJetSSOs, aod::D0CEWSJetMOs, aod::StoredHfD0CollBase, aod::StoredHfD0Bases, aod::StoredHfD0Pars, aod::StoredHfD0ParEs, aod::StoredHfD0Sels, aod::StoredHfD0Mls, aod::StoredHfD0Mcs, aod::StoredHfD0McCollBases, aod::StoredHfD0McRCollIds, aod::StoredHfD0PBases, aod::D0CollisionCounts>; -using JetSubstructureOutputLc = JetSubstructureHFOutputTask, CandidatesLcData, CandidatesLcMCD, CandidatesLcMCP, aod::JTrackLcSubs, soa::Join, soa::Join, aod::LcCJetCOs, aod::LcCJetOs, aod::LcCJetSSOs, aod::LcCJetMOs, soa::Join, aod::LcCMCDJetCOs, aod::LcCMCDJetOs, aod::LcCMCDJetSSOs, aod::LcCMCDJetMOs, soa::Join, aod::LcCMCPJetCOs, aod::LcCMCPJetOs, aod::LcCMCPJetSSOs, aod::LcCMCPJetMOs, soa::Join, aod::LcCEWSJetCOs, aod::LcCEWSJetOs, aod::LcCEWSJetSSOs, aod::LcCEWSJetMOs, aod::StoredHf3PCollBase, aod::StoredHf3PBases, aod::StoredHf3PPars, aod::StoredHf3PParEs, aod::StoredHf3PSels, aod::StoredHf3PMls, aod::StoredHf3PMcs, aod::StoredHf3PMcCollBases, aod::StoredHf3PMcRCollIds, aod::StoredHf3PPBases, aod::LcCollisionCounts>; -// using JetSubstructureOutputBplus = JetSubstructureHFOutputTask, CandidatesBplusData, CandidatesBplusMCD, CandidatesBplusMCP, aod::JTrackBplusSubs, soa::Join, soa::Join, aod::BplusCJetCOs, aod::BplusCJetOs, aod::BplusCJetSSOs, aod::BplusCJetMOs, soa::Join, aod::BplusCMCDJetCOs, aod::BplusCMCDJetOs, aod::BplusCMCDJetSSOs, aod::BplusCMCDJetMOs, soa::Join, aod::BplusCMCPJetCOs, aod::BplusCMCPJetOs, aod::BplusCMCPJetSSOs, aod::BplusCMCPJetMOs, soa::Join, aod::BplusCEWSJetCOs, aod::BplusCEWSJetOs, aod::BplusCEWSJetSSOs, aod::BplusCEWSJetMOs, aod::StoredHfBplusCollBase, aod::StoredHfBplusBases, aod::StoredHfBplusPars, aod::StoredHfBplusParEs, aod::StoredHfBplusSels, aod::StoredHfBplusMls, aod::StoredHfBplusMcs, aod::StoredHfBplusPBases, aod::BplusCollisionCounts>; -using JetSubstructureOutputDielectron = JetSubstructureHFOutputTask, soa::Join, aod::DielectronCJetCOs, aod::DielectronCJetOs, aod::DielectronCJetSSOs, aod::DielectronCJetMOs, soa::Join, aod::DielectronCMCDJetCOs, aod::DielectronCMCDJetOs, aod::DielectronCMCDJetSSOs, aod::DielectronCMCDJetMOs, soa::Join, aod::DielectronCMCPJetCOs, aod::DielectronCMCPJetOs, aod::DielectronCMCPJetSSOs, aod::DielectronCMCPJetMOs, soa::Join, aod::DielectronCEWSJetCOs, aod::DielectronCEWSJetOs, aod::DielectronCEWSJetSSOs, aod::DielectronCEWSJetMOs, aod::StoredReducedEvents, aod::StoredDielectrons, aod::JDielectron1Dummys, aod::JDielectron2Dummys, aod::JDielectron3Dummys, aod::JDielectron4Dummys, aod::JDielectron5Dummys, aod::StoredJDielectronMcCollisions, aod::JDielectron6Dummys, aod::StoredJDielectronMcs, aod::DielectronCollisionCounts>; +using JetSubstructureOutputD0 = JetSubstructureHFOutputTask, CandidatesD0Data, CandidatesD0MCD, CandidatesD0MCP, aod::JTrackD0Subs, soa::Join, soa::Join, aod::D0CJetCOs, aod::D0CJetOs, aod::D0CJetSSOs, aod::D0CJetMOs, soa::Join, aod::D0CMCDJetCOs, aod::D0CMCDJetOs, aod::D0CMCDJetSSOs, aod::D0CMCDJetMOs, soa::Join, aod::D0CMCPJetCOs, aod::D0CMCPJetOs, aod::D0CMCPJetSSOs, aod::D0CMCPJetMOs, soa::Join, aod::D0CEWSJetCOs, aod::D0CEWSJetOs, aod::D0CEWSJetSSOs, aod::D0CEWSJetMOs, aod::StoredHfD0CollBase, aod::StoredHfD0Bases, aod::StoredHfD0Pars, aod::StoredHfD0ParEs, aod::StoredHfD0Sels, aod::StoredHfD0Mls, aod::StoredHfD0Mcs, aod::StoredHfD0McCollBases, aod::StoredHfD0McRCollIds, aod::StoredHfD0PBases, aod::D0BCCounts, aod::D0CollisionCounts>; +using JetSubstructureOutputLc = JetSubstructureHFOutputTask, CandidatesLcData, CandidatesLcMCD, CandidatesLcMCP, aod::JTrackLcSubs, soa::Join, soa::Join, aod::LcCJetCOs, aod::LcCJetOs, aod::LcCJetSSOs, aod::LcCJetMOs, soa::Join, aod::LcCMCDJetCOs, aod::LcCMCDJetOs, aod::LcCMCDJetSSOs, aod::LcCMCDJetMOs, soa::Join, aod::LcCMCPJetCOs, aod::LcCMCPJetOs, aod::LcCMCPJetSSOs, aod::LcCMCPJetMOs, soa::Join, aod::LcCEWSJetCOs, aod::LcCEWSJetOs, aod::LcCEWSJetSSOs, aod::LcCEWSJetMOs, aod::StoredHf3PCollBase, aod::StoredHf3PBases, aod::StoredHf3PPars, aod::StoredHf3PParEs, aod::StoredHf3PSels, aod::StoredHf3PMls, aod::StoredHf3PMcs, aod::StoredHf3PMcCollBases, aod::StoredHf3PMcRCollIds, aod::StoredHf3PPBases, aod::LcBCCounts, aod::LcCollisionCounts>; +// using JetSubstructureOutputBplus = JetSubstructureHFOutputTask, CandidatesBplusData, CandidatesBplusMCD, CandidatesBplusMCP, aod::JTrackBplusSubs, soa::Join, soa::Join, aod::BplusCJetCOs, aod::BplusCJetOs, aod::BplusCJetSSOs, aod::BplusCJetMOs, soa::Join, aod::BplusCMCDJetCOs, aod::BplusCMCDJetOs, aod::BplusCMCDJetSSOs, aod::BplusCMCDJetMOs, soa::Join, aod::BplusCMCPJetCOs, aod::BplusCMCPJetOs, aod::BplusCMCPJetSSOs, aod::BplusCMCPJetMOs, soa::Join, aod::BplusCEWSJetCOs, aod::BplusCEWSJetOs, aod::BplusCEWSJetSSOs, aod::BplusCEWSJetMOs, aod::StoredHfBplusCollBase, aod::StoredHfBplusBases, aod::StoredHfBplusPars, aod::StoredHfBplusParEs, aod::StoredHfBplusSels, aod::StoredHfBplusMls, aod::StoredHfBplusMcs, aod::StoredHfBplusPBases, aod::BplusBCCounts, aod::BplusCollisionCounts>; +using JetSubstructureOutputDielectron = JetSubstructureHFOutputTask, soa::Join, aod::DielectronCJetCOs, aod::DielectronCJetOs, aod::DielectronCJetSSOs, aod::DielectronCJetMOs, soa::Join, aod::DielectronCMCDJetCOs, aod::DielectronCMCDJetOs, aod::DielectronCMCDJetSSOs, aod::DielectronCMCDJetMOs, soa::Join, aod::DielectronCMCPJetCOs, aod::DielectronCMCPJetOs, aod::DielectronCMCPJetSSOs, aod::DielectronCMCPJetMOs, soa::Join, aod::DielectronCEWSJetCOs, aod::DielectronCEWSJetOs, aod::DielectronCEWSJetSSOs, aod::DielectronCEWSJetMOs, aod::StoredReducedEvents, aod::StoredDielectrons, aod::JDielectron1Dummys, aod::JDielectron2Dummys, aod::JDielectron3Dummys, aod::JDielectron4Dummys, aod::JDielectron5Dummys, aod::StoredJDielectronMcCollisions, aod::JDielectron6Dummys, aod::StoredJDielectronMcs, aod::DielectronBCCounts, aod::DielectronCollisionCounts>; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { diff --git a/PWGJE/Tasks/jetsubstructureoutput.cxx b/PWGJE/Tasks/jetsubstructureoutput.cxx index fed22a1b826..9b99e2eae9d 100644 --- a/PWGJE/Tasks/jetsubstructureoutput.cxx +++ b/PWGJE/Tasks/jetsubstructureoutput.cxx @@ -23,6 +23,7 @@ #include "Common/Core/TrackSelection.h" #include "Common/Core/TrackSelectionDefaults.h" #include "Common/DataModel/EventSelection.h" +#include "Common/CCDB/EventSelectionParams.h" #include "Common/DataModel/TrackSelectionTables.h" #include "PWGJE/Core/JetFinder.h" @@ -40,6 +41,7 @@ using namespace o2::framework::expressions; struct JetSubstructureOutputTask { + Produces storedBCCountsTable; Produces storedCollisionCountsTable; Produces collisionOutputTableData; Produces jetOutputTableData; @@ -70,6 +72,7 @@ struct JetSubstructureOutputTask { Configurable trackEtaMax{"trackEtaMax", 0.9, "maximum track pseudorapidity"}; Configurable eventSelectionForCounting{"eventSelectionForCounting", "sel8", "choose event selection for collision counter"}; + Configurable vertexZCutForCounting{"vertexZCutForCounting", 10.0, "choose z-vertex cut for collision counter"}; std::map jetMappingData; std::map jetMappingDataSub; @@ -192,42 +195,102 @@ struct JetSubstructureOutputTask { } PROCESS_SWITCH(JetSubstructureOutputTask, processClearMaps, "process function that clears all the maps in each dataframe", true); + void processCountBCs(aod::JBCs const& bcs, aod::BCCounts const& bcCounts) + { + int readBCCounter = 0; + int readBCWithTVXCounter = 0; + int readBCWithTVXAndITSROFBAndNoTFBCounter = 0; + for (const auto& bc : bcs) { + readBCCounter++; + if (bc.selection_bit(aod::evsel::EventSelectionFlags::kIsTriggerTVX)) { + readBCWithTVXCounter++; + if (bc.selection_bit(aod::evsel::EventSelectionFlags::kNoITSROFrameBorder) && bc.selection_bit(aod::evsel::EventSelectionFlags::kNoTimeFrameBorder)) { + readBCWithTVXAndITSROFBAndNoTFBCounter++; + } + } + } + std::vector previousReadCounts; + std::vector previousReadCountsWithTVX; + std::vector previousReadCountsWithTVXAndITSROFBAndNoTFB; + int iPreviousDataFrame = 0; + for (const auto& bcCount : bcCounts) { + auto readBCCounterSpan = bcCount.readCounts(); + auto readBCWithTVXCounterSpan = bcCount.readCountsWithTVX(); + auto readBCWithTVXAndITSROFBAndNoTFBCounterSpan = bcCount.readCountsWithTVXAndITSROFBAndNoTFB(); + if (iPreviousDataFrame == 0) { + std::copy(readBCCounterSpan.begin(), readBCCounterSpan.end(), std::back_inserter(previousReadCounts)); + std::copy(readBCWithTVXCounterSpan.begin(), readBCWithTVXCounterSpan.end(), std::back_inserter(previousReadCountsWithTVX)); + std::copy(readBCWithTVXAndITSROFBAndNoTFBCounterSpan.begin(), readBCWithTVXAndITSROFBAndNoTFBCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndITSROFBAndNoTFB)); + } else { + for (unsigned int i = 0; i < previousReadCounts.size(); i++) { + previousReadCounts[i] += readBCCounterSpan[i]; + previousReadCountsWithTVX[i] += readBCWithTVXCounterSpan[i]; + previousReadCountsWithTVXAndITSROFBAndNoTFB[i] += readBCWithTVXAndITSROFBAndNoTFBCounterSpan[i]; + } + } + iPreviousDataFrame++; + } + previousReadCounts.push_back(readBCCounter); + previousReadCountsWithTVX.push_back(readBCWithTVXCounter); + previousReadCountsWithTVXAndITSROFBAndNoTFB.push_back(readBCWithTVXAndITSROFBAndNoTFBCounter); + storedBCCountsTable(previousReadCounts, previousReadCountsWithTVX, previousReadCountsWithTVXAndITSROFBAndNoTFB); + } + PROCESS_SWITCH(JetSubstructureOutputTask, processCountBCs, "write out bc counting output table", false); + void processCountCollisions(JetCollisions const& collisions, aod::CollisionCounts const& collisionCounts) { int readCollisionCounter = 0; - int readSelectedCollisionCounter = 0; + int readCollisionWithTVXCounter = 0; + int readCollisionWithTVXAndSelectionCounter = 0; + int readCollisionWithTVXAndSelectionAndZVertexCounter = 0; int writtenCollisionCounter = -1; - for (auto const& collision : collisions) { + for (const auto& collision : collisions) { readCollisionCounter++; - if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { - readSelectedCollisionCounter++; + if (jetderiveddatautilities::selectCollision(collision, jetderiveddatautilities::JCollisionSel::selTVX)) { + readCollisionWithTVXCounter++; + if (jetderiveddatautilities::selectCollision(collision, eventSelection)) { + readCollisionWithTVXAndSelectionCounter++; + if (std::abs(collision.posZ()) < vertexZCutForCounting) { + readCollisionWithTVXAndSelectionAndZVertexCounter++; + } + } } } std::vector previousReadCounts; - std::vector previousReadSelectedCounts; + std::vector previousReadCountsWithTVX; + std::vector previousReadCountsWithTVXAndSelection; + std::vector previousReadCountsWithTVXAndSelectionAndZVertex; std::vector previousWrittenCounts; int iPreviousDataFrame = 0; for (const auto& collisionCount : collisionCounts) { auto readCollisionCounterSpan = collisionCount.readCounts(); - auto readSelectedCollisionCounterSpan = collisionCount.readSelectedCounts(); + auto readCollisionWithTVXCounterSpan = collisionCount.readCountsWithTVX(); + auto readCollisionWithTVXAndSelectionCounterSpan = collisionCount.readCountsWithTVXAndSelection(); + auto readCollisionWithTVXAndSelectionAndZVertexCounterSpan = collisionCount.readCountsWithTVXAndSelectionAndZVertex(); auto writtenCollisionCounterSpan = collisionCount.writtenCounts(); if (iPreviousDataFrame == 0) { std::copy(readCollisionCounterSpan.begin(), readCollisionCounterSpan.end(), std::back_inserter(previousReadCounts)); - std::copy(readSelectedCollisionCounterSpan.begin(), readSelectedCollisionCounterSpan.end(), std::back_inserter(previousReadSelectedCounts)); + std::copy(readCollisionWithTVXCounterSpan.begin(), readCollisionWithTVXCounterSpan.end(), std::back_inserter(previousReadCountsWithTVX)); + std::copy(readCollisionWithTVXAndSelectionCounterSpan.begin(), readCollisionWithTVXAndSelectionCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndSelection)); + std::copy(readCollisionWithTVXAndSelectionAndZVertexCounterSpan.begin(), readCollisionWithTVXAndSelectionAndZVertexCounterSpan.end(), std::back_inserter(previousReadCountsWithTVXAndSelectionAndZVertex)); std::copy(writtenCollisionCounterSpan.begin(), writtenCollisionCounterSpan.end(), std::back_inserter(previousWrittenCounts)); } else { for (unsigned int i = 0; i < previousReadCounts.size(); i++) { previousReadCounts[i] += readCollisionCounterSpan[i]; - previousReadSelectedCounts[i] += readSelectedCollisionCounterSpan[i]; + previousReadCountsWithTVX[i] += readCollisionWithTVXCounterSpan[i]; + previousReadCountsWithTVXAndSelection[i] += readCollisionWithTVXAndSelectionCounterSpan[i]; + previousReadCountsWithTVXAndSelectionAndZVertex[i] += readCollisionWithTVXAndSelectionAndZVertexCounterSpan[i]; previousWrittenCounts[i] += writtenCollisionCounterSpan[i]; } } iPreviousDataFrame++; } previousReadCounts.push_back(readCollisionCounter); - previousReadSelectedCounts.push_back(readSelectedCollisionCounter); + previousReadCountsWithTVX.push_back(readCollisionWithTVXCounter); + previousReadCountsWithTVXAndSelection.push_back(readCollisionWithTVXAndSelectionCounter); + previousReadCountsWithTVXAndSelectionAndZVertex.push_back(readCollisionWithTVXAndSelectionAndZVertexCounter); previousWrittenCounts.push_back(writtenCollisionCounter); - storedCollisionCountsTable(previousReadCounts, previousReadSelectedCounts, previousWrittenCounts); + storedCollisionCountsTable(previousReadCounts, previousReadCountsWithTVX, previousReadCountsWithTVXAndSelection, previousReadCountsWithTVXAndSelectionAndZVertex, previousWrittenCounts); } PROCESS_SWITCH(JetSubstructureOutputTask, processCountCollisions, "process function that counts read in collisions", false);