1314 {
1315 std::vector<std::pair<Trk::VxCascadeInfo*,Trk::VxCascadeInfo*> >
result;
1316
1317 std::vector<const xAOD::TrackParticle*> tracksJX;
1320 if (tracksJX.size() != massesJX.size()) {
1321 ATH_MSG_ERROR(
"Problems with JX input: number of tracks or track mass inputs is not correct!");
1323 }
1324
1325 if(std::find(tracksJX.cbegin(), tracksJX.cend(), V0vtx->
trackParticle(0)) != tracksJX.cend())
return result;
1326 if(std::find(tracksJX.cbegin(), tracksJX.cend(), V0vtx->
trackParticle(1)) != tracksJX.cend())
return result;
1327 std::vector<const xAOD::TrackParticle*> tracksV0;
1330
1331 std::vector<const xAOD::TrackParticle*> tracksJpsi{tracksJX[0], tracksJX[1]};
1332 std::vector<const xAOD::TrackParticle*> tracksX;
1335
1336 std::vector<double> massesV0;
1339 }
1342 }
1345 }
1346
1347 TLorentzVector p4_moth, p4_v0,
tmp;
1351 }
1352 xAOD::BPhysHelper V0_helper(V0vtx);
1353 for(
int it=0;
it<V0_helper.nRefTrks();
it++) {
1354 p4_moth += V0_helper.refTrk(it,massesV0[it]);
1355 p4_v0 += V0_helper.refTrk(it,massesV0[it]);
1356 }
1357
1363 xAOD::BPhysHelper JX_helper(JXvtx);
1366 std::unique_ptr<Trk::RecVertex> pv_AOD;
1367 if(pv_xAOD) pv_AOD = std::make_unique<Trk::RecVertex>(pv_xAOD->
position(),pv_xAOD->covariancePosition(),pv_xAOD->
numberDoF(),pv_xAOD->
chiSquared());
1368
1369 SG::AuxElement::Decorator<float> chi2_V1_decor("ChiSquared_V1");
1370 SG::AuxElement::Decorator<int> ndof_V1_decor("nDoF_V1");
1371 SG::AuxElement::Decorator<std::string> type_V1_decor("Type_V1");
1372
1373 SG::AuxElement::Accessor<int> mAcc_gfit("gamma_fit");
1374 SG::AuxElement::Accessor<float> mAcc_gmass("gamma_mass");
1375 SG::AuxElement::Accessor<float> mAcc_gmasserr("gamma_massError");
1376 SG::AuxElement::Accessor<float> mAcc_gchisq("gamma_chisq");
1377 SG::AuxElement::Accessor<int> mAcc_gndof("gamma_ndof");
1378 SG::AuxElement::Accessor<float> mAcc_gprob("gamma_probability");
1379
1380 SG::AuxElement::Decorator<int> mDec_gfit("gamma_fit");
1381 SG::AuxElement::Decorator<float> mDec_gmass("gamma_mass");
1382 SG::AuxElement::Decorator<float> mDec_gmasserr("gamma_massError");
1383 SG::AuxElement::Decorator<float> mDec_gchisq("gamma_chisq");
1384 SG::AuxElement::Decorator<int> mDec_gndof("gamma_ndof");
1385 SG::AuxElement::Decorator<float> mDec_gprob("gamma_probability");
1386 SG::AuxElement::Decorator< std::vector<float> > trk_pxDeco("TrackPx_V0nc");
1387 SG::AuxElement::Decorator< std::vector<float> > trk_pyDeco("TrackPy_V0nc");
1388 SG::AuxElement::Decorator< std::vector<float> > trk_pzDeco("TrackPz_V0nc");
1389
1390 std::vector<float> trk_px;
1391 std::vector<float> trk_py;
1392 std::vector<float> trk_pz;
1393
1395 double main_mass = p4_moth.M();
1401 }
1403
1404
1405 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState();
1406
1407 int robustness = 0;
1409
1410
1411 std::vector<Trk::VertexID> vrtList;
1412
1413
1417 } else {
1419 }
1420 vrtList.push_back(vID1);
1423
1426 } else {
1428 }
1429 vrtList.push_back(vID2);
1430
1431 std::vector<const xAOD::TrackParticle*> tp;
1432 std::vector<double> tp_masses;
1435 } else {
1437 }
1438 }
1439 else {
1440
1443 } else {
1445 }
1447 std::vector<Trk::VertexID> cnstV;
1450 }
1451 }
1452 }
1454 std::vector<Trk::VertexID> cnstV;
1457 }
1458 }
1460 std::vector<Trk::VertexID> cnstV;
1463 }
1464 }
1465
1466 std::unique_ptr<Trk::VxCascadeInfo> fit_result = std::unique_ptr<Trk::VxCascadeInfo>(
m_iVertexFitter->fitCascade(*state, pv_AOD.get(), pv_AOD.get() &&
m_firstDecayAtPV ?
true :
false) );
1467
1468 if (fit_result) {
1469 for(auto& v : fit_result->vertices()) {
1470 if(
v->nTrackParticles()==0) {
1471 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1472 v->setTrackParticleLinks(nullLinkVector);
1473 }
1474 }
1475
1477
1478
1479 fit_result->setSVOwnership(true);
1480
1481
1482 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1484
1485 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1486 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1487 size_t iMoth = cascadeVertices.size()-1;
1488 double lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1490 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1491 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1493 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1494 }
1496 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1497 }
1499 type_V1_decor(*cascadeVertices[0]) = "Ks";
1500 }
1501 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1502 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1503 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1504 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1505 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1506 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1507 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1508 trk_px.reserve(V0_helper.nRefTrks());
1509 trk_py.reserve(V0_helper.nRefTrks());
1510 trk_pz.reserve(V0_helper.nRefTrks());
1511 for(auto&& vec3 : V0_helper.refTrks()) {
1512 trk_px.push_back( vec3.Px() );
1513 trk_py.push_back( vec3.Py() );
1514 trk_pz.push_back( vec3.Pz() );
1515 }
1516 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1517 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1518 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1519
1520 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1521 }
1522 }
1523 }
1526 std::vector<double> massesJXExtra = massesJX; massesJXExtra.push_back(
m_extraTrk1MassHypo);
1527
1531
1532 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1533 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1534
1537 double main_mass = (p4_moth+
tmp).M();
1543 }
1544 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1545
1546 std::vector<const xAOD::TrackParticle*> tracksExtra{tpExtra};
1547 std::vector<const xAOD::TrackParticle*> tracksJXExtra = tracksJX; tracksJXExtra.push_back(tpExtra);
1548
1549
1550 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState();
1551
1552 int robustness = 0;
1554
1555
1556 std::vector<Trk::VertexID> vrtList;
1557 std::vector<Trk::VertexID> vrtList2;
1560
1564 } else {
1566 }
1567 vrtList.push_back(vID1);
1568
1571 } else {
1573 }
1574 vrtList2.push_back(vID2);
1575
1578 } else {
1580 }
1581 }
1582 else {
1583
1587 } else {
1589 }
1590 vrtList.push_back(vID1);
1592
1594 vrtList.push_back(vID2);
1595
1598 } else {
1600 }
1601 }
1602 else {
1603
1606 } else {
1607 vID2 =
m_iVertexFitter->nextVertex(tracksJXExtra,massesJXExtra,vrtList,*state);
1608 }
1609 }
1610 }
1612 std::vector<Trk::VertexID> cnstV;
1615 }
1616 }
1618 std::vector<Trk::VertexID> cnstV;
1621 }
1622 }
1624 std::vector<Trk::VertexID> cnstV;
1627 }
1628 }
1629
1630 std::unique_ptr<Trk::VxCascadeInfo> fit_result = std::unique_ptr<Trk::VxCascadeInfo>(
m_iVertexFitter->fitCascade(*state, pv_AOD.get(), pv_AOD.get() &&
m_firstDecayAtPV ?
true :
false) );
1631
1632 if (fit_result) {
1633 for(auto& v : fit_result->vertices()) {
1634 if(
v->nTrackParticles()==0) {
1635 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1636 v->setTrackParticleLinks(nullLinkVector);
1637 }
1638 }
1639
1641
1642
1643 fit_result->setSVOwnership(true);
1644
1645
1646 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1648 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1649 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1650 size_t iMoth = cascadeVertices.size()-1;
1651 double lxy_SV1(0);
1653 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
1654 }
1655 else {
1656 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1657 }
1659 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1660 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1662 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1663 }
1665 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1666 }
1668 type_V1_decor(*cascadeVertices[0]) = "Ks";
1669 }
1670 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1671 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1672 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1673 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1674 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1675 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1676 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1677 trk_px.reserve(V0_helper.nRefTrks());
1678 trk_py.reserve(V0_helper.nRefTrks());
1679 trk_pz.reserve(V0_helper.nRefTrks());
1680 for(auto&& vec3 : V0_helper.refTrks()) {
1681 trk_px.push_back( vec3.Px() );
1682 trk_py.push_back( vec3.Py() );
1683 trk_pz.push_back( vec3.Pz() );
1684 }
1685 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1686 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1687 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1688
1689 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1690 }
1691 }
1692 }
1693 }
1695 std::vector<const xAOD::TrackParticle*> tracksPlus;
1696 std::vector<const xAOD::TrackParticle*> tracksMinus;
1700
1701 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1702 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1703 if(tpExtra->charge()>0) {
1704 tracksPlus.push_back(tpExtra);
1705 }
1706 else {
1707 tracksMinus.push_back(tpExtra);
1708 }
1709 }
1710
1712 TLorentzVector p4_ExtraTrk1, p4_ExtraTrk2;
1719 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2).M();
1726 }
1727 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1729 if(
D0.extraTrack1) D0Candidates.push_back(
D0);
1730 }
1731 }
1732 }
1733
1735
1736 for(
auto&&
D0 : D0Candidates.vector()) {
1737 std::vector<const xAOD::TrackParticle*> tracksExtra{
D0.extraTrack1,
D0.extraTrack2};
1738
1739
1740 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState();
1741
1742 int robustness = 0;
1744
1745
1746 std::vector<Trk::VertexID> vrtList;
1747
1748
1752 } else {
1754 }
1755 vrtList.push_back(vID1);
1756
1760 } else {
1762 }
1763 vrtList.push_back(vID2);
1764
1768 } else {
1770 }
1772 std::vector<Trk::VertexID> cnstV;
1775 }
1776 }
1778 std::vector<Trk::VertexID> cnstV;
1781 }
1782 }
1784 std::vector<Trk::VertexID> cnstV;
1787 }
1788 }
1789
1790 std::unique_ptr<Trk::VxCascadeInfo> fit_result = std::unique_ptr<Trk::VxCascadeInfo>(
m_iVertexFitter->fitCascade(*state, pv_AOD.get(), pv_AOD.get() &&
m_firstDecayAtPV ?
true :
false) );
1791
1792 if (fit_result) {
1793 for(auto& v : fit_result->vertices()) {
1794 if(
v->nTrackParticles()==0) {
1795 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1796 v->setTrackParticleLinks(nullLinkVector);
1797 }
1798 }
1799
1801
1802
1803 fit_result->setSVOwnership(true);
1804
1805
1806 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1808 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1809 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1810 size_t iMoth = cascadeVertices.size()-1;
1811 double lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1812 double lxy_SV2 =
m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[iMoth]);
1814 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1815 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1817 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1818 }
1820 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1821 }
1823 type_V1_decor(*cascadeVertices[0]) = "Ks";
1824 }
1825 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1826 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1827 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1828 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1829 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1830 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1831 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1832 trk_px.reserve(V0_helper.nRefTrks());
1833 trk_py.reserve(V0_helper.nRefTrks());
1834 trk_pz.reserve(V0_helper.nRefTrks());
1835 for(auto&& vec3 : V0_helper.refTrks()) {
1836 trk_px.push_back( vec3.Px() );
1837 trk_py.push_back( vec3.Py() );
1838 trk_pz.push_back( vec3.Pz() );
1839 }
1840 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1841 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1842 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1843
1844 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1845 }
1846 }
1847 }
1848 }
1850 std::vector<const xAOD::TrackParticle*> tracksPlus;
1851 std::vector<const xAOD::TrackParticle*> tracksMinus;
1854 if( tpExtra->pt() < minTrkPt ) continue;
1856
1857 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1858 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1859 if(tpExtra->charge()>0) {
1860 tracksPlus.push_back(tpExtra);
1861 }
1862 else {
1863 tracksMinus.push_back(tpExtra);
1864 }
1865 }
1866
1868 TLorentzVector p4_ExtraTrk1, p4_ExtraTrk2, p4_ExtraTrk3;
1869
1872 for(auto tp2Itr=tracksMinus.cbegin(); tp2Itr!=tracksMinus.cend(); ++tp2Itr) {
1874 for(auto tp3Itr=tp2Itr+1; tp3Itr!=tracksMinus.cend(); ++tp3Itr) {
1881 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M();
1887 if(
m_massDpm>0) main_mass += - (p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M() +
m_massDpm;
1888 }
1889 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1891 if(Dpm.extraTrack1) DpmCandidates.push_back(Dpm);
1892 }
1893 }
1894 }
1895 }
1896
1899 for(auto tp2Itr=tracksPlus.cbegin(); tp2Itr!=tracksPlus.cend(); ++tp2Itr) {
1901 for(auto tp3Itr=tp2Itr+1; tp3Itr!=tracksPlus.cend(); ++tp3Itr) {
1908 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M();
1914 if(
m_massDpm>0) main_mass += - (p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M() +
m_massDpm;
1915 }
1916 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1918 if(Dpm.extraTrack1) DpmCandidates.push_back(Dpm);
1919 }
1920 }
1921 }
1922 }
1923
1925
1926 for(auto&& Dpm : DpmCandidates.vector()) {
1927 std::vector<const xAOD::TrackParticle*> tracksExtra{Dpm.extraTrack1,Dpm.extraTrack2,Dpm.extraTrack3};
1928
1929
1930 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState();
1931
1932 int robustness = 0;
1934
1935
1936 std::vector<Trk::VertexID> vrtList;
1937 std::vector<Trk::VertexID> vrtList2;
1938
1940
1944 } else {
1946 }
1947 vrtList.push_back(vID1);
1948
1952 } else {
1954 }
1955 vrtList2.push_back(vID2);
1959 } else {
1961 }
1962 vrtList2.push_back(vID3);
1963
1964 std::vector<const xAOD::TrackParticle*> tp;
1965 std::vector<double> tp_masses;
1968 } else {
1970 }
1972 std::vector<Trk::VertexID> cnstV;
1975 }
1976 }
1978 std::vector<Trk::VertexID> cnstV;
1981 }
1982 }
1984 std::vector<Trk::VertexID> cnstV;
1987 }
1988 }
1989 }
1990 else {
1991
1995 } else {
1997 }
1998 vrtList.push_back(vID1);
1999
2003 } else {
2005 }
2006 vrtList.push_back(vID2);
2007
2011 } else {
2013 }
2015 std::vector<Trk::VertexID> cnstV;
2018 }
2019 }
2021 std::vector<Trk::VertexID> cnstV;
2024 }
2025 }
2027 std::vector<Trk::VertexID> cnstV;
2030 }
2031 }
2032 }
2033
2034 std::unique_ptr<Trk::VxCascadeInfo> fit_result = std::unique_ptr<Trk::VxCascadeInfo>(
m_iVertexFitter->fitCascade(*state, pv_AOD.get(), pv_AOD.get() &&
m_firstDecayAtPV ?
true :
false) );
2035
2036 if (fit_result) {
2037 for(auto& v : fit_result->vertices()) {
2038 if(
v->nTrackParticles()==0) {
2039 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
2040 v->setTrackParticleLinks(nullLinkVector);
2041 }
2042 }
2043
2045
2046
2047 fit_result->setSVOwnership(true);
2048
2049
2050 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
2052 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
2053 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
2054 size_t iMoth = cascadeVertices.size()-1;
2055 double lxy_SV1(0), lxy_SV2(0);
2057 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
2058 lxy_SV2 =
m_CascadeTools->lxy(moms[2],cascadeVertices[2],cascadeVertices[iMoth]);
2059 }
2060 else {
2061 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
2062 lxy_SV2 =
m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[iMoth]);
2063 }
2065 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
2066 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
2068 type_V1_decor(*cascadeVertices[0]) = "Lambda";
2069 }
2071 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
2072 }
2074 type_V1_decor(*cascadeVertices[0]) = "Ks";
2075 }
2076 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
2077 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
2078 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
2079 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
2080 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
2081 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
2082 trk_px.clear(); trk_py.clear(); trk_pz.clear();
2083 trk_px.reserve(V0_helper.nRefTrks());
2084 trk_py.reserve(V0_helper.nRefTrks());
2085 trk_pz.reserve(V0_helper.nRefTrks());
2086 for(auto&& vec3 : V0_helper.refTrks()) {
2087 trk_px.push_back( vec3.Px() );
2088 trk_py.push_back( vec3.Py() );
2089 trk_pz.push_back( vec3.Pz() );
2090 }
2091 trk_pxDeco(*cascadeVertices[0]) = trk_px;
2092 trk_pyDeco(*cascadeVertices[0]) = trk_py;
2093 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
2094
2095
2097 TLorentzVector totalMom;
2098 for(
size_t it=0;
it<moms[iMoth].size();
it++) totalMom += moms[iMoth][it];
2099 double mainV_mass = totalMom.M();
2101 std::unique_ptr<Trk::IVKalState> state_mvc =
m_iVertexFitter->makeState();
2102 int robustness_mvc = 0;
2104 std::vector<Trk::VertexID> vrtList_mvc;
2105 std::vector<Trk::VertexID> vrtList2_mvc;
2110 } else {
2111 vID1_mvc =
m_iVertexFitter->startVertex(tracksV0,massesV0,*state_mvc);
2112 }
2113 vrtList_mvc.push_back(vID1_mvc);
2117 } else {
2118 vID2_mvc =
m_iVertexFitter->nextVertex(tracksJX,massesJX,vrtList_mvc,*state_mvc);
2119 }
2120 vrtList2_mvc.push_back(vID2_mvc);
2124 } else {
2125 vID3_mvc =
m_iVertexFitter->nextVertex(tracksExtra,massesExtra,*state_mvc);
2126 }
2127 vrtList2_mvc.push_back(vID3_mvc);
2128 std::vector<const xAOD::TrackParticle*> tp;
2129 std::vector<double> tp_masses;
2132 std::vector<Trk::VertexID> cnstV_mvc;
2135 }
2136 }
2138 std::vector<Trk::VertexID> cnstV_mvc;
2141 }
2142 }
2144 std::vector<Trk::VertexID> cnstV_mvc;
2147 }
2148 }
2149 }
2150 else {
2154 } else {
2155 vID1_mvc =
m_iVertexFitter->startVertex(tracksV0,massesV0,*state_mvc);
2156 }
2157 vrtList_mvc.push_back(vID1_mvc);
2161 } else {
2162 vID2_mvc =
m_iVertexFitter->nextVertex(tracksExtra,massesExtra,*state_mvc);
2163 }
2164 vrtList_mvc.push_back(vID2_mvc);
2167 std::vector<Trk::VertexID> cnstV_mvc;
2170 }
2171 }
2173 std::vector<Trk::VertexID> cnstV_mvc;
2176 }
2177 }
2179 std::vector<Trk::VertexID> cnstV_mvc;
2182 }
2183 }
2184 }
2185
2186 std::unique_ptr<Trk::VxCascadeInfo> fit_result_mvc = std::unique_ptr<Trk::VxCascadeInfo>(
m_iVertexFitter->fitCascade(*state_mvc, pv_AOD.get(), pv_AOD.get() &&
m_firstDecayAtPV ?
true :
false) );
2187
2188 if (fit_result_mvc) {
2189 for(auto& v : fit_result_mvc->vertices()) {
2190 if(
v->nTrackParticles()==0) {
2191 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
2192 v->setTrackParticleLinks(nullLinkVector);
2193 }
2194 }
2196 fit_result_mvc->setSVOwnership(true);
2197 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
2198 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
2200 type_V1_decor(*cascadeVertices[0]) = "Lambda";
2201 }
2203 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
2204 }
2206 type_V1_decor(*cascadeVertices[0]) = "Ks";
2207 }
2208 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
2209 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
2210 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
2211 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
2212 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
2213 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
2214 trk_px.clear(); trk_py.clear(); trk_pz.clear();
2215 trk_px.reserve(V0_helper.nRefTrks());
2216 trk_py.reserve(V0_helper.nRefTrks());
2217 trk_pz.reserve(V0_helper.nRefTrks());
2218 for(auto&& vec3 : V0_helper.refTrks()) {
2219 trk_px.push_back( vec3.Px() );
2220 trk_py.push_back( vec3.Py() );
2221 trk_pz.push_back( vec3.Pz() );
2222 }
2223 trk_pxDeco(*cascadeVertices[0]) = trk_px;
2224 trk_pyDeco(*cascadeVertices[0]) = trk_py;
2225 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
2226
2227 result.push_back( std::make_pair(fit_result.release(),fit_result_mvc.release()) );
2228 }
2229 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2230 }
2231 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2232 }
2233 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2234 }
2235 }
2236 }
2237 }
2238
2239 if(pv_xAOD) {
2240 for(auto cascade_info_pair : result) {
2241 if(cascade_info_pair.first && cascade_info_pair.first->getParticleMoms().size()>0) {
2242 size_t index = cascade_info_pair.first->getParticleMoms().size() - 1;
2243 const std::vector<TLorentzVector> &
mom = cascade_info_pair.first->getParticleMoms()[
index];
2246 xAOD::BPhysHypoHelper vtx(
m_hypoName, mainVertex);
2247 bool isInDefaultPVCont = false;
2249 if(pv_xAOD == pvVtx) { isInDefaultPVCont = true; break; }
2250 }
2251 if(isInDefaultPVCont) vtx.setPv( pv_xAOD, defaultPVContainer, pvtype );
2252 else vtx.setPv( pv_xAOD, pvContainer, pvtype );
2253 if(origPv_xAOD) vtx.setOrigPv( origPv_xAOD, defaultPVContainer, pvtype );
2254 vtx.setLxy (
m_CascadeTools->lxy (mom, vtx.vtx(), pv_xAOD), pvtype );
2255 vtx.setLxyErr (
m_CascadeTools->lxyError (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2256 vtx.setA0 (
m_CascadeTools->a0 (mom, vtx.vtx(), pv_xAOD), pvtype );
2257 vtx.setA0Err (
m_CascadeTools->a0Error (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2258 vtx.setA0xy (
m_CascadeTools->a0xy (mom, vtx.vtx(), pv_xAOD), pvtype );
2259 vtx.setA0xyErr(
m_CascadeTools->a0xyError(mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2260 vtx.setZ0 (
m_CascadeTools->a0z (mom, vtx.vtx(), pv_xAOD), pvtype );
2261 vtx.setZ0Err (
m_CascadeTools->a0zError (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2262 vtx.setRefitPVStatus( 0, pvtype );
2263
2268
2269 if(cascade_info_pair.second && cascade_info_pair.second->getParticleMoms().size()>0) {
2270 index = cascade_info_pair.second->getParticleMoms().size() - 1;
2271 const std::vector<TLorentzVector> &mom_mvc = cascade_info_pair.second->getParticleMoms()[
index];
2273 const xAOD::Vertex* mainVertex_mvc = cascade_info_pair.second->vertices()[
index];
2274 xAOD::BPhysHypoHelper vtx_mvc(
m_hypoName, mainVertex_mvc);
2275 if(isInDefaultPVCont) vtx_mvc.setPv( pv_xAOD, defaultPVContainer, pvtype );
2276 else vtx_mvc.setPv( pv_xAOD, pvContainer, pvtype );
2277 if(origPv_xAOD) vtx.setOrigPv( origPv_xAOD, defaultPVContainer, pvtype );
2278 vtx_mvc.setLxy (
m_CascadeTools->lxy (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2279 vtx_mvc.setLxyErr (
m_CascadeTools->lxyError (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2280 vtx_mvc.setA0 (
m_CascadeTools->a0 (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2281 vtx_mvc.setA0Err (
m_CascadeTools->a0Error (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2282 vtx_mvc.setA0xy (
m_CascadeTools->a0xy (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2283 vtx_mvc.setA0xyErr(
m_CascadeTools->a0xyError(mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2284 vtx_mvc.setZ0 (
m_CascadeTools->a0z (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2285 vtx_mvc.setZ0Err (
m_CascadeTools->a0zError (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2286 vtx_mvc.setRefitPVStatus( 0, pvtype );
2287
2292 }
2293 }
2294 }
2295 }
2296
2298 }
MesonCandidate getD0Candidate(const xAOD::Vertex *JXvtx, const xAOD::TrackParticle *extraTrk1, const xAOD::TrackParticle *extraTrk2) const
MesonCandidate getDpmCandidate(const xAOD::Vertex *JXvtx, const xAOD::TrackParticle *extraTrk1, const xAOD::TrackParticle *extraTrk2, const xAOD::TrackParticle *extraTrk3) const
pv_type
: Enum type of the PV
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .).
virtual double pt() const override final
The transverse momentum ( ) of the particle.
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
const TrackParticle * trackParticle(size_t i) const
Get the pointer to a given track that was used in vertex reco.
float numberDoF() const
Returns the number of degrees of freedom of the vertex fit as float.
float chiSquared() const
Returns the of the vertex fit as float.
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)
1.16.1