235 assert(cascadeinfoContainer!=
nullptr);
244 if (pvContainer.cptr()->size()==0) {
245 ATH_MSG_WARNING(
"You have no primary vertices: " << pvContainer.cptr()->size());
246 return StatusCode::RECOVERABLE;
249 std::vector<double> massesJX;
254 std::vector<double> massesV0_ppi;
257 std::vector<double> massesV0_pip;
260 std::vector<double> massesV0_pipi;
269 std::vector<const xAOD::VertexContainer*> V0Containers;
270 std::array<SG::ReadHandle<xAOD::VertexContainer>, 10> V0Handles;
int ikey(0);
274 V0Containers.push_back(V0Handles[ikey].cptr());
301 std::vector<float> trk_px;
302 std::vector<float> trk_py;
303 std::vector<float> trk_pz;
304 std::vector<const xAOD::TrackParticle*> tracksV0;
307 std::vector<std::pair<const xAOD::Vertex*,V0Enum> > selectedV0Candidates_EXISTING;
308 std::vector<std::pair<xAOD::Vertex*,V0Enum> > selectedV0Candidates_CREATED;
309 for(
size_t ic=0;
ic<V0Containers.size();
ic++) {
317 if(flagAcc.isAvailable(*vtx) && flagAcc(*vtx)) {
328 double massSig_V0_Ks = std::abs(
m_V0Tools->invariantMass(vtx, massesV0_pipi)-
m_mass_Ks)/
m_V0Tools->invariantMassError(vtx, massesV0_pipi);
329 if(massSig_V0_Lambda1<=massSig_V0_Lambda2 && massSig_V0_Lambda1<=massSig_V0_Ks) {
331 massV0 =
m_V0Tools->invariantMass(vtx, massesV0_ppi);
333 else if(massSig_V0_Lambda2<=massSig_V0_Lambda1 && massSig_V0_Lambda2<=massSig_V0_Ks) {
335 massV0 =
m_V0Tools->invariantMass(vtx, massesV0_pip);
337 else if(massSig_V0_Ks<=massSig_V0_Lambda1 && massSig_V0_Ks<=massSig_V0_Lambda2) {
339 massV0 =
m_V0Tools->invariantMass(vtx, massesV0_pipi);
368 std::string type_V0Vtx;
369 if(mAcc_type.isAvailable(*vtx)) type_V0Vtx = mAcc_type(*vtx);
372 else if(type_V0Vtx ==
"Ks")
opt =
KS;
386 int gamma_fit = 0;
int gamma_ndof = 0;
387 double gamma_chisq = 999999., gamma_prob = -1., gamma_mass = -1., gamma_massErr = -1.;
388 if(mAcc_gfit.isAvailable(*vtx)) {
389 gamma_fit = mAcc_gfit.isAvailable(*vtx) ? mAcc_gfit(*vtx) : 0;
390 gamma_mass = mAcc_gmass.isAvailable(*vtx) ? mAcc_gmass(*vtx) : -1;
391 gamma_massErr = mAcc_gmasserr.isAvailable(*vtx) ? mAcc_gmasserr(*vtx) : -1;
392 gamma_chisq = mAcc_gchisq.isAvailable(*vtx) ? mAcc_gchisq(*vtx) : 999999;
393 gamma_ndof = mAcc_gndof.isAvailable(*vtx) ? mAcc_gndof(*vtx) : 0;
394 gamma_prob = mAcc_gprob.isAvailable(*vtx) ? mAcc_gprob(*vtx) : -1;
397 std::unique_ptr<xAOD::Vertex> gammaVtx = std::unique_ptr<xAOD::Vertex>(
m_iGammaFitter->fit(tracksV0, vtxPos) );
402 gamma_chisq =
m_V0Tools->chisq(gammaVtx.get());
403 gamma_ndof =
m_V0Tools->ndof(gammaVtx.get());
404 gamma_prob =
m_V0Tools->vertexProbability(gammaVtx.get());
410 trk_px.clear(); trk_py.clear(); trk_pz.clear();
421 std::unique_ptr<xAOD::Vertex> V0vtx;
423 std::vector<double> massesV0;
424 if(
opt ==
LAMBDA) massesV0 = massesV0_ppi;
426 else if(
opt ==
KS) massesV0 = massesV0_pipi;
431 V0vtx = std::unique_ptr<xAOD::Vertex>(
m_iV0Fitter->fit(tracksV0, vtxPos) );
438 V0_helper.setRefTrks();
450 mDec_gfit(*V0vtx.get()) = gamma_fit;
451 mDec_gmass(*V0vtx.get()) = gamma_mass;
452 mDec_gmasserr(*V0vtx.get()) = gamma_massErr;
453 mDec_gchisq(*V0vtx.get()) = gamma_chisq;
454 mDec_gndof(*V0vtx.get()) = gamma_ndof;
455 mDec_gprob(*V0vtx.get()) = gamma_prob;
456 if(
opt==
LAMBDA) mDec_type(*V0vtx.get()) =
"Lambda";
457 else if(
opt==
LAMBDABAR) mDec_type(*V0vtx.get()) =
"Lambdabar";
458 else if(
opt==
KS) mDec_type(*V0vtx.get()) =
"Ks";
460 trk_pxDeco(*V0vtx.get()) = trk_px;
461 trk_pyDeco(*V0vtx.get()) = trk_py;
462 trk_pzDeco(*V0vtx.get()) = trk_pz;
464 selectedV0Candidates_CREATED.push_back(std::pair<xAOD::Vertex*,V0Enum>{V0vtx.release(),
opt});
470 mDec_gfit(*vtx) = gamma_fit;
471 mDec_gmass(*vtx) = gamma_mass;
472 mDec_gmasserr(*vtx) = gamma_massErr;
473 mDec_gchisq(*vtx) = gamma_chisq;
474 mDec_gndof(*vtx) = gamma_ndof;
475 mDec_gprob(*vtx) = gamma_prob;
476 if(
opt==
LAMBDA) mDec_type(*vtx) =
"Lambda";
478 else if(
opt==
KS) mDec_type(*vtx) =
"Ks";
479 selectedV0Candidates_EXISTING.push_back(std::pair<const xAOD::Vertex*,V0Enum>{vtx,
opt});
483 if((
m_refitV0 && selectedV0Candidates_CREATED.size()==0) || (!
m_refitV0 && selectedV0Candidates_EXISTING.size()==0))
return StatusCode::SUCCESS;
485 std::vector<std::pair<const xAOD::Vertex*,V0Enum> > selectedV01Candidates_EXISTING;
486 std::vector<std::pair<const xAOD::Vertex*,V0Enum> > selectedV02Candidates_EXISTING;
487 std::vector<std::pair<xAOD::Vertex*,V0Enum> > selectedV01Candidates_CREATED;
488 std::vector<std::pair<xAOD::Vertex*,V0Enum> > selectedV02Candidates_CREATED;
491 for(
size_t j=0; j<selectedV0Candidates_CREATED.size(); j++) {
492 std::pair<xAOD::Vertex*,V0Enum> candidate = selectedV0Candidates_CREATED[j];
494 if(
m_V01Hypothesis ==
"Lambda") selectedV01Candidates_CREATED.push_back(candidate);
495 else if(
m_V02Hypothesis ==
"Lambda") selectedV02Candidates_CREATED.push_back(candidate);
497 else if(candidate.second==
KS) {
498 if(
m_V01Hypothesis ==
"Ks") selectedV01Candidates_CREATED.push_back(candidate);
499 else if(
m_V02Hypothesis ==
"Ks") selectedV02Candidates_CREATED.push_back(candidate);
503 std::sort( selectedV01Candidates_CREATED.begin(), selectedV01Candidates_CREATED.end(), [](std::pair<xAOD::Vertex*,V0Enum>
a, std::pair<xAOD::Vertex*,V0Enum>
b) { return a.first->chiSquared()/a.first->numberDoF() < b.first->chiSquared()/b.first->numberDoF(); } );
505 for(
auto it=selectedV01Candidates_CREATED.begin()+
m_maxV0Candidates;
it!=selectedV01Candidates_CREATED.end();
it++)
delete it->first;
506 selectedV01Candidates_CREATED.erase(selectedV01Candidates_CREATED.begin()+
m_maxV0Candidates, selectedV01Candidates_CREATED.end());
508 std::sort( selectedV02Candidates_CREATED.begin(), selectedV02Candidates_CREATED.end(), [](std::pair<xAOD::Vertex*,V0Enum>
a, std::pair<xAOD::Vertex*,V0Enum>
b) { return a.first->chiSquared()/a.first->numberDoF() < b.first->chiSquared()/b.first->numberDoF(); } );
510 for(
auto it=selectedV02Candidates_CREATED.begin()+
m_maxV0Candidates;
it!=selectedV02Candidates_CREATED.end();
it++)
delete it->first;
511 selectedV02Candidates_CREATED.erase(selectedV02Candidates_CREATED.begin()+
m_maxV0Candidates, selectedV02Candidates_CREATED.end());
514 if(V0OutputContainers.size()==2) {
515 for(
auto v0VItr=selectedV01Candidates_CREATED.begin(); v0VItr!=selectedV01Candidates_CREATED.end(); ++v0VItr) V0OutputContainers[0]->push_back(v0VItr->first);
516 for(
auto v0VItr=selectedV02Candidates_CREATED.begin(); v0VItr!=selectedV02Candidates_CREATED.end(); ++v0VItr) V0OutputContainers[1]->push_back(v0VItr->first);
520 for(
size_t j=0; j<selectedV0Candidates_EXISTING.size(); j++) {
521 std::pair<const xAOD::Vertex*,V0Enum> candidate = selectedV0Candidates_EXISTING[j];
523 if(
m_V01Hypothesis ==
"Lambda") selectedV01Candidates_EXISTING.push_back(candidate);
524 else if(
m_V02Hypothesis ==
"Lambda") selectedV02Candidates_EXISTING.push_back(candidate);
526 else if(candidate.second==
KS) {
527 if(
m_V01Hypothesis ==
"Ks") selectedV01Candidates_EXISTING.push_back(candidate);
528 else if(
m_V02Hypothesis ==
"Ks") selectedV02Candidates_EXISTING.push_back(candidate);
532 std::sort( selectedV01Candidates_EXISTING.begin(), selectedV01Candidates_EXISTING.end(), [](std::pair<const xAOD::Vertex*,V0Enum>
a, std::pair<const xAOD::Vertex*,V0Enum>
b) { return a.first->chiSquared()/a.first->numberDoF() < b.first->chiSquared()/b.first->numberDoF(); } );
534 selectedV01Candidates_EXISTING.erase(selectedV01Candidates_EXISTING.begin()+
m_maxV0Candidates, selectedV01Candidates_EXISTING.end());
536 std::sort( selectedV02Candidates_EXISTING.begin(), selectedV02Candidates_EXISTING.end(), [](std::pair<const xAOD::Vertex*,V0Enum>
a, std::pair<const xAOD::Vertex*,V0Enum>
b) { return a.first->chiSquared()/a.first->numberDoF() < b.first->chiSquared()/b.first->numberDoF(); } );
538 selectedV02Candidates_EXISTING.erase(selectedV02Candidates_EXISTING.begin()+
m_maxV0Candidates, selectedV02Candidates_EXISTING.end());
544 std::sort( selectedV0Candidates_CREATED.begin(), selectedV0Candidates_CREATED.end(), [](std::pair<xAOD::Vertex*,V0Enum>
a, std::pair<xAOD::Vertex*,V0Enum>
b) { return a.first->chiSquared()/a.first->numberDoF() < b.first->chiSquared()/b.first->numberDoF(); } );
546 for(
auto it=selectedV0Candidates_CREATED.begin()+
m_maxV0Candidates;
it!=selectedV0Candidates_CREATED.end();
it++)
delete it->first;
547 selectedV0Candidates_CREATED.erase(selectedV0Candidates_CREATED.begin()+
m_maxV0Candidates, selectedV0Candidates_CREATED.end());
550 if(V0OutputContainers.size()==1) {
551 for(
auto v0VItr=selectedV0Candidates_CREATED.begin(); v0VItr!=selectedV0Candidates_CREATED.end(); ++v0VItr) V0OutputContainers[0]->push_back(v0VItr->first);
555 std::sort( selectedV0Candidates_EXISTING.begin(), selectedV0Candidates_EXISTING.end(), [](std::pair<const xAOD::Vertex*,V0Enum>
a, std::pair<const xAOD::Vertex*,V0Enum>
b) { return a.first->chiSquared()/a.first->numberDoF() < b.first->chiSquared()/b.first->numberDoF(); } );
557 selectedV0Candidates_EXISTING.erase(selectedV0Candidates_EXISTING.begin()+
m_maxV0Candidates, selectedV0Candidates_EXISTING.end());
563 std::vector<const xAOD::Vertex*> selectedJXCandidates;
564 for(
auto vxcItr=jxContainer.ptr()->begin(); vxcItr!=jxContainer.ptr()->end(); ++vxcItr) {
570 if(flagAcc.isAvailable(*vtx) && flagAcc(*vtx)) {
578 double mass_jx =
m_V0Tools->invariantMass(*vxcItr,massesJX);
579 if(mass_jx < m_jxMassLower || mass_jx >
m_jxMassUpper)
continue;
583 TLorentzVector p4_mu1, p4_mu2;
590 double mass_jpsi = (p4_mu1 + p4_mu2).M();
591 if (mass_jpsi < m_jpsiMassLower || mass_jpsi >
m_jpsiMassUpper)
continue;
594 TLorentzVector p4_trk1, p4_trk2;
601 double mass_diTrk = (p4_trk1 + p4_trk2).M();
608 selectedJXCandidates.push_back(vtx);
611 if(selectedJXCandidates.size()==0) {
612 if(V0OutputContainers.size()==0) {
614 for(
auto v0VItr=selectedV01Candidates_CREATED.begin(); v0VItr!=selectedV01Candidates_CREATED.end(); ++v0VItr)
delete v0VItr->first;
615 for(
auto v0VItr=selectedV02Candidates_CREATED.begin(); v0VItr!=selectedV02Candidates_CREATED.end(); ++v0VItr)
delete v0VItr->first;
617 for(
auto v0VItr=selectedV0Candidates_CREATED.begin(); v0VItr!=selectedV0Candidates_CREATED.end(); ++v0VItr)
delete v0VItr->first;
620 return StatusCode::SUCCESS;
623 std::sort( selectedJXCandidates.begin(), selectedJXCandidates.end(), [](
const xAOD::Vertex*
a,
const xAOD::Vertex*
b) { return a->chiSquared()/a->numberDoF() < b->chiSquared()/b->numberDoF(); } );
625 selectedJXCandidates.erase(selectedJXCandidates.begin()+
m_maxJXCandidates, selectedJXCandidates.end());
630 for(
auto jxItr=selectedJXCandidates.cbegin(); jxItr!=selectedJXCandidates.cend(); ++jxItr) {
634 for(
auto V0Itr1=selectedV0Candidates_CREATED.begin(); V0Itr1!=selectedV0Candidates_CREATED.end(); ++V0Itr1) {
635 for(
auto V0Itr2=V0Itr1+1; V0Itr2!=selectedV0Candidates_CREATED.end(); ++V0Itr2) {
642 for(
auto V0Itr1=selectedV0Candidates_EXISTING.begin(); V0Itr1!=selectedV0Candidates_EXISTING.end(); ++V0Itr1) {
643 for(
auto V0Itr2=V0Itr1+1; V0Itr2!=selectedV0Candidates_EXISTING.end(); ++V0Itr2) {
652 for(
auto V0Itr1=selectedV01Candidates_CREATED.begin(); V0Itr1!=selectedV01Candidates_CREATED.end(); ++V0Itr1) {
653 for(
auto V0Itr2=selectedV02Candidates_CREATED.begin(); V0Itr2!=selectedV02Candidates_CREATED.end(); ++V0Itr2) {
660 for(
auto V0Itr1=selectedV01Candidates_EXISTING.begin(); V0Itr1!=selectedV01Candidates_EXISTING.end(); ++V0Itr1) {
661 for(
auto V0Itr2=selectedV02Candidates_EXISTING.begin(); V0Itr2!=selectedV02Candidates_EXISTING.end(); ++V0Itr2) {
671 if(V0OutputContainers.size()==0) {
673 for(
auto v0VItr=selectedV01Candidates_CREATED.begin(); v0VItr!=selectedV01Candidates_CREATED.end(); ++v0VItr)
delete v0VItr->first;
674 for(
auto v0VItr=selectedV02Candidates_CREATED.begin(); v0VItr!=selectedV02Candidates_CREATED.end(); ++v0VItr)
delete v0VItr->first;
676 for(
auto v0VItr=selectedV0Candidates_CREATED.begin(); v0VItr!=selectedV0Candidates_CREATED.end(); ++v0VItr)
delete v0VItr->first;
680 return StatusCode::SUCCESS;
1.8.18