diff --git a/PWGMM/Mult/Tasks/vertexing-fwd.cxx b/PWGMM/Mult/Tasks/vertexing-fwd.cxx index 722dae9050588..e35d5fcb5af5e 100644 --- a/PWGMM/Mult/Tasks/vertexing-fwd.cxx +++ b/PWGMM/Mult/Tasks/vertexing-fwd.cxx @@ -37,238 +37,289 @@ using SMatrix55 = ROOT::Math::SMatrix; using MFTTracksLabeled = soa::Join; -using FullBCs = soa::Join; -using FullCollision = soa::Join; +using CollisionsLabeled = soa::Join; +using ExtBCs = soa::Join; -namespace o2::aod -{ -DECLARE_SOA_TABLE(AmbiguousTracksMFT, "AOD", "AMBIGUOUSTRMFT", //! Table for MFT tracks which are not uniquely associated with a collision - o2::soa::Index<>, o2::aod::ambiguous::MFTTrackId, o2::aod::ambiguous::BCIdSlice, o2::soa::Marker<2>); -} // namespace o2::aod +AxisSpec ZAxis = {301, -30.1, 30.1}; struct vertexingfwd { - /// Could be TEMPORARY: store the vertex, collision, dca, and ambiguous tracks information - /// into different std::vector to easily handle them later outside the loops - std::vector vecCollForAmb; // vector for collisions associated to an ambiguous track - std::vector vecDCACollForAmb; // vector for dca collision associated to an ambiguous track - std::vector vecAmbTrack; // vector for ambiguous track quantities like chi2 and z - std::vector vecZposCollForAmb; // vector for z vertex of collisions associated to an ambiguous track - Configurable maxDCAXY{"maxDCAXY", 6.0, "max allowed transverse DCA"}; // To be used when associating ambitrack to collision using best DCA + std::vector ambTrackIds; HistogramRegistry registry{ "registry", - {{"TracksDCAXY", "; DCA_{xy} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, - {"TracksDCAX", "; DCA_{x} (cm); counts", {HistType::kTH1F, {{100, -10, 10}}}}, - {"TracksDCAY", "; DCA_{y} (cm); counts", {HistType::kTH1F, {{100, -10, 10}}}}, - {"AmbiguousTracksStatus", "; Status; counts", {HistType::kTH1F, {{6, -0.5, 5.5}}}}, - {"NbCollComp", "; NbCollComp", {HistType::kTH1F, {{20, -0.5, 19.5}}}}, - {"NumberOfContributors", "; N_{tr} for vertexing; counts", {HistType::kTH1F, {{100, 0, 100}}}}, - {"CollisionsMatchIndicesMC", "; Rec. minDCA ambitrack coll.ID; Gen. ambitrack coll.ID", {HistType::kTH2F, {{401, -0.5, 1000.5}, {401, -0.5, 1000.5}}}}, - {"TracksDCAXYBest", "; DCA_{xy}^{best} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, - {"TracksDCAXYBestFalse", "; DCA_{xy}^{best, false} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, - {"EfficiencyZvtx", "; z vertex; Efficiency", {HistType::kTProfile, {{100, -30, 30}}}}, - {"DeltaZvtx", "; #delta z (cm); counts", {HistType::kTH1F, {{400, -20, 20}}}}, - {"DeltaZvtxBest", "; #delta z = z_{best} - z_{true} (cm); counts", {HistType::kTH1F, {{400, -20, 20}}}}, - {"CorrectMatch", "; Matching value; counts", {HistType::kTH1F, {{5, -0.5, 4.5}}}}}}; + {{"ParticleZR", "; #it{z}_{vtx} (cm); #it{R} (cm) ; count", {HistType::kTH2F, {ZAxis, {1001, -0.5, 100.5}}}}, // + {"Primary/ParticleZR", "; #it{z}_{vtx} (cm); #it{R} (cm) ; count", {HistType::kTH2F, {ZAxis, {1001, -0.5, 100.5}}}}, // + + {"Truth/DCAxTruth", "; DCA_{x}^{truth} (cm); counts", {HistType::kTH1F, {{500, -5, 5}}}}, + {"Truth/DCAyTruth", "; DCA_{y}^{truth} (cm); counts", {HistType::kTH1F, {{500, -5, 5}}}}, + + {"Primary/DCAxPrimNAmb", "; DCA_{x} (cm); counts", {HistType::kTH1F, {{500, -5, 5}}}}, + {"Primary/DCAyPrimNAmb", "; DCA_{y} (cm); counts", {HistType::kTH1F, {{500, -5, 5}}}}, + {"Primary/DCAxPtPrimNAmb", "; DCA_{x} (cm); #it{p}_{T}^{true} (GeV/#it{c}) ; counts", {HistType::kTH2F, {{2500, -5, 5}, {21, -0.05, 10.05}}}}, + + {"Primary/DCAxPrimAmb1", "; DCA_{x} (cm); counts", {HistType::kTH1F, {{500, -5, 5}}}}, + {"Primary/DCAyPrimAmb1", "; DCA_{y} (cm); counts", {HistType::kTH1F, {{500, -5, 5}}}}, + + {"Primary/DCAxPrimAmb2", "; DCA_{x} (cm); counts", {HistType::kTH1F, {{500, -5, 5}}}}, + {"Primary/DCAyPrimAmb2", "; DCA_{y} (cm); counts", {HistType::kTH1F, {{500, -5, 5}}}}, + + // ambiguous tracks and DCA with all compatible collisions + {"Ambiguous/TracksDCAXY", "; DCA_{xy} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, + {"Ambiguous/TracksDCAX", "; DCA_{x} (cm); counts", {HistType::kTH1F, {{1000, -10, 10}}}}, + {"Ambiguous/TracksDCAY", "; DCA_{y} (cm); counts", {HistType::kTH1F, {{1000, -10, 10}}}}, + + // all tracks (before amb reassociation) + {"DCAXYAll", "; DCA_{xy} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, + {"DCAXAll", "; DCA_{x} (cm); counts", {HistType::kTH1F, {{1000, -10, 10}}}}, + {"DCAYAll", "; DCA_{y} (cm); counts", {HistType::kTH1F, {{1000, -10, 10}}}}, + + // ambiguous tracks before reassociation + {"DCAXYAmb", "; DCA_{xy} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, + {"DCAXAmb", "; DCA_{x} (cm); counts", {HistType::kTH1F, {{1000, -10, 10}}}}, + {"DCAYAmb", "; DCA_{y} (cm); counts", {HistType::kTH1F, {{1000, -10, 10}}}}, + + // non ambiguous tracks + {"DCAXYNAmb", "; DCA_{xy} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, + {"DCAXNAmb", "; DCA_{x} (cm); counts", {HistType::kTH1F, {{1000, -10, 10}}}}, + {"DCAYNAmb", "; DCA_{y} (cm); counts", {HistType::kTH1F, {{1000, -10, 10}}}}, + + {"AmbiguousTrackStatus", "; ; N_{trk}", {HistType::kTH1F, {{6, 0.5, 6.5}}}}, + + // DCAxy, x and y distributions for reassociated ambiguous tracks + // when it is a false reassociation and when it is true + {"Ambiguous/TracksDCAXYBest", "; DCA_{xy}^{best} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, + {"Ambiguous/TracksDCAXBest", "; DCA_{x}^{best} (cm); counts", {HistType::kTH1F, {{500, -10, 10}}}}, + {"Ambiguous/TracksDCAYBest", "; DCA_{y}^{best} (cm); counts", {HistType::kTH1F, {{500, -10, 10}}}}, + + {"Ambiguous/TracksDCAXYBestTrue", "; DCA_{xy}^{best, true} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, + {"Ambiguous/TracksDCAXYBestFalse", "; DCA_{xy}^{best, false} (cm); counts", {HistType::kTH1F, {{100, -1, 10}}}}, + + {"Ambiguous/TracksDCAXBestTrue", "; DCA_{x}^{best, true} (cm); counts", {HistType::kTH1F, {{500, -10, 10}}}}, + {"Ambiguous/TracksDCAYBestTrue", "; DCA_{y}^{best, true} (cm); counts", {HistType::kTH1F, {{500, -10, 10}}}}, + {"Ambiguous/TracksDCAXBestFalse", "; DCA_{x}^{best, false} (cm); counts", {HistType::kTH1F, {{500, -10, 10}}}}, + {"Ambiguous/TracksDCAYBestFalse", "; DCA_{y}^{best, false} (cm); counts", {HistType::kTH1F, {{500, -10, 10}}}} + + }}; void init(InitContext&) { - auto hstat = registry.get(HIST("CorrectMatch")); - auto* x1 = hstat->GetXaxis(); - x1->SetBinLabel(1, "Incorrect match"); - x1->SetBinLabel(2, "Correct match"); - x1->SetBinLabel(3, "N_{ambitrack} associable"); - x1->SetBinLabel(4, "N_{ambitrack} w N_{coll} > 0"); - x1->SetBinLabel(5, "N_{ambitrack} total"); - - auto hstatus = registry.get(HIST("AmbiguousTracksStatus")); + auto hstatus = registry.get(HIST("AmbiguousTrackStatus")); auto* x2 = hstatus->GetXaxis(); - x2->SetBinLabel(1, "MFT tracks "); - x2->SetBinLabel(2, "MFT ambiguous tracks "); - x2->SetBinLabel(3, "All ambiguous primary"); - x2->SetBinLabel(4, "Orphan + primary"); - x2->SetBinLabel(5, "All ambiguous secondary"); - x2->SetBinLabel(6, "Orphan + secondary"); + x2->SetBinLabel(1, "MFT tracks"); + x2->SetBinLabel(2, "MFT ambiguous tracks"); + x2->SetBinLabel(3, "Reassigned tracks"); + x2->SetBinLabel(4, "Extra tracks"); + x2->SetBinLabel(5, "orig=true"); + x2->SetBinLabel(6, "best=true"); } - int getIndexBestCollision(std::vector vecOfDCA, int method = 0) + void processDCAamb(MFTTracksLabeled const&, + CollisionsLabeled const&, ExtBCs const& bcs, + aod::AmbiguousMFTTracks const& atracks, + aod::McParticles const&, + aod::McCollisions const&) { - int indice = 0; - if (vecOfDCA.size() == 0) { - return -1; + + if (bcs.size() == 0) { + return; } - if (method == 0) { - indice = std::distance(vecOfDCA.begin(), std::min_element(vecOfDCA.begin(), vecOfDCA.end())); + if (atracks.size() == 0) { + return; } - return indice; - } - - template - void doProcess(T const& ambitracks, aod::BCs const& bcs, MFTTracksLabeled const& tracks, FullCollision const& collisions, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions) - { - int ntracks = tracks.size(); - int nambitracks = ambitracks.size(); - - registry.fill(HIST("AmbiguousTracksStatus"), 0.0, ntracks); - registry.fill(HIST("AmbiguousTracksStatus"), 1.0, nambitracks); + // initCCDB(bcs.begin()); if Bz is needed + ambTrackIds.clear(); - for (auto& ambitrack : ambitracks) { - vecCollForAmb.clear(); - vecDCACollForAmb.clear(); - vecAmbTrack.clear(); - vecZposCollForAmb.clear(); + float dcaXY; + float bestDCA, bestDCAX, bestDCAY; + o2::track::TrackParCovFwd bestTrackPar; - double value = 0.0; // matching value for collision association to an ambiguous track - double zVtxMCAmbi = 0; // z vertex associated to the mc collision - int mcCollAmbiID = -1; // mc value for the collision containing the ambiguous track + for (auto& atrack : atracks) { - //auto track = ambitrack.mfttrack_as(); // Obtain the MFT ambiguous track with the MC labels - auto track = ambitrack.template mfttrack_as(); //This is the synthax when calling a templated funcction on a template + dcaXY = 999; // DCAxy + bestDCA = 999; + auto track = atrack.mfttrack_as(); + if (track.has_collision()) { + ambTrackIds.push_back(atrack.mfttrackId()); + } if (!track.has_mcParticle()) { LOGF(warning, "No MC particle for ambiguous track, skip..."); continue; } auto particle = track.mcParticle(); - mcCollAmbiID = particle.mcCollisionId(); - zVtxMCAmbi = particle.mcCollision().posZ(); - - if (particle.isPhysicalPrimary()) { - registry.fill(HIST("AmbiguousTracksStatus"), 2.0); - } else { - registry.fill(HIST("AmbiguousTracksStatus"), 4.0); - } - // Fill the std::vector for ambiguous tracks with the quantities needed - vecAmbTrack.push_back(track.x()); - vecAmbTrack.push_back(track.y()); - vecAmbTrack.push_back(track.phi()); - vecAmbTrack.push_back(track.tgl()); - vecAmbTrack.push_back(track.signed1Pt()); - vecAmbTrack.push_back(track.z()); - vecAmbTrack.push_back(track.chi2()); + auto bestCol = track.has_collision() ? track.collisionId() : -1; + int bestMCCol = -1; + std::vector v1; // Temporary null vector for the computation of the covariance matrix + SMatrix55 tcovs(v1.begin(), v1.end()); + SMatrix5 tpars(track.x(), track.y(), track.phi(), track.tgl(), track.signed1Pt()); + o2::track::TrackParCovFwd trackPar{track.z(), tpars, tcovs, track.chi2()}; - auto bcambis = ambitrack.bc(); + auto compatibleBCs = atrack.bc_as(); - int collCounter = 0; - for (auto& collision : collisions) { - uint64_t mostProbableBC = collision.bc().globalBC(); - //uint64_t meanBC = mostProbableBC - std::lround(collision.collisionTime() / (o2::constants::lhc::LHCBunchSpacingNS / 1000)); - //int deltaBC = std::ceil(collision.collisionTimeRes() / (o2::constants::lhc::LHCBunchSpacingNS / 1000) * 4); - - for (auto& bcambi : bcambis) { - - if (bcambi.globalBC() != mostProbableBC) { - continue; + for (auto& bc : compatibleBCs) { + if (!bc.has_collisions()) { + continue; + } + auto collisions = bc.collisions_as(); // compatible collisions + for (auto const& collision : collisions) { + + // trackPar.propagateToZhelix(collision.posZ(), Bz); // track parameters propagation to the position of the z vertex + trackPar.propagateToZlinear(collision.posZ()); + + const auto dcaX(trackPar.getX() - collision.posX()); + const auto dcaY(trackPar.getY() - collision.posY()); + dcaXY = std::sqrt(dcaX * dcaX + dcaY * dcaY); + + registry.fill(HIST("Ambiguous/TracksDCAXY"), dcaXY); + registry.fill(HIST("Ambiguous/TracksDCAX"), dcaX); + registry.fill(HIST("Ambiguous/TracksDCAY"), dcaY); + // registry.fill(HIST("NumberOfContributors"), collision.numContrib()); + + if ((dcaXY < bestDCA)) { + bestCol = collision.globalIndex(); + bestMCCol = collision.mcCollisionId(); + bestDCA = dcaXY; + bestDCAX = dcaX; + bestDCAY = dcaY; + bestTrackPar = trackPar; } - //here the bc of the ambitrack is the bc of the collision we are looking at - collCounter++; + } + } - // We compute the DCAxy of this track wrt the primary vertex of the current collision - SMatrix5 tpars(vecAmbTrack[0], vecAmbTrack[1], vecAmbTrack[2], vecAmbTrack[3], vecAmbTrack[4]); - // std::vector v1{extAmbiTrack.cXX(), extAmbiTrack.cXY(), extAmbiTrack.cYY(), extAmbiTrack.cPhiX(), extAmbiTrack.cPhiY(), - // extAmbiTrack.cPhiPhi(), extAmbiTrack.cTglX(), extAmbiTrack.cTglY(), extAmbiTrack.cTglPhi(), extAmbiTrack.cTglTgl(), - // extAmbiTrack.c1PtX(), extAmbiTrack.c1PtY(), extAmbiTrack.c1PtPhi(), extAmbiTrack.c1PtTgl(), extAmbiTrack.c1Pt21Pt2()}; + // other option for the truth : collision.mcCollision().posZ(); - std::vector v1; // Temporary null vector for the computation of the covariance matrix - SMatrix55 tcovs(v1.begin(), v1.end()); - o2::track::TrackParCovFwd pars1{vecAmbTrack[5], tpars, tcovs, vecAmbTrack[6]}; + registry.fill(HIST("Ambiguous/TracksDCAXYBest"), bestDCA); + registry.fill(HIST("Ambiguous/TracksDCAXBest"), bestDCAX); + registry.fill(HIST("Ambiguous/TracksDCAYBest"), bestDCAY); - // o2::track::TrackParCovFwd pars1{extAmbiTrack.z(), tpars, tcovs, chi2}; - pars1.propagateToZlinear(collision.posZ()); // track parameters propagation to the position of the z vertex + if (particle.isPhysicalPrimary()) { + registry.fill(HIST("Primary/DCAxPrimAmb2"), bestDCAX); + registry.fill(HIST("Primary/DCAyPrimAmb2"), bestDCAY); + } - const auto dcaX(pars1.getX() - collision.posX()); - const auto dcaY(pars1.getY() - collision.posY()); - auto dcaXY = std::sqrt(dcaX * dcaX + dcaY * dcaY); + auto mcCollID = particle.mcCollisionId(); + registry.fill(HIST("AmbiguousTrackStatus"), 2); + if (!track.has_collision()) { + // this is a track extra + registry.fill(HIST("AmbiguousTrackStatus"), 4); + if (bestMCCol == mcCollID) // correctly assigned to bestCol + { + registry.fill(HIST("AmbiguousTrackStatus"), 6); + registry.fill(HIST("Ambiguous/TracksDCAXYBestTrue"), bestDCA); + registry.fill(HIST("Ambiguous/TracksDCAXBestTrue"), bestDCAX); + registry.fill(HIST("Ambiguous/TracksDCAYBestTrue"), bestDCAY); + } else { + registry.fill(HIST("Ambiguous/TracksDCAXYBestFalse"), bestDCA); + registry.fill(HIST("Ambiguous/TracksDCAXBestFalse"), bestDCAX); + registry.fill(HIST("Ambiguous/TracksDCAYBestFalse"), bestDCAY); + } - registry.fill(HIST("TracksDCAXY"), dcaXY); - registry.fill(HIST("TracksDCAX"), dcaX); - registry.fill(HIST("TracksDCAY"), dcaY); - registry.fill(HIST("NumberOfContributors"), collision.numContrib()); + } else if (track.collisionId() != bestCol) { + // this track has been reassigned + auto collOrig = track.collision_as(); + registry.fill(HIST("AmbiguousTrackStatus"), 3); + if (bestMCCol == mcCollID) // correctly reassigned + { + registry.fill(HIST("AmbiguousTrackStatus"), 6); + registry.fill(HIST("Ambiguous/TracksDCAXYBestTrue"), bestDCA); + registry.fill(HIST("Ambiguous/TracksDCAXBestTrue"), bestDCAX); + registry.fill(HIST("Ambiguous/TracksDCAYBestTrue"), bestDCAY); + } else { // uncorrectly reassigned + registry.fill(HIST("Ambiguous/TracksDCAXYBestFalse"), bestDCA); + registry.fill(HIST("Ambiguous/TracksDCAXBestFalse"), bestDCAX); + registry.fill(HIST("Ambiguous/TracksDCAYBestFalse"), bestDCAY); + } - if (dcaXY > maxDCAXY) { - continue; - } + if (collOrig.mcCollisionId() == mcCollID) { // initially correctly assigned + registry.fill(HIST("AmbiguousTrackStatus"), 5); + } + } + } + } + PROCESS_SWITCH(vertexingfwd, processDCAamb, "get the DCAxy of MFT ambiguous tracks", true); - vecDCACollForAmb.push_back(dcaXY); + void processDCA(MFTTracksLabeled const& tracks, + aod::Collisions const&, + aod::McParticles const&, + aod::McCollisions const&) + { + if (tracks.size() == 0) { + return; + } + registry.fill(HIST("AmbiguousTrackStatus"), 1, tracks.size()); + float dcaXY; + o2::track::TrackParCovFwd bestTrackPar; - if (!collision.has_mcCollision()) { - continue; - } + for (auto& track : tracks) { + if (!track.has_mcParticle()) { + LOGF(warning, "No MC particle for ambiguous track, skip..."); + continue; + } + auto particle = track.mcParticle(); + if (!track.has_collision()) { + continue; + } + auto collision = track.collision(); - int mcCollindex = collision.mcCollision().globalIndex(); - vecCollForAmb.push_back(mcCollindex); + std::vector v1; // Temporary null vector for the computation of the covariance matrix + SMatrix55 tcovs(v1.begin(), v1.end()); + SMatrix5 tpars(track.x(), track.y(), track.phi(), track.tgl(), track.signed1Pt()); + o2::track::TrackParCovFwd trackPar{track.z(), tpars, tcovs, track.chi2()}; - vecZposCollForAmb.push_back(collision.mcCollision().posZ()); + trackPar.propagateToZlinear(collision.posZ()); - registry.fill(HIST("DeltaZvtx"), collision.mcCollision().posZ() - zVtxMCAmbi); - break; //once we found a bc that corresponds to the bc of the collision we are working on, go out of the bcambi loop - //We then look at the next collision - } - } + const auto dcaX(trackPar.getX() - collision.posX()); + const auto dcaY(trackPar.getY() - collision.posY()); + dcaXY = std::sqrt(dcaX * dcaX + dcaY * dcaY); - registry.fill(HIST("NbCollComp"), collCounter); - registry.fill(HIST("CorrectMatch"), 4.0); // counting for ambiguous track with N collisions >=0 + float Rv = std::sqrt(pow(particle.vx(), 2) + pow(particle.vy(), 2)); + registry.fill(HIST("ParticleZR"), particle.vz(), Rv); - if (collCounter == 0) { //these are orphan tracks - if (!particle.isPhysicalPrimary()) { //orphan and secondary - registry.fill(HIST("AmbiguousTracksStatus"), 5.0); - } - if (particle.isPhysicalPrimary()) { //orphan and primary - registry.fill(HIST("AmbiguousTracksStatus"), 3.0); - } - continue; + if (particle.isPhysicalPrimary()) { + registry.fill(HIST("Primary/ParticleZR"), particle.vz(), Rv); } - registry.fill(HIST("CorrectMatch"), 3.0); // counting for ambiguous track with N collisions >0 + const auto dcaXtruth(particle.vx() - particle.mcCollision().posX()); + const auto dcaYtruth(particle.vy() - particle.mcCollision().posY()); + // auto dcaXYtruth = std::sqrt(dcaXtruth * dcaXtruth + dcaYtruth * dcaYtruth); // this is DCA_xy truth - int indexMinDCA = getIndexBestCollision(vecDCACollForAmb, 0); // obtain min value in the stored vector of DCAs - int indexMCcoll = -1; - if (indexMinDCA == -1) { - continue; //if no DCAxy was < maxDCAXY - } - indexMCcoll = vecCollForAmb[indexMinDCA]; + registry.fill(HIST("Truth/DCAxTruth"), dcaXtruth); + registry.fill(HIST("Truth/DCAyTruth"), dcaYtruth); - registry.fill(HIST("CollisionsMatchIndicesMC"), mcCollAmbiID, indexMCcoll); + registry.fill(HIST("DCAXYAll"), dcaXY); + registry.fill(HIST("DCAXAll"), dcaX); + registry.fill(HIST("DCAYAll"), dcaY); - if (collCounter == 1) { //This shouldn't happen after Ruben's fix - printf("strange ambiguous track of mfttrackId %d\n", ambitrack.mfttrackId()); - if (mcCollAmbiID == indexMCcoll) { - printf("and this is a correct match for the ambiguous track of mfttrackid %d\n", ambitrack.mfttrackId()); + if (find(ambTrackIds.begin(), ambTrackIds.end(), track.globalIndex()) != ambTrackIds.end()) { + registry.fill(HIST("DCAXYAmb"), dcaXY); + registry.fill(HIST("DCAXAmb"), dcaX); + registry.fill(HIST("DCAYAmb"), dcaY); + if (particle.isPhysicalPrimary()) { + registry.fill(HIST("Primary/DCAxPrimAmb1"), dcaX); + registry.fill(HIST("Primary/DCAyPrimAmb1"), dcaY); } - } - registry.fill(HIST("DeltaZvtxBest"), vecZposCollForAmb[indexMinDCA] - zVtxMCAmbi); - - if (mcCollAmbiID == indexMCcoll) { //correct match - value = 1.0; - // LOGF(info, " --> Ambitrack correctly associated to collision, dca= %f", vecDCACollForAmb[indexMinDCA]); + continue; // this track has already been reassigned to bestcollision, don't double count } - registry.fill(HIST("TracksDCAXYBest"), vecDCACollForAmb[indexMinDCA]); - registry.fill(HIST("CorrectMatch"), value); - registry.fill(HIST("EfficiencyZvtx"), zVtxMCAmbi, value); - registry.fill(HIST("CorrectMatch"), 2.0); // Counting for amibuous track with N collisions > 0 + registry.fill(HIST("DCAXYNAmb"), dcaXY); + registry.fill(HIST("DCAXNAmb"), dcaX); + registry.fill(HIST("DCAYNAmb"), dcaY); - if (value == 0.0) { //incorrect match - registry.fill(HIST("TracksDCAXYBestFalse"), vecDCACollForAmb[indexMinDCA]); // Incorrect association with min DCA + if (!particle.isPhysicalPrimary()) { + continue; } + // only tracks coming from primary particles here + // non ambiguous tracks + registry.fill(HIST("Primary/DCAxPrimNAmb"), dcaX); + registry.fill(HIST("Primary/DCAyPrimNAmb"), dcaY); - } // ambitracks loop - } //end of doProcess - - void processNew(aod::AmbiguousMFTTracks const& ambitracks, aod::BCs const& bcs, MFTTracksLabeled const& tracks, FullCollision const& collisions, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions) - { - doProcess(ambitracks, bcs, tracks, collisions, mcParticles, mcCollisions); - } - PROCESS_SWITCH(vertexingfwd, processNew, "Process ambiguous track DCA", true); - - void processOld(aod::AmbiguousTracksMFT const& ambitracks, aod::BCs const& bcs, MFTTracksLabeled const& tracks, FullCollision const& collisions, aod::McParticles const& mcParticles, aod::McCollisions const& mcCollisions) - { - doProcess(ambitracks, bcs, tracks, collisions, mcParticles, mcCollisions); + registry.fill(HIST("Primary/DCAxPtPrimNAmb"), dcaX, particle.pt()); + } } - PROCESS_SWITCH(vertexingfwd, processOld, "Process ambiguous track DCA", false); + PROCESS_SWITCH(vertexingfwd, processDCA, "get the DCAxy of MFT tracks", true); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)