1312 {
1313 std::vector<std::pair<Trk::VxCascadeInfo*,Trk::VxCascadeInfo*> >
result;
1314
1315 std::vector<const xAOD::TrackParticle*> tracksJX;
1318 if (tracksJX.size() != massesJX.size()) {
1319 ATH_MSG_ERROR(
"Problems with JX input: number of tracks or track mass inputs is not correct!");
1321 }
1322
1323 if(std::find(tracksJX.cbegin(), tracksJX.cend(), V0vtx->
trackParticle(0)) != tracksJX.cend())
return result;
1324 if(std::find(tracksJX.cbegin(), tracksJX.cend(), V0vtx->
trackParticle(1)) != tracksJX.cend())
return result;
1325 std::vector<const xAOD::TrackParticle*> tracksV0;
1328
1329 std::vector<const xAOD::TrackParticle*> tracksJpsi{tracksJX[0], tracksJX[1]};
1330 std::vector<const xAOD::TrackParticle*> tracksX;
1333
1334 std::vector<double> massesV0;
1337 }
1340 }
1343 }
1344
1345 TLorentzVector p4_moth, p4_v0,
tmp;
1349 }
1350 xAOD::BPhysHelper V0_helper(V0vtx);
1351 for(
int it=0;
it<V0_helper.nRefTrks();
it++) {
1352 p4_moth += V0_helper.refTrk(it,massesV0[it]);
1353 p4_v0 += V0_helper.refTrk(it,massesV0[it]);
1354 }
1355
1361 xAOD::BPhysHelper JX_helper(JXvtx);
1364 std::unique_ptr<Trk::RecVertex> pv_AOD;
1365 if(pv_xAOD) pv_AOD = std::make_unique<Trk::RecVertex>(pv_xAOD->
position(),pv_xAOD->covariancePosition(),pv_xAOD->
numberDoF(),pv_xAOD->
chiSquared());
1366
1367 SG::AuxElement::Decorator<float> chi2_V1_decor("ChiSquared_V1");
1368 SG::AuxElement::Decorator<int> ndof_V1_decor("nDoF_V1");
1369 SG::AuxElement::Decorator<std::string> type_V1_decor("Type_V1");
1370
1371 SG::AuxElement::Accessor<int> mAcc_gfit("gamma_fit");
1372 SG::AuxElement::Accessor<float> mAcc_gmass("gamma_mass");
1373 SG::AuxElement::Accessor<float> mAcc_gmasserr("gamma_massError");
1374 SG::AuxElement::Accessor<float> mAcc_gchisq("gamma_chisq");
1375 SG::AuxElement::Accessor<int> mAcc_gndof("gamma_ndof");
1376 SG::AuxElement::Accessor<float> mAcc_gprob("gamma_probability");
1377
1378 SG::AuxElement::Decorator<int> mDec_gfit("gamma_fit");
1379 SG::AuxElement::Decorator<float> mDec_gmass("gamma_mass");
1380 SG::AuxElement::Decorator<float> mDec_gmasserr("gamma_massError");
1381 SG::AuxElement::Decorator<float> mDec_gchisq("gamma_chisq");
1382 SG::AuxElement::Decorator<int> mDec_gndof("gamma_ndof");
1383 SG::AuxElement::Decorator<float> mDec_gprob("gamma_probability");
1384 SG::AuxElement::Decorator< std::vector<float> > trk_pxDeco("TrackPx_V0nc");
1385 SG::AuxElement::Decorator< std::vector<float> > trk_pyDeco("TrackPy_V0nc");
1386 SG::AuxElement::Decorator< std::vector<float> > trk_pzDeco("TrackPz_V0nc");
1387
1388 std::vector<float> trk_px;
1389 std::vector<float> trk_py;
1390 std::vector<float> trk_pz;
1391
1393 double main_mass = p4_moth.M();
1399 }
1401
1402
1403 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState(ctx);
1404
1405 int robustness = 0;
1407
1408
1409 std::vector<Trk::VertexID> vrtList;
1410
1411
1415 } else {
1417 }
1418 vrtList.push_back(vID1);
1421
1424 } else {
1426 }
1427 vrtList.push_back(vID2);
1428
1429 std::vector<const xAOD::TrackParticle*> tp;
1430 std::vector<double> tp_masses;
1433 } else {
1435 }
1436 }
1437 else {
1438
1441 } else {
1443 }
1445 std::vector<Trk::VertexID> cnstV;
1448 }
1449 }
1450 }
1452 std::vector<Trk::VertexID> cnstV;
1455 }
1456 }
1458 std::vector<Trk::VertexID> cnstV;
1461 }
1462 }
1463
1464 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) );
1465
1466 if (fit_result) {
1467 for(auto& v : fit_result->vertices()) {
1468 if(
v->nTrackParticles()==0) {
1469 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1470 v->setTrackParticleLinks(nullLinkVector);
1471 }
1472 }
1473
1475
1476
1477 fit_result->setSVOwnership(true);
1478
1479
1480 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1482
1483 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1484 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1485 size_t iMoth = cascadeVertices.size()-1;
1486 double lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1488 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1489 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1491 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1492 }
1494 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1495 }
1497 type_V1_decor(*cascadeVertices[0]) = "Ks";
1498 }
1499 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1500 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1501 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1502 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1503 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1504 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1505 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1506 trk_px.reserve(V0_helper.nRefTrks());
1507 trk_py.reserve(V0_helper.nRefTrks());
1508 trk_pz.reserve(V0_helper.nRefTrks());
1509 for(auto&& vec3 : V0_helper.refTrks()) {
1510 trk_px.push_back( vec3.Px() );
1511 trk_py.push_back( vec3.Py() );
1512 trk_pz.push_back( vec3.Pz() );
1513 }
1514 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1515 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1516 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1517
1518 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1519 }
1520 }
1521 }
1524 std::vector<double> massesJXExtra = massesJX; massesJXExtra.push_back(
m_extraTrk1MassHypo);
1525
1529
1530 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1531 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1532
1535 double main_mass = (p4_moth+
tmp).M();
1541 }
1542 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1543
1544 std::vector<const xAOD::TrackParticle*> tracksExtra{tpExtra};
1545 std::vector<const xAOD::TrackParticle*> tracksJXExtra = tracksJX; tracksJXExtra.push_back(tpExtra);
1546
1547
1548 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState(ctx);
1549
1550 int robustness = 0;
1552
1553
1554 std::vector<Trk::VertexID> vrtList;
1555 std::vector<Trk::VertexID> vrtList2;
1558
1562 } else {
1564 }
1565 vrtList.push_back(vID1);
1566
1569 } else {
1571 }
1572 vrtList2.push_back(vID2);
1573
1576 } else {
1578 }
1579 }
1580 else {
1581
1585 } else {
1587 }
1588 vrtList.push_back(vID1);
1590
1592 vrtList.push_back(vID2);
1593
1596 } else {
1598 }
1599 }
1600 else {
1601
1604 } else {
1605 vID2 =
m_iVertexFitter->nextVertex(tracksJXExtra,massesJXExtra,vrtList,*state);
1606 }
1607 }
1608 }
1610 std::vector<Trk::VertexID> cnstV;
1613 }
1614 }
1616 std::vector<Trk::VertexID> cnstV;
1619 }
1620 }
1622 std::vector<Trk::VertexID> cnstV;
1625 }
1626 }
1627
1628 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) );
1629
1630 if (fit_result) {
1631 for(auto& v : fit_result->vertices()) {
1632 if(
v->nTrackParticles()==0) {
1633 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1634 v->setTrackParticleLinks(nullLinkVector);
1635 }
1636 }
1637
1639
1640
1641 fit_result->setSVOwnership(true);
1642
1643
1644 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1646 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1647 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1648 size_t iMoth = cascadeVertices.size()-1;
1649 double lxy_SV1(0);
1651 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
1652 }
1653 else {
1654 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1655 }
1657 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1658 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1660 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1661 }
1663 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1664 }
1666 type_V1_decor(*cascadeVertices[0]) = "Ks";
1667 }
1668 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1669 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1670 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1671 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1672 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1673 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1674 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1675 trk_px.reserve(V0_helper.nRefTrks());
1676 trk_py.reserve(V0_helper.nRefTrks());
1677 trk_pz.reserve(V0_helper.nRefTrks());
1678 for(auto&& vec3 : V0_helper.refTrks()) {
1679 trk_px.push_back( vec3.Px() );
1680 trk_py.push_back( vec3.Py() );
1681 trk_pz.push_back( vec3.Pz() );
1682 }
1683 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1684 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1685 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1686
1687 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1688 }
1689 }
1690 }
1691 }
1693 std::vector<const xAOD::TrackParticle*> tracksPlus;
1694 std::vector<const xAOD::TrackParticle*> tracksMinus;
1698
1699 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1700 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1701 if(tpExtra->charge()>0) {
1702 tracksPlus.push_back(tpExtra);
1703 }
1704 else {
1705 tracksMinus.push_back(tpExtra);
1706 }
1707 }
1708
1710 TLorentzVector p4_ExtraTrk1, p4_ExtraTrk2;
1717 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2).M();
1724 }
1725 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1727 if(
D0.extraTrack1) D0Candidates.push_back(
D0);
1728 }
1729 }
1730 }
1731
1733
1734 for(
auto&&
D0 : D0Candidates.vector()) {
1735 std::vector<const xAOD::TrackParticle*> tracksExtra{
D0.extraTrack1,
D0.extraTrack2};
1736
1737
1738 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState(ctx);
1739
1740 int robustness = 0;
1742
1743
1744 std::vector<Trk::VertexID> vrtList;
1745
1746
1750 } else {
1752 }
1753 vrtList.push_back(vID1);
1754
1758 } else {
1760 }
1761 vrtList.push_back(vID2);
1762
1766 } else {
1768 }
1770 std::vector<Trk::VertexID> cnstV;
1773 }
1774 }
1776 std::vector<Trk::VertexID> cnstV;
1779 }
1780 }
1782 std::vector<Trk::VertexID> cnstV;
1785 }
1786 }
1787
1788 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) );
1789
1790 if (fit_result) {
1791 for(auto& v : fit_result->vertices()) {
1792 if(
v->nTrackParticles()==0) {
1793 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
1794 v->setTrackParticleLinks(nullLinkVector);
1795 }
1796 }
1797
1799
1800
1801 fit_result->setSVOwnership(true);
1802
1803
1804 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
1806 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
1807 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
1808 size_t iMoth = cascadeVertices.size()-1;
1809 double lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
1810 double lxy_SV2 =
m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[iMoth]);
1812 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
1813 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
1815 type_V1_decor(*cascadeVertices[0]) = "Lambda";
1816 }
1818 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
1819 }
1821 type_V1_decor(*cascadeVertices[0]) = "Ks";
1822 }
1823 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
1824 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
1825 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
1826 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
1827 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
1828 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
1829 trk_px.clear(); trk_py.clear(); trk_pz.clear();
1830 trk_px.reserve(V0_helper.nRefTrks());
1831 trk_py.reserve(V0_helper.nRefTrks());
1832 trk_pz.reserve(V0_helper.nRefTrks());
1833 for(auto&& vec3 : V0_helper.refTrks()) {
1834 trk_px.push_back( vec3.Px() );
1835 trk_py.push_back( vec3.Py() );
1836 trk_pz.push_back( vec3.Pz() );
1837 }
1838 trk_pxDeco(*cascadeVertices[0]) = trk_px;
1839 trk_pyDeco(*cascadeVertices[0]) = trk_py;
1840 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
1841
1842 result.push_back( std::make_pair(fit_result.release(),
nullptr) );
1843 }
1844 }
1845 }
1846 }
1848 std::vector<const xAOD::TrackParticle*> tracksPlus;
1849 std::vector<const xAOD::TrackParticle*> tracksMinus;
1852 if( tpExtra->pt() < minTrkPt ) continue;
1854
1855 if(std::find(tracksJX.cbegin(),tracksJX.cend(),tpExtra) != tracksJX.cend()) continue;
1856 if(std::find(tracksV0.cbegin(),tracksV0.cend(),tpExtra) != tracksV0.cend()) continue;
1857 if(tpExtra->charge()>0) {
1858 tracksPlus.push_back(tpExtra);
1859 }
1860 else {
1861 tracksMinus.push_back(tpExtra);
1862 }
1863 }
1864
1866 TLorentzVector p4_ExtraTrk1, p4_ExtraTrk2, p4_ExtraTrk3;
1867
1870 for(auto tp2Itr=tracksMinus.cbegin(); tp2Itr!=tracksMinus.cend(); ++tp2Itr) {
1872 for(auto tp3Itr=tp2Itr+1; tp3Itr!=tracksMinus.cend(); ++tp3Itr) {
1879 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M();
1885 if(
m_massDpm>0) main_mass += - (p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M() +
m_massDpm;
1886 }
1887 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1889 if(Dpm.extraTrack1) DpmCandidates.push_back(Dpm);
1890 }
1891 }
1892 }
1893 }
1894
1897 for(auto tp2Itr=tracksPlus.cbegin(); tp2Itr!=tracksPlus.cend(); ++tp2Itr) {
1899 for(auto tp3Itr=tp2Itr+1; tp3Itr!=tracksPlus.cend(); ++tp3Itr) {
1906 double main_mass = (p4_moth+p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M();
1912 if(
m_massDpm>0) main_mass += - (p4_ExtraTrk1+p4_ExtraTrk2+p4_ExtraTrk3).M() +
m_massDpm;
1913 }
1914 if(main_mass < m_MassLower || main_mass >
m_MassUpper)
continue;
1916 if(Dpm.extraTrack1) DpmCandidates.push_back(Dpm);
1917 }
1918 }
1919 }
1920 }
1921
1923
1924 for(auto&& Dpm : DpmCandidates.vector()) {
1925 std::vector<const xAOD::TrackParticle*> tracksExtra{Dpm.extraTrack1,Dpm.extraTrack2,Dpm.extraTrack3};
1926
1927
1928 std::unique_ptr<Trk::IVKalState> state =
m_iVertexFitter->makeState(ctx);
1929
1930 int robustness = 0;
1932
1933
1934 std::vector<Trk::VertexID> vrtList;
1935 std::vector<Trk::VertexID> vrtList2;
1936
1938
1942 } else {
1944 }
1945 vrtList.push_back(vID1);
1946
1950 } else {
1952 }
1953 vrtList2.push_back(vID2);
1957 } else {
1959 }
1960 vrtList2.push_back(vID3);
1961
1962 std::vector<const xAOD::TrackParticle*> tp;
1963 std::vector<double> tp_masses;
1966 } else {
1968 }
1970 std::vector<Trk::VertexID> cnstV;
1973 }
1974 }
1976 std::vector<Trk::VertexID> cnstV;
1979 }
1980 }
1982 std::vector<Trk::VertexID> cnstV;
1985 }
1986 }
1987 }
1988 else {
1989
1993 } else {
1995 }
1996 vrtList.push_back(vID1);
1997
2001 } else {
2003 }
2004 vrtList.push_back(vID2);
2005
2009 } else {
2011 }
2013 std::vector<Trk::VertexID> cnstV;
2016 }
2017 }
2019 std::vector<Trk::VertexID> cnstV;
2022 }
2023 }
2025 std::vector<Trk::VertexID> cnstV;
2028 }
2029 }
2030 }
2031
2032 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) );
2033
2034 if (fit_result) {
2035 for(auto& v : fit_result->vertices()) {
2036 if(
v->nTrackParticles()==0) {
2037 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
2038 v->setTrackParticleLinks(nullLinkVector);
2039 }
2040 }
2041
2043
2044
2045 fit_result->setSVOwnership(true);
2046
2047
2048 double chi2DOF = fit_result->fitChi2()/fit_result->nDoF();
2050 const std::vector<std::vector<TLorentzVector> > &moms = fit_result->getParticleMoms();
2051 const std::vector<xAOD::Vertex*> &cascadeVertices = fit_result->vertices();
2052 size_t iMoth = cascadeVertices.size()-1;
2053 double lxy_SV1(0), lxy_SV2(0);
2055 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
2056 lxy_SV2 =
m_CascadeTools->lxy(moms[2],cascadeVertices[2],cascadeVertices[iMoth]);
2057 }
2058 else {
2059 lxy_SV1 =
m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[iMoth]);
2060 lxy_SV2 =
m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[iMoth]);
2061 }
2063 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
2064 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
2066 type_V1_decor(*cascadeVertices[0]) = "Lambda";
2067 }
2069 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
2070 }
2072 type_V1_decor(*cascadeVertices[0]) = "Ks";
2073 }
2074 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
2075 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
2076 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
2077 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
2078 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
2079 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
2080 trk_px.clear(); trk_py.clear(); trk_pz.clear();
2081 trk_px.reserve(V0_helper.nRefTrks());
2082 trk_py.reserve(V0_helper.nRefTrks());
2083 trk_pz.reserve(V0_helper.nRefTrks());
2084 for(auto&& vec3 : V0_helper.refTrks()) {
2085 trk_px.push_back( vec3.Px() );
2086 trk_py.push_back( vec3.Py() );
2087 trk_pz.push_back( vec3.Pz() );
2088 }
2089 trk_pxDeco(*cascadeVertices[0]) = trk_px;
2090 trk_pyDeco(*cascadeVertices[0]) = trk_py;
2091 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
2092
2093
2095 TLorentzVector totalMom;
2096 for(
size_t it=0;
it<moms[iMoth].size();
it++) totalMom += moms[iMoth][it];
2097 double mainV_mass = totalMom.M();
2099 std::unique_ptr<Trk::IVKalState> state_mvc =
m_iVertexFitter->makeState(ctx);
2100 int robustness_mvc = 0;
2102 std::vector<Trk::VertexID> vrtList_mvc;
2103 std::vector<Trk::VertexID> vrtList2_mvc;
2108 } else {
2109 vID1_mvc =
m_iVertexFitter->startVertex(tracksV0,massesV0,*state_mvc);
2110 }
2111 vrtList_mvc.push_back(vID1_mvc);
2115 } else {
2116 vID2_mvc =
m_iVertexFitter->nextVertex(tracksJX,massesJX,vrtList_mvc,*state_mvc);
2117 }
2118 vrtList2_mvc.push_back(vID2_mvc);
2122 } else {
2123 vID3_mvc =
m_iVertexFitter->nextVertex(tracksExtra,massesExtra,*state_mvc);
2124 }
2125 vrtList2_mvc.push_back(vID3_mvc);
2126 std::vector<const xAOD::TrackParticle*> tp;
2127 std::vector<double> tp_masses;
2130 std::vector<Trk::VertexID> cnstV_mvc;
2133 }
2134 }
2136 std::vector<Trk::VertexID> cnstV_mvc;
2139 }
2140 }
2142 std::vector<Trk::VertexID> cnstV_mvc;
2145 }
2146 }
2147 }
2148 else {
2152 } else {
2153 vID1_mvc =
m_iVertexFitter->startVertex(tracksV0,massesV0,*state_mvc);
2154 }
2155 vrtList_mvc.push_back(vID1_mvc);
2159 } else {
2160 vID2_mvc =
m_iVertexFitter->nextVertex(tracksExtra,massesExtra,*state_mvc);
2161 }
2162 vrtList_mvc.push_back(vID2_mvc);
2165 std::vector<Trk::VertexID> cnstV_mvc;
2168 }
2169 }
2171 std::vector<Trk::VertexID> cnstV_mvc;
2174 }
2175 }
2177 std::vector<Trk::VertexID> cnstV_mvc;
2180 }
2181 }
2182 }
2183
2184 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) );
2185
2186 if (fit_result_mvc) {
2187 for(auto& v : fit_result_mvc->vertices()) {
2188 if(
v->nTrackParticles()==0) {
2189 std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
2190 v->setTrackParticleLinks(nullLinkVector);
2191 }
2192 }
2194 fit_result_mvc->setSVOwnership(true);
2195 chi2_V1_decor(*cascadeVertices[0]) = V0vtx->
chiSquared();
2196 ndof_V1_decor(*cascadeVertices[0]) = V0vtx->
numberDoF();
2198 type_V1_decor(*cascadeVertices[0]) = "Lambda";
2199 }
2201 type_V1_decor(*cascadeVertices[0]) = "Lambdabar";
2202 }
2204 type_V1_decor(*cascadeVertices[0]) = "Ks";
2205 }
2206 mDec_gfit(*cascadeVertices[0]) = mAcc_gfit.isAvailable(*V0vtx) ? mAcc_gfit(*V0vtx) : 0;
2207 mDec_gmass(*cascadeVertices[0]) = mAcc_gmass.isAvailable(*V0vtx) ? mAcc_gmass(*V0vtx) : -1;
2208 mDec_gmasserr(*cascadeVertices[0]) = mAcc_gmasserr.isAvailable(*V0vtx) ? mAcc_gmasserr(*V0vtx) : -1;
2209 mDec_gchisq(*cascadeVertices[0]) = mAcc_gchisq.isAvailable(*V0vtx) ? mAcc_gchisq(*V0vtx) : 999999;
2210 mDec_gndof(*cascadeVertices[0]) = mAcc_gndof.isAvailable(*V0vtx) ? mAcc_gndof(*V0vtx) : 0;
2211 mDec_gprob(*cascadeVertices[0]) = mAcc_gprob.isAvailable(*V0vtx) ? mAcc_gprob(*V0vtx) : -1;
2212 trk_px.clear(); trk_py.clear(); trk_pz.clear();
2213 trk_px.reserve(V0_helper.nRefTrks());
2214 trk_py.reserve(V0_helper.nRefTrks());
2215 trk_pz.reserve(V0_helper.nRefTrks());
2216 for(auto&& vec3 : V0_helper.refTrks()) {
2217 trk_px.push_back( vec3.Px() );
2218 trk_py.push_back( vec3.Py() );
2219 trk_pz.push_back( vec3.Pz() );
2220 }
2221 trk_pxDeco(*cascadeVertices[0]) = trk_px;
2222 trk_pyDeco(*cascadeVertices[0]) = trk_py;
2223 trk_pzDeco(*cascadeVertices[0]) = trk_pz;
2224
2225 result.push_back( std::make_pair(fit_result.release(),fit_result_mvc.release()) );
2226 }
2227 else result.push_back( std::make_pair(fit_result.release(),
nullptr) );
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 }
2234 }
2235 }
2236
2237 if(pv_xAOD) {
2238 for(auto cascade_info_pair : result) {
2239 if(cascade_info_pair.first && cascade_info_pair.first->getParticleMoms().size()>0) {
2240 size_t index = cascade_info_pair.first->getParticleMoms().size() - 1;
2241 const std::vector<TLorentzVector> &
mom = cascade_info_pair.first->getParticleMoms()[
index];
2244 xAOD::BPhysHypoHelper vtx(
m_hypoName, mainVertex);
2245 bool isInDefaultPVCont = false;
2247 if(pv_xAOD == pvVtx) { isInDefaultPVCont = true; break; }
2248 }
2249 if(isInDefaultPVCont) vtx.setPv( pv_xAOD, defaultPVContainer, pvtype );
2250 else vtx.setPv( pv_xAOD, pvContainer, pvtype );
2251 if(origPv_xAOD) vtx.setOrigPv( origPv_xAOD, defaultPVContainer, pvtype );
2252 vtx.setLxy (
m_CascadeTools->lxy (mom, vtx.vtx(), pv_xAOD), pvtype );
2253 vtx.setLxyErr (
m_CascadeTools->lxyError (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2254 vtx.setA0 (
m_CascadeTools->a0 (mom, vtx.vtx(), pv_xAOD), pvtype );
2255 vtx.setA0Err (
m_CascadeTools->a0Error (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2256 vtx.setA0xy (
m_CascadeTools->a0xy (mom, vtx.vtx(), pv_xAOD), pvtype );
2257 vtx.setA0xyErr(
m_CascadeTools->a0xyError(mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2258 vtx.setZ0 (
m_CascadeTools->a0z (mom, vtx.vtx(), pv_xAOD), pvtype );
2259 vtx.setZ0Err (
m_CascadeTools->a0zError (mom, cov, vtx.vtx(), pv_xAOD), pvtype );
2260 vtx.setRefitPVStatus( 0, pvtype );
2261
2266
2267 if(cascade_info_pair.second && cascade_info_pair.second->getParticleMoms().size()>0) {
2268 index = cascade_info_pair.second->getParticleMoms().size() - 1;
2269 const std::vector<TLorentzVector> &mom_mvc = cascade_info_pair.second->getParticleMoms()[
index];
2271 const xAOD::Vertex* mainVertex_mvc = cascade_info_pair.second->vertices()[
index];
2272 xAOD::BPhysHypoHelper vtx_mvc(
m_hypoName, mainVertex_mvc);
2273 if(isInDefaultPVCont) vtx_mvc.setPv( pv_xAOD, defaultPVContainer, pvtype );
2274 else vtx_mvc.setPv( pv_xAOD, pvContainer, pvtype );
2275 if(origPv_xAOD) vtx.setOrigPv( origPv_xAOD, defaultPVContainer, pvtype );
2276 vtx_mvc.setLxy (
m_CascadeTools->lxy (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2277 vtx_mvc.setLxyErr (
m_CascadeTools->lxyError (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2278 vtx_mvc.setA0 (
m_CascadeTools->a0 (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2279 vtx_mvc.setA0Err (
m_CascadeTools->a0Error (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2280 vtx_mvc.setA0xy (
m_CascadeTools->a0xy (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2281 vtx_mvc.setA0xyErr(
m_CascadeTools->a0xyError(mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2282 vtx_mvc.setZ0 (
m_CascadeTools->a0z (mom_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2283 vtx_mvc.setZ0Err (
m_CascadeTools->a0zError (mom_mvc, cov_mvc, vtx_mvc.vtx(), pv_xAOD), pvtype );
2284 vtx_mvc.setRefitPVStatus( 0, pvtype );
2285
2290 }
2291 }
2292 }
2293 }
2294
2296 }
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