1309 {
1310 std::vector<std::pair<Trk::VxCascadeInfo*,Trk::VxCascadeInfo*> >
result;
1311
1312 std::vector<const xAOD::TrackParticle*> tracksJX;
1315 if (tracksJX.size() != massesJX.size()) {
1316 ATH_MSG_ERROR(
"Problems with JX input: number of tracks or track mass inputs is not correct!");
1318 }
1319
1320 if(std::find(tracksJX.cbegin(), tracksJX.cend(), V0vtx->
trackParticle(0)) != tracksJX.cend())
return result;
1321 if(std::find(tracksJX.cbegin(), tracksJX.cend(), V0vtx->
trackParticle(1)) != tracksJX.cend())
return result;
1322 std::vector<const xAOD::TrackParticle*> tracksV0;
1325
1326 std::vector<const xAOD::TrackParticle*> tracksJpsi{tracksJX[0], tracksJX[1]};
1327 std::vector<const xAOD::TrackParticle*> tracksX;
1330
1331 std::vector<double> massesV0;
1334 }
1337 }
1340 }
1341
1342 TLorentzVector p4_moth, p4_v0,
tmp;
1346 }
1347 xAOD::BPhysHelper V0_helper(V0vtx);
1348 for(
int it=0;
it<V0_helper.nRefTrks();
it++) {
1349 p4_moth += V0_helper.refTrk(it,massesV0[it]);
1350 p4_v0 += V0_helper.refTrk(it,massesV0[it]);
1351 }
1352
1358 xAOD::BPhysHelper JX_helper(JXvtx);
1361 std::unique_ptr<Trk::RecVertex> pv_AOD;
1362 if(pv_xAOD) pv_AOD = std::make_unique<Trk::RecVertex>(pv_xAOD->
position(),pv_xAOD->covariancePosition(),pv_xAOD->
numberDoF(),pv_xAOD->
chiSquared());
1363
1364 SG::AuxElement::Decorator<float> chi2_V1_decor("ChiSquared_V1");
1365 SG::AuxElement::Decorator<int> ndof_V1_decor("nDoF_V1");
1366 SG::AuxElement::Decorator<std::string> type_V1_decor("Type_V1");
1367
1368 SG::AuxElement::Accessor<int> mAcc_gfit("gamma_fit");
1369 SG::AuxElement::Accessor<float> mAcc_gmass("gamma_mass");
1370 SG::AuxElement::Accessor<float> mAcc_gmasserr("gamma_massError");
1371 SG::AuxElement::Accessor<float> mAcc_gchisq("gamma_chisq");
1372 SG::AuxElement::Accessor<int> mAcc_gndof("gamma_ndof");
1373 SG::AuxElement::Accessor<float> mAcc_gprob("gamma_probability");
1374
1375 SG::AuxElement::Decorator<int> mDec_gfit("gamma_fit");
1376 SG::AuxElement::Decorator<float> mDec_gmass("gamma_mass");
1377 SG::AuxElement::Decorator<float> mDec_gmasserr("gamma_massError");
1378 SG::AuxElement::Decorator<float> mDec_gchisq("gamma_chisq");
1379 SG::AuxElement::Decorator<int> mDec_gndof("gamma_ndof");
1380 SG::AuxElement::Decorator<float> mDec_gprob("gamma_probability");
1381 SG::AuxElement::Decorator< std::vector<float> > trk_pxDeco("TrackPx_V0nc");
1382 SG::AuxElement::Decorator< std::vector<float> > trk_pyDeco("TrackPy_V0nc");
1383 SG::AuxElement::Decorator< std::vector<float> > trk_pzDeco("TrackPz_V0nc");
1384
1385 std::vector<float> trk_px;
1386 std::vector<float> trk_py;
1387 std::vector<float> trk_pz;
1388
1390 double main_mass = p4_moth.M();
1396 }
1398
1399
1400 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState(ctx);
1401
1402 int robustness = 0;
1404
1405
1406 std::vector<Trk::VertexID> vrtList;
1407
1408
1412 } else {
1414 }
1415 vrtList.push_back(vID1);
1418
1421 } else {
1423 }
1424 vrtList.push_back(vID2);
1425
1426 std::vector<const xAOD::TrackParticle*> tp;
1427 std::vector<double> tp_masses;
1430 } else {
1432 }
1433 }
1434 else {
1435
1438 } else {
1440 }
1442 std::vector<Trk::VertexID> cnstV;
1445 }
1446 }
1447 }
1449 std::vector<Trk::VertexID> cnstV;
1452 }
1453 }
1455 std::vector<Trk::VertexID> cnstV;
1458 }
1459 }
1460
1461 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) );
1462
1463 if (fit_result) {
1464 for(auto& v : fit_result->vertices()) {
1465 if(
v->nTrackParticles()==0) {
1466 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1467 v->setTrackParticleLinks(nullLinkVector);
1468 }
1469 }
1470
1472
1473
1474 fit_result->setSVOwnership(true);
1475
1476
1477 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1479
1480 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1481 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1482 size_t iMoth = cascadeVertices.size()-1;
1483 double lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1485 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1486 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1488 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1489 }
1491 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1492 }
1494 type_V1_decor(*cascadeVertices[0]) = "Ks";
1495 }
1496 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1497 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1498 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1499 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1500 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1501 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1502 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1503 trk_px.reserve(V0_helper.nRefTrks());
1504 trk_py.reserve(V0_helper.nRefTrks());
1505 trk_pz.reserve(V0_helper.nRefTrks());
1506 for(auto&& vec3 : V0_helper.refTrks()) {
1507 trk_px.push_back( vec3.Px() );
1508 trk_py.push_back( vec3.Py() );
1509 trk_pz.push_back( vec3.Pz() );
1510 }
1511 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1512 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1513 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1514
1515 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1516 }
1517 }
1518 }
1521 std::vector<double> massesJXExtra = massesJX; massesJXExtra.push_back(
m_extraTrk1MassHypo);
1522
1526
1527 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1528 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1529
1532 double main_mass = (p4_moth+
tmp).M();
1538 }
1539 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1540
1541 std::vector<const xAOD::TrackParticle*> tracksExtra{tpExtra};
1542 std::vector<const xAOD::TrackParticle*> tracksJXExtra = tracksJX; tracksJXExtra.push_back(tpExtra);
1543
1544
1545 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState(ctx);
1546
1547 int robustness = 0;
1549
1550
1551 std::vector<Trk::VertexID> vrtList;
1552 std::vector<Trk::VertexID> vrtList2;
1555
1559 } else {
1561 }
1562 vrtList.push_back(vID1);
1563
1566 } else {
1568 }
1569 vrtList2.push_back(vID2);
1570
1573 } else {
1575 }
1576 }
1577 else {
1578
1582 } else {
1584 }
1585 vrtList.push_back(vID1);
1587
1589 vrtList.push_back(vID2);
1590
1593 } else {
1595 }
1596 }
1597 else {
1598
1601 } else {
1602 vID2 =
m_iVertexFitter->nextVertex(tracksJXExtra,massesJXExtra,vrtList,*state);
1603 }
1604 }
1605 }
1607 std::vector<Trk::VertexID> cnstV;
1610 }
1611 }
1613 std::vector<Trk::VertexID> cnstV;
1616 }
1617 }
1619 std::vector<Trk::VertexID> cnstV;
1622 }
1623 }
1624
1625 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) );
1626
1627 if (fit_result) {
1628 for(auto& v : fit_result->vertices()) {
1629 if(
v->nTrackParticles()==0) {
1630 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1631 v->setTrackParticleLinks(nullLinkVector);
1632 }
1633 }
1634
1636
1637
1638 fit_result->setSVOwnership(true);
1639
1640
1641 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1643 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1644 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1645 size_t iMoth = cascadeVertices.size()-1;
1646 double lxy_SV1(0);
1648 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
1649 }
1650 else {
1651 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1652 }
1654 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1655 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1657 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1658 }
1660 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1661 }
1663 type_V1_decor(*cascadeVertices[0]) = "Ks";
1664 }
1665 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1666 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1667 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1668 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1669 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1670 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1671 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1672 trk_px.reserve(V0_helper.nRefTrks());
1673 trk_py.reserve(V0_helper.nRefTrks());
1674 trk_pz.reserve(V0_helper.nRefTrks());
1675 for(auto&& vec3 : V0_helper.refTrks()) {
1676 trk_px.push_back( vec3.Px() );
1677 trk_py.push_back( vec3.Py() );
1678 trk_pz.push_back( vec3.Pz() );
1679 }
1680 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1681 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1682 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1683
1684 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1685 }
1686 }
1687 }
1688 }
1690 std::vector<const xAOD::TrackParticle*> tracksPlus;
1691 std::vector<const xAOD::TrackParticle*> tracksMinus;
1695
1696 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1697 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1698 if(tpExtra->charge()>0) {
1699 tracksPlus.push_back(tpExtra);
1700 }
1701 else {
1702 tracksMinus.push_back(tpExtra);
1703 }
1704 }
1705
1707 TLorentzVector p4_ExtraTrk1, p4_ExtraTrk2;
1714 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2).M();
1721 }
1722 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1724 if(
D0.extraTrack1) D0Candidates.push_back(
D0);
1725 }
1726 }
1727 }
1728
1730
1731 for(
auto&&
D0 : D0Candidates.vector()) {
1732 std::vector<const xAOD::TrackParticle*> tracksExtra{
D0.extraTrack1,
D0.extraTrack2};
1733
1734
1735 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState(ctx);
1736
1737 int robustness = 0;
1739
1740
1741 std::vector<Trk::VertexID> vrtList;
1742
1743
1747 } else {
1749 }
1750 vrtList.push_back(vID1);
1751
1755 } else {
1757 }
1758 vrtList.push_back(vID2);
1759
1763 } else {
1765 }
1767 std::vector<Trk::VertexID> cnstV;
1770 }
1771 }
1773 std::vector<Trk::VertexID> cnstV;
1776 }
1777 }
1779 std::vector<Trk::VertexID> cnstV;
1782 }
1783 }
1784
1785 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) );
1786
1787 if (fit_result) {
1788 for(auto& v : fit_result->vertices()) {
1789 if(
v->nTrackParticles()==0) {
1790 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1791 v->setTrackParticleLinks(nullLinkVector);
1792 }
1793 }
1794
1796
1797
1798 fit_result->setSVOwnership(true);
1799
1800
1801 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1803 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1804 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1805 size_t iMoth = cascadeVertices.size()-1;
1806 double lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1807 double lxy_SV2 =
m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[iMoth]);
1809 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1810 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1812 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1813 }
1815 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1816 }
1818 type_V1_decor(*cascadeVertices[0]) = "Ks";
1819 }
1820 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1821 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1822 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1823 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1824 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1825 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1826 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1827 trk_px.reserve(V0_helper.nRefTrks());
1828 trk_py.reserve(V0_helper.nRefTrks());
1829 trk_pz.reserve(V0_helper.nRefTrks());
1830 for(auto&& vec3 : V0_helper.refTrks()) {
1831 trk_px.push_back( vec3.Px() );
1832 trk_py.push_back( vec3.Py() );
1833 trk_pz.push_back( vec3.Pz() );
1834 }
1835 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1836 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1837 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1838
1839 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1840 }
1841 }
1842 }
1843 }
1845 std::vector<const xAOD::TrackParticle*> tracksPlus;
1846 std::vector<const xAOD::TrackParticle*> tracksMinus;
1849 if( tpExtra->pt() < minTrkPt ) continue;
1851
1852 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1853 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1854 if(tpExtra->charge()>0) {
1855 tracksPlus.push_back(tpExtra);
1856 }
1857 else {
1858 tracksMinus.push_back(tpExtra);
1859 }
1860 }
1861
1863 TLorentzVector p4_ExtraTrk1, p4_ExtraTrk2, p4_ExtraTrk3;
1864
1867 for(auto tp2Itr=tracksMinus.cbegin(); tp2Itr!=tracksMinus.cend(); ++tp2Itr) {
1869 for(auto tp3Itr=tp2Itr+1; tp3Itr!=tracksMinus.cend(); ++tp3Itr) {
1876 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M();
1882 if(
m_massDpm>0) main_mass += - (p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M() +
m_massDpm;
1883 }
1884 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1886 if(Dpm.extraTrack1) DpmCandidates.push_back(Dpm);
1887 }
1888 }
1889 }
1890 }
1891
1894 for(auto tp2Itr=tracksPlus.cbegin(); tp2Itr!=tracksPlus.cend(); ++tp2Itr) {
1896 for(auto tp3Itr=tp2Itr+1; tp3Itr!=tracksPlus.cend(); ++tp3Itr) {
1903 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M();
1909 if(
m_massDpm>0) main_mass += - (p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M() +
m_massDpm;
1910 }
1911 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1913 if(Dpm.extraTrack1) DpmCandidates.push_back(Dpm);
1914 }
1915 }
1916 }
1917 }
1918
1920
1921 for(auto&& Dpm : DpmCandidates.vector()) {
1922 std::vector<const xAOD::TrackParticle*> tracksExtra{Dpm.extraTrack1,Dpm.extraTrack2,Dpm.extraTrack3};
1923
1924
1925 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState(ctx);
1926
1927 int robustness = 0;
1929
1930
1931 std::vector<Trk::VertexID> vrtList;
1932 std::vector<Trk::VertexID> vrtList2;
1933
1935
1939 } else {
1941 }
1942 vrtList.push_back(vID1);
1943
1947 } else {
1949 }
1950 vrtList2.push_back(vID2);
1954 } else {
1956 }
1957 vrtList2.push_back(vID3);
1958
1959 std::vector<const xAOD::TrackParticle*> tp;
1960 std::vector<double> tp_masses;
1963 } else {
1965 }
1967 std::vector<Trk::VertexID> cnstV;
1970 }
1971 }
1973 std::vector<Trk::VertexID> cnstV;
1976 }
1977 }
1979 std::vector<Trk::VertexID> cnstV;
1982 }
1983 }
1984 }
1985 else {
1986
1990 } else {
1992 }
1993 vrtList.push_back(vID1);
1994
1998 } else {
2000 }
2001 vrtList.push_back(vID2);
2002
2006 } else {
2008 }
2010 std::vector<Trk::VertexID> cnstV;
2013 }
2014 }
2016 std::vector<Trk::VertexID> cnstV;
2019 }
2020 }
2022 std::vector<Trk::VertexID> cnstV;
2025 }
2026 }
2027 }
2028
2029 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) );
2030
2031 if (fit_result) {
2032 for(auto& v : fit_result->vertices()) {
2033 if(
v->nTrackParticles()==0) {
2034 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
2035 v->setTrackParticleLinks(nullLinkVector);
2036 }
2037 }
2038
2040
2041
2042 fit_result->setSVOwnership(true);
2043
2044
2045 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
2047 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
2048 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
2049 size_t iMoth = cascadeVertices.size()-1;
2050 double lxy_SV1(0), lxy_SV2(0);
2052 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
2053 lxy_SV2 =
m_CascadeTools->lxy(moms[2],cascadeVertices[2],cascadeVertices[iMoth]);
2054 }
2055 else {
2056 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
2057 lxy_SV2 =
m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[iMoth]);
2058 }
2060 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
2061 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
2063 type_V1_decor(*cascadeVertices[0]) = "Lambda";
2064 }
2066 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
2067 }
2069 type_V1_decor(*cascadeVertices[0]) = "Ks";
2070 }
2071 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
2072 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
2073 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
2074 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
2075 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
2076 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
2077 trk_px.clear(); trk_py.clear(); trk_pz.clear();
2078 trk_px.reserve(V0_helper.nRefTrks());
2079 trk_py.reserve(V0_helper.nRefTrks());
2080 trk_pz.reserve(V0_helper.nRefTrks());
2081 for(auto&& vec3 : V0_helper.refTrks()) {
2082 trk_px.push_back( vec3.Px() );
2083 trk_py.push_back( vec3.Py() );
2084 trk_pz.push_back( vec3.Pz() );
2085 }
2086 trk_pxDeco(*cascadeVertices[0]) = trk_px;
2087 trk_pyDeco(*cascadeVertices[0]) = trk_py;
2088 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
2089
2090
2092 TLorentzVector totalMom;
2093 for(
size_t it=0;
it<moms[iMoth].size();
it++) totalMom += moms[iMoth][it];
2094 double mainV_mass = totalMom.M();
2096 std::unique_ptr<Trk::IVKalState> state_mvc =
m_iVertexFitter->makeState(ctx);
2097 int robustness_mvc = 0;
2099 std::vector<Trk::VertexID> vrtList_mvc;
2100 std::vector<Trk::VertexID> vrtList2_mvc;
2105 } else {
2106 vID1_mvc =
m_iVertexFitter->startVertex(tracksV0,massesV0,*state_mvc);
2107 }
2108 vrtList_mvc.push_back(vID1_mvc);
2112 } else {
2113 vID2_mvc =
m_iVertexFitter->nextVertex(tracksJX,massesJX,vrtList_mvc,*state_mvc);
2114 }
2115 vrtList2_mvc.push_back(vID2_mvc);
2119 } else {
2120 vID3_mvc =
m_iVertexFitter->nextVertex(tracksExtra,massesExtra,*state_mvc);
2121 }
2122 vrtList2_mvc.push_back(vID3_mvc);
2123 std::vector<const xAOD::TrackParticle*> tp;
2124 std::vector<double> tp_masses;
2127 std::vector<Trk::VertexID> cnstV_mvc;
2130 }
2131 }
2133 std::vector<Trk::VertexID> cnstV_mvc;
2136 }
2137 }
2139 std::vector<Trk::VertexID> cnstV_mvc;
2142 }
2143 }
2144 }
2145 else {
2149 } else {
2150 vID1_mvc =
m_iVertexFitter->startVertex(tracksV0,massesV0,*state_mvc);
2151 }
2152 vrtList_mvc.push_back(vID1_mvc);
2156 } else {
2157 vID2_mvc =
m_iVertexFitter->nextVertex(tracksExtra,massesExtra,*state_mvc);
2158 }
2159 vrtList_mvc.push_back(vID2_mvc);
2162 std::vector<Trk::VertexID> cnstV_mvc;
2165 }
2166 }
2168 std::vector<Trk::VertexID> cnstV_mvc;
2171 }
2172 }
2174 std::vector<Trk::VertexID> cnstV_mvc;
2177 }
2178 }
2179 }
2180
2181 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) );
2182
2183 if (fit_result_mvc) {
2184 for(auto& v : fit_result_mvc->vertices()) {
2185 if(
v->nTrackParticles()==0) {
2186 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
2187 v->setTrackParticleLinks(nullLinkVector);
2188 }
2189 }
2191 fit_result_mvc->setSVOwnership(true);
2192 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
2193 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
2195 type_V1_decor(*cascadeVertices[0]) = "Lambda";
2196 }
2198 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
2199 }
2201 type_V1_decor(*cascadeVertices[0]) = "Ks";
2202 }
2203 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
2204 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
2205 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
2206 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
2207 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
2208 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
2209 trk_px.clear(); trk_py.clear(); trk_pz.clear();
2210 trk_px.reserve(V0_helper.nRefTrks());
2211 trk_py.reserve(V0_helper.nRefTrks());
2212 trk_pz.reserve(V0_helper.nRefTrks());
2213 for(auto&& vec3 : V0_helper.refTrks()) {
2214 trk_px.push_back( vec3.Px() );
2215 trk_py.push_back( vec3.Py() );
2216 trk_pz.push_back( vec3.Pz() );
2217 }
2218 trk_pxDeco(*cascadeVertices[0]) = trk_px;
2219 trk_pyDeco(*cascadeVertices[0]) = trk_py;
2220 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
2221
2222 result.push_back( std::make_pair(fit_result.release(),fit_result_mvc.release()) );
2223 }
2224 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2225 }
2226 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2227 }
2228 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2229 }
2230 }
2231 }
2232 }
2233
2234 if(pv_xAOD) {
2235 for(auto cascade_info_pair : result) {
2236 if(cascade_info_pair.first && cascade_info_pair.first->getParticleMoms().size()>0) {
2237 size_t index = cascade_info_pair.first->getParticleMoms().size() - 1;
2238 const std::vector<TLorentzVector> &
mom = cascade_info_pair.first->getParticleMoms()[
index];
2241 xAOD::BPhysHypoHelper vtx(
m_hypoName, mainVertex);
2242 bool isInDefaultPVCont = false;
2244 if(pv_xAOD == pvVtx) { isInDefaultPVCont = true; break; }
2245 }
2246 if(isInDefaultPVCont) vtx.setPv( pv_xAOD, defaultPVContainer, pvtype );
2247 else vtx.setPv( pv_xAOD, pvContainer, pvtype );
2248 if(origPv_xAOD) vtx.setOrigPv( origPv_xAOD, defaultPVContainer, pvtype );
2249 vtx.setLxy (
m_CascadeTools->lxy (mom, vtx.vtx(), pv_xAOD), pvtype );
2250 vtx.setLxyErr (
m_CascadeTools->lxyError (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2251 vtx.setA0 (
m_CascadeTools->a0 (mom, vtx.vtx(), pv_xAOD), pvtype );
2252 vtx.setA0Err (
m_CascadeTools->a0Error (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2253 vtx.setA0xy (
m_CascadeTools->a0xy (mom, vtx.vtx(), pv_xAOD), pvtype );
2254 vtx.setA0xyErr(
m_CascadeTools->a0xyError(mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2255 vtx.setZ0 (
m_CascadeTools->a0z (mom, vtx.vtx(), pv_xAOD), pvtype );
2256 vtx.setZ0Err (
m_CascadeTools->a0zError (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2257 vtx.setRefitPVStatus( 0, pvtype );
2258
2263
2264 if(cascade_info_pair.second && cascade_info_pair.second->getParticleMoms().size()>0) {
2265 index = cascade_info_pair.second->getParticleMoms().size() - 1;
2266 const std::vector<TLorentzVector> &mom_mvc = cascade_info_pair.second->getParticleMoms()[
index];
2268 const xAOD::Vertex* mainVertex_mvc = cascade_info_pair.second->vertices()[
index];
2269 xAOD::BPhysHypoHelper vtx_mvc(
m_hypoName, mainVertex_mvc);
2270 if(isInDefaultPVCont) vtx_mvc.setPv( pv_xAOD, defaultPVContainer, pvtype );
2271 else vtx_mvc.setPv( pv_xAOD, pvContainer, pvtype );
2272 if(origPv_xAOD) vtx.setOrigPv( origPv_xAOD, defaultPVContainer, pvtype );
2273 vtx_mvc.setLxy (
m_CascadeTools->lxy (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2274 vtx_mvc.setLxyErr (
m_CascadeTools->lxyError (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2275 vtx_mvc.setA0 (
m_CascadeTools->a0 (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2276 vtx_mvc.setA0Err (
m_CascadeTools->a0Error (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2277 vtx_mvc.setA0xy (
m_CascadeTools->a0xy (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2278 vtx_mvc.setA0xyErr(
m_CascadeTools->a0xyError(mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2279 vtx_mvc.setZ0 (
m_CascadeTools->a0z (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2280 vtx_mvc.setZ0Err (
m_CascadeTools->a0zError (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2281 vtx_mvc.setRefitPVStatus( 0, pvtype );
2282
2287 }
2288 }
2289 }
2290 }
2291
2293 }
MesonCandidate getD0Candidate(const EventContext &ctx, const xAOD::Vertex *JXvtx, const xAOD::TrackParticle *extraTrk1, const xAOD::TrackParticle *extraTrk2) const
MesonCandidate getDpmCandidate(const EventContext &ctx, 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