diff --git a/PWGJE/Core/JetCandidateUtilities.h b/PWGJE/Core/JetCandidateUtilities.h index 6c5c0328ef5..8b31b11634e 100644 --- a/PWGJE/Core/JetCandidateUtilities.h +++ b/PWGJE/Core/JetCandidateUtilities.h @@ -373,42 +373,42 @@ float getCandidateInvariantMass(T const& candidate) } template -void fillCandidateCollisionTable(T const& collision, U const& /*candidates*/, V& CandiateCollisionTable, int32_t& CandidateCollisionTableIndex) +void fillCandidateCollisionTable(T const& collision, U const& /*candidates*/, V& CandiateCollisionTable) { if constexpr (jethfutilities::isHFTable()) { - jethfutilities::fillHFCollisionTable(collision, CandiateCollisionTable, CandidateCollisionTableIndex); + jethfutilities::fillHFCollisionTable(collision, CandiateCollisionTable); } else if constexpr (jetdqutilities::isDielectronTable()) { - jetdqutilities::fillDielectronCollisionTable(collision, CandiateCollisionTable, CandidateCollisionTableIndex); // if more dilepton tables are added we would need a fillDQCollisionTable + jetdqutilities::fillDielectronCollisionTable(collision, CandiateCollisionTable); // if more dilepton tables are added we would need a fillDQCollisionTable } } template -void fillCandidateMcCollisionTable(T const& mcCollision, U const& /*candidates*/, V& CandiateMcCollisionTable, int32_t& CandidateMcCollisionTableIndex) +void fillCandidateMcCollisionTable(T const& mcCollision, U const& /*candidates*/, V& CandiateMcCollisionTable) { if constexpr (jethfutilities::isHFMcTable()) { - jethfutilities::fillHFMcCollisionTable(mcCollision, CandiateMcCollisionTable, CandidateMcCollisionTableIndex); + jethfutilities::fillHFMcCollisionTable(mcCollision, CandiateMcCollisionTable); } else if constexpr (jetdqutilities::isDielectronMcTable()) { - jetdqutilities::fillDielectronMcCollisionTable(mcCollision, CandiateMcCollisionTable, CandidateMcCollisionTableIndex); + jetdqutilities::fillDielectronMcCollisionTable(mcCollision, CandiateMcCollisionTable); } } template -void fillCandidateTable(T const& candidate, int32_t collisionIndex, U& BaseTable, V& HFParTable, M& HFParETable, N& HFParDaughterTable, O& HFSelectionFlagTable, P& HFMlTable, Q& HFMlDaughterTable, S& HFMCDTable, int32_t& candidateTableIndex) +void fillCandidateTable(T const& candidate, int32_t collisionIndex, U& BaseTable, V& HFParTable, M& HFParETable, N& HFParDaughterTable, O& HFSelectionFlagTable, P& HFMlTable, Q& HFMlDaughterTable, S& HFMCDTable) { if constexpr (jethfutilities::isHFCandidate()) { - jethfutilities::fillHFCandidateTable(candidate, collisionIndex, BaseTable, HFParTable, HFParETable, HFParDaughterTable, HFSelectionFlagTable, HFMlTable, HFMlDaughterTable, HFMCDTable, candidateTableIndex); + jethfutilities::fillHFCandidateTable(candidate, collisionIndex, BaseTable, HFParTable, HFParETable, HFParDaughterTable, HFSelectionFlagTable, HFMlTable, HFMlDaughterTable, HFMCDTable); } else if constexpr (jetdqutilities::isDielectronCandidate()) { - jetdqutilities::fillDielectronCandidateTable(candidate, collisionIndex, BaseTable, candidateTableIndex); + jetdqutilities::fillDielectronCandidateTable(candidate, collisionIndex, BaseTable); } } template -void fillCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& BaseMcTable, int32_t& candidateTableIndex) +void fillCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& BaseMcTable) { if constexpr (jethfutilities::isHFMcCandidate()) { - jethfutilities::fillHFCandidateMcTable(candidate, mcCollisionIndex, BaseMcTable, candidateTableIndex); + jethfutilities::fillHFCandidateMcTable(candidate, mcCollisionIndex, BaseMcTable); } else if constexpr (jetdqutilities::isDielectronMcCandidate()) { - jetdqutilities::fillDielectronCandidateMcTable(candidate, mcCollisionIndex, BaseMcTable, candidateTableIndex); + jetdqutilities::fillDielectronCandidateMcTable(candidate, mcCollisionIndex, BaseMcTable); } } diff --git a/PWGJE/Core/JetDQUtilities.h b/PWGJE/Core/JetDQUtilities.h index 91b4c3cdd30..cc26582ca53 100644 --- a/PWGJE/Core/JetDQUtilities.h +++ b/PWGJE/Core/JetDQUtilities.h @@ -312,31 +312,27 @@ uint8_t setDielectronParticleDecayBit(T const& particles, U const& particle) } template -void fillDielectronCollisionTable(T const& collision, U& DielectronCollisionTable, int32_t& DielectronCollisionTableIndex) +void fillDielectronCollisionTable(T const& collision, U& DielectronCollisionTable) { DielectronCollisionTable(collision.tag_raw(), collision.runNumber(), collision.posX(), collision.posY(), collision.posZ(), collision.numContrib(), collision.collisionTime(), collision.collisionTimeRes()); - DielectronCollisionTableIndex = DielectronCollisionTable.lastIndex(); } template -void fillDielectronMcCollisionTable(T const& mcCollision, U& DielectronMcCollisionTable, int32_t& DielectronMcCollisionTableIndex) +void fillDielectronMcCollisionTable(T const& mcCollision, U& DielectronMcCollisionTable) { DielectronMcCollisionTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()); - DielectronMcCollisionTableIndex = DielectronMcCollisionTable.lastIndex(); } template -void fillDielectronCandidateTable(T const& candidate, int32_t collisionIndex, U& DielectronTable, int32_t& DielectronCandidateTableIndex) +void fillDielectronCandidateTable(T const& candidate, int32_t collisionIndex, U& DielectronTable) { DielectronTable(collisionIndex, candidate.mass(), candidate.pt(), candidate.eta(), candidate.phi(), candidate.sign(), candidate.filterMap_raw(), candidate.mcDecision()); - DielectronCandidateTableIndex = DielectronTable.lastIndex(); } template -void fillDielectronCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& DielectronMcTable, int32_t& DielectronCandidateTableIndex) +void fillDielectronCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& DielectronMcTable) { DielectronMcTable(mcCollisionIndex, candidate.pt(), candidate.eta(), candidate.phi(), candidate.y(), candidate.e(), candidate.m(), candidate.pdgCode(), candidate.getGenStatusCode(), candidate.getHepMCStatusCode(), candidate.isPhysicalPrimary(), candidate.decayFlag(), candidate.origin()); - DielectronCandidateTableIndex = DielectronMcTable.lastIndex(); } }; // namespace jetdqutilities diff --git a/PWGJE/Core/JetHFUtilities.h b/PWGJE/Core/JetHFUtilities.h index 1334d8ad6f6..b281da526c0 100644 --- a/PWGJE/Core/JetHFUtilities.h +++ b/PWGJE/Core/JetHFUtilities.h @@ -481,17 +481,15 @@ float getHFCandidateInvariantMass(T const& candidate) } template -void fillHFCollisionTable(T const& collision, U& HFCollisionTable, int32_t& HFCollisionTableIndex) +void fillHFCollisionTable(T const& collision, U& HFCollisionTable) { HFCollisionTable(collision.posX(), collision.posY(), collision.posZ(), collision.numContrib(), collision.centFT0A(), collision.centFT0C(), collision.centFT0M(), collision.centFV0A(), collision.multZeqNTracksPV()); - HFCollisionTableIndex = HFCollisionTable.lastIndex(); } template -void fillHFMcCollisionTable(T const& mcCollision, U& HFMcCollisionTable, int32_t& HFMcCollisionTableIndex) +void fillHFMcCollisionTable(T const& mcCollision, U& HFMcCollisionTable) { HFMcCollisionTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.centFT0M()); - HFMcCollisionTableIndex = HFMcCollisionTable.lastIndex(); } template @@ -706,10 +704,9 @@ void fillBplusCandidateTable(T const& candidate, U& BplusParTable, V& BplusParET } template -void fillHFCandidateTable(T const& candidate, int32_t collisionIndex, U& HFBaseTable, V& HFParTable, M& HFParETable, N& HFParDaughterTable, O& HFSelectionFlagTable, P& HFMlTable, Q& HFMlDaughterTable, S& HFMCDTable, int32_t& HFCandidateTableIndex) +void fillHFCandidateTable(T const& candidate, int32_t collisionIndex, U& HFBaseTable, V& HFParTable, M& HFParETable, N& HFParDaughterTable, O& HFSelectionFlagTable, P& HFMlTable, Q& HFMlDaughterTable, S& HFMCDTable) { HFBaseTable(collisionIndex, candidate.pt(), candidate.eta(), candidate.phi(), candidate.m(), candidate.y()); - HFCandidateTableIndex = HFBaseTable.lastIndex(); HFSelectionFlagTable(candidate.candidateSelFlag()); if constexpr (isD0Candidate()) { @@ -724,10 +721,9 @@ void fillHFCandidateTable(T const& candidate, int32_t collisionIndex, U& HFBaseT } template -void fillHFCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& BaseMcTable, int32_t& candidateTableIndex) +void fillHFCandidateMcTable(T const& candidate, int32_t mcCollisionIndex, U& BaseMcTable) { BaseMcTable(mcCollisionIndex, candidate.pt(), candidate.eta(), candidate.phi(), candidate.y(), candidate.flagMcMatchGen(), candidate.originMcGen()); - candidateTableIndex = BaseMcTable.lastIndex(); } }; // namespace jethfutilities diff --git a/PWGJE/DataModel/JetReducedDataSelector.h b/PWGJE/DataModel/JetReducedDataSelector.h new file mode 100644 index 00000000000..4e6b07a955b --- /dev/null +++ b/PWGJE/DataModel/JetReducedDataSelector.h @@ -0,0 +1,39 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// +/// \brief Table definitions for selectors for writing out reduced data model for jets +/// +/// \author Nima Zardoshti + +#ifndef PWGJE_DATAMODEL_JETREDUCEDDATASELECTOR_H_ +#define PWGJE_DATAMODEL_JETREDUCEDDATASELECTOR_H_ + +#include +#include +#include "Framework/AnalysisDataModel.h" + +namespace o2::aod +{ +namespace jetreduceddataselector +{ +DECLARE_SOA_COLUMN(IsCollisionSelected, isCollisionSelected, bool); +DECLARE_SOA_COLUMN(IsMcCollisionSelected, isMcCollisionSelected, bool); + +} // namespace jetreduceddataselector +DECLARE_SOA_TABLE(JCollisionSelections, "AOD", "JCOLLSELECTION", + jetreduceddataselector::IsCollisionSelected); + +DECLARE_SOA_TABLE(JMcCollisionSelections, "AOD", "JMCCOLLSELECTION", + jetreduceddataselector::IsMcCollisionSelected); +} // namespace o2::aod + +#endif // PWGJE_DATAMODEL_JETREDUCEDDATASELECTOR_H_ diff --git a/PWGJE/TableProducer/CMakeLists.txt b/PWGJE/TableProducer/CMakeLists.txt index c946a8722e5..85083da0801 100644 --- a/PWGJE/TableProducer/CMakeLists.txt +++ b/PWGJE/TableProducer/CMakeLists.txt @@ -23,33 +23,8 @@ o2physics_add_dpl_workflow(jet-deriveddata-trigger-producer PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy - SOURCES derivedDataProducerDummy.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-charged - SOURCES derivedDataProducerDummyCharged.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-d0 - SOURCES derivedDataProducerDummyD0.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-lc - SOURCES derivedDataProducerDummyLc.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-bplus - SOURCES derivedDataProducerDummyBplus.cxx - PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore - COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(jet-deriveddata-producer-dummy-dielectron - SOURCES derivedDataProducerDummyDielectron.cxx +o2physics_add_dpl_workflow(jet-deriveddata-selector + SOURCES derivedDataSelector.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) diff --git a/PWGJE/TableProducer/derivedDataProducerDummy.cxx b/PWGJE/TableProducer/derivedDataProducerDummy.cxx deleted file mode 100644 index c5a68c7c6b8..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummy.cxx +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -// temporary task to produce HF and DQ tables needed when making inclusive derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyBplus.cxx b/PWGJE/TableProducer/derivedDataProducerDummyBplus.cxx deleted file mode 100644 index 8f3e238710a..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyBplus.cxx +++ /dev/null @@ -1,69 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -// temporary task to produce HF and DQ tables needed when making B+ jet derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyCharged.cxx b/PWGJE/TableProducer/derivedDataProducerDummyCharged.cxx deleted file mode 100644 index 28cfa369b73..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyCharged.cxx +++ /dev/null @@ -1,84 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -// temporary task to produce HF, DQ and EMCal tables needed when making inclusive derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyChargedTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - Produces jClustersCorrectedEnergiesTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyChargedTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy-charged"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyD0.cxx b/PWGJE/TableProducer/derivedDataProducerDummyD0.cxx deleted file mode 100644 index 4cbbfdeedea..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyD0.cxx +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -// temporary task to produce HF and DQ tables needed when making D0 jet derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyD0Task { - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyD0Task, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy-d0"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyDielectron.cxx b/PWGJE/TableProducer/derivedDataProducerDummyDielectron.cxx deleted file mode 100644 index c24cf13bd41..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyDielectron.cxx +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -// temporary task to produce HF tables needed when making dielectron jet derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyDielectronTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces lcCollisionsTable; - Produces lcCollisionsMatchingTable; - Produces lcsTable; - Produces lcParsTable; - Produces lcParExtrasTable; - Produces lcSelsTable; - Produces lcMlsTable; - Produces lcMcsTable; - Produces lcMcCollisionsTable; - Produces lcParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyDielectronTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy-dielectron"})}; -} diff --git a/PWGJE/TableProducer/derivedDataProducerDummyLc.cxx b/PWGJE/TableProducer/derivedDataProducerDummyLc.cxx deleted file mode 100644 index 9913e1da37f..00000000000 --- a/PWGJE/TableProducer/derivedDataProducerDummyLc.cxx +++ /dev/null @@ -1,71 +0,0 @@ -// Copyright 2019-2020 CERN and copyright holders of ALICE O2. -// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. -// All rights not expressly granted are reserved. -// -// This software is distributed under the terms of the GNU General Public -// License v3 (GPL Version 3), copied verbatim in the file "COPYING". -// -// In applying this license CERN does not waive the privileges and immunities -// granted to it by virtue of its status as an Intergovernmental Organization -// or submit itself to any jurisdiction. - -// temporary task to produce HF and DQ tables needed when making Lc jet derived data - should become obsolete when tables are able to be prouduced based on a configurable -// -/// \author Nima Zardoshti - -#include "Framework/AnalysisTask.h" -#include "Framework/AnalysisDataModel.h" -#include "Framework/ASoA.h" -#include "Framework/runDataProcessing.h" -#include "PWGJE/DataModel/JetReducedData.h" -#include "PWGHF/DataModel/DerivedTables.h" -#include "PWGDQ/DataModel/ReducedInfoTables.h" - -using namespace o2; -using namespace o2::framework; -using namespace o2::framework::expressions; - -struct JetDerivedDataProducerDummyLcTask { - - Produces d0CollisionsTable; - Produces d0CollisionsMatchingTable; - Produces d0sTable; - Produces d0ParsTable; - Produces d0ParExtrasTable; - Produces d0SelsTable; - Produces d0MlsTable; - Produces d0McsTable; - Produces d0McCollisionsTable; - Produces d0ParticlesTable; - - Produces bplusCollisionsTable; - Produces bplusCollisionsMatchingTable; - Produces bplussTable; - Produces bplusParsTable; - Produces bplusParExtrasTable; - Produces bplusParD0sTable; - Produces bplusSelsTable; - Produces bplusMlsTable; - Produces bplusMlD0sTable; - Produces bplusMcsTable; - Produces bplusMcCollisionsTable; - Produces bplusParticlesTable; - - Produces dielectronCollisionsTable; - Produces dielectronTable; - - void init(InitContext const&) - { - } - - void processDummy(aod::JDummys const&) - { - } - PROCESS_SWITCH(JetDerivedDataProducerDummyLcTask, processDummy, "leaves all tables empty", true); -}; - -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ - return WorkflowSpec{ - adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-producer-dummy-lc"})}; -} diff --git a/PWGJE/TableProducer/derivedDataSelector.cxx b/PWGJE/TableProducer/derivedDataSelector.cxx new file mode 100644 index 00000000000..88398f796f5 --- /dev/null +++ b/PWGJE/TableProducer/derivedDataSelector.cxx @@ -0,0 +1,331 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \file jetderiveddataselector.cxx +/// \brief Task to store decision of which events to skim for producing jet framework tables (aod::JetCollisions, aod::JetTracks, aod::JetClusters, ...) +/// while adjusting indices accordingly +/// +/// \author Nima Zardoshti +/// \author Jochen Klein + +#include +#include +#include +#include + +#include + +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoA.h" +#include "Framework/runDataProcessing.h" + +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetReducedDataSelector.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct JetDerivedDataSelector { + + Produces collisionSelectionsTable; + Produces mcCollisionSelectionsTable; + + struct : ConfigurableGroup { + Configurable thresholdChargedJetPtMin{"thresholdChargedJetPtMin", 0.0, "Minimum charged jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedJetPtMin{"thresholdChargedEventWiseSubtractedJetPtMin", 0.0, "Minimum charged event-wise subtracted jet pt to accept event"}; + Configurable thresholdChargedMCPJetPtMin{"thresholdChargedMCPJetPtMin", 0.0, "Minimum charged mcp jet pt to accept event"}; + Configurable thresholdNeutralJetPtMin{"thresholdNeutralJetPtMin", 0.0, "Minimum neutral jet pt to accept event"}; + Configurable thresholdNeutralMCPJetPtMin{"thresholdNeutralMCPJetPtMin", 0.0, "Minimum neutal mcp jet pt to accept event"}; + Configurable thresholdFullJetPtMin{"thresholdFullJetPtMin", 0.0, "Minimum full jet pt to accept event"}; + Configurable thresholdFullMCPJetPtMin{"thresholdFullMCPJetPtMin", 0.0, "Minimum full mcp jet pt to accept event"}; + Configurable thresholdChargedD0JetPtMin{"thresholdChargedD0JetPtMin", 0.0, "Minimum charged D0 jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedD0JetPtMin{"thresholdChargedEventWiseSubtractedD0JetPtMin", 0.0, "Minimum charged event-wise subtracted D0 jet pt to accept event"}; + Configurable thresholdChargedD0MCPJetPtMin{"thresholdChargedD0MCPJetPtMin", 0.0, "Minimum charged D0 mcp jet pt to accept event"}; + Configurable thresholdChargedLcJetPtMin{"thresholdChargedLcJetPtMin", 0.0, "Minimum charged Lc jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedLcJetPtMin{"thresholdChargedEventWiseSubtractedLcJetPtMin", 0.0, "Minimum charged event-wise subtracted Lc jet pt to accept event"}; + Configurable thresholdChargedLcMCPJetPtMin{"thresholdChargedLcMCPJetPtMin", 0.0, "Minimum charged Lc mcp jet pt to accept event"}; + Configurable thresholdChargedBplusJetPtMin{"thresholdChargedBplusJetPtMin", 0.0, "Minimum charged Bplus jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedBplusJetPtMin{"thresholdChargedEventWiseSubtractedBplusJetPtMin", 0.0, "Minimum charged event-wise subtracted Bplus jet pt to accept event"}; + Configurable thresholdChargedBplusMCPJetPtMin{"thresholdChargedBplusMCPJetPtMin", 0.0, "Minimum charged Bplus mcp jet pt to accept event"}; + Configurable thresholdChargedDielectronJetPtMin{"thresholdChargedDielectronJetPtMin", 0.0, "Minimum charged Dielectron jet pt to accept event"}; + Configurable thresholdChargedEventWiseSubtractedDielectronJetPtMin{"thresholdChargedEventWiseSubtractedDielectronJetPtMin", 0.0, "Minimum charged event-wise subtracted Dielectron jet pt to accept event"}; + Configurable thresholdChargedDielectronMCPJetPtMin{"thresholdChargedDielectronMCPJetPtMin", 0.0, "Minimum charged Dielectron mcp jet pt to accept event"}; + Configurable thresholdTriggerTrackPtMin{"thresholdTriggerTrackPtMin", 0.0, "Minimum trigger track pt to accept event"}; + Configurable thresholdClusterEnergyMin{"thresholdClusterEnergyMin", 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"}; + Configurable performTrackSelection{"performTrackSelection", true, "only save tracks that pass one of the track selections"}; + 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 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; + + std::vector collisionFlag; + std::vector McCollisionFlag; + + TRandom3 randomNumber; + + std::vector triggerMaskBits; + void init(InitContext&) + { + randomNumber.SetSeed(0); + triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(config.triggerMasks); + } + + PresliceUnsorted> CollisionsPerMcCollision = aod::jmccollisionlb::mcCollisionId; + + void processSetupCollisions(aod::JCollisions const& collisions) + { + collisionFlag.clear(); + collisionFlag.resize(collisions.size(), false); + } + + void processSetupMcCollisions(aod::JMcCollisions const& mcCollisions) + { + McCollisionFlag.clear(); + McCollisionFlag.resize(mcCollisions.size(), false); + } + + void processSelectMcCollisionsPerCollision(aod::JMcCollisions const& mcCollisions, soa::Join const& collisions) + { + for (auto mcCollision : mcCollisions) { + const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex()); + for (auto collision : collisionsPerMcCollision) { + if (collisionFlag[collision.globalIndex()]) { + McCollisionFlag[mcCollision.globalIndex()] = true; + } + } + } + } + + void processSelectCollisionsPerMcCollision(soa::Join::iterator const& collision) + { + if (McCollisionFlag[collision.mcCollisionId()]) { + collisionFlag[collision.globalIndex()] = true; + } + } + + void processSetupAllCollisionsWithDownscaling(aod::JCollisions const& collisions) + { + collisionFlag.clear(); + collisionFlag.resize(collisions.size(), false); + for (const auto& collision : collisions) { + if (randomNumber.Integer(config.downscaleFactor) == 0) { + collisionFlag[collision.globalIndex()] = true; + } + } + } + + void processSetupAllMcCollisionsWithDownscaling(aod::JMcCollisions const& mcCollisions) + { + McCollisionFlag.clear(); + McCollisionFlag.resize(mcCollisions.size(), false); + for (const auto& mcCollision : mcCollisions) { + if (randomNumber.Integer(config.downscaleFactor) == 0) { + McCollisionFlag[mcCollision.globalIndex()] = true; + } + } + } + + template + void processDoDownscaling(T const& collisions) + { + for (const auto& collision : collisions) { + if constexpr (std::is_same_v, aod::JCollisions>) { + if (collisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) { + collisionFlag[collision.globalIndex()] = false; + } + } + if constexpr (std::is_same_v, aod::JMcCollisions>) { + if (McCollisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) { + McCollisionFlag[collision.globalIndex()] = false; + } + } + } + } + + void processSetupEventTriggering(aod::JCollision const& collision) + { + if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { + collisionFlag[collision.globalIndex()] = true; + } + } + + 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 || std::abs(collision.posZ()) > config.vertexZCut) { + collisionFlag[collision.globalIndex()] = false; + } + } + + template + void processSelectionObjects(T& selectionObjects) + { + float selectionObjectPtMin = 0.0; + if constexpr (std::is_same_v, aod::ChargedJets> || std::is_same_v, aod::ChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedJetPtMin; + } else if constexpr (std::is_same_v, aod::ChargedEventWiseSubtractedJets> || std::is_same_v, aod::ChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedJetPtMin; + } else if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::NeutralJets> || std::is_same_v, aod::NeutralMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdNeutralJetPtMin; + } else if constexpr (std::is_same_v, aod::NeutralMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdNeutralMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::FullJets> || std::is_same_v, aod::FullMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdFullJetPtMin; + } else if constexpr (std::is_same_v, aod::FullMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdFullMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::D0ChargedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedD0JetPtMin; + } else if constexpr (std::is_same_v, aod::D0ChargedEventWiseSubtractedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedD0JetPtMin; + } else if constexpr (std::is_same_v, aod::D0ChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedD0MCPJetPtMin; + } else if constexpr (std::is_same_v, aod::LcChargedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedLcJetPtMin; + } else if constexpr (std::is_same_v, aod::LcChargedEventWiseSubtractedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedLcJetPtMin; + } else if constexpr (std::is_same_v, aod::LcChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedLcMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::BplusChargedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedBplusJetPtMin; + } else if constexpr (std::is_same_v, aod::BplusChargedEventWiseSubtractedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedBplusJetPtMin; + } else if constexpr (std::is_same_v, aod::BplusChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedBplusMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::DielectronChargedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelJets>) { + selectionObjectPtMin = config.thresholdChargedDielectronJetPtMin; + } else if constexpr (std::is_same_v, aod::DielectronChargedEventWiseSubtractedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelEventWiseSubtractedJets>) { + selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDielectronJetPtMin; + } else if constexpr (std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { + selectionObjectPtMin = config.thresholdChargedDielectronMCPJetPtMin; + } else if constexpr (std::is_same_v, aod::JTracks>) { + selectionObjectPtMin = config.thresholdTriggerTrackPtMin; + } else if constexpr (std::is_same_v, aod::JClusters>) { + selectionObjectPtMin = config.thresholdClusterEnergyMin; + } else { + selectionObjectPtMin = 0.0; + } + for (const auto& selectionObject : selectionObjects) { + bool isTriggerObject = false; + if constexpr (std::is_same_v, aod::JClusters>) { + if (selectionObject.energy() >= selectionObjectPtMin) { + isTriggerObject = true; + } + } else { + if constexpr (std::is_same_v, aod::JTracks>) { + if (config.performTrackSelection && !(selectionObject.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { + continue; + } + if (selectionObject.pt() < config.trackPtSelectionMin || std::abs(selectionObject.eta()) > config.trackEtaSelectionMax) { + continue; + } + } + 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>) { + if (selectionObject.mcCollisionId() >= 0) { + McCollisionFlag[selectionObject.mcCollisionId()] = true; + } + } else { + if (selectionObject.collisionId() >= 0) { + collisionFlag[selectionObject.collisionId()] = true; + } + } + } + } + } + // Todo : Check memory consumption of having so many Process Switches + PROCESS_SWITCH(JetDerivedDataSelector, processSetupCollisions, "setup the writing for data and MCD based on collisions", true); + PROCESS_SWITCH(JetDerivedDataSelector, processSetupMcCollisions, "setup the writing for MCP based on mcCollisions", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSetupAllCollisionsWithDownscaling, "setup the writing of untriggered collisions with downscaling", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSetupAllMcCollisionsWithDownscaling, "setup the writing of untriggered mccollisions with downscaling", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSetupEventTriggering, "process software triggers", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedJets, "process charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedEventWiseSubtractedJets, "process charged event-wise subtracted jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedMCDJets, "process charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedMCDetectorLevelEventWiseSubtractedJets, "process charged event-wise subtracted mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingChargedMCPJets, "process charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingNeutralJets, "process neutral jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingNeutralMCDJets, "process neutral mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingNeutralMCPJets, "process neutral mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingFullJets, "process full jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingFullMCDJets, "process full mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingFullMCPJets, "process full mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedJets, "process D0 charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedEventWiseSubtractedJets, "process D0 event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedMCDJets, "process D0 charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedMCDetectorLevelEventWiseSubtractedJets, "process D0 event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingD0ChargedMCPJets, "process D0 charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedJets, "process Lc charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedEventWiseSubtractedJets, "process Lc event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCDJets, "process Lc charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCDetectorLevelEventWiseSubtractedJets, "process Lc event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingLcChargedMCPJets, "process Lc charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedJets, "process Bplus charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedEventWiseSubtractedJets, "process Bplus event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedMCDJets, "process Bplus charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedMCDetectorLevelEventWiseSubtractedJets, "process Bplus event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingBplusChargedMCPJets, "process Bplus charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedJets, "process Dielectron charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedMCDJets, "process Dielectron charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedMCDetectorLevelEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged mcd jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingDielectronChargedMCPJets, "process Dielectron charged mcp jets", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingClusters, "process EMCal clusters", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects, processSelectingTracks, "process high pt tracks", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processDoDownscaling, processCollisionDownscaling, "process downsaling of triggered collisions", false); + PROCESS_SWITCH_FULL(JetDerivedDataSelector, processDoDownscaling, processMcCollisionDownscaling, "process downsaling of triggered mccollisions", false); + PROCESS_SWITCH(JetDerivedDataSelector, processDoCollisionSelections, "process event selections for saved events", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSelectMcCollisionsPerCollision, "select McCollisions due to a triggered reconstructed collision", false); + PROCESS_SWITCH(JetDerivedDataSelector, processSelectCollisionsPerMcCollision, "select collisions due to a triggered McCollision", false); + + void processStoreCollisionDecision(aod::JCollision const& collision) + { + if (collisionFlag[collision.globalIndex()]) { + collisionSelectionsTable(true); + } else { + collisionSelectionsTable(false); + } + } + PROCESS_SWITCH(JetDerivedDataSelector, processStoreCollisionDecision, "write out decision of storing collision", true); + + void processStoreMcCollisionDecision(aod::JMcCollision const& mcCollision) + { + if (McCollisionFlag[mcCollision.globalIndex()]) { + mcCollisionSelectionsTable(true); + } else { + mcCollisionSelectionsTable(false); + } + } + PROCESS_SWITCH(JetDerivedDataSelector, processStoreMcCollisionDecision, "write out decision of storing mcCollision", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + std::vector tasks; + + tasks.emplace_back(adaptAnalysisTask(cfgc, TaskName{"jet-deriveddata-selector"})); + + return WorkflowSpec{tasks}; +} diff --git a/PWGJE/TableProducer/derivedDataWriter.cxx b/PWGJE/TableProducer/derivedDataWriter.cxx index ee4eeea7c10..234cc219b8b 100644 --- a/PWGJE/TableProducer/derivedDataWriter.cxx +++ b/PWGJE/TableProducer/derivedDataWriter.cxx @@ -18,8 +18,8 @@ #include #include - -#include +#include +#include #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" @@ -30,6 +30,7 @@ #include "PWGJE/Core/JetDQUtilities.h" #include "PWGJE/DataModel/Jet.h" #include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetReducedDataSelector.h" using namespace o2; using namespace o2::framework; @@ -38,42 +39,9 @@ using namespace o2::framework::expressions; struct JetDerivedDataWriter { struct : ConfigurableGroup { - Configurable thresholdChargedJetPtMin{"thresholdChargedJetPtMin", 0.0, "Minimum charged jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedJetPtMin{"thresholdChargedEventWiseSubtractedJetPtMin", 0.0, "Minimum charged event-wise subtracted jet pt to accept event"}; - Configurable thresholdChargedMCPJetPtMin{"thresholdChargedMCPJetPtMin", 0.0, "Minimum charged mcp jet pt to accept event"}; - Configurable thresholdNeutralJetPtMin{"thresholdNeutralJetPtMin", 0.0, "Minimum neutral jet pt to accept event"}; - Configurable thresholdNeutralMCPJetPtMin{"thresholdNeutralMCPJetPtMin", 0.0, "Minimum neutal mcp jet pt to accept event"}; - Configurable thresholdFullJetPtMin{"thresholdFullJetPtMin", 0.0, "Minimum full jet pt to accept event"}; - Configurable thresholdFullMCPJetPtMin{"thresholdFullMCPJetPtMin", 0.0, "Minimum full mcp jet pt to accept event"}; - Configurable thresholdChargedD0JetPtMin{"thresholdChargedD0JetPtMin", 0.0, "Minimum charged D0 jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedD0JetPtMin{"thresholdChargedEventWiseSubtractedD0JetPtMin", 0.0, "Minimum charged event-wise subtracted D0 jet pt to accept event"}; - Configurable thresholdChargedD0MCPJetPtMin{"thresholdChargedD0MCPJetPtMin", 0.0, "Minimum charged D0 mcp jet pt to accept event"}; - Configurable thresholdChargedLcJetPtMin{"thresholdChargedLcJetPtMin", 0.0, "Minimum charged Lc jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedLcJetPtMin{"thresholdChargedEventWiseSubtractedLcJetPtMin", 0.0, "Minimum charged event-wise subtracted Lc jet pt to accept event"}; - Configurable thresholdChargedLcMCPJetPtMin{"thresholdChargedLcMCPJetPtMin", 0.0, "Minimum charged Lc mcp jet pt to accept event"}; - Configurable thresholdChargedBplusJetPtMin{"thresholdChargedBplusJetPtMin", 0.0, "Minimum charged Bplus jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedBplusJetPtMin{"thresholdChargedEventWiseSubtractedBplusJetPtMin", 0.0, "Minimum charged event-wise subtracted Bplus jet pt to accept event"}; - Configurable thresholdChargedBplusMCPJetPtMin{"thresholdChargedBplusMCPJetPtMin", 0.0, "Minimum charged Bplus mcp jet pt to accept event"}; - Configurable thresholdChargedDielectronJetPtMin{"thresholdChargedDielectronJetPtMin", 0.0, "Minimum charged Dielectron jet pt to accept event"}; - Configurable thresholdChargedEventWiseSubtractedDielectronJetPtMin{"thresholdChargedEventWiseSubtractedDielectronJetPtMin", 0.0, "Minimum charged event-wise subtracted Dielectron jet pt to accept event"}; - Configurable thresholdChargedDielectronMCPJetPtMin{"thresholdChargedDielectronMCPJetPtMin", 0.0, "Minimum charged Dielectron mcp jet pt to accept event"}; - Configurable thresholdTriggerTrackPtMin{"thresholdTriggerTrackPtMin", 0.0, "Minimum trigger track pt to accept event"}; - Configurable thresholdClusterEnergyMin{"thresholdClusterEnergyMin", 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"}; Configurable performTrackSelection{"performTrackSelection", true, "only save tracks that pass one of the track selections"}; 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", false, "save the clusters table to the output"}; - Configurable saveD0Table{"saveD0Table", false, "save the D0 tables to the output"}; - Configurable saveLcTable{"saveLcTable", false, "save the Lc tables to the output"}; - Configurable saveBplusTable{"saveBplusTable", false, "save the Bplus tables to the output"}; - Configurable saveDielectronTable{"saveDielectronTable", false, "save the Dielectron tables to the output"}; 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; @@ -165,994 +133,482 @@ struct JetDerivedDataWriter { Produces storedDielectronParticleIdsTable; } products; - PresliceUnsorted> CollisionsPerMcCollision = aod::jmccollisionlb::mcCollisionId; - PresliceUnsorted> ParticlesPerMcCollision = aod::jmcparticle::mcCollisionId; + Preslice> TracksPerCollisionData = aod::jtrack::collisionId; + + Preslice> ParticlesPerMcCollision = aod::jmcparticle::mcCollisionId; Preslice> TracksPerCollision = aod::jtrack::collisionId; - Preslice> ClustersPerCollision = aod::jcluster::collisionId; - Preslice> D0McCollisionsPerMcCollision = aod::jd0indices::mcCollisionId; - Preslice> LcMcCollisionsPerMcCollision = aod::jlcindices::mcCollisionId; - Preslice> BplusMcCollisionsPerMcCollision = aod::jbplusindices::mcCollisionId; + Preslice D0McCollisionsPerMcCollision = aod::jd0indices::mcCollisionId; + Preslice LcMcCollisionsPerMcCollision = aod::jlcindices::mcCollisionId; + Preslice BplusMcCollisionsPerMcCollision = aod::jbplusindices::mcCollisionId; Preslice DielectronMcCollisionsPerMcCollision = aod::jdielectronindices::mcCollisionId; - Preslice D0CollisionsPerCollision = aod::jd0indices::collisionId; - Preslice LcCollisionsPerCollision = aod::jlcindices::collisionId; - Preslice BplusCollisionsPerCollision = aod::jbplusindices::collisionId; - Preslice DielectronCollisionsPerCollision = aod::jdielectronindices::collisionId; - Preslice D0sPerCollision = aod::jd0indices::collisionId; - Preslice LcsPerCollision = aod::jlcindices::collisionId; - Preslice BplussPerCollision = aod::jbplusindices::collisionId; - Preslice DielectronsPerCollision = aod::jdielectronindices::collisionId; + Preslice D0ParticlesPerMcCollision = aod::jd0indices::mcCollisionId; + Preslice LcParticlesPerMcCollision = aod::jlcindices::mcCollisionId; + Preslice BplusParticlesPerMcCollision = aod::jbplusindices::mcCollisionId; PresliceUnsorted EMCTrackPerTrack = aod::jemctrack::trackId; - std::vector collisionFlag; - std::vector McCollisionFlag; - std::vector bcIndicies; - uint32_t precisionPositionMask; uint32_t precisionMomentumMask; - TRandom3 randomNumber; - - std::vector triggerMaskBits; void init(InitContext&) { precisionPositionMask = 0xFFFFFC00; // 13 bits precisionMomentumMask = 0xFFFFFC00; // 13 bits this is currently keept at 13 bits wihich gives roughly a resolution of 1/8000. This can be increased to 15 bits if really needed - randomNumber.SetSeed(0); - triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(config.triggerMasks); } - bool acceptCollision(aod::JCollision const&) + template + bool trackSelection(T const& track) { + if (config.performTrackSelection && !(track.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept. This includes also the track pT selction. + return false; + } + if (track.pt() < config.trackPtSelectionMin || std::abs(track.eta()) > config.trackEtaSelectionMax) { + return false; + } return true; } - void processSetupCollisions(aod::JCollisions const& collisions) + template + void storeD0(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsD0 const& D0Collisions, T const& D0s) { - collisionFlag.clear(); - collisionFlag.resize(collisions.size()); - std::fill(collisionFlag.begin(), collisionFlag.end(), false); - } - void processSetupMcCollisions(aod::JMcCollisions const& McCollisions) - { - McCollisionFlag.clear(); - McCollisionFlag.resize(McCollisions.size()); - std::fill(McCollisionFlag.begin(), McCollisionFlag.end(), false); + if (collision.isCollisionSelected()) { + for (const auto& D0Collision : D0Collisions) { // should only ever be one + jethfutilities::fillHFCollisionTable(D0Collision, products.storedD0CollisionsTable); + products.storedD0CollisionIdsTable(collisionMapping[collision.globalIndex()]); + } + for (const auto& D0 : D0s) { + jethfutilities::fillHFCandidateTable(D0, products.storedD0CollisionsTable.lastIndex(), products.storedD0sTable, products.storedD0ParsTable, products.storedD0ParExtrasTable, products.storedD0ParDaughtersDummyTable, products.storedD0SelsTable, products.storedD0MlsTable, products.storedD0MlDughtersDummyTable, products.storedD0McsTable); + products.storedD0IdsTable(collisionMapping[collision.globalIndex()], trackMapping[D0.prong0Id()], trackMapping[D0.prong1Id()]); + } + } } - void processSetupAllCollisionsWithDownscaling(aod::JCollisions const& collisions) + template + void storeLc(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsLc const& LcCollisions, T const& Lcs) { - collisionFlag.clear(); - collisionFlag.resize(collisions.size()); - for (const auto& collision : collisions) { - if (randomNumber.Integer(config.downscaleFactor) == 0) { - collisionFlag[collision.globalIndex()] = true; - } else { - collisionFlag[collision.globalIndex()] = false; + if (collision.isCollisionSelected()) { + for (const auto& LcCollision : LcCollisions) { // should only ever be one + jethfutilities::fillHFCollisionTable(LcCollision, products.storedLcCollisionsTable); + products.storedLcCollisionIdsTable(collisionMapping[collision.globalIndex()]); + } + for (const auto& Lc : Lcs) { + jethfutilities::fillHFCandidateTable(Lc, products.storedLcCollisionsTable.lastIndex(), products.storedLcsTable, products.storedLcParsTable, products.storedLcParExtrasTable, products.storedLcParDaughtersDummyTable, products.storedLcSelsTable, products.storedLcMlsTable, products.storedLcMlDughtersDummyTable, products.storedLcMcsTable); + products.storedLcIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Lc.prong0Id()], trackMapping[Lc.prong1Id()], trackMapping[Lc.prong2Id()]); } } } - void processSetupAllMcCollisionsWithDownscaling(aod::JMcCollisions const& McCollisions) + template + void storeBplus(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsBplus const& BplusCollisions, T const& Bpluss) { - McCollisionFlag.clear(); - McCollisionFlag.resize(McCollisions.size()); - for (const auto& mcCollision : McCollisions) { - if (randomNumber.Integer(config.downscaleFactor) == 0) { - McCollisionFlag[mcCollision.globalIndex()] = true; - } else { - McCollisionFlag[mcCollision.globalIndex()] = false; + if (collision.isCollisionSelected()) { + for (const auto& BplusCollision : BplusCollisions) { // should only ever be one + jethfutilities::fillHFCollisionTable(BplusCollision, products.storedBplusCollisionsTable); + products.storedBplusCollisionIdsTable(collisionMapping[collision.globalIndex()]); + } + for (const auto& Bplus : Bpluss) { + jethfutilities::fillHFCandidateTable(Bplus, products.storedBplusCollisionsTable.lastIndex(), products.storedBplussTable, products.storedBplusParsTable, products.storedBplusParExtrasTable, products.storedBplusParD0sTable, products.storedBplusSelsTable, products.storedBplusMlsTable, products.storedBplusMlD0sTable, products.storedBplusMcsTable); + products.storedBplusIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Bplus.prong0Id()], trackMapping[Bplus.prong1Id()], trackMapping[Bplus.prong2Id()]); } } } - template - void processDoDownscaling(T const& collisions) + void processDummyTable(aod::JDummys const&) { - for (const auto& collision : collisions) { - if constexpr (std::is_same_v, aod::JCollisions>) { - if (collisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) { - collisionFlag[collision.globalIndex()] = false; - } - } - if constexpr (std::is_same_v, aod::JMcCollisions>) { - if (McCollisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) { - McCollisionFlag[collision.globalIndex()] = false; + products.storedJDummysTable(1); + } + PROCESS_SWITCH(JetDerivedDataWriter, processDummyTable, "write out dummy output table", true); + + std::vector collisionMapping; + std::vector bcMapping; + std::vector trackMapping; + std::vector mcCollisionMapping; + std::vector particleMapping; + std::vector d0McCollisionMapping; + std::vector lcMcCollisionMapping; + std::vector bplusMcCollisionMapping; + std::vector dielectronMcCollisionMapping; + + void processBCs(soa::Join const& collisions, soa::Join const& bcs) + { + std::vector bcIndicies; + bcMapping.clear(); + bcMapping.resize(bcs.size(), -1); + + for (auto const& collision : collisions) { + if (collision.isCollisionSelected()) { + auto bc = collision.bc_as>(); + if (std::find(bcIndicies.begin(), bcIndicies.end(), bc.globalIndex()) == bcIndicies.end()) { + products.storedJBCsTable(bc.runNumber(), bc.globalBC(), bc.timestamp(), bc.alias_raw(), bc.selection_raw()); + products.storedJBCParentIndexTable(bc.bcId()); + bcIndicies.push_back(bc.globalIndex()); + bcMapping[bc.globalIndex()] = products.storedJBCsTable.lastIndex(); } } } } + PROCESS_SWITCH(JetDerivedDataWriter, processBCs, "write out output tables for Bunch crossings", true); - void processSetupEventTriggering(aod::JCollision const& collision) + void processColllisons(soa::Join const& collisions) { - if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) { - collisionFlag[collision.globalIndex()] = true; - } - } + collisionMapping.clear(); + collisionMapping.resize(collisions.size(), -1); + + for (auto const& collision : collisions) { + if (collision.isCollisionSelected()) { - 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 || std::abs(collision.posZ()) > config.vertexZCut) { - collisionFlag[collision.globalIndex()] = false; + products.storedJCollisionsTable(collision.posX(), collision.posY(), collision.posZ(), collision.multiplicity(), collision.centrality(), collision.trackOccupancyInTimeRange(), collision.eventSel(), collision.alias_raw(), collision.triggerSel()); + collisionMapping[collision.globalIndex()] = products.storedJCollisionsTable.lastIndex(); + products.storedJCollisionMcInfosTable(collision.weight(), collision.subGeneratorId()); + products.storedJCollisionsParentIndexTable(collision.collisionId()); + if (doprocessBCs) { + products.storedJCollisionsBunchCrossingIndexTable(bcMapping[collision.bcId()]); + } + } } } + PROCESS_SWITCH(JetDerivedDataWriter, processColllisons, "write out output tables for collisions", true); - template - void processSelectionObjects(T& selectionObjects) + void processTracks(soa::Join const& collisions, soa::Join const& tracks) { - float selectionObjectPtMin = 0.0; - if constexpr (std::is_same_v, aod::ChargedJets> || std::is_same_v, aod::ChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedJetPtMin; - } else if constexpr (std::is_same_v, aod::ChargedEventWiseSubtractedJets> || std::is_same_v, aod::ChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedJetPtMin; - } else if constexpr (std::is_same_v, aod::ChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::NeutralJets> || std::is_same_v, aod::NeutralMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdNeutralJetPtMin; - } else if constexpr (std::is_same_v, aod::NeutralMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdNeutralMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::FullJets> || std::is_same_v, aod::FullMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdFullJetPtMin; - } else if constexpr (std::is_same_v, aod::FullMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdFullMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::D0ChargedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedD0JetPtMin; - } else if constexpr (std::is_same_v, aod::D0ChargedEventWiseSubtractedJets> || std::is_same_v, aod::D0ChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedD0JetPtMin; - } else if constexpr (std::is_same_v, aod::D0ChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedD0MCPJetPtMin; - } else if constexpr (std::is_same_v, aod::LcChargedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedLcJetPtMin; - } else if constexpr (std::is_same_v, aod::LcChargedEventWiseSubtractedJets> || std::is_same_v, aod::LcChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedLcJetPtMin; - } else if constexpr (std::is_same_v, aod::LcChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedLcMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::BplusChargedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedBplusJetPtMin; - } else if constexpr (std::is_same_v, aod::BplusChargedEventWiseSubtractedJets> || std::is_same_v, aod::BplusChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedBplusJetPtMin; - } else if constexpr (std::is_same_v, aod::BplusChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedBplusMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::DielectronChargedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelJets>) { - selectionObjectPtMin = config.thresholdChargedDielectronJetPtMin; - } else if constexpr (std::is_same_v, aod::DielectronChargedEventWiseSubtractedJets> || std::is_same_v, aod::DielectronChargedMCDetectorLevelEventWiseSubtractedJets>) { - selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDielectronJetPtMin; - } else if constexpr (std::is_same_v, aod::DielectronChargedMCParticleLevelJets>) { - selectionObjectPtMin = config.thresholdChargedDielectronMCPJetPtMin; - } else if constexpr (std::is_same_v, aod::JTracks>) { - selectionObjectPtMin = config.thresholdTriggerTrackPtMin; - } else if constexpr (std::is_same_v, aod::JClusters>) { - selectionObjectPtMin = config.thresholdClusterEnergyMin; - } else { - selectionObjectPtMin = 0.0; - } - for (const auto& selectionObject : selectionObjects) { - bool isTriggerObject = false; - if constexpr (std::is_same_v, aod::JClusters>) { - if (selectionObject.energy() >= selectionObjectPtMin) { - isTriggerObject = true; - } - } else { - if constexpr (std::is_same_v, aod::JTracks>) { - if (config.performTrackSelection && !(selectionObject.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { + trackMapping.clear(); + trackMapping.resize(tracks.size(), -1); + + for (auto const& collision : collisions) { + if (collision.isCollisionSelected()) { + const auto tracksPerCollision = tracks.sliceBy(TracksPerCollisionData, collision.globalIndex()); + for (const auto& track : tracksPerCollision) { + if (!trackSelection(track)) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept. This includes also the track pT selction. continue; } - } - 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>) { - if (selectionObject.mcCollisionId() >= 0) { - McCollisionFlag[selectionObject.mcCollisionId()] = true; - } - } else { - if (selectionObject.collisionId() >= 0) { - collisionFlag[selectionObject.collisionId()] = true; - } + products.storedJTracksTable(collisionMapping[collision.globalIndex()], 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.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[track.globalIndex()] = products.storedJTracksTable.lastIndex(); } } } } - // Todo : Check memory consumption of having so many Process Switches - 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", false); - 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, processSelectingBplusChargedJets, "process Bplus charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedEventWiseSubtractedJets, "process Bplus event-wise subtracted charged jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedMCDJets, "process Bplus charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedMCDetectorLevelEventWiseSubtractedJets, "process Bplus event-wise subtracted charged mcd jets", false); - PROCESS_SWITCH_FULL(JetDerivedDataWriter, processSelectionObjects, processSelectingBplusChargedMCPJets, "process Bplus 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); + PROCESS_SWITCH(JetDerivedDataWriter, processTracks, "write out output tables for tracks", true); - void processStoreDummyTable(aod::JDummys const&) + void processClusters(soa::Join::iterator const& collision, aod::JTracks const&, aod::JEMCTracks const& emcTracks, soa::Join const& clusters) { - products.storedJDummysTable(1); + if (collision.isCollisionSelected()) { + products.storedJCollisionsEMCalLabelTable(collision.isAmbiguous(), collision.isEmcalReadout()); + for (const auto& cluster : clusters) { + products.storedJClustersTable(collisionMapping[collision.globalIndex()], cluster.id(), cluster.energy(), cluster.coreEnergy(), cluster.rawEnergy(), + cluster.eta(), cluster.phi(), cluster.m02(), cluster.m20(), cluster.nCells(), cluster.time(), cluster.isExotic(), cluster.distanceToBadChannel(), + cluster.nlm(), cluster.definition(), cluster.leadingCellEnergy(), cluster.subleadingCellEnergy(), cluster.leadingCellNumber(), cluster.subleadingCellNumber()); + products.storedJClustersCorrectedEnergiesTable(cluster.energyCorrectedOneTrack1(), cluster.energyCorrectedOneTrack2(), cluster.energyCorrectedAllTracks1(), cluster.energyCorrectedAllTracks2()); + products.storedJClustersParentIndexTable(cluster.clusterId()); + + std::vector clusterStoredJTrackIDs; + for (const auto& clusterTrack : cluster.matchedTracks_as()) { + clusterStoredJTrackIDs.push_back(trackMapping[clusterTrack.globalIndex()]); + auto emcTracksPerTrack = emcTracks.sliceBy(EMCTrackPerTrack, clusterTrack.globalIndex()); + auto emcTrackPerTrack = emcTracksPerTrack.iteratorAt(0); + products.storedJTracksEMCalTable(trackMapping[clusterTrack.globalIndex()], emcTrackPerTrack.etaEmcal(), emcTrackPerTrack.phiEmcal()); + } + products.storedJClustersMatchedTracksTable(clusterStoredJTrackIDs); + } + } } - PROCESS_SWITCH(JetDerivedDataWriter, processStoreDummyTable, "write out dummy output table", true); + PROCESS_SWITCH(JetDerivedDataWriter, processClusters, "write out output tables for clusters", false); + + //!!!!!!!!!! need to add the hadronic corrected energy and delete the new dummy process function - void processStoreData(soa::Join::iterator const& collision, soa::Join const&, soa::Join const& tracks, aod::JEMCTracks const& emcTracks, soa::Join const& clusters, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0Data const& D0s, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcData const& Lcs, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusData const& Bpluss, aod::CollisionsDielectron const& DielectronCollisions, aod::CandidatesDielectronData const& Dielectrons) + void processD0Data(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0Data const& D0s) { - std::map bcMapping; - std::map trackMapping; + storeD0(collision, tracks, D0Collisions, D0s); + } + PROCESS_SWITCH(JetDerivedDataWriter, processD0Data, "write out data output tables for D0", false); - if (collisionFlag[collision.globalIndex()]) { - 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(), 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())); - } - } + void processD0MCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0MCD const& D0s) + { + storeD0(collision, tracks, D0Collisions, D0s); + } + PROCESS_SWITCH(JetDerivedDataWriter, processD0MCD, "write out mcd output tables for D0", false); - products.storedJCollisionsTable(collision.posX(), collision.posY(), collision.posZ(), collision.multiplicity(), collision.centrality(), collision.trackOccupancyInTimeRange(), collision.eventSel(), collision.alias_raw(), collision.triggerSel()); - products.storedJCollisionMcInfosTable(collision.weight(), collision.subGeneratorId()); - products.storedJCollisionsParentIndexTable(collision.collisionId()); - if (config.saveBCsTable) { - int32_t storedBCID = -1; - auto JBCIndex = bcMapping.find(collision.bcId()); - if (JBCIndex != bcMapping.end()) { - storedBCID = JBCIndex->second; - } - products.storedJCollisionsBunchCrossingIndexTable(storedBCID); - } - if (config.saveClustersTable) { - products.storedJCollisionsEMCalLabelTable(collision.isAmbiguous(), collision.isEmcalReadout()); - } + void processLcData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcData const& Lcs) + { + storeLc(collision, tracks, LcCollisions, Lcs); + } + PROCESS_SWITCH(JetDerivedDataWriter, processLcData, "write out data output tables for Lc", false); - for (const auto& track : tracks) { - if (config.performTrackSelection && !(track.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept. This includes also the track pT selction. - continue; - } - if (track.pt() < config.trackPtSelectionMin || std::abs(track.eta()) > config.trackEtaSelectionMax) { - 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.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())); - } - if (config.saveClustersTable) { - for (const auto& cluster : clusters) { - products.storedJClustersTable(products.storedJCollisionsTable.lastIndex(), cluster.id(), cluster.energy(), cluster.coreEnergy(), cluster.rawEnergy(), - cluster.eta(), cluster.phi(), cluster.m02(), cluster.m20(), cluster.nCells(), cluster.time(), cluster.isExotic(), cluster.distanceToBadChannel(), - cluster.nlm(), cluster.definition(), cluster.leadingCellEnergy(), cluster.subleadingCellEnergy(), cluster.leadingCellNumber(), cluster.subleadingCellNumber()); - products.storedJClustersCorrectedEnergiesTable(cluster.energyCorrectedOneTrack1(), cluster.energyCorrectedOneTrack2(), cluster.energyCorrectedAllTracks1(), cluster.energyCorrectedAllTracks2()); - products.storedJClustersParentIndexTable(cluster.clusterId()); + void processLcMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcMCD const& Lcs) + { + storeLc(collision, tracks, LcCollisions, Lcs); + } + PROCESS_SWITCH(JetDerivedDataWriter, processLcMCD, "write out mcd output tables for Lc", false); - std::vector clusterStoredJTrackIDs; - for (const auto& clusterTrack : cluster.matchedTracks_as>()) { - auto JtrackIndex = trackMapping.find(clusterTrack.globalIndex()); - if (JtrackIndex != trackMapping.end()) { - clusterStoredJTrackIDs.push_back(JtrackIndex->second); - auto emcTracksPerTrack = emcTracks.sliceBy(EMCTrackPerTrack, clusterTrack.globalIndex()); - auto emcTrackPerTrack = emcTracksPerTrack.iteratorAt(0); - products.storedJTracksEMCalTable(JtrackIndex->second, emcTrackPerTrack.etaEmcal(), emcTrackPerTrack.phiEmcal()); - } - } - products.storedJClustersMatchedTracksTable(clusterStoredJTrackIDs); - } - } + void processBplusData(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusData const& Bpluss) + { + storeBplus(collision, tracks, BplusCollisions, Bpluss); + } + PROCESS_SWITCH(JetDerivedDataWriter, processBplusData, "write out data output tables for bplus", false); - if (config.saveD0Table) { - int32_t collisionD0Index = -1; - for (const auto& D0Collision : D0Collisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(D0Collision, products.storedD0CollisionsTable, collisionD0Index); - products.storedD0CollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - } - for (const auto& D0 : D0s) { - int32_t D0Index = -1; - jethfutilities::fillHFCandidateTable(D0, collisionD0Index, products.storedD0sTable, products.storedD0ParsTable, products.storedD0ParExtrasTable, products.storedD0ParDaughtersDummyTable, products.storedD0SelsTable, products.storedD0MlsTable, products.storedD0MlDughtersDummyTable, products.storedD0McsTable, D0Index); + void processBplusMCD(soa::Join::iterator const& collision, aod::JTracks const& tracks, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusMCD const& Bpluss) + { + storeBplus(collision, tracks, BplusCollisions, Bpluss); + } + PROCESS_SWITCH(JetDerivedDataWriter, processBplusMCD, "write out mcd output tables for bplus", false); - int32_t prong0Id = -1; - int32_t prong1Id = -1; - auto JtrackIndex = trackMapping.find(D0.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(D0.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - products.storedD0IdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id); - } + void processDielectron(soa::Join::iterator const& collision, aod::JTracks const&, aod::CollisionsDielectron const& DielectronCollisions, aod::CandidatesDielectronData const& Dielectrons) + { + if (collision.isCollisionSelected()) { + for (const auto& DielectronCollision : DielectronCollisions) { // should only ever be one + jetdqutilities::fillDielectronCollisionTable(DielectronCollision, products.storedDielectronCollisionsTable); + products.storedDielectronCollisionIdsTable(collisionMapping[collision.globalIndex()]); } - - if (config.saveLcTable) { - int32_t collisionLcIndex = -1; - for (const auto& LcCollision : LcCollisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(LcCollision, products.storedLcCollisionsTable, collisionLcIndex); - products.storedLcCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - } - for (const auto& Lc : Lcs) { - int32_t LcIndex = -1; - jethfutilities::fillHFCandidateTable(Lc, collisionLcIndex, products.storedLcsTable, products.storedLcParsTable, products.storedLcParExtrasTable, products.storedLcParDaughtersDummyTable, products.storedLcSelsTable, products.storedLcMlsTable, products.storedLcMlDughtersDummyTable, products.storedLcMcsTable, LcIndex); - - int32_t prong0Id = -1; - int32_t prong1Id = -1; - int32_t prong2Id = -1; - auto JtrackIndex = trackMapping.find(Lc.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Lc.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Lc.prong2Id()); - if (JtrackIndex != trackMapping.end()) { - prong2Id = JtrackIndex->second; - } - products.storedLcIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id, prong2Id); - } + for (const auto& Dielectron : Dielectrons) { + jetdqutilities::fillDielectronCandidateTable(Dielectron, products.storedDielectronCollisionsTable.lastIndex(), products.storedDielectronsTable); + products.storedDielectronIdsTable(collisionMapping[collision.globalIndex()], trackMapping[Dielectron.prong0Id()], trackMapping[Dielectron.prong1Id()]); } - if (config.saveBplusTable) { - int32_t collisionBplusIndex = -1; - for (const auto& BplusCollision : BplusCollisions) { // should only ever be one - jethfutilities::fillHFCollisionTable(BplusCollision, products.storedBplusCollisionsTable, collisionBplusIndex); - products.storedBplusCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - } - for (const auto& Bplus : Bpluss) { - int32_t BplusIndex = -1; - jethfutilities::fillHFCandidateTable(Bplus, collisionBplusIndex, products.storedBplussTable, products.storedBplusParsTable, products.storedBplusParExtrasTable, products.storedBplusParD0sTable, products.storedBplusSelsTable, products.storedBplusMlsTable, products.storedBplusMlD0sTable, products.storedBplusMcsTable, BplusIndex); + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processDielectron, "write out data output tables for dielectrons", false); - int32_t prong0Id = -1; - int32_t prong1Id = -1; - int32_t prong2Id = -1; - auto JtrackIndex = trackMapping.find(Bplus.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Bplus.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Bplus.prong2Id()); - if (JtrackIndex != trackMapping.end()) { - prong2Id = JtrackIndex->second; - } - products.storedBplusIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id, prong2Id); - } - } - if (config.saveDielectronTable) { - int32_t collisionDielectronIndex = -1; - for (const auto& DielectronCollision : DielectronCollisions) { // should only ever be one - jetdqutilities::fillDielectronCollisionTable(DielectronCollision, products.storedDielectronCollisionsTable, collisionDielectronIndex); - products.storedDielectronCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - } - for (const auto& Dielectron : Dielectrons) { - int32_t DielectronIndex = -1; - jetdqutilities::fillDielectronCandidateTable(Dielectron, collisionDielectronIndex, products.storedDielectronsTable, DielectronIndex); + void processMcCollisions(soa::Join const& mcCollisions) + { + mcCollisionMapping.clear(); + mcCollisionMapping.resize(mcCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { - int32_t prong0Id = -1; - int32_t prong1Id = -1; - auto JtrackIndex = trackMapping.find(Dielectron.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Dielectron.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - products.storedDielectronIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id); - } + products.storedJMcCollisionsTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.weight(), mcCollision.subGeneratorId()); + products.storedJMcCollisionsParentIndexTable(mcCollision.mcCollisionId()); + mcCollisionMapping[mcCollision.globalIndex()] = products.storedJMcCollisionsTable.lastIndex(); } } } - // process switch for output writing must be last - // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processStoreData, "write out data output tables", false); + PROCESS_SWITCH(JetDerivedDataWriter, processMcCollisions, "write out mcCollision output tables", false); - void processStoreMC(soa::Join const& mcCollisions, soa::Join const& collisions, soa::Join const&, soa::Join const& tracks, aod::JEMCTracks const& emcTracks, soa::Join const& clusters, soa::Join const& particles, aod::CollisionsD0 const& D0Collisions, aod::CandidatesD0MCD const& D0s, soa::Join const& D0McCollisions, aod::CandidatesD0MCP const& D0Particles, aod::CollisionsLc const& LcCollisions, aod::CandidatesLcMCD const& Lcs, soa::Join const& LcMcCollisions, aod::CandidatesLcMCP const& LcParticles, aod::CollisionsBplus const& BplusCollisions, aod::CandidatesBplusMCD const& Bpluss, soa::Join const& BplusMcCollisions, aod::CandidatesBplusMCP const& BplusParticles, aod::CollisionsDielectron const& DielectronCollisions, aod::CandidatesDielectronMCD const& Dielectrons, aod::McCollisionsDielectron const& DielectronMcCollisions, aod::CandidatesDielectronMCP const& DielectronParticles) + void processMcParticles(soa::Join const& mcCollisions, soa::Join const& particles) { - std::map bcMapping; - std::map paticleMapping; - std::map mcCollisionMapping; - std::map D0CollisionMapping; - std::map LcCollisionMapping; - std::map BplusCollisionMapping; + particleMapping.clear(); + particleMapping.resize(particles.size(), -1); int particleTableIndex = 0; - for (auto mcCollision : mcCollisions) { - bool collisionSelected = false; - const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex()); - for (auto collision : collisionsPerMcCollision) { - if (collisionFlag[collision.globalIndex()]) { - collisionSelected = true; - } - } - - if (McCollisionFlag[mcCollision.globalIndex()] || collisionSelected) { + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { const auto particlesPerMcCollision = particles.sliceBy(ParticlesPerMcCollision, mcCollision.globalIndex()); - products.storedJMcCollisionsTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.weight(), mcCollision.subGeneratorId()); - products.storedJMcCollisionsParentIndexTable(mcCollision.mcCollisionId()); - mcCollisionMapping.insert(std::make_pair(mcCollision.globalIndex(), products.storedJMcCollisionsTable.lastIndex())); - for (auto particle : particlesPerMcCollision) { - paticleMapping.insert(std::make_pair(particle.globalIndex(), particleTableIndex)); + particleMapping[particle.globalIndex()] = particleTableIndex; particleTableIndex++; } for (auto particle : particlesPerMcCollision) { - std::vector mothersId; + std::vector mothersIds; if (particle.has_mothers()) { auto mothersIdTemps = particle.mothersIds(); for (auto mothersIdTemp : mothersIdTemps) { - - auto JMotherIndex = paticleMapping.find(mothersIdTemp); - if (JMotherIndex != paticleMapping.end()) { - mothersId.push_back(JMotherIndex->second); - } + mothersIds.push_back(particleMapping[mothersIdTemp]); } } - int daughtersId[2] = {-1, -1}; + int daughtersIds[2] = {-1, -1}; auto i = 0; if (particle.has_daughters()) { for (auto daughterId : particle.daughtersIds()) { if (i > 1) { break; } - auto JDaughterIndex = paticleMapping.find(daughterId); - if (JDaughterIndex != paticleMapping.end()) { - daughtersId[i] = JDaughterIndex->second; - } + daughtersIds[i] = particleMapping[daughterId]; i++; } } - products.storedJMcParticlesTable(products.storedJMcCollisionsTable.lastIndex(), o2::math_utils::detail::truncateFloatFraction(particle.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(particle.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.phi(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.y(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.e(), precisionMomentumMask), particle.pdgCode(), particle.getGenStatusCode(), particle.getHepMCStatusCode(), particle.isPhysicalPrimary(), mothersId, daughtersId); + products.storedJMcParticlesTable(mcCollisionMapping[mcCollision.globalIndex()], o2::math_utils::detail::truncateFloatFraction(particle.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(particle.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.phi(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.y(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.e(), precisionMomentumMask), particle.pdgCode(), particle.getGenStatusCode(), particle.getHepMCStatusCode(), particle.isPhysicalPrimary(), mothersIds, daughtersIds); products.storedJParticlesParentIndexTable(particle.mcParticleId()); } + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processMcParticles, "write out mcParticle output tables", false); - if (config.saveD0Table) { - const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionD0Index = -1; - for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(d0McCollisionPerMcCollision, products.storedD0McCollisionsTable, mcCollisionD0Index); - products.storedD0McCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& D0Particle : D0Particles) { - int32_t D0ParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(D0Particle, mcCollisionD0Index, products.storedD0ParticlesTable, D0ParticleIndex); - int32_t D0ParticleId = -1; - auto JParticleIndex = paticleMapping.find(D0Particle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - D0ParticleId = JParticleIndex->second; - } - products.storedD0ParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), D0ParticleId); - } - } - - if (config.saveLcTable) { - const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionLcIndex = -1; - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedLcMcCollisionsTable, mcCollisionLcIndex); - products.storedLcMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& LcParticle : LcParticles) { - int32_t LcParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(LcParticle, mcCollisionLcIndex, products.storedLcParticlesTable, LcParticleIndex); - int32_t LcParticleId = -1; - auto JParticleIndex = paticleMapping.find(LcParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - LcParticleId = JParticleIndex->second; - } - products.storedLcParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), LcParticleId); - } - } - if (config.saveBplusTable) { - const auto lcMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionBplusIndex = -1; - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedBplusMcCollisionsTable, mcCollisionBplusIndex); - products.storedBplusMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& BplusParticle : BplusParticles) { - int32_t BplusParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(BplusParticle, mcCollisionBplusIndex, products.storedBplusParticlesTable, BplusParticleIndex); - int32_t BplusParticleId = -1; - auto JParticleIndex = paticleMapping.find(BplusParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - BplusParticleId = JParticleIndex->second; - } - products.storedBplusParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), BplusParticleId); - } - } - if (config.saveDielectronTable) { - const auto dielectronMcCollisionsPerMcCollision = DielectronMcCollisions.sliceBy(DielectronMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionDielectronIndex = -1; - for (const auto& dielectronMcCollisionPerMcCollision : dielectronMcCollisionsPerMcCollision) { // should only ever be one - jetdqutilities::fillDielectronMcCollisionTable(dielectronMcCollisionPerMcCollision, products.storedDielectronMcCollisionsTable, mcCollisionDielectronIndex); - products.storedDielectronMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& DielectronParticle : DielectronParticles) { - int32_t DielectronParticleIndex = -1; - jetdqutilities::fillDielectronCandidateMcTable(DielectronParticle, mcCollisionDielectronIndex, products.storedDielectronParticlesTable, DielectronParticleIndex); - int32_t DielectronParticleId = -1; - auto JParticleIndex = paticleMapping.find(DielectronParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - DielectronParticleId = JParticleIndex->second; - } - std::vector DielectronMothersId; - int DielectronDaughtersId[2]; - if (DielectronParticle.has_mothers()) { - for (auto const& DielectronMother : DielectronParticle.template mothers_as>()) { - auto JDielectronMotherIndex = paticleMapping.find(DielectronMother.globalIndex()); - if (JDielectronMotherIndex != paticleMapping.end()) { - DielectronMothersId.push_back(JDielectronMotherIndex->second); - } - } - } - auto i = 0; - if (DielectronParticle.has_daughters()) { - for (auto const& DielectronDaughter : DielectronParticle.template daughters_as>()) { - if (i > 1) { - break; - } - auto JDielectronDaughterIndex = paticleMapping.find(DielectronDaughter.globalIndex()); - if (JDielectronDaughterIndex != paticleMapping.end()) { - DielectronDaughtersId[i] = JDielectronDaughterIndex->second; - } - i++; - } - } - products.storedDielectronParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), DielectronParticleId, DielectronMothersId, DielectronDaughtersId); - } + void processD0MCP(soa::Join const& mcCollisions, aod::McCollisionsD0 const& D0McCollisions, aod::CandidatesD0MCP const& D0Particles) + { + d0McCollisionMapping.clear(); + d0McCollisionMapping.resize(D0McCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { + const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { + jethfutilities::fillHFMcCollisionTable(d0McCollisionPerMcCollision, products.storedD0McCollisionsTable); + products.storedD0McCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + d0McCollisionMapping[d0McCollisionPerMcCollision.globalIndex()] = products.storedD0McCollisionsTable.lastIndex(); + } + const auto d0ParticlesPerMcCollision = D0Particles.sliceBy(D0ParticlesPerMcCollision, mcCollision.globalIndex()); + for (const auto& D0Particle : d0ParticlesPerMcCollision) { + jethfutilities::fillHFCandidateMcTable(D0Particle, products.storedD0McCollisionsTable.lastIndex(), products.storedD0ParticlesTable); + products.storedD0ParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[D0Particle.mcParticleId()]); } } } + } + PROCESS_SWITCH(JetDerivedDataWriter, processD0MCP, "write out D0 mcp output tables", false); - for (auto mcCollision : mcCollisions) { - bool collisionSelected = false; - const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex()); - for (auto collision : collisionsPerMcCollision) { - if (collisionFlag[collision.globalIndex()]) { - collisionSelected = true; + void processLcMCP(soa::Join const& mcCollisions, aod::McCollisionsLc const& LcMcCollisions, aod::CandidatesLcMCP const& LcParticles) + { + lcMcCollisionMapping.clear(); + lcMcCollisionMapping.resize(LcMcCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { + const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one + jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedLcMcCollisionsTable); + products.storedLcMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + lcMcCollisionMapping[lcMcCollisionPerMcCollision.globalIndex()] = products.storedLcMcCollisionsTable.lastIndex(); + } + const auto lcParticlesPerMcCollision = LcParticles.sliceBy(LcParticlesPerMcCollision, mcCollision.globalIndex()); + for (const auto& LcParticle : lcParticlesPerMcCollision) { + jethfutilities::fillHFCandidateMcTable(LcParticle, products.storedLcMcCollisionsTable.lastIndex(), products.storedLcParticlesTable); + products.storedLcParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[LcParticle.mcParticleId()]); } } + } + } - if (McCollisionFlag[mcCollision.globalIndex()] || collisionSelected) { - - for (auto collision : collisionsPerMcCollision) { - std::map trackMapping; - 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(), 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())); - } - } - - products.storedJCollisionsTable(collision.posX(), collision.posY(), collision.posZ(), collision.multiplicity(), collision.centrality(), collision.trackOccupancyInTimeRange(), collision.eventSel(), collision.alias_raw(), collision.triggerSel()); - products.storedJCollisionMcInfosTable(collision.weight(), collision.subGeneratorId()); - products.storedJCollisionsParentIndexTable(collision.collisionId()); - - auto JMcCollisionIndex = mcCollisionMapping.find(mcCollision.globalIndex()); - if (JMcCollisionIndex != mcCollisionMapping.end()) { - products.storedJMcCollisionsLabelTable(JMcCollisionIndex->second); - } - if (config.saveBCsTable) { - int32_t storedBCID = -1; - auto JBCIndex = bcMapping.find(collision.bcId()); - if (JBCIndex != bcMapping.end()) { - storedBCID = JBCIndex->second; - } - products.storedJCollisionsBunchCrossingIndexTable(storedBCID); - } - if (config.saveClustersTable) { - products.storedJCollisionsEMCalLabelTable(collision.isAmbiguous(), collision.isEmcalReadout()); - } - - const auto tracksPerCollision = tracks.sliceBy(TracksPerCollision, collision.globalIndex()); - for (const auto& track : tracksPerCollision) { - if (config.performTrackSelection && !(track.trackSel() & ~(1 << jetderiveddatautilities::JTrackSel::trackSign))) { // skips tracks that pass no selections. This might cause a problem with tracks matched with clusters. We should generate a track selection purely for cluster matched tracks so that they are kept - continue; - } - if (track.pt() < config.trackPtSelectionMin || std::abs(track.eta()) > config.trackEtaSelectionMax) { - 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.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()) { - auto JParticleIndex = paticleMapping.find(track.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - products.storedJMcTracksLabelTable(JParticleIndex->second); - } else { - products.storedJMcTracksLabelTable(-1); // this can happen because there are some tracks that are reconstucted in a wrong collision, but their original McCollision did not pass the required cuts so that McParticle is not saved. These are very few but we should look into them further and see what to do about them - } - } else { - products.storedJMcTracksLabelTable(-1); - } - trackMapping.insert(std::make_pair(track.globalIndex(), products.storedJTracksTable.lastIndex())); - } - if (config.saveClustersTable) { - const auto clustersPerCollision = clusters.sliceBy(ClustersPerCollision, collision.globalIndex()); - for (const auto& cluster : clustersPerCollision) { - products.storedJClustersTable(products.storedJCollisionsTable.lastIndex(), cluster.id(), cluster.energy(), cluster.coreEnergy(), cluster.rawEnergy(), - cluster.eta(), cluster.phi(), cluster.m02(), cluster.m20(), cluster.nCells(), cluster.time(), cluster.isExotic(), cluster.distanceToBadChannel(), - cluster.nlm(), cluster.definition(), cluster.leadingCellEnergy(), cluster.subleadingCellEnergy(), cluster.leadingCellNumber(), cluster.subleadingCellNumber()); - products.storedJClustersCorrectedEnergiesTable(cluster.energyCorrectedOneTrack1(), cluster.energyCorrectedOneTrack2(), cluster.energyCorrectedAllTracks1(), cluster.energyCorrectedAllTracks2()); - products.storedJClustersParentIndexTable(cluster.clusterId()); - - std::vector clusterStoredJTrackIDs; - for (const auto& clusterTrack : cluster.matchedTracks_as>()) { - auto JtrackIndex = trackMapping.find(clusterTrack.globalIndex()); - if (JtrackIndex != trackMapping.end()) { - clusterStoredJTrackIDs.push_back(JtrackIndex->second); - const auto emcTracksPerTrack = emcTracks.sliceBy(EMCTrackPerTrack, clusterTrack.globalIndex()); - auto emcTrackPerTrack = emcTracksPerTrack.iteratorAt(0); - products.storedJTracksEMCalTable(JtrackIndex->second, emcTrackPerTrack.etaEmcal(), emcTrackPerTrack.phiEmcal()); - } - } - products.storedJClustersMatchedTracksTable(clusterStoredJTrackIDs); - - std::vector clusterStoredJParticleIDs; - for (const auto& clusterParticleId : cluster.mcParticlesIds()) { - auto JParticleIndex = paticleMapping.find(clusterParticleId); - if (JParticleIndex != paticleMapping.end()) { - clusterStoredJParticleIDs.push_back(JParticleIndex->second); - } - } - std::vector amplitudeA; - auto amplitudeASpan = cluster.amplitudeA(); - std::copy(amplitudeASpan.begin(), amplitudeASpan.end(), std::back_inserter(amplitudeA)); - products.storedJMcClustersLabelTable(clusterStoredJParticleIDs, amplitudeA); - } - } - - if (config.saveD0Table) { - const auto d0CollisionsPerCollision = D0Collisions.sliceBy(D0CollisionsPerCollision, collision.globalIndex()); - int32_t collisionD0Index = -1; - for (const auto& d0CollisionPerCollision : d0CollisionsPerCollision) { // should only ever be one - jethfutilities::fillHFCollisionTable(d0CollisionPerCollision, products.storedD0CollisionsTable, collisionD0Index); - products.storedD0CollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - D0CollisionMapping.insert(std::make_pair(d0CollisionPerCollision.globalIndex(), products.storedD0CollisionsTable.lastIndex())); - } - const auto d0sPerCollision = D0s.sliceBy(D0sPerCollision, collision.globalIndex()); - for (const auto& D0 : d0sPerCollision) { - int32_t D0Index = -1; - jethfutilities::fillHFCandidateTable(D0, collisionD0Index, products.storedD0sTable, products.storedD0ParsTable, products.storedD0ParExtrasTable, products.storedD0ParDaughtersDummyTable, products.storedD0SelsTable, products.storedD0MlsTable, products.storedD0MlDughtersDummyTable, products.storedD0McsTable, D0Index); - - int32_t prong0Id = -1; - int32_t prong1Id = -1; - auto JtrackIndex = trackMapping.find(D0.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(D0.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - products.storedD0IdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id); - } - } - - if (config.saveLcTable) { - const auto lcCollisionsPerCollision = LcCollisions.sliceBy(LcCollisionsPerCollision, collision.globalIndex()); - int32_t collisionLcIndex = -1; - for (const auto& lcCollisionPerCollision : lcCollisionsPerCollision) { // should only ever be one - jethfutilities::fillHFCollisionTable(lcCollisionPerCollision, products.storedLcCollisionsTable, collisionLcIndex); - products.storedLcCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - LcCollisionMapping.insert(std::make_pair(lcCollisionPerCollision.globalIndex(), products.storedLcCollisionsTable.lastIndex())); - } - const auto lcsPerCollision = Lcs.sliceBy(LcsPerCollision, collision.globalIndex()); - for (const auto& Lc : lcsPerCollision) { - int32_t LcIndex = -1; - jethfutilities::fillHFCandidateTable(Lc, collisionLcIndex, products.storedLcsTable, products.storedLcParsTable, products.storedLcParExtrasTable, products.storedLcParDaughtersDummyTable, products.storedLcSelsTable, products.storedLcMlsTable, products.storedLcMlDughtersDummyTable, products.storedLcMcsTable, LcIndex); - - int32_t prong0Id = -1; - int32_t prong1Id = -1; - int32_t prong2Id = -1; - auto JtrackIndex = trackMapping.find(Lc.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Lc.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Lc.prong2Id()); - if (JtrackIndex != trackMapping.end()) { - prong2Id = JtrackIndex->second; - } - products.storedLcIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id, prong2Id); - } - } - - if (config.saveBplusTable) { - const auto lcCollisionsPerCollision = BplusCollisions.sliceBy(BplusCollisionsPerCollision, collision.globalIndex()); - int32_t collisionBplusIndex = -1; - for (const auto& lcCollisionPerCollision : lcCollisionsPerCollision) { // should only ever be one - jethfutilities::fillHFCollisionTable(lcCollisionPerCollision, products.storedBplusCollisionsTable, collisionBplusIndex); - products.storedBplusCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - BplusCollisionMapping.insert(std::make_pair(lcCollisionPerCollision.globalIndex(), products.storedBplusCollisionsTable.lastIndex())); - } - const auto lcsPerCollision = Bpluss.sliceBy(BplussPerCollision, collision.globalIndex()); - for (const auto& Bplus : lcsPerCollision) { - int32_t BplusIndex = -1; - jethfutilities::fillHFCandidateTable(Bplus, collisionBplusIndex, products.storedBplussTable, products.storedBplusParsTable, products.storedBplusParExtrasTable, products.storedBplusParD0sTable, products.storedBplusSelsTable, products.storedBplusMlsTable, products.storedBplusMlD0sTable, products.storedBplusMcsTable, BplusIndex); - - int32_t prong0Id = -1; - int32_t prong1Id = -1; - int32_t prong2Id = -1; - auto JtrackIndex = trackMapping.find(Bplus.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Bplus.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Bplus.prong2Id()); - if (JtrackIndex != trackMapping.end()) { - prong2Id = JtrackIndex->second; - } - products.storedBplusIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id, prong2Id); - } - } - - if (config.saveDielectronTable) { - const auto dielectronCollisionsPerCollision = DielectronCollisions.sliceBy(DielectronCollisionsPerCollision, collision.globalIndex()); - int32_t collisionDielectronIndex = -1; - for (const auto& dielectronCollisionPerCollision : dielectronCollisionsPerCollision) { // should only ever be one - jetdqutilities::fillDielectronCollisionTable(dielectronCollisionPerCollision, products.storedDielectronCollisionsTable, collisionDielectronIndex); - products.storedDielectronCollisionIdsTable(products.storedJCollisionsTable.lastIndex()); - // D0CollisionMapping.insert(std::make_pair(d0CollisionPerCollision.globalIndex(), products.storedD0CollisionsTable.lastIndex())); // if DielectronMCCollisions are indexed to Dielectron Collisions then this can be added - } - const auto dielectronsPerCollision = Dielectrons.sliceBy(DielectronsPerCollision, collision.globalIndex()); - for (const auto& Dielectron : dielectronsPerCollision) { - int32_t DielectronIndex = -1; - jetdqutilities::fillDielectronCandidateTable(Dielectron, collisionDielectronIndex, products.storedDielectronsTable, DielectronIndex); + PROCESS_SWITCH(JetDerivedDataWriter, processLcMCP, "write out Lc mcp output tables", false); - int32_t prong0Id = -1; - int32_t prong1Id = -1; - auto JtrackIndex = trackMapping.find(Dielectron.prong0Id()); - if (JtrackIndex != trackMapping.end()) { - prong0Id = JtrackIndex->second; - } - JtrackIndex = trackMapping.find(Dielectron.prong1Id()); - if (JtrackIndex != trackMapping.end()) { - prong1Id = JtrackIndex->second; - } - products.storedDielectronIdsTable(products.storedJCollisionsTable.lastIndex(), prong0Id, prong1Id); - } - } + void processBplusMCP(soa::Join const& mcCollisions, aod::McCollisionsBplus const& BplusMcCollisions, aod::CandidatesBplusMCP const& BplusParticles) + { + bplusMcCollisionMapping.clear(); + bplusMcCollisionMapping.resize(BplusMcCollisions.size(), -1); + for (auto const& mcCollision : mcCollisions) { + if (mcCollision.isMcCollisionSelected()) { + const auto bplusMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& bplusMcCollisionPerMcCollision : bplusMcCollisionsPerMcCollision) { // should only ever be one + jethfutilities::fillHFMcCollisionTable(bplusMcCollisionPerMcCollision, products.storedBplusMcCollisionsTable); + products.storedBplusMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + bplusMcCollisionMapping[bplusMcCollisionPerMcCollision.globalIndex()] = products.storedBplusMcCollisionsTable.lastIndex(); + } + const auto bplusParticlesPerMcCollision = BplusParticles.sliceBy(BplusParticlesPerMcCollision, mcCollision.globalIndex()); + for (const auto& BplusParticle : bplusParticlesPerMcCollision) { + jethfutilities::fillHFCandidateMcTable(BplusParticle, products.storedBplusMcCollisionsTable.lastIndex(), products.storedBplusParticlesTable); + products.storedBplusParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[BplusParticle.mcParticleId()]); } + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processBplusMCP, "write out Bplus mcp output tables", false); - if (config.saveD0Table) { - const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); - for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { // should just be one - std::vector d0CollisionIDs; - for (auto const& d0CollisionPerMcCollision : d0McCollisionPerMcCollision.template hfCollBases_as()) { - auto d0CollisionIndex = D0CollisionMapping.find(d0CollisionPerMcCollision.globalIndex()); - if (d0CollisionIndex != D0CollisionMapping.end()) { - d0CollisionIDs.push_back(d0CollisionIndex->second); - } - } - products.storedD0McCollisionsMatchingTable(d0CollisionIDs); - } - } + void processDielectronMCP(soa::Join::iterator const& mcCollision, aod::JMcParticles const&, aod::McCollisionsDielectron const& DielectronMcCollisions, aod::CandidatesDielectronMCP const& DielectronParticles) + { + if (mcCollision.isMcCollisionSelected()) { - if (config.saveLcTable) { - const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should just be one - std::vector lcCollisionIDs; - for (auto const& lcCollisionPerMcCollision : lcMcCollisionPerMcCollision.template hfCollBases_as()) { - auto lcCollisionIndex = LcCollisionMapping.find(lcCollisionPerMcCollision.globalIndex()); - if (lcCollisionIndex != LcCollisionMapping.end()) { - lcCollisionIDs.push_back(lcCollisionIndex->second); - } - } - products.storedLcMcCollisionsMatchingTable(lcCollisionIDs); + const auto dielectronMcCollisionsPerMcCollision = DielectronMcCollisions.sliceBy(DielectronMcCollisionsPerMcCollision, mcCollision.globalIndex()); + for (const auto& dielectronMcCollisionPerMcCollision : dielectronMcCollisionsPerMcCollision) { // should only ever be one + jetdqutilities::fillDielectronMcCollisionTable(dielectronMcCollisionPerMcCollision, products.storedDielectronMcCollisionsTable); + products.storedDielectronMcCollisionIdsTable(mcCollisionMapping[mcCollision.globalIndex()]); + } + for (const auto& DielectronParticle : DielectronParticles) { + jetdqutilities::fillDielectronCandidateMcTable(DielectronParticle, products.storedDielectronMcCollisionsTable.lastIndex(), products.storedDielectronParticlesTable); + std::vector DielectronMothersIds; + int DielectronDaughtersId[2]; + if (DielectronParticle.has_mothers()) { + for (auto const& DielectronMother : DielectronParticle.template mothers_as()) { + DielectronMothersIds.push_back(particleMapping[DielectronMother.globalIndex()]); } } - - if (config.saveBplusTable) { - const auto lcMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should just be one - std::vector lcCollisionIDs; - for (auto const& lcCollisionPerMcCollision : lcMcCollisionPerMcCollision.template hfCollBases_as()) { - auto lcCollisionIndex = BplusCollisionMapping.find(lcCollisionPerMcCollision.globalIndex()); - if (lcCollisionIndex != BplusCollisionMapping.end()) { - lcCollisionIDs.push_back(lcCollisionIndex->second); - } + auto i = 0; + if (DielectronParticle.has_daughters()) { + for (auto const& DielectronDaughter : DielectronParticle.template daughters_as()) { + if (i > 1) { + break; } - products.storedBplusMcCollisionsMatchingTable(lcCollisionIDs); + DielectronDaughtersId[i] = particleMapping[DielectronDaughter.globalIndex()]; + i++; } } + products.storedDielectronParticleIdsTable(mcCollisionMapping[mcCollision.globalIndex()], particleMapping[DielectronParticle.mcParticleId()], DielectronMothersIds, DielectronDaughtersId); } } } - // process switch for output writing must be last - // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processStoreMC, "write out data output tables for mc", false); + PROCESS_SWITCH(JetDerivedDataWriter, processDielectronMCP, "write out Dielectron mcp output tables", false); - void processStoreMCP(soa::Join const& mcCollisions, soa::Join const& particles, aod::McCollisionsD0 const& D0McCollisions, aod::CandidatesD0MCP const& D0Particles, aod::McCollisionsLc const& LcMcCollisions, aod::CandidatesLcMCP const& LcParticles, aod::McCollisionsBplus const& BplusMcCollisions, aod::CandidatesBplusMCP const& BplusParticles, aod::McCollisionsDielectron const& DielectronMcCollisions, aod::CandidatesDielectronMCP const& DielectronParticles) + void processColllisonsMcCollisionLabel(soa::Join::iterator const& collision) { + if (collision.isCollisionSelected()) { + products.storedJMcCollisionsLabelTable(mcCollisionMapping[collision.mcCollisionId()]); + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processColllisonsMcCollisionLabel, "write out collision mcCollision label output tables", false); - int particleTableIndex = 0; - for (auto mcCollision : mcCollisions) { - if (McCollisionFlag[mcCollision.globalIndex()]) { // you can also check if any of its detector level counterparts are correct - std::map paticleMapping; - - products.storedJMcCollisionsTable(mcCollision.posX(), mcCollision.posY(), mcCollision.posZ(), mcCollision.weight(), mcCollision.subGeneratorId()); - products.storedJMcCollisionsParentIndexTable(mcCollision.mcCollisionId()); - - const auto particlesPerMcCollision = particles.sliceBy(ParticlesPerMcCollision, mcCollision.globalIndex()); - - for (auto particle : particlesPerMcCollision) { - paticleMapping.insert(std::make_pair(particle.globalIndex(), particleTableIndex)); - particleTableIndex++; + void processTracksMcParticleLabel(soa::Join::iterator const& collision, soa::Join const& tracks) + { + if (collision.isCollisionSelected()) { + for (const auto& track : tracks) { + if (!trackSelection(track)) { + continue; } - for (auto particle : particlesPerMcCollision) { - std::vector mothersId; - int daughtersId[2]; - if (particle.has_mothers()) { - for (auto const& mother : particle.template mothers_as>()) { - auto JMotherIndex = paticleMapping.find(mother.globalIndex()); - if (JMotherIndex != paticleMapping.end()) { - mothersId.push_back(JMotherIndex->second); - } - } - } - auto i = 0; - if (particle.has_daughters()) { - for (auto const& daughter : particle.template daughters_as>()) { - if (i > 1) { - break; - } - auto JDaughterIndex = paticleMapping.find(daughter.globalIndex()); - if (JDaughterIndex != paticleMapping.end()) { - daughtersId[i] = JDaughterIndex->second; - } - i++; - } - } - products.storedJMcParticlesTable(products.storedJMcCollisionsTable.lastIndex(), o2::math_utils::detail::truncateFloatFraction(particle.pt(), precisionMomentumMask), o2::math_utils::detail::truncateFloatFraction(particle.eta(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.phi(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.y(), precisionPositionMask), o2::math_utils::detail::truncateFloatFraction(particle.e(), precisionMomentumMask), particle.pdgCode(), particle.getGenStatusCode(), particle.getHepMCStatusCode(), particle.isPhysicalPrimary(), mothersId, daughtersId); - products.storedJParticlesParentIndexTable(particle.mcParticleId()); + if (track.has_mcParticle()) { + products.storedJMcTracksLabelTable(particleMapping[track.mcParticleId()]); + } else { + products.storedJMcTracksLabelTable(-1); } + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processTracksMcParticleLabel, "write out track mcParticle label output tables", false); - if (config.saveD0Table) { - const auto d0McCollisionsPerMcCollision = D0McCollisions.sliceBy(D0McCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionD0Index = -1; - for (const auto& d0McCollisionPerMcCollision : d0McCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(d0McCollisionPerMcCollision, products.storedD0McCollisionsTable, mcCollisionD0Index); - products.storedD0McCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& D0Particle : D0Particles) { - int32_t D0ParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(D0Particle, mcCollisionD0Index, products.storedD0ParticlesTable, D0ParticleIndex); - int32_t D0ParticleId = -1; - auto JParticleIndex = paticleMapping.find(D0Particle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - D0ParticleId = JParticleIndex->second; - } - products.storedD0ParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), D0ParticleId); - } - } - if (config.saveLcTable) { - const auto lcMcCollisionsPerMcCollision = LcMcCollisions.sliceBy(LcMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionLcIndex = -1; - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedLcMcCollisionsTable, mcCollisionLcIndex); - products.storedLcMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& LcParticle : LcParticles) { - int32_t LcParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(LcParticle, mcCollisionLcIndex, products.storedLcParticlesTable, LcParticleIndex); - int32_t LcParticleId = -1; - auto JParticleIndex = paticleMapping.find(LcParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - LcParticleId = JParticleIndex->second; - } - products.storedLcParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), LcParticleId); - } + void processClusterMcLabel(soa::Join::iterator const& collision, soa::Join const& clusters) + { + if (collision.isCollisionSelected()) { + for (const auto& cluster : clusters) { + std::vector clusterStoredJParticleIDs; + for (const auto& clusterParticleId : cluster.mcParticlesIds()) { + clusterStoredJParticleIDs.push_back(particleMapping[clusterParticleId]); + } + std::vector amplitudeA; + auto amplitudeASpan = cluster.amplitudeA(); + std::copy(amplitudeASpan.begin(), amplitudeASpan.end(), std::back_inserter(amplitudeA)); + products.storedJMcClustersLabelTable(clusterStoredJParticleIDs, amplitudeA); + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processClusterMcLabel, "write out cluster mc label output tables", false); + + void processD0McCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& D0McCollisions, aod::CollisionsD0 const&) + { + if (mcCollision.isMcCollisionSelected()) { + for (const auto& D0McCollision : D0McCollisions) { // should just be one + std::vector d0CollisionIDs; + for (auto const& d0CollisionPerMcCollision : D0McCollision.hfCollBases_as()) { + d0CollisionIDs.push_back(d0McCollisionMapping[d0CollisionPerMcCollision.globalIndex()]); } - if (config.saveBplusTable) { - const auto lcMcCollisionsPerMcCollision = BplusMcCollisions.sliceBy(BplusMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionBplusIndex = -1; - for (const auto& lcMcCollisionPerMcCollision : lcMcCollisionsPerMcCollision) { // should only ever be one - jethfutilities::fillHFMcCollisionTable(lcMcCollisionPerMcCollision, products.storedBplusMcCollisionsTable, mcCollisionBplusIndex); - products.storedBplusMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& BplusParticle : BplusParticles) { - int32_t BplusParticleIndex = -1; - jethfutilities::fillHFCandidateMcTable(BplusParticle, mcCollisionBplusIndex, products.storedBplusParticlesTable, BplusParticleIndex); - int32_t BplusParticleId = -1; - auto JParticleIndex = paticleMapping.find(BplusParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - BplusParticleId = JParticleIndex->second; - } - products.storedBplusParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), BplusParticleId); - } + products.storedD0McCollisionsMatchingTable(d0CollisionIDs); + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processD0McCollisionMatch, "write out D0 McCollision collision label output tables", false); + + void processLcMcCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& LcMcCollisions, aod::CollisionsLc const&) + { + if (mcCollision.isMcCollisionSelected()) { + for (const auto& LcMcCollision : LcMcCollisions) { // should just be one + std::vector lcCollisionIDs; + for (auto const& lcCollisionPerMcCollision : LcMcCollision.hfCollBases_as()) { + lcCollisionIDs.push_back(lcMcCollisionMapping[lcCollisionPerMcCollision.globalIndex()]); } - if (config.saveDielectronTable) { - const auto dielectronMcCollisionsPerMcCollision = DielectronMcCollisions.sliceBy(DielectronMcCollisionsPerMcCollision, mcCollision.globalIndex()); - int32_t mcCollisionDielectronIndex = -1; - for (const auto& dielectronMcCollisionPerMcCollision : dielectronMcCollisionsPerMcCollision) { // should only ever be one - jetdqutilities::fillDielectronMcCollisionTable(dielectronMcCollisionPerMcCollision, products.storedDielectronMcCollisionsTable, mcCollisionDielectronIndex); - products.storedDielectronMcCollisionIdsTable(products.storedJMcCollisionsTable.lastIndex()); - } - for (const auto& DielectronParticle : DielectronParticles) { - int32_t DielectronParticleIndex = -1; - jetdqutilities::fillDielectronCandidateMcTable(DielectronParticle, mcCollisionDielectronIndex, products.storedDielectronParticlesTable, DielectronParticleIndex); - int32_t DielectronParticleId = -1; - auto JParticleIndex = paticleMapping.find(DielectronParticle.mcParticleId()); - if (JParticleIndex != paticleMapping.end()) { - DielectronParticleId = JParticleIndex->second; - } - std::vector DielectronMothersId; - int DielectronDaughtersId[2]; - if (DielectronParticle.has_mothers()) { - for (auto const& DielectronMother : DielectronParticle.template mothers_as>()) { - auto JDielectronMotherIndex = paticleMapping.find(DielectronMother.globalIndex()); - if (JDielectronMotherIndex != paticleMapping.end()) { - DielectronMothersId.push_back(JDielectronMotherIndex->second); - } - } - } - auto i = 0; - if (DielectronParticle.has_daughters()) { - for (auto const& DielectronDaughter : DielectronParticle.template daughters_as>()) { - if (i > 1) { - break; - } - auto JDielectronDaughterIndex = paticleMapping.find(DielectronDaughter.globalIndex()); - if (JDielectronDaughterIndex != paticleMapping.end()) { - DielectronDaughtersId[i] = JDielectronDaughterIndex->second; - } - i++; - } - } - products.storedDielectronParticleIdsTable(products.storedJMcCollisionsTable.lastIndex(), DielectronParticleId, DielectronMothersId, DielectronDaughtersId); - } + products.storedLcMcCollisionsMatchingTable(lcCollisionIDs); + } + } + } + PROCESS_SWITCH(JetDerivedDataWriter, processLcMcCollisionMatch, "write out Lc McCollision collision label output tables", false); + + void processBplusMcCollisionMatch(soa::Join::iterator const& mcCollision, soa::Join const& BplusMcCollisions, aod::CollisionsBplus const&) + { + if (mcCollision.isMcCollisionSelected()) { + for (const auto& BplusMcCollision : BplusMcCollisions) { // should just be one + std::vector bplusCollisionIDs; + for (auto const& bplusCollisionPerMcCollision : BplusMcCollision.hfCollBases_as()) { + bplusCollisionIDs.push_back(bplusMcCollisionMapping[bplusCollisionPerMcCollision.globalIndex()]); } + products.storedBplusMcCollisionsMatchingTable(bplusCollisionIDs); } } } - // process switch for output writing must be last - // to run after all jet selections - PROCESS_SWITCH(JetDerivedDataWriter, processStoreMCP, "write out data output tables for mcp", false); + PROCESS_SWITCH(JetDerivedDataWriter, processBplusMcCollisionMatch, "write out Bplus McCollision collision label output tables", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) diff --git a/PWGJE/Tasks/jetSubstructureHFOutput.cxx b/PWGJE/Tasks/jetSubstructureHFOutput.cxx index 667ad11ef65..fd2c3e327c8 100644 --- a/PWGJE/Tasks/jetSubstructureHFOutput.cxx +++ b/PWGJE/Tasks/jetSubstructureHFOutput.cxx @@ -15,6 +15,9 @@ // #include +#include +#include +#include #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" @@ -203,21 +206,21 @@ struct JetSubstructureHFOutputTask { continue; } int32_t candidateCollisionIndex = -1; - int32_t candidateIndex = -1; if constexpr (isMCP) { auto hfMcCollisionIndex = candidateMcCollisionMapping.find(jetcandidateutilities::getMcCandidateCollisionId(candidate)); if (hfMcCollisionIndex != candidateMcCollisionMapping.end()) { candidateCollisionIndex = hfMcCollisionIndex->second; } - jetcandidateutilities::fillCandidateMcTable(candidate, candidateCollisionIndex, hfParticlesTable, candidateIndex); + jetcandidateutilities::fillCandidateMcTable(candidate, candidateCollisionIndex, hfParticlesTable); + candidateMap.insert(std::make_pair(candidate.globalIndex(), hfParticlesTable.lastIndex())); } else { auto hfCollisionIndex = candidateCollisionMapping.find(jetcandidateutilities::getCandidateCollisionId(candidate)); if (hfCollisionIndex != candidateCollisionMapping.end()) { candidateCollisionIndex = hfCollisionIndex->second; } - jetcandidateutilities::fillCandidateTable(candidate, candidateCollisionIndex, candidateTable, candidateParsTable, candidateParExtrasTable, candidateParsDaughterTable, candidateSelsTable, candidateMlsTable, candidateMlsDaughterTable, candidateMcsTable, candidateIndex); + jetcandidateutilities::fillCandidateTable(candidate, candidateCollisionIndex, candidateTable, candidateParsTable, candidateParExtrasTable, candidateParsDaughterTable, candidateSelsTable, candidateMlsTable, candidateMlsDaughterTable, candidateMcsTable); + candidateMap.insert(std::make_pair(candidate.globalIndex(), candidateTable.lastIndex())); } - candidateMap.insert(std::make_pair(candidate.globalIndex(), candidateIndex)); } } } @@ -331,13 +334,12 @@ struct JetSubstructureHFOutputTask { for (const auto& collision : collisions) { if (collisionFlag[collision.globalIndex()]) { const auto hfCollisionsPerCollision = jetcandidateutilities::slicedPerCandidateCollision(hfCollisions, candidates, collision, D0CollisionsPerCollision, LcCollisionsPerCollision, BplusCollisionsPerCollision, DielectronCollisionsPerCollision); // add Bplus later - int32_t candidateCollisionIndex = -1; for (const auto& hfCollisionPerCollision : hfCollisionsPerCollision) { // should only ever be one auto hfCollisionTableIndex = candidateCollisionMapping.find(hfCollisionPerCollision.globalIndex()); if (hfCollisionTableIndex != candidateCollisionMapping.end()) { continue; } - jetcandidateutilities::fillCandidateCollisionTable(hfCollisionPerCollision, candidates, hfCollisionsTable, candidateCollisionIndex); + jetcandidateutilities::fillCandidateCollisionTable(hfCollisionPerCollision, candidates, hfCollisionsTable); candidateCollisionMapping.insert(std::make_pair(hfCollisionPerCollision.globalIndex(), hfCollisionsTable.lastIndex())); } } @@ -347,13 +349,12 @@ struct JetSubstructureHFOutputTask { for (const auto& mcCollision : mcCollisions) { if (mcCollisionFlag[mcCollision.globalIndex()]) { const auto hfMcCollisionsPerMcCollision = jetcandidateutilities::slicedPerCandidateCollision(hfMcCollisions, candidatesMCP, mcCollision, D0McCollisionsPerMcCollision, LcMcCollisionsPerMcCollision, BplusMcCollisionsPerMcCollision, DielectronMcCollisionsPerMcCollision); // add Bplus later - int32_t candidateMcCollisionIndex = -1; for (const auto& hfMcCollisionPerMcCollision : hfMcCollisionsPerMcCollision) { // should only ever be one auto hfMcCollisionTableIndex = candidateMcCollisionMapping.find(hfMcCollisionPerMcCollision.globalIndex()); if (hfMcCollisionTableIndex != candidateMcCollisionMapping.end()) { continue; } - jetcandidateutilities::fillCandidateMcCollisionTable(hfMcCollisionPerMcCollision, candidatesMCP, hfMcCollisionsTable, candidateMcCollisionIndex); + jetcandidateutilities::fillCandidateMcCollisionTable(hfMcCollisionPerMcCollision, candidatesMCP, hfMcCollisionsTable); candidateMcCollisionMapping.insert(std::make_pair(hfMcCollisionPerMcCollision.globalIndex(), hfMcCollisionsTable.lastIndex())); if constexpr (!isMCPOnly && (jethfutilities::isHFTable

() || jethfutilities::isHFMcTable())) { // the matching of mcCollision to Collision is only done for HF tables std::vector hfCollisionIDs; diff --git a/PWGJE/Tasks/jetSubstructureOutput.cxx b/PWGJE/Tasks/jetSubstructureOutput.cxx index ca20d891b95..602c6526523 100644 --- a/PWGJE/Tasks/jetSubstructureOutput.cxx +++ b/PWGJE/Tasks/jetSubstructureOutput.cxx @@ -14,6 +14,11 @@ /// \author Nima Zardoshti // +#include +#include +#include +#include + #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h"