Skip to content

Commit c0e75c4

Browse files
zhangbiao-phyalibuild
authored and
smaff92
committed
[PWGHF] Add vertex building into the Tcc tree creator (AliceO2Group#11169)
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
1 parent 4870181 commit c0e75c4

File tree

1 file changed

+197
-40
lines changed

1 file changed

+197
-40
lines changed

‎PWGHF/TableProducer/treeCreatorTccToD0D0Pi.cxx‎

Lines changed: 197 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -18,13 +18,16 @@
1818
#include <vector>
1919
#include <algorithm>
2020
#include <utility>
21+
#include <string>
22+
#include <memory>
2123

2224
#include "CommonConstants/PhysicsConstants.h"
2325
#include "DCAFitter/DCAFitterN.h"
2426
#include "Framework/AnalysisTask.h"
2527
#include "Framework/O2DatabasePDGPlugin.h"
2628
#include "Framework/runDataProcessing.h"
2729
#include "ReconstructionDataFormats/DCA.h"
30+
#include "ReconstructionDataFormats/V0.h"
2831

2932
#include "Common/Core/trackUtilities.h"
3033
#include "Common/Core/TrackSelection.h"
@@ -53,9 +56,6 @@ namespace o2::aod
5356
namespace full
5457
{
5558
DECLARE_SOA_INDEX_COLUMN(Collision, collision);
56-
DECLARE_SOA_COLUMN(PtD1, ptD1, float);
57-
DECLARE_SOA_COLUMN(PtD2, ptD2, float);
58-
DECLARE_SOA_COLUMN(PtPi, ptPi, float);
5959
DECLARE_SOA_COLUMN(PxProng0D1, pxProng0D1, float);
6060
DECLARE_SOA_COLUMN(PxProng1D1, pxProng1D1, float);
6161
DECLARE_SOA_COLUMN(PyProng0D1, pyProng0D1, float);
@@ -95,10 +95,12 @@ DECLARE_SOA_COLUMN(NSigTpcSoftPi, nSigTpcSoftPi, float);
9595
DECLARE_SOA_COLUMN(NSigTofSoftPi, nSigTofSoftPi, float);
9696
DECLARE_SOA_COLUMN(MlScoreD1, mlScoreD1, float);
9797
DECLARE_SOA_COLUMN(MlScoreD2, mlScoreD2, float);
98-
DECLARE_SOA_COLUMN(DecayLengthD1, decayLengthD1, float);
99-
DECLARE_SOA_COLUMN(DecayLengthD2, decayLengthD2, float);
98+
DECLARE_SOA_COLUMN(ImpactParameterD1, impactParameterD1, float);
99+
DECLARE_SOA_COLUMN(ImpactParameterD2, impactParameterD2, float);
100+
DECLARE_SOA_COLUMN(ImpactParameterSoftPi, impactParameterSoftPi, float);
100101
DECLARE_SOA_COLUMN(CpaD1, cpaD1, float);
101102
DECLARE_SOA_COLUMN(CpaD2, cpaD2, float);
103+
DECLARE_SOA_COLUMN(Chi2PCA, chi2PCA, float);
102104
DECLARE_SOA_COLUMN(SignSoftPi, signSoftPi, float);
103105
DECLARE_SOA_COLUMN(DcaXYSoftPi, dcaXYSoftPi, float);
104106
DECLARE_SOA_COLUMN(DcaZSoftPi, dcaZSoftPi, float);
@@ -112,9 +114,6 @@ DECLARE_SOA_COLUMN(RunNumber, runNumber, int);
112114
} // namespace full
113115

114116
DECLARE_SOA_TABLE(HfCandTccLites, "AOD", "HFCANDTCCLITE",
115-
full::PtD1,
116-
full::PtD2,
117-
full::PtPi,
118117
full::PxProng0D1,
119118
full::PxProng1D1,
120119
full::PyProng0D1,
@@ -154,10 +153,12 @@ DECLARE_SOA_TABLE(HfCandTccLites, "AOD", "HFCANDTCCLITE",
154153
full::NSigTofSoftPi,
155154
full::MlScoreD1,
156155
full::MlScoreD2,
157-
full::DecayLengthD1,
158-
full::DecayLengthD2,
156+
full::ImpactParameterD1,
157+
full::ImpactParameterD2,
158+
full::ImpactParameterSoftPi,
159159
full::CpaD1,
160160
full::CpaD2,
161+
full::Chi2PCA,
161162
full::SignSoftPi,
162163
full::DcaXYSoftPi,
163164
full::DcaZSoftPi,
@@ -184,16 +185,37 @@ struct HfTreeCreatorTccToD0D0Pi {
184185
Configurable<float> ptMinSoftPion{"ptMinSoftPion", 0.0, "Min pt for the soft pion"};
185186
Configurable<bool> usePionIsGlobalTrackWoDCA{"usePionIsGlobalTrackWoDCA", true, "check isGlobalTrackWoDCA status for pions"};
186187

187-
// Configurable<float> softPiEtaMax{"softPiEtaMax", 0.9f, "Soft pion max value for pseudorapidity (abs vale)"};
188-
// Configurable<float> softPiChi2Max{"softPiChi2Max", 36.f, "Soft pion max value for chi2 ITS"};
189-
// Configurable<int> softPiItsHitMap{"softPiItsHitMap", 127, "Soft pion ITS hitmap"};
190-
// Configurable<int> softPiItsHitsMin{"softPiItsHitsMin", 1, "Minimum number of ITS layers crossed by the soft pion among those in \"softPiItsHitMap\""};
188+
// vertexing
189+
Configurable<bool> propagateToPCA{"propagateToPCA", true, "create tracks version propagated to PCA"};
190+
Configurable<bool> useAbsDCA{"useAbsDCA", false, "Minimise abs. distance rather than chi2"};
191+
Configurable<bool> useWeightedFinalPCA{"useWeightedFinalPCA", false, "Recalculate vertex position using track covariances, effective only if useAbsDCA is true"};
192+
Configurable<float> maxR{"maxR", 200., "reject PCA's above this radius"};
193+
Configurable<float> maxDZIni{"maxDZIni", 4., "reject (if>0) PCA candidate if tracks DZ exceeds threshold"};
194+
Configurable<float> minParamChange{"minParamChange", 1.e-3, "stop iterations if largest change of any Lb is smaller than this"};
195+
Configurable<float> minRelChi2Change{"minRelChi2Change", 0.9, "stop iterations is chi2/chi2old > this"};
196+
191197
Configurable<float> softPiDcaXYMax{"softPiDcaXYMax", 0.065, "Soft pion max dcaXY (cm)"};
192198
Configurable<float> softPiDcaZMax{"softPiDcaZMax", 0.065, "Soft pion max dcaZ (cm)"};
193199
Configurable<float> deltaMassCanMax{"deltaMassCanMax", 2, "delta candidate max mass (DDPi-D0D0) ((GeV/c2)"};
194200
Configurable<float> massCanMax{"massCanMax", 4.0, "candidate max mass (DDPi) ((GeV/c2)"};
195201

202+
// magnetic field setting from CCDB
203+
Configurable<bool> isRun2{"isRun2", false, "enable Run 2 or Run 3 GRP objects for magnetic field"};
204+
Configurable<std::string> ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"};
205+
Configurable<std::string> ccdbPathLut{"ccdbPathLut", "GLO/Param/MatLUT", "Path for LUT parametrization"};
206+
Configurable<std::string> ccdbPathGrp{"ccdbPathGrp", "GLO/GRP/GRP", "Path of the grp file (Run 2)"};
207+
Configurable<std::string> ccdbPathGrpMag{"ccdbPathGrpMag", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object (Run 3)"};
208+
209+
o2::vertexing::DCAFitterN<3> dfTcc; // Tcc vertex fitter
210+
o2::vertexing::DCAFitterN<2> dfD1; // 2-prong vertex fitter (to rebuild D01 vertex)
211+
o2::vertexing::DCAFitterN<2> dfD2; // 2-prong vertex fitter (to rebuild D02 vertex)
212+
196213
HfHelper hfHelper;
214+
Service<o2::ccdb::BasicCCDBManager> ccdb;
215+
o2::base::MatLayerCylSet* lut;
216+
o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
217+
int runNumber;
218+
double bz{0.};
197219

198220
using TracksPid = soa::Join<aod::pidTPCFullPi, aod::pidTOFFullPi, aod::pidTPCFullKa, aod::pidTOFFullKa>;
199221
using TracksWPid = soa::Join<aod::TracksWCovDcaExtra, TracksPid, aod::TrackSelection>;
@@ -209,14 +231,47 @@ struct HfTreeCreatorTccToD0D0Pi {
209231
Preslice<SelectedCandidatesMl> candsD0PerCollisionWithMl = aod::track_association::collisionId;
210232
Preslice<aod::TrackAssoc> trackIndicesPerCollision = aod::track_association::collisionId;
211233
// Partition<SelectedCandidatesMl> candidatesMlAll = aod::hf_sel_candidate_d0::isSelD0 >= 0;
212-
234+
std::shared_ptr<TH1> hCandidatesD1, hCandidatesD2, hCandidatesTcc;
235+
OutputObj<TH1F> hCovPVXX{TH1F("hCovPVXX", "Tcc candidates;XX element of cov. matrix of prim. vtx. position (cm^{2});entries", 100, 0., 1.e-4)};
236+
OutputObj<TH1F> hCovSVXX{TH1F("hCovSVXX", "Tcc candidates;XX element of cov. matrix of sec. vtx. position (cm^{2});entries", 100, 0., 0.2)};
213237
void init(InitContext const&)
214238
{
215239

216240
std::array<bool, 3> doprocess{doprocessDataWithMl, doprocessDataWithMlWithFT0C, doprocessDataWithMlWithFT0M};
217241
if (std::accumulate(doprocess.begin(), doprocess.end(), 0) != 1) {
218242
LOGP(fatal, "Only one process function can be enabled at a time.");
219243
}
244+
245+
dfD1.setPropagateToPCA(propagateToPCA);
246+
dfD1.setMaxR(maxR);
247+
dfD1.setMaxDZIni(maxDZIni);
248+
dfD1.setMinParamChange(minParamChange);
249+
dfD1.setMinRelChi2Change(minRelChi2Change);
250+
dfD1.setUseAbsDCA(useAbsDCA);
251+
dfD1.setWeightedFinalPCA(useWeightedFinalPCA);
252+
253+
dfD2.setPropagateToPCA(propagateToPCA);
254+
dfD2.setMaxR(maxR);
255+
dfD2.setMaxDZIni(maxDZIni);
256+
dfD2.setMinParamChange(minParamChange);
257+
dfD2.setMinRelChi2Change(minRelChi2Change);
258+
dfD2.setUseAbsDCA(useAbsDCA);
259+
dfD2.setWeightedFinalPCA(useWeightedFinalPCA);
260+
261+
dfTcc.setPropagateToPCA(propagateToPCA);
262+
dfTcc.setMaxR(maxR);
263+
dfTcc.setMaxDZIni(maxDZIni);
264+
dfTcc.setMinParamChange(minParamChange);
265+
dfTcc.setMinRelChi2Change(minRelChi2Change);
266+
dfTcc.setUseAbsDCA(useAbsDCA);
267+
dfTcc.setWeightedFinalPCA(useWeightedFinalPCA);
268+
269+
// Configure CCDB access
270+
ccdb->setURL(ccdbUrl);
271+
ccdb->setCaching(true);
272+
ccdb->setLocalObjectValidityChecking();
273+
lut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdb->get<o2::base::MatLayerCylSet>(ccdbPathLut));
274+
runNumber = 0;
220275
}
221276

222277
template <typename T>
@@ -245,10 +300,86 @@ struct HfTreeCreatorTccToD0D0Pi {
245300
void runCandCreatorData(CollType const& collision,
246301
CandType const& candidates,
247302
aod::TrackAssoc const& trackIndices,
248-
TrkType const& track, aod::BCs const&)
303+
TrkType const&,
304+
aod::BCs const&)
249305
{
306+
307+
auto primaryVertex = getPrimaryVertex(collision);
308+
auto bc = collision.template bc_as<aod::BCsWithTimestamps>();
309+
if (runNumber != bc.runNumber()) {
310+
LOG(info) << ">>>>>>>>>>>> Current run number: " << runNumber;
311+
initCCDB(bc, runNumber, ccdb, isRun2 ? ccdbPathGrp : ccdbPathGrpMag, lut, isRun2);
312+
bz = o2::base::Propagator::Instance()->getNominalBz();
313+
LOG(info) << ">>>>>>>>>>>> Magnetic field: " << bz;
314+
}
315+
dfTcc.setBz(bz);
316+
dfD1.setBz(bz);
317+
dfD2.setBz(bz);
318+
250319
for (const auto& candidateD1 : candidates) {
320+
321+
auto trackD1Prong0 = candidateD1.template prong0_as<TrkType>();
322+
auto trackD1Prong1 = candidateD1.template prong1_as<TrkType>();
323+
auto trackParVarD1Prong0 = getTrackParCov(trackD1Prong0);
324+
auto trackParVarD1Prong1 = getTrackParCov(trackD1Prong1);
325+
// reconstruct the 2-prong secondary vertex
326+
hCandidatesD1->Fill(SVFitting::BeforeFit);
327+
try {
328+
if (dfD1.process(trackParVarD1Prong0, trackParVarD1Prong1) == 0) {
329+
continue;
330+
}
331+
} catch (const std::runtime_error& error) {
332+
LOG(info) << "Run time error found: " << error.what() << ". DCAFitterN for first D0 cannot work, skipping the candidate.";
333+
hCandidatesD1->Fill(SVFitting::Fail);
334+
continue;
335+
}
336+
hCandidatesD1->Fill(SVFitting::FitOk);
337+
const auto& vertexD1 = dfD1.getPCACandidatePos();
338+
trackParVarD1Prong0.propagateTo(vertexD1[0], bz);
339+
trackParVarD1Prong1.propagateTo(vertexD1[0], bz);
340+
// Get pVec of tracks of D1
341+
std::array<float, 3> pVecD1Prong0 = {0};
342+
std::array<float, 3> pVecD1Prong1 = {0};
343+
dfD1.getTrack(0).getPxPyPzGlo(pVecD1Prong0);
344+
dfD1.getTrack(1).getPxPyPzGlo(pVecD1Prong1);
345+
// Get D1 momentum
346+
std::array<float, 3> pVecD1 = RecoDecay::pVec(pVecD1Prong0, pVecD1Prong1);
347+
348+
// build a D1 neutral track
349+
auto trackD1 = o2::dataformats::V0(vertexD1, pVecD1, dfD1.calcPCACovMatrixFlat(), trackParVarD1Prong0, trackParVarD1Prong1);
350+
251351
for (auto candidateD2 = candidateD1 + 1; candidateD2 != candidates.end(); ++candidateD2) {
352+
353+
auto trackD2Prong0 = candidateD2.template prong0_as<TrkType>();
354+
auto trackD2Prong1 = candidateD2.template prong1_as<TrkType>();
355+
auto trackParVarD2Prong0 = getTrackParCov(trackD2Prong0);
356+
auto trackParVarD2Prong1 = getTrackParCov(trackD2Prong1);
357+
// reconstruct the 2-prong secondary vertex
358+
hCandidatesD2->Fill(SVFitting::BeforeFit);
359+
try {
360+
if (dfD2.process(trackParVarD2Prong0, trackParVarD2Prong1) == 0) {
361+
continue;
362+
}
363+
} catch (const std::runtime_error& error) {
364+
LOG(info) << "Run time error found: " << error.what() << ". DCAFitterN for second D0 cannot work, skipping the candidate.";
365+
hCandidatesD2->Fill(SVFitting::Fail);
366+
continue;
367+
}
368+
hCandidatesD2->Fill(SVFitting::FitOk);
369+
const auto& vertexD2 = dfD2.getPCACandidatePos();
370+
trackParVarD2Prong0.propagateTo(vertexD2[0], bz);
371+
trackParVarD2Prong1.propagateTo(vertexD2[0], bz);
372+
// Get pVec of tracks of D2
373+
std::array<float, 3> pVecD2Prong0 = {0};
374+
std::array<float, 3> pVecD2Prong1 = {0};
375+
dfD2.getTrack(0).getPxPyPzGlo(pVecD2Prong0);
376+
dfD2.getTrack(1).getPxPyPzGlo(pVecD2Prong1);
377+
// Get D2 momentum
378+
std::array<float, 3> pVecD2 = RecoDecay::pVec(pVecD2Prong0, pVecD2Prong1);
379+
380+
// build a D2 neutral track
381+
auto trackD2 = o2::dataformats::V0(vertexD2, pVecD2, dfD2.calcPCACovMatrixFlat(), trackParVarD2Prong0, trackParVarD2Prong1);
382+
252383
for (const auto& trackId : trackIndices) {
253384
auto trackPion = trackId.template track_as<TrkType>();
254385
if (usePionIsGlobalTrackWoDCA && !trackPion.isGlobalTrackWoDCA()) {
@@ -273,6 +404,46 @@ struct HfTreeCreatorTccToD0D0Pi {
273404
(candidateD2.prong1Id() == trackPion.globalIndex())) {
274405
continue;
275406
}
407+
408+
auto trackParCovPi = getTrackParCov(trackPion);
409+
std::array<float, 3> pVecD1New = {0., 0., 0.};
410+
std::array<float, 3> pVecD2New = {0., 0., 0.};
411+
std::array<float, 3> pVecSoftPi = {0., 0., 0.};
412+
413+
// find the DCA between the D01, D02 and the bachelor track, for Tcc
414+
hCandidatesTcc->Fill(SVFitting::BeforeFit);
415+
try {
416+
if (dfTcc.process(trackD1, trackD2, trackParCovPi) == 0) {
417+
continue;
418+
}
419+
} catch (const std::runtime_error& error) {
420+
LOG(info) << "Run time error found: " << error.what() << ". DCAFitterN for Tcc cannot work, skipping the candidate.";
421+
hCandidatesTcc->Fill(SVFitting::Fail);
422+
continue;
423+
}
424+
hCandidatesTcc->Fill(SVFitting::FitOk);
425+
426+
dfTcc.propagateTracksToVertex(); // propagate the softpi and D0 pair to the Tcc vertex
427+
trackD1.getPxPyPzGlo(pVecD1New); // momentum of D1 at the Tcc vertex
428+
trackD2.getPxPyPzGlo(pVecD2New); // momentum of D2 at the Tcc vertex
429+
trackParCovPi.getPxPyPzGlo(pVecSoftPi); // momentum of pi at the Tcc vertex
430+
431+
auto chi2PCA = dfTcc.getChi2AtPCACandidate();
432+
auto covMatrixPCA = dfTcc.calcPCACovMatrixFlat();
433+
hCovSVXX->Fill(covMatrixPCA[0]);
434+
435+
// get track impact parameters
436+
// This modifies track momenta!
437+
auto covMatrixPV = primaryVertex.getCov();
438+
hCovPVXX->Fill(covMatrixPV[0]);
439+
o2::dataformats::DCA impactParameterD1;
440+
o2::dataformats::DCA impactParameterD2;
441+
o2::dataformats::DCA impactParameterSoftPi;
442+
443+
trackD1.propagateToDCA(primaryVertex, bz, &impactParameterD1);
444+
trackD2.propagateToDCA(primaryVertex, bz, &impactParameterD2);
445+
trackParCovPi.propagateToDCA(primaryVertex, bz, &impactParameterSoftPi);
446+
276447
// Retrieve properties of the two D0 candidates
277448
float yD1 = hfHelper.yD0(candidateD1);
278449
float yD2 = hfHelper.yD0(candidateD2);
@@ -292,7 +463,7 @@ struct HfTreeCreatorTccToD0D0Pi {
292463
std::copy(candidateD1.mlProbD0().begin(), candidateD1.mlProbD0().end(), std::back_inserter(mlScoresD1));
293464
massD01 = hfHelper.invMassD0ToPiK(candidateD1);
294465
}
295-
if (candidateD1.isSelD0bar()) {
466+
if (candidateD1.isSelD0bar() && !candidateD1.isSelD0()) {
296467
candFlagD1 = 2;
297468
std::copy(candidateD1.mlProbD0bar().begin(), candidateD1.mlProbD0bar().end(), std::back_inserter(mlScoresD1));
298469
massD01 = hfHelper.invMassD0barToKPi(candidateD1);
@@ -303,25 +474,14 @@ struct HfTreeCreatorTccToD0D0Pi {
303474
std::copy(candidateD2.mlProbD0().begin(), candidateD2.mlProbD0().end(), std::back_inserter(mlScoresD2));
304475
massD02 = hfHelper.invMassD0ToPiK(candidateD2);
305476
}
306-
if (candidateD2.isSelD0bar()) {
477+
if (candidateD2.isSelD0bar() && !candidateD2.isSelD0()) {
307478
candFlagD2 = 2;
308479
std::copy(candidateD2.mlProbD0bar().begin(), candidateD2.mlProbD0bar().end(), std::back_inserter(mlScoresD2));
309480
massD02 = hfHelper.invMassD0barToKPi(candidateD2);
310481
}
311482

312483
// LOG(info) << " candidateD1.collisionId() " << candidateD1.collisionId()<<" massD01 "<<massD01<<" massD02 "<<massD02 <<" trackPion.pt() "<< trackPion.pt();
313484

314-
auto trackPosD1Dau = track.rawIteratorAt(candidateD1.prong0Id()); // positive daughter D01
315-
auto trackNegD1Dau = track.rawIteratorAt(candidateD1.prong1Id()); // negative daughter D01
316-
317-
auto trackPosD2Dau = track.rawIteratorAt(candidateD2.prong0Id()); // positive daughter D02
318-
auto trackNegD2Dau = track.rawIteratorAt(candidateD2.prong1Id()); // negative daughter D02
319-
320-
std::array<float, 3> pVecPosD1Dau{trackPosD1Dau.pVector()};
321-
std::array<float, 3> pVecNegD1Dau{trackNegD1Dau.pVector()};
322-
std::array<float, 3> pVecPosD2Dau{trackPosD2Dau.pVector()};
323-
std::array<float, 3> pVecNegD2Dau{trackNegD2Dau.pVector()};
324-
std::array<float, 3> pVecSoftPion = {trackPion.pVector()};
325485
std::array<double, 2> massD1Daus{MassPiPlus, MassKPlus};
326486
std::array<double, 2> massD2Daus{MassPiPlus, MassKPlus};
327487

@@ -335,27 +495,22 @@ struct HfTreeCreatorTccToD0D0Pi {
335495
massD2Daus[1] = MassPiPlus;
336496
}
337497

338-
auto massKpipi1 = RecoDecay::m(std::array{pVecPosD1Dau, pVecNegD1Dau, pVecSoftPion}, std::array{massD1Daus[0], massD1Daus[1], MassPiPlus});
339-
auto massKpipi2 = RecoDecay::m(std::array{pVecPosD2Dau, pVecNegD2Dau, pVecSoftPion}, std::array{massD2Daus[0], massD2Daus[1], MassPiPlus});
498+
auto massKpipi1 = RecoDecay::m(std::array{pVecD1Prong0, pVecD1Prong1, pVecSoftPi}, std::array{massD1Daus[0], massD1Daus[1], MassPiPlus});
499+
auto massKpipi2 = RecoDecay::m(std::array{pVecD2Prong0, pVecD2Prong1, pVecSoftPi}, std::array{massD2Daus[0], massD2Daus[1], MassPiPlus});
340500

341501
deltaMassD01 = massKpipi1 - massD01;
342502
deltaMassD02 = massKpipi2 - massD02;
343503

344-
std::array<float, 3> pVecD1{candidateD1.px(), candidateD1.py(), candidateD1.pz()};
345-
std::array<float, 3> pVecD2{candidateD2.px(), candidateD2.py(), candidateD2.pz()};
346-
auto arrayMomentaDDpi = std::array{pVecD1, pVecD2, pVecSoftPion};
504+
auto arrayMomentaDDpi = std::array{pVecD1New, pVecD2New, pVecSoftPi};
347505
const auto massD0D0Pi = RecoDecay::m(std::move(arrayMomentaDDpi), std::array{MassD0, MassD0, MassPiPlus});
348506
const auto deltaMassD0D0Pi = massD0D0Pi - (massD01 + massD02);
349-
const auto massD0D0Pair = RecoDecay::m(std::array{pVecD1, pVecD2}, std::array{MassD0, MassD0});
507+
const auto massD0D0Pair = RecoDecay::m(std::array{pVecD1New, pVecD2New}, std::array{MassD0, MassD0});
350508

351509
if (deltaMassD0D0Pi > deltaMassCanMax || massD0D0Pi > massCanMax) {
352510
continue;
353511
}
354512

355513
rowCandidateLite(
356-
candidateD1.pt(),
357-
candidateD2.pt(),
358-
trackPion.pt(),
359514
candidateD1.pxProng0(),
360515
candidateD1.pxProng1(),
361516
candidateD1.pyProng0(),
@@ -395,10 +550,12 @@ struct HfTreeCreatorTccToD0D0Pi {
395550
trackPion.tofNSigmaPi(),
396551
mlScoresD1[0],
397552
mlScoresD2[0],
398-
candidateD1.decayLength(),
399-
candidateD2.decayLength(),
553+
impactParameterD1.getY(),
554+
impactParameterD2.getY(),
555+
impactParameterSoftPi.getY(),
400556
candidateD1.cpa(),
401557
candidateD2.cpa(),
558+
chi2PCA,
402559
trackPion.sign(),
403560
trackPion.dcaXY(),
404561
trackPion.dcaZ(),

0 commit comments

Comments
 (0)