1315 {
1316 std::vector<std::pair<Trk::VxCascadeInfo*,Trk::VxCascadeInfo*> >
result;
1317
1318 std::vector<const xAOD::TrackParticle*> tracksJX;
1321 if (tracksJX.size() != massesJX.size()) {
1322 ATH_MSG_ERROR(
"Problems with JX input: number of tracks or track mass inputs is not correct!");
1324 }
1325
1326 if(std::find(tracksJX.cbegin(), tracksJX.cend(), V0vtx->
trackParticle(0)) != tracksJX.cend())
return result;
1327 if(std::find(tracksJX.cbegin(), tracksJX.cend(), V0vtx->
trackParticle(1)) != tracksJX.cend())
return result;
1328 std::vector<const xAOD::TrackParticle*> tracksV0;
1331
1332 std::vector<const xAOD::TrackParticle*> tracksJpsi{tracksJX[0], tracksJX[1]};
1333 std::vector<const xAOD::TrackParticle*> tracksX;
1336
1337 std::vector<double> massesV0;
1340 }
1343 }
1346 }
1347
1348 TLorentzVector p4_moth, p4_v0,
tmp;
1352 }
1353 xAOD::BPhysHelper V0_helper(V0vtx);
1354 for(
int it=0;
it<V0_helper.nRefTrks();
it++) {
1355 p4_moth += V0_helper.refTrk(it,massesV0[it]);
1356 p4_v0 += V0_helper.refTrk(it,massesV0[it]);
1357 }
1358
1364 xAOD::BPhysHelper JX_helper(JXvtx);
1367 std::unique_ptr<Trk::RecVertex> pv_AOD;
1368 if(pv_xAOD) pv_AOD = std::make_unique<Trk::RecVertex>(pv_xAOD->
position(),pv_xAOD->covariancePosition(),pv_xAOD->
numberDoF(),pv_xAOD->
chiSquared());
1369
1370 SG::AuxElement::Decorator<float> chi2_V1_decor("ChiSquared_V1");
1371 SG::AuxElement::Decorator<int> ndof_V1_decor("nDoF_V1");
1373
1375 SG::AuxElement::Accessor<float> mAcc_gmass("gamma_mass");
1376 SG::AuxElement::Accessor<float> mAcc_gmasserr("gamma_massError");
1377 SG::AuxElement::Accessor<float> mAcc_gchisq("gamma_chisq");
1379 SG::AuxElement::Accessor<float> mAcc_gprob("gamma_probability");
1380
1381 SG::AuxElement::Decorator<int> mDec_gfit("gamma_fit");
1382 SG::AuxElement::Decorator<float> mDec_gmass("gamma_mass");
1383 SG::AuxElement::Decorator<float> mDec_gmasserr("gamma_massError");
1384 SG::AuxElement::Decorator<float> mDec_gchisq("gamma_chisq");
1385 SG::AuxElement::Decorator<int> mDec_gndof("gamma_ndof");
1386 SG::AuxElement::Decorator<float> mDec_gprob("gamma_probability");
1390
1391 std::vector<float> trk_px;
1392 std::vector<float> trk_py;
1393 std::vector<float> trk_pz;
1394
1396 double main_mass = p4_moth.M();
1402 }
1404
1405
1406 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState();
1407
1408 int robustness = 0;
1410
1411
1412 std::vector<Trk::VertexID> vrtList;
1413
1414
1418 } else {
1420 }
1421 vrtList.push_back(vID1);
1424
1427 } else {
1429 }
1430 vrtList.push_back(vID2);
1431
1432 std::vector<const xAOD::TrackParticle*>
tp;
1433 std::vector<double> tp_masses;
1436 } else {
1438 }
1439 }
1440 else {
1441
1444 } else {
1446 }
1448 std::vector<Trk::VertexID> cnstV;
1451 }
1452 }
1453 }
1455 std::vector<Trk::VertexID> cnstV;
1458 }
1459 }
1461 std::vector<Trk::VertexID> cnstV;
1464 }
1465 }
1466
1467 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) );
1468
1469 if (fit_result) {
1470 for(auto& v : fit_result->vertices()) {
1471 if(
v->nTrackParticles()==0) {
1472 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1473 v->setTrackParticleLinks(nullLinkVector);
1474 }
1475 }
1476
1478
1479
1480 fit_result->setSVOwnership(true);
1481
1482
1483 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1485
1486 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1487 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1488 size_t iMoth = cascadeVertices.size()-1;
1489 double lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1491 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1492 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1494 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1495 }
1497 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1498 }
1500 type_V1_decor(*cascadeVertices[0]) = "Ks";
1501 }
1502 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1503 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1504 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1505 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1506 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1507 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1508 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1509 trk_px.reserve(V0_helper.nRefTrks());
1510 trk_py.reserve(V0_helper.nRefTrks());
1511 trk_pz.reserve(V0_helper.nRefTrks());
1512 for(auto&& vec3 : V0_helper.refTrks()) {
1513 trk_px.push_back( vec3.Px() );
1514 trk_py.push_back( vec3.Py() );
1515 trk_pz.push_back( vec3.Pz() );
1516 }
1517 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1518 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1519 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1520
1521 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1522 }
1523 }
1524 }
1527 std::vector<double> massesJXExtra = massesJX; massesJXExtra.push_back(
m_extraTrk1MassHypo);
1528
1532
1533 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1534 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1535
1538 double main_mass = (p4_moth+
tmp).M();
1544 }
1545 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1546
1547 std::vector<const xAOD::TrackParticle*> tracksExtra{tpExtra};
1548 std::vector<const xAOD::TrackParticle*> tracksJXExtra = tracksJX; tracksJXExtra.push_back(tpExtra);
1549
1550
1551 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState();
1552
1553 int robustness = 0;
1555
1556
1557 std::vector<Trk::VertexID> vrtList;
1558 std::vector<Trk::VertexID> vrtList2;
1561
1565 } else {
1567 }
1568 vrtList.push_back(vID1);
1569
1572 } else {
1574 }
1575 vrtList2.push_back(vID2);
1576
1579 } else {
1581 }
1582 }
1583 else {
1584
1588 } else {
1590 }
1591 vrtList.push_back(vID1);
1593
1595 vrtList.push_back(vID2);
1596
1599 } else {
1601 }
1602 }
1603 else {
1604
1607 } else {
1608 vID2 =
m_iVertexFitter->nextVertex(tracksJXExtra,massesJXExtra,vrtList,*state);
1609 }
1610 }
1611 }
1613 std::vector<Trk::VertexID> cnstV;
1616 }
1617 }
1619 std::vector<Trk::VertexID> cnstV;
1622 }
1623 }
1625 std::vector<Trk::VertexID> cnstV;
1628 }
1629 }
1630
1631 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) );
1632
1633 if (fit_result) {
1634 for(auto& v : fit_result->vertices()) {
1635 if(
v->nTrackParticles()==0) {
1636 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1637 v->setTrackParticleLinks(nullLinkVector);
1638 }
1639 }
1640
1642
1643
1644 fit_result->setSVOwnership(true);
1645
1646
1647 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1649 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1650 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1651 size_t iMoth = cascadeVertices.size()-1;
1652 double lxy_SV1(0);
1654 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
1655 }
1656 else {
1657 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1658 }
1660 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1661 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1663 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1664 }
1666 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1667 }
1669 type_V1_decor(*cascadeVertices[0]) = "Ks";
1670 }
1671 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1672 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1673 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1674 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1675 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1676 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1677 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1678 trk_px.reserve(V0_helper.nRefTrks());
1679 trk_py.reserve(V0_helper.nRefTrks());
1680 trk_pz.reserve(V0_helper.nRefTrks());
1681 for(auto&& vec3 : V0_helper.refTrks()) {
1682 trk_px.push_back( vec3.Px() );
1683 trk_py.push_back( vec3.Py() );
1684 trk_pz.push_back( vec3.Pz() );
1685 }
1686 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1687 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1688 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1689
1690 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1691 }
1692 }
1693 }
1694 }
1696 std::vector<const xAOD::TrackParticle*> tracksPlus;
1697 std::vector<const xAOD::TrackParticle*> tracksMinus;
1701
1702 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1703 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1704 if(tpExtra->charge()>0) {
1705 tracksPlus.push_back(tpExtra);
1706 }
1707 else {
1708 tracksMinus.push_back(tpExtra);
1709 }
1710 }
1711
1713 TLorentzVector p4_ExtraTrk1, p4_ExtraTrk2;
1720 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2).M();
1727 }
1728 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1730 if(
D0.extraTrack1) D0Candidates.push_back(
D0);
1731 }
1732 }
1733 }
1734
1736
1737 for(
auto&&
D0 : D0Candidates.vector()) {
1738 std::vector<const xAOD::TrackParticle*> tracksExtra{
D0.extraTrack1,
D0.extraTrack2};
1739
1740
1741 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState();
1742
1743 int robustness = 0;
1745
1746
1747 std::vector<Trk::VertexID> vrtList;
1748
1749
1753 } else {
1755 }
1756 vrtList.push_back(vID1);
1757
1761 } else {
1763 }
1764 vrtList.push_back(vID2);
1765
1769 } else {
1771 }
1773 std::vector<Trk::VertexID> cnstV;
1776 }
1777 }
1779 std::vector<Trk::VertexID> cnstV;
1782 }
1783 }
1785 std::vector<Trk::VertexID> cnstV;
1788 }
1789 }
1790
1791 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) );
1792
1793 if (fit_result) {
1794 for(auto& v : fit_result->vertices()) {
1795 if(
v->nTrackParticles()==0) {
1796 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1797 v->setTrackParticleLinks(nullLinkVector);
1798 }
1799 }
1800
1802
1803
1804 fit_result->setSVOwnership(true);
1805
1806
1807 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1809 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1810 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1811 size_t iMoth = cascadeVertices.size()-1;
1812 double lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1813 double lxy_SV2 =
m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[iMoth]);
1815 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1816 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1818 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1819 }
1821 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1822 }
1824 type_V1_decor(*cascadeVertices[0]) = "Ks";
1825 }
1826 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1827 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1828 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1829 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1830 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1831 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1832 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1833 trk_px.reserve(V0_helper.nRefTrks());
1834 trk_py.reserve(V0_helper.nRefTrks());
1835 trk_pz.reserve(V0_helper.nRefTrks());
1836 for(auto&& vec3 : V0_helper.refTrks()) {
1837 trk_px.push_back( vec3.Px() );
1838 trk_py.push_back( vec3.Py() );
1839 trk_pz.push_back( vec3.Pz() );
1840 }
1841 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1842 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1843 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1844
1845 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1846 }
1847 }
1848 }
1849 }
1851 std::vector<const xAOD::TrackParticle*> tracksPlus;
1852 std::vector<const xAOD::TrackParticle*> tracksMinus;
1855 if( tpExtra->pt() < minTrkPt ) continue;
1857
1858 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1859 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1860 if(tpExtra->charge()>0) {
1861 tracksPlus.push_back(tpExtra);
1862 }
1863 else {
1864 tracksMinus.push_back(tpExtra);
1865 }
1866 }
1867
1869 TLorentzVector p4_ExtraTrk1, p4_ExtraTrk2, p4_ExtraTrk3;
1870
1873 for(auto tp2Itr=tracksMinus.cbegin(); tp2Itr!=tracksMinus.cend(); ++tp2Itr) {
1875 for(auto tp3Itr=tp2Itr+1; tp3Itr!=tracksMinus.cend(); ++tp3Itr) {
1882 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M();
1888 if(
m_massDpm>0) main_mass += - (p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M() +
m_massDpm;
1889 }
1890 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1892 if(Dpm.extraTrack1) DpmCandidates.push_back(Dpm);
1893 }
1894 }
1895 }
1896 }
1897
1900 for(auto tp2Itr=tracksPlus.cbegin(); tp2Itr!=tracksPlus.cend(); ++tp2Itr) {
1902 for(auto tp3Itr=tp2Itr+1; tp3Itr!=tracksPlus.cend(); ++tp3Itr) {
1909 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M();
1915 if(
m_massDpm>0) main_mass += - (p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M() +
m_massDpm;
1916 }
1917 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1919 if(Dpm.extraTrack1) DpmCandidates.push_back(Dpm);
1920 }
1921 }
1922 }
1923 }
1924
1926
1927 for(auto&& Dpm : DpmCandidates.vector()) {
1928 std::vector<const xAOD::TrackParticle*> tracksExtra{Dpm.extraTrack1,Dpm.extraTrack2,Dpm.extraTrack3};
1929
1930
1931 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState();
1932
1933 int robustness = 0;
1935
1936
1937 std::vector<Trk::VertexID> vrtList;
1938 std::vector<Trk::VertexID> vrtList2;
1939
1941
1945 } else {
1947 }
1948 vrtList.push_back(vID1);
1949
1953 } else {
1955 }
1956 vrtList2.push_back(vID2);
1960 } else {
1962 }
1963 vrtList2.push_back(vID3);
1964
1965 std::vector<const xAOD::TrackParticle*>
tp;
1966 std::vector<double> tp_masses;
1969 } else {
1971 }
1973 std::vector<Trk::VertexID> cnstV;
1976 }
1977 }
1979 std::vector<Trk::VertexID> cnstV;
1982 }
1983 }
1985 std::vector<Trk::VertexID> cnstV;
1988 }
1989 }
1990 }
1991 else {
1992
1996 } else {
1998 }
1999 vrtList.push_back(vID1);
2000
2004 } else {
2006 }
2007 vrtList.push_back(vID2);
2008
2012 } else {
2014 }
2016 std::vector<Trk::VertexID> cnstV;
2019 }
2020 }
2022 std::vector<Trk::VertexID> cnstV;
2025 }
2026 }
2028 std::vector<Trk::VertexID> cnstV;
2031 }
2032 }
2033 }
2034
2035 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) );
2036
2037 if (fit_result) {
2038 for(auto& v : fit_result->vertices()) {
2039 if(
v->nTrackParticles()==0) {
2040 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
2041 v->setTrackParticleLinks(nullLinkVector);
2042 }
2043 }
2044
2046
2047
2048 fit_result->setSVOwnership(true);
2049
2050
2051 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
2053 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
2054 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
2055 size_t iMoth = cascadeVertices.size()-1;
2056 double lxy_SV1(0), lxy_SV2(0);
2058 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
2059 lxy_SV2 =
m_CascadeTools->lxy(moms[2],cascadeVertices[2],cascadeVertices[iMoth]);
2060 }
2061 else {
2062 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
2063 lxy_SV2 =
m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[iMoth]);
2064 }
2066 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
2067 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
2069 type_V1_decor(*cascadeVertices[0]) = "Lambda";
2070 }
2072 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
2073 }
2075 type_V1_decor(*cascadeVertices[0]) = "Ks";
2076 }
2077 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
2078 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
2079 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
2080 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
2081 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
2082 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
2083 trk_px.clear(); trk_py.clear(); trk_pz.clear();
2084 trk_px.reserve(V0_helper.nRefTrks());
2085 trk_py.reserve(V0_helper.nRefTrks());
2086 trk_pz.reserve(V0_helper.nRefTrks());
2087 for(auto&& vec3 : V0_helper.refTrks()) {
2088 trk_px.push_back( vec3.Px() );
2089 trk_py.push_back( vec3.Py() );
2090 trk_pz.push_back( vec3.Pz() );
2091 }
2092 trk_pxDeco(*cascadeVertices[0]) = trk_px;
2093 trk_pyDeco(*cascadeVertices[0]) = trk_py;
2094 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
2095
2096
2098 TLorentzVector totalMom;
2099 for(
size_t it=0;
it<moms[iMoth].size();
it++) totalMom += moms[iMoth][it];
2100 double mainV_mass = totalMom.M();
2102 std::unique_ptr<Trk::IVKalState> state_mvc =
m_iVertexFitter->makeState();
2103 int robustness_mvc = 0;
2105 std::vector<Trk::VertexID> vrtList_mvc;
2106 std::vector<Trk::VertexID> vrtList2_mvc;
2111 } else {
2112 vID1_mvc =
m_iVertexFitter->startVertex(tracksV0,massesV0,*state_mvc);
2113 }
2114 vrtList_mvc.push_back(vID1_mvc);
2118 } else {
2119 vID2_mvc =
m_iVertexFitter->nextVertex(tracksJX,massesJX,vrtList_mvc,*state_mvc);
2120 }
2121 vrtList2_mvc.push_back(vID2_mvc);
2125 } else {
2126 vID3_mvc =
m_iVertexFitter->nextVertex(tracksExtra,massesExtra,*state_mvc);
2127 }
2128 vrtList2_mvc.push_back(vID3_mvc);
2129 std::vector<const xAOD::TrackParticle*>
tp;
2130 std::vector<double> tp_masses;
2133 std::vector<Trk::VertexID> cnstV_mvc;
2136 }
2137 }
2139 std::vector<Trk::VertexID> cnstV_mvc;
2142 }
2143 }
2145 std::vector<Trk::VertexID> cnstV_mvc;
2148 }
2149 }
2150 }
2151 else {
2155 } else {
2156 vID1_mvc =
m_iVertexFitter->startVertex(tracksV0,massesV0,*state_mvc);
2157 }
2158 vrtList_mvc.push_back(vID1_mvc);
2162 } else {
2163 vID2_mvc =
m_iVertexFitter->nextVertex(tracksExtra,massesExtra,*state_mvc);
2164 }
2165 vrtList_mvc.push_back(vID2_mvc);
2168 std::vector<Trk::VertexID> cnstV_mvc;
2171 }
2172 }
2174 std::vector<Trk::VertexID> cnstV_mvc;
2177 }
2178 }
2180 std::vector<Trk::VertexID> cnstV_mvc;
2183 }
2184 }
2185 }
2186
2187 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) );
2188
2189 if (fit_result_mvc) {
2190 for(auto& v : fit_result_mvc->vertices()) {
2191 if(
v->nTrackParticles()==0) {
2192 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
2193 v->setTrackParticleLinks(nullLinkVector);
2194 }
2195 }
2197 fit_result_mvc->setSVOwnership(true);
2198 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
2199 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
2201 type_V1_decor(*cascadeVertices[0]) = "Lambda";
2202 }
2204 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
2205 }
2207 type_V1_decor(*cascadeVertices[0]) = "Ks";
2208 }
2209 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
2210 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
2211 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
2212 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
2213 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
2214 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
2215 trk_px.clear(); trk_py.clear(); trk_pz.clear();
2216 trk_px.reserve(V0_helper.nRefTrks());
2217 trk_py.reserve(V0_helper.nRefTrks());
2218 trk_pz.reserve(V0_helper.nRefTrks());
2219 for(auto&& vec3 : V0_helper.refTrks()) {
2220 trk_px.push_back( vec3.Px() );
2221 trk_py.push_back( vec3.Py() );
2222 trk_pz.push_back( vec3.Pz() );
2223 }
2224 trk_pxDeco(*cascadeVertices[0]) = trk_px;
2225 trk_pyDeco(*cascadeVertices[0]) = trk_py;
2226 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
2227
2228 result.push_back( std::make_pair(fit_result.release(),fit_result_mvc.release()) );
2229 }
2230 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2231 }
2232 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2233 }
2234 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
2235 }
2236 }
2237 }
2238 }
2239
2240 if(pv_xAOD) {
2241 for(auto cascade_info_pair : result) {
2242 if(cascade_info_pair.first && cascade_info_pair.first->getParticleMoms().size()>0) {
2243 size_t index = cascade_info_pair.first->getParticleMoms().size() - 1;
2244 const std::vector<TLorentzVector> &
mom = cascade_info_pair.first->getParticleMoms()[
index];
2247 xAOD::BPhysHypoHelper vtx(
m_hypoName, mainVertex);
2248 bool isInDefaultPVCont = false;
2250 if(pv_xAOD == pvVtx) { isInDefaultPVCont = true; break; }
2251 }
2252 if(isInDefaultPVCont) vtx.setPv( pv_xAOD, defaultPVContainer, pvtype );
2253 else vtx.setPv( pv_xAOD, pvContainer, pvtype );
2254 if(origPv_xAOD) vtx.setOrigPv( origPv_xAOD, defaultPVContainer, pvtype );
2255 vtx.setLxy (
m_CascadeTools->lxy (mom, vtx.vtx(), pv_xAOD), pvtype );
2256 vtx.setLxyErr (
m_CascadeTools->lxyError (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2257 vtx.setA0 (
m_CascadeTools->a0 (mom, vtx.vtx(), pv_xAOD), pvtype );
2258 vtx.setA0Err (
m_CascadeTools->a0Error (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2259 vtx.setA0xy (
m_CascadeTools->a0xy (mom, vtx.vtx(), pv_xAOD), pvtype );
2260 vtx.setA0xyErr(
m_CascadeTools->a0xyError(mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2261 vtx.setZ0 (
m_CascadeTools->a0z (mom, vtx.vtx(), pv_xAOD), pvtype );
2262 vtx.setZ0Err (
m_CascadeTools->a0zError (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2263 vtx.setRefitPVStatus( 0, pvtype );
2264
2269
2270 if(cascade_info_pair.second && cascade_info_pair.second->getParticleMoms().size()>0) {
2271 index = cascade_info_pair.second->getParticleMoms().size() - 1;
2272 const std::vector<TLorentzVector> &mom_mvc = cascade_info_pair.second->getParticleMoms()[
index];
2274 const xAOD::Vertex* mainVertex_mvc = cascade_info_pair.second->vertices()[
index];
2275 xAOD::BPhysHypoHelper vtx_mvc(
m_hypoName, mainVertex_mvc);
2276 if(isInDefaultPVCont) vtx_mvc.setPv( pv_xAOD, defaultPVContainer, pvtype );
2277 else vtx_mvc.setPv( pv_xAOD, pvContainer, pvtype );
2278 if(origPv_xAOD) vtx.setOrigPv( origPv_xAOD, defaultPVContainer, pvtype );
2279 vtx_mvc.setLxy (
m_CascadeTools->lxy (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2280 vtx_mvc.setLxyErr (
m_CascadeTools->lxyError (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2281 vtx_mvc.setA0 (
m_CascadeTools->a0 (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2282 vtx_mvc.setA0Err (
m_CascadeTools->a0Error (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2283 vtx_mvc.setA0xy (
m_CascadeTools->a0xy (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2284 vtx_mvc.setA0xyErr(
m_CascadeTools->a0xyError(mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2285 vtx_mvc.setZ0 (
m_CascadeTools->a0z (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2286 vtx_mvc.setZ0Err (
m_CascadeTools->a0zError (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2287 vtx_mvc.setRefitPVStatus( 0, pvtype );
2288
2293 }
2294 }
2295 }
2296 }
2297
2299 }
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.
1.14.0