diff --git a/PWGCF/FemtoDream/CMakeLists.txt b/PWGCF/FemtoDream/CMakeLists.txt index f91c8552d08..6cceb1d200e 100644 --- a/PWGCF/FemtoDream/CMakeLists.txt +++ b/PWGCF/FemtoDream/CMakeLists.txt @@ -49,3 +49,7 @@ o2physics_add_executable(femtodream-cutculator PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(femtodream-producer-v0 + SOURCES femtoDreamProducerTaskV0Only.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) \ No newline at end of file diff --git a/PWGCF/FemtoDream/FemtoDreamTrackSelection.h b/PWGCF/FemtoDream/FemtoDreamTrackSelection.h index 7e6f850f7b6..a4f575e976e 100644 --- a/PWGCF/FemtoDream/FemtoDreamTrackSelection.h +++ b/PWGCF/FemtoDream/FemtoDreamTrackSelection.h @@ -188,6 +188,11 @@ class FemtoDreamTrackSelection : public FemtoDreamObjectSelection 0 && std::abs(dca) < dcaMin) { return false; } + if (std::abs(dca) > 1e3) { + return false; + } + if (nPIDnSigmaSel > 0) { bool isFulfilled = false; for (size_t i = 0; i < pidTPC.size(); ++i) { auto pidTPCVal = pidTPC.at(i); - auto pidTOFVal = pidTOF.at(i); - auto pidComb = std::sqrt(pidTPCVal * pidTPCVal + pidTOFVal * pidTOFVal); - if (std::abs(pidTPCVal) < nSigmaPIDMax || pidComb < nSigmaPIDMax) { + if (std::abs(pidTPCVal) < nSigmaPIDMax) { isFulfilled = true; } } diff --git a/PWGCF/FemtoDream/FemtoDreamV0Selection.h b/PWGCF/FemtoDream/FemtoDreamV0Selection.h index 4382d1cc6a9..59928e3a029 100644 --- a/PWGCF/FemtoDream/FemtoDreamV0Selection.h +++ b/PWGCF/FemtoDream/FemtoDreamV0Selection.h @@ -305,7 +305,6 @@ bool FemtoDreamV0Selection::isSelectedMinimal(C const& col, V const& v0, T const if ((invMassLambda < fInvMassLowLimit or invMassLambda > fInvMassUpLimit) and (invMassAntiLambda < fInvMassLowLimit or invMassAntiLambda > fInvMassUpLimit)) { return false; } - if (nPtV0MinSel > 0 && pT < pTV0Min) { return false; } @@ -329,15 +328,25 @@ bool FemtoDreamV0Selection::isSelectedMinimal(C const& col, V const& v0, T const return false; } } - // const auto dcaXYpos = posTrack.dcaXY(); - // const auto dcaZpos = posTrack.dcaZ(); - // const auto dcapos = std::sqrt(pow(dcaXYpos, 2.) + pow(dcaZpos, 2.)); if (!PosDaughTrack.isSelectedMinimal(posTrack)) { return false; } if (!NegDaughTrack.isSelectedMinimal(negTrack)) { return false; } + + // check that track combinations for V0 or antiV0 would be fulfilling PID + int nSigmaPIDMax = PosDaughTrack.getSigmaPIDMax(); + // antiV0 + auto nSigmaPrNeg = negTrack.tpcNSigmaPr(); + auto nSigmaPiPos = posTrack.tpcNSigmaPi(); + // v0 + auto nSigmaPiNeg = negTrack.tpcNSigmaPi(); + auto nSigmaPrPos = posTrack.tpcNSigmaPr(); + if (!(abs(nSigmaPrNeg) < nSigmaPIDMax and abs(nSigmaPiPos) < nSigmaPIDMax) and !(abs(nSigmaPrPos) < nSigmaPIDMax and abs(nSigmaPiNeg) < nSigmaPIDMax)) { + return false; + } + return true; } @@ -411,16 +420,17 @@ std::array FemtoDreamV0Selection::getCutContainer(C const& for (auto& sel : mSelections) { const auto selVariable = sel.getSelectionVariable(); if (selVariable == femtoDreamV0Selection::kV0Sign) { + int nSigmaPIDMax = PosDaughTrack.getSigmaPIDMax(); if (sel.getSelectionValue() < 0) { auto nSigmaPr = negTrack.tpcNSigmaPr(); auto nSigmaPi = posTrack.tpcNSigmaPi(); - if (abs(nSigmaPr) < 5 && abs(nSigmaPi) < 5) { + if (abs(nSigmaPr) < nSigmaPIDMax && abs(nSigmaPi) < nSigmaPIDMax) { sign = -1.; } } else { auto nSigmaPi = negTrack.tpcNSigmaPi(); auto nSigmaPr = posTrack.tpcNSigmaPr(); - if (abs(nSigmaPr) < 5 && abs(nSigmaPi) < 5) { + if (abs(nSigmaPr) < nSigmaPIDMax && abs(nSigmaPi) < nSigmaPIDMax) { sign = 1.; } } diff --git a/PWGCF/FemtoDream/femtoDreamProducerTask.cxx b/PWGCF/FemtoDream/femtoDreamProducerTask.cxx index f5fb7ffc789..6a8c65cdf9d 100644 --- a/PWGCF/FemtoDream/femtoDreamProducerTask.cxx +++ b/PWGCF/FemtoDream/femtoDreamProducerTask.cxx @@ -126,7 +126,7 @@ struct femtoDreamProducerTask { Configurable> ConfV0DaughDCAMin{"ConfV0DaughDCAMin", std::vector{0.05f, 0.06f}, "V0 Daugh sel: Max. DCA Daugh to PV (cm)"}; Configurable> ConfV0DaughPIDnSigmaMax{"ConfV0DaughPIDnSigmaMax", std::vector{5.f, 4.f}, "V0 Daugh sel: Max. PID nSigma TPC"}; - Configurable> ConfV0DaughTPIDspecies{"ConfV0DaughTPIDspecies", std::vector{o2::track::PID::Pion, o2::track::PID::Kaon, o2::track::PID::Proton}, "V0 Daugh sel: Particles species for PID"}; + Configurable> ConfV0DaughTPIDspecies{"ConfV0DaughTPIDspecies", std::vector{o2::track::PID::Pion, o2::track::PID::Proton}, "V0 Daugh sel: Particles species for PID"}; Configurable ConfInvMassLowLimit{"ConfInvMassLowLimit", 1.05, "Lower limit of the V0 invariant mass"}; Configurable ConfInvMassUpLimit{"ConfInvMassUpLimit", 1.30, "Upper limit of the V0 invariant mass"}; @@ -170,12 +170,12 @@ struct femtoDreamProducerTask { v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfTrkCharge, femtoDreamTrackSelection::kSign, femtoDreamSelection::kEqual); v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfTrkEta, femtoDreamTrackSelection::kEtaMax, femtoDreamSelection::kAbsUpperLimit); v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfV0DaughTPCnclsMin, femtoDreamTrackSelection::kTPCnClsMin, femtoDreamSelection::kLowerLimit); - // v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfV0DaughDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfV0DaughDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit); v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfV0DaughPIDnSigmaMax, femtoDreamTrackSelection::kPIDnSigmaMax, femtoDreamSelection::kAbsUpperLimit); v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfTrkCharge, femtoDreamTrackSelection::kSign, femtoDreamSelection::kEqual); v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfTrkEta, femtoDreamTrackSelection::kEtaMax, femtoDreamSelection::kAbsUpperLimit); v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfV0DaughTPCnclsMin, femtoDreamTrackSelection::kTPCnClsMin, femtoDreamSelection::kLowerLimit); - // v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfV0DaughDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfV0DaughDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit); v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfV0DaughPIDnSigmaMax, femtoDreamTrackSelection::kPIDnSigmaMax, femtoDreamSelection::kAbsUpperLimit); v0Cuts.setChildPIDSpecies(femtoDreamV0Selection::kPosTrack, ConfV0DaughTPIDspecies); v0Cuts.setChildPIDSpecies(femtoDreamV0Selection::kNegTrack, ConfV0DaughTPIDspecies); diff --git a/PWGCF/FemtoDream/femtoDreamProducerTaskV0Only.cxx b/PWGCF/FemtoDream/femtoDreamProducerTaskV0Only.cxx new file mode 100644 index 00000000000..056626021d3 --- /dev/null +++ b/PWGCF/FemtoDream/femtoDreamProducerTaskV0Only.cxx @@ -0,0 +1,310 @@ +// 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 femtoDreamProducerTaskV0Only.cxx +/// \brief Tasks that produces the track tables used for the pairing +/// \author Andi Mathis, TU München, andreas.mathis@ph.tum.de + +#include "FemtoDreamCollisionSelection.h" +#include "FemtoDreamTrackSelection.h" +#include "FemtoDreamV0Selection.h" +#include "PWGCF/DataModel/FemtoDerived.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/ASoAHelpers.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/PIDResponse.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "ReconstructionDataFormats/Track.h" +#include "Common/Core/trackUtilities.h" +#include "Common/DataModel/StrangenessTables.h" +#include "Math/Vector4D.h" +#include "TMath.h" + +using namespace o2; +using namespace o2::analysis::femtoDream; +using namespace o2::framework; +using namespace o2::framework::expressions; + +namespace o2::aod +{ + +using FemtoFullCollision = soa::Join::iterator; +using FemtoFullTracks = soa::Join; +// using FilteredFullV0s = soa::Filtered; /// predefined Join table for o2::aod::V0s = soa::Join to be used when we add v0Filter +} // namespace o2::aod + +/// \todo fix how to pass array to setSelection, getRow() passing a different type! +// static constexpr float arrayV0Sel[3][3] = {{100.f, 100.f, 100.f}, {0.2f, 0.2f, 0.2f}, {100.f, 100.f, 100.f}}; +// unsigned int rows = sizeof(arrayV0Sel) / sizeof(arrayV0Sel[0]); +// unsigned int columns = sizeof(arrayV0Sel[0]) / sizeof(arrayV0Sel[0][0]); + +template +int getRowDaughters(int daughID, T const& vecID) +{ + int rowInPrimaryTrackTableDaugh = -1; + for (size_t i = 0; i < vecID.size(); i++) { + if (vecID.at(i) == daughID) { + rowInPrimaryTrackTableDaugh = i; + break; + } + } + return rowInPrimaryTrackTableDaugh; +} + +struct femtoDreamProducerTaskV0Only { + + Produces outputCollision; + Produces outputParts; + Produces outputDebugParts; + + Configurable ConfDebugOutput{"ConfDebugOutput", true, "Debug output"}; + + // Choose if filtering or skimming version is run + + Configurable ConfIsTrigger{"ConfIsTrigger", false, "Store all collisions"}; + + // Choose if running on converted data or pilot beam + Configurable ConfIsRun3{"ConfIsRun3", false, "Running on Pilot beam"}; + + /// Event cuts + FemtoDreamCollisionSelection colCuts; + Configurable ConfEvtZvtx{"ConfEvtZvtx", 10.f, "Evt sel: Max. z-Vertex (cm)"}; + Configurable ConfEvtTriggerCheck{"ConfEvtTriggerCheck", true, "Evt sel: check for trigger"}; + Configurable ConfEvtTriggerSel{"ConfEvtTriggerSel", kINT7, "Evt sel: trigger"}; + Configurable ConfEvtOfflineCheck{"ConfEvtOfflineCheck", false, "Evt sel: check for offline selection"}; + + Configurable ConfStoreV0{"ConfStoreV0", true, "True: store V0 table"}; + + FemtoDreamV0Selection v0Cuts; + /// \todo Labeled array (see Track-Track task) + + Configurable> ConfV0Sign{FemtoDreamV0Selection::getSelectionName(femtoDreamV0Selection::kV0Sign, "ConfV0"), std::vector{-1, 1}, FemtoDreamV0Selection::getSelectionHelper(femtoDreamV0Selection::kV0Sign, "V0 selection: ")}; + Configurable> ConfV0PtMin{FemtoDreamV0Selection::getSelectionName(femtoDreamV0Selection::kpTV0Min, "ConfV0"), std::vector{0.3f}, FemtoDreamV0Selection::getSelectionHelper(femtoDreamV0Selection::kpTV0Min, "V0 selection: ")}; + Configurable> ConfDCAV0DaughMax{FemtoDreamV0Selection::getSelectionName(femtoDreamV0Selection::kDCAV0DaughMax, "ConfV0"), std::vector{1.5f}, FemtoDreamV0Selection::getSelectionHelper(femtoDreamV0Selection::kDCAV0DaughMax, "V0 selection: ")}; + Configurable> ConfCPAV0Min{FemtoDreamV0Selection::getSelectionName(femtoDreamV0Selection::kCPAV0Min, "ConfV0"), std::vector{0.99f}, FemtoDreamV0Selection::getSelectionHelper(femtoDreamV0Selection::kCPAV0Min, "V0 selection: ")}; + + Configurable> V0TranRadV0Min{FemtoDreamV0Selection::getSelectionName(femtoDreamV0Selection::kTranRadV0Min, "ConfV0"), std::vector{0.2f}, FemtoDreamV0Selection::getSelectionHelper(femtoDreamV0Selection::kTranRadV0Min, "V0 selection: ")}; + Configurable> V0TranRadV0Max{FemtoDreamV0Selection::getSelectionName(femtoDreamV0Selection::kTranRadV0Max, "ConfV0"), std::vector{100.f}, FemtoDreamV0Selection::getSelectionHelper(femtoDreamV0Selection::kTranRadV0Max, "V0 selection: ")}; + Configurable> V0DecVtxMax{FemtoDreamV0Selection::getSelectionName(femtoDreamV0Selection::kDecVtxMax, "ConfV0"), std::vector{100.f}, FemtoDreamV0Selection::getSelectionHelper(femtoDreamV0Selection::kDecVtxMax, "V0 selection: ")}; + + Configurable> ConfV0DaughCharge{"ConfV0DaughCharge", std::vector{-1, 1}, "V0 Daugh sel: Charge"}; + Configurable> ConfDaughEta{"ConfDaughEta", std::vector{0.8f}, "V0 Daugh sel: max eta"}; + Configurable> ConfV0DaughTPCnclsMin{"ConfV0DaughTPCnclsMin", std::vector{70.f}, "V0 Daugh sel: Min. nCls TPC"}; + Configurable> ConfV0DaughDCAMin{"ConfV0DaughDCAMin", std::vector{0.05f}, "V0 Daugh sel: Max. DCA Daugh to PV (cm)"}; + Configurable> ConfV0DaughPIDnSigmaMax{"ConfV0DaughPIDnSigmaMax", std::vector{5.f}, "V0 Daugh sel: Max. PID nSigma TPC"}; + + Configurable> ConfV0DaughTPIDspecies{"ConfV0DaughTPIDspecies", std::vector{o2::track::PID::Pion, o2::track::PID::Kaon, o2::track::PID::Proton}, "V0 Daugh sel: Particles species for PID"}; + + Configurable ConfInvMassLowLimit{"ConfInvMassLowLimit", 1.05, "Lower limit of the V0 invariant mass"}; + Configurable ConfInvMassUpLimit{"ConfInvMassUpLimit", 1.30, "Upper limit of the V0 invariant mass"}; + + /// \todo should we add filter on min value pT/eta of V0 and daughters? + /*Filter v0Filter = (nabs(aod::v0data::x) < V0DecVtxMax.value) && + (nabs(aod::v0data::y) < V0DecVtxMax.value) && + (nabs(aod::v0data::z) < V0DecVtxMax.value);*/ + // (aod::v0data::v0radius > V0TranRadV0Min.value); to be added, not working for now do not know why + + HistogramRegistry qaRegistry{"QAHistos", {}, OutputObjHandlingPolicy::QAObject}; + + void init(InitContext&) + { + colCuts.setCuts(ConfEvtZvtx, ConfEvtTriggerCheck, ConfEvtTriggerSel, ConfEvtOfflineCheck, ConfIsRun3); + colCuts.init(&qaRegistry); + + /// \todo fix how to pass array to setSelection, getRow() passing a different type! + // v0Cuts.setSelection(ConfV0Selection->getRow(0), femtoDreamV0Selection::kDecVtxMax, femtoDreamSelection::kAbsUpperLimit); + if (ConfStoreV0) { + v0Cuts.setSelection(ConfV0Sign, femtoDreamV0Selection::kV0Sign, femtoDreamSelection::kEqual); + v0Cuts.setSelection(ConfV0PtMin, femtoDreamV0Selection::kpTV0Min, femtoDreamSelection::kLowerLimit); + v0Cuts.setSelection(ConfDCAV0DaughMax, femtoDreamV0Selection::kDCAV0DaughMax, femtoDreamSelection::kUpperLimit); + v0Cuts.setSelection(ConfCPAV0Min, femtoDreamV0Selection::kCPAV0Min, femtoDreamSelection::kLowerLimit); + + v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfV0DaughCharge, femtoDreamTrackSelection::kSign, femtoDreamSelection::kEqual); + v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfDaughEta, femtoDreamTrackSelection::kEtaMax, femtoDreamSelection::kAbsUpperLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfV0DaughTPCnclsMin, femtoDreamTrackSelection::kTPCnClsMin, femtoDreamSelection::kLowerLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfV0DaughDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kPosTrack, ConfV0DaughPIDnSigmaMax, femtoDreamTrackSelection::kPIDnSigmaMax, femtoDreamSelection::kAbsUpperLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfV0DaughCharge, femtoDreamTrackSelection::kSign, femtoDreamSelection::kEqual); + v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfDaughEta, femtoDreamTrackSelection::kEtaMax, femtoDreamSelection::kAbsUpperLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfV0DaughTPCnclsMin, femtoDreamTrackSelection::kTPCnClsMin, femtoDreamSelection::kLowerLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfV0DaughDCAMin, femtoDreamTrackSelection::kDCAMin, femtoDreamSelection::kAbsLowerLimit); + v0Cuts.setChildCuts(femtoDreamV0Selection::kNegTrack, ConfV0DaughPIDnSigmaMax, femtoDreamTrackSelection::kPIDnSigmaMax, femtoDreamSelection::kAbsUpperLimit); + v0Cuts.setChildPIDSpecies(femtoDreamV0Selection::kPosTrack, ConfV0DaughTPIDspecies); + v0Cuts.setChildPIDSpecies(femtoDreamV0Selection::kNegTrack, ConfV0DaughTPIDspecies); + v0Cuts.init(&qaRegistry); + v0Cuts.setInvMassLimits(ConfInvMassLowLimit, ConfInvMassUpLimit); + } + } + + void process(aod::FemtoFullCollision const& col, aod::BCsWithTimestamps const&, aod::FemtoFullTracks const& tracks, + o2::aod::V0Datas const& fullV0s) /// \todo with FilteredFullV0s + { + auto bc = col.bc_as(); /// adding timestamp to access magnetic field later + /// First thing to do is to check whether the basic event selection criteria are fulfilled + // If the basic selection is NOT fullfilled: + // in case of skimming run - don't store such collisions + // in case of trigger run - store such collisions but don't store any particle candidates for such collisions + if (!colCuts.isSelected(col)) { + if (ConfIsTrigger) { + outputCollision(col.posZ(), col.multFV0M(), colCuts.computeSphericity(col, tracks), bc.timestamp()); + } + return; + } + + const auto vtxZ = col.posZ(); + const auto mult = col.multFV0M(); + const auto spher = colCuts.computeSphericity(col, tracks); + colCuts.fillQA(col); + + // now the table is filled + if (ConfIsRun3) { + outputCollision(vtxZ, col.multFT0M(), spher, bc.timestamp()); + } else { + outputCollision(vtxZ, mult, spher, bc.timestamp()); + } + + int childIDs[2] = {0, 0}; // these IDs are necessary to keep track of the children + std::vector tmpIDtrack; // this vector keeps track of the matching of the primary track table row <-> aod::track table global index + + if (ConfStoreV0) { + for (auto& v0 : fullV0s) { + auto postrack = v0.posTrack_as(); + auto negtrack = v0.negTrack_as(); ///\tocheck funnily enough if we apply the filter the sign of Pos and Neg track is always negative + // const auto dcaXYpos = postrack.dcaXY(); + // const auto dcaZpos = postrack.dcaZ(); + // const auto dcapos = std::sqrt(pow(dcaXYpos, 2.) + pow(dcaZpos, 2.)); + v0Cuts.fillLambdaQA(col, v0, postrack, negtrack); + + if (!v0Cuts.isSelectedMinimal(col, v0, postrack, negtrack)) { + continue; + } + v0Cuts.fillQA(col, v0, postrack, negtrack); ///\todo fill QA also for daughters + auto cutContainerV0 = v0Cuts.getCutContainer(col, v0, postrack, negtrack); + + if ((cutContainerV0.at(femtoDreamV0Selection::V0ContainerPosition::kV0) > 0) && (cutContainerV0.at(femtoDreamV0Selection::V0ContainerPosition::kPosCuts) > 0) && (cutContainerV0.at(femtoDreamV0Selection::V0ContainerPosition::kNegCuts) > 0)) { + int postrackID = v0.posTrackId(); + int rowInPrimaryTrackTablePos = -1; + rowInPrimaryTrackTablePos = getRowDaughters(postrackID, tmpIDtrack); + childIDs[0] = rowInPrimaryTrackTablePos; + childIDs[1] = 0; + outputParts(outputCollision.lastIndex(), v0.positivept(), v0.positiveeta(), v0.positivephi(), aod::femtodreamparticle::ParticleType::kV0Child, cutContainerV0.at(femtoDreamV0Selection::V0ContainerPosition::kPosCuts), cutContainerV0.at(femtoDreamV0Selection::V0ContainerPosition::kPosPID), 0., childIDs, 0, 0); + const int rowOfPosTrack = outputParts.lastIndex(); + int negtrackID = v0.negTrackId(); + int rowInPrimaryTrackTableNeg = -1; + rowInPrimaryTrackTableNeg = getRowDaughters(negtrackID, tmpIDtrack); + childIDs[0] = 0; + childIDs[1] = rowInPrimaryTrackTableNeg; + outputParts(outputCollision.lastIndex(), v0.negativept(), v0.negativeeta(), v0.negativephi(), aod::femtodreamparticle::ParticleType::kV0Child, cutContainerV0.at(femtoDreamV0Selection::V0ContainerPosition::kNegCuts), cutContainerV0.at(femtoDreamV0Selection::V0ContainerPosition::kNegPID), 0., childIDs, 0, 0); + const int rowOfNegTrack = outputParts.lastIndex(); + int indexChildID[2] = {rowOfPosTrack, rowOfNegTrack}; + outputParts(outputCollision.lastIndex(), v0.pt(), v0.eta(), v0.phi(), aod::femtodreamparticle::ParticleType::kV0, cutContainerV0.at(femtoDreamV0Selection::V0ContainerPosition::kV0), 0, v0.v0cosPA(col.posX(), col.posY(), col.posZ()), indexChildID, v0.mLambda(), v0.mAntiLambda()); + if (ConfDebugOutput) { + outputDebugParts(postrack.sign(), + (uint8_t)postrack.tpcNClsFound(), + postrack.tpcNClsFindable(), + (uint8_t)postrack.tpcNClsCrossedRows(), + postrack.tpcNClsShared(), + postrack.tpcInnerParam(), + postrack.itsNCls(), + postrack.itsNClsInnerBarrel(), + postrack.dcaXY(), + postrack.dcaZ(), + postrack.tpcSignal(), + postrack.tpcNSigmaStoreEl(), + postrack.tpcNSigmaStorePi(), + postrack.tpcNSigmaStoreKa(), + postrack.tpcNSigmaStorePr(), + postrack.tpcNSigmaStoreDe(), + postrack.tofNSigmaStoreEl(), + postrack.tofNSigmaStorePi(), + postrack.tofNSigmaStoreKa(), + postrack.tofNSigmaStorePr(), + postrack.tofNSigmaStoreDe(), + -999., + -999., + -999., + -999., + -999.); // QA for positive daughter + outputDebugParts(negtrack.sign(), + (uint8_t)negtrack.tpcNClsFound(), + negtrack.tpcNClsFindable(), + (uint8_t)negtrack.tpcNClsCrossedRows(), + negtrack.tpcNClsShared(), + negtrack.tpcInnerParam(), + negtrack.itsNCls(), + negtrack.itsNClsInnerBarrel(), + negtrack.dcaXY(), + negtrack.dcaZ(), + negtrack.tpcSignal(), + negtrack.tpcNSigmaStoreEl(), + negtrack.tpcNSigmaStorePi(), + negtrack.tpcNSigmaStoreKa(), + negtrack.tpcNSigmaStorePr(), + negtrack.tpcNSigmaStoreDe(), + negtrack.tofNSigmaStoreEl(), + negtrack.tofNSigmaStorePi(), + negtrack.tofNSigmaStoreKa(), + negtrack.tofNSigmaStorePr(), + negtrack.tofNSigmaStoreDe(), + -999., + -999., + -999., + -999., + -999.); // QA for negative daughter + outputDebugParts(-999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + -999., + v0.dcaV0daughters(), + v0.v0radius(), + v0.x(), + v0.y(), + v0.z()); // QA for V0 + } + } + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + WorkflowSpec workflow{adaptAnalysisTask(cfgc)}; + return workflow; +}