260 const std::vector<Track*>& all_tracks,
265 std::vector<Track> electrons, positrons;
266 std::vector<Track> all_good_tracks;
273 electrons.push_back(ele_trk);
278 positrons.push_back(pos_trk);
283 std::set<int> included_track_ids;
284 if (ele_trk.
getID() >= 0) included_track_ids.insert(ele_trk.
getID());
285 if (pos_trk.
getID() >= 0) included_track_ids.insert(pos_trk.
getID());
288 for (
auto* trk : all_tracks) {
290 if (trk->getID() >= 0 && included_track_ids.count(trk->getID()) > 0) {
298 all_good_tracks.push_back(*trk);
301 if (trk->getCharge() < 0) {
302 electrons.push_back(*trk);
303 }
else if (trk->getCharge() > 0) {
304 positrons.push_back(*trk);
310 bus_.set(
"all_preselected_tracks", all_good_tracks);
314 double min_dTanLambda = 9999.0, max_dTanLambda = -9999.0;
315 double min_opening = 9999.0, max_opening = -9999.0;
316 double min_mass = 9999.0, max_mass = -9999.0;
317 double min_asym = 9999.0, max_asym = -9999.0;
318 double min_dPhi = 9999.0, max_dPhi = -9999.0;
320 const double me = 0.000511;
323 for (
auto& ele_track : electrons) {
324 const std::vector<double>& ele_mom = ele_track.getMomentum();
325 TVector3 pe(ele_mom[0], ele_mom[1], ele_mom[2]);
326 double pe_mag = pe.Mag();
327 double ele_tanLambda = ele_track.getTanLambda();
328 double ele_phi0 = ele_track.getPhi();
330 for (
auto& pos_track : positrons) {
331 const std::vector<double>& pos_mom = pos_track.getMomentum();
332 TVector3 pp(pos_mom[0], pos_mom[1], pos_mom[2]);
333 double pp_mag = pp.Mag();
334 double pos_tanLambda = pos_track.getTanLambda();
335 double pos_phi0 = pos_track.getPhi();
338 double dTanLambda = std::fabs(ele_tanLambda - pos_tanLambda);
339 min_dTanLambda = std::min(min_dTanLambda, dTanLambda);
340 max_dTanLambda = std::max(max_dTanLambda, dTanLambda);
343 double dPhi = std::fabs(ele_phi0 - pos_phi0);
344 min_dPhi = std::min(min_dPhi, dPhi);
345 max_dPhi = std::max(max_dPhi, dPhi);
348 double cos_theta = pe.Dot(pp) / (pe_mag * pp_mag);
349 cos_theta = std::max(-1.0, std::min(1.0, cos_theta));
350 double opening_angle = std::acos(cos_theta);
351 min_opening = std::min(min_opening, opening_angle);
352 max_opening = std::max(max_opening, opening_angle);
355 double Ee = std::sqrt(pe_mag * pe_mag + me * me);
356 double Ep = std::sqrt(pp_mag * pp_mag + me * me);
357 TVector3 p_tot = pe + pp;
358 double E_tot = Ee + Ep;
359 double m2 = E_tot * E_tot - p_tot.Mag2();
360 double mass = (m2 > 0) ? std::sqrt(m2) : 0.0;
361 min_mass = std::min(min_mass, mass);
362 max_mass = std::max(max_mass, mass);
365 double asymmetry = std::fabs(pe_mag - pp_mag) / (pe_mag + pp_mag);
366 min_asym = std::min(min_asym, asymmetry);
367 max_asym = std::max(max_asym, asymmetry);
372 bool has_pairs = (!electrons.empty() && !positrons.empty());
374 bus_.set(
"min_dTanLambda", has_pairs ? min_dTanLambda : -9999.0);
375 bus_.set(
"max_dTanLambda", has_pairs ? max_dTanLambda : -9999.0);
376 bus_.set(
"min_opening", has_pairs ? min_opening : -9999.0);
377 bus_.set(
"max_opening", has_pairs ? max_opening : -9999.0);
378 bus_.set(
"min_mass", has_pairs ? min_mass : -9999.0);
379 bus_.set(
"max_mass", has_pairs ? max_mass : -9999.0);
380 bus_.set(
"min_asym", has_pairs ? min_asym : -9999.0);
381 bus_.set(
"max_asym", has_pairs ? max_asym : -9999.0);
382 bus_.set(
"min_dPhi", has_pairs ? min_dPhi : -9999.0);
383 bus_.set(
"max_dPhi", has_pairs ? max_dPhi : -9999.0);
609 bus_.clear_outputs();
611 const auto& tsbank{
bus_.get<
TSData>(
"TSBank")};
613 int run_number = eh.getRunNumber();
615 const std::vector<MCParticle*>* mcParticles =
617 corrector_->beginEvent(run_number, mcParticles);
621 bus_.set(
"run_number", run_number);
622 bus_.set(
"event_number", eh.getEventNumber());
634 ? tsbank.isPairTrigger()
635 : (tsbank.isSingle3Trigger() || tsbank.isSingle2Trigger());
636 event_cf_.apply(
"single_trigger", trigger_decision);
637 event_cf_.fill_nm1(
"single_trigger", trigger_decision ? 1 : 0);
645 const auto& allClusters{
bus_.get<std::vector<CalCluster*>>(
"RecoEcalClusters")};
647 const auto& vtxs{
bus_.get<std::vector<Vertex*>>(
vtxColl_)};
652 event_cf_.apply(
"at_least_one_v0", vtxs.size() >= 1);
653 event_cf_.fill_nm1(
"at_least_one_v0", vtxs.size());
676 struct PreselectedVertex {
682 TVector3 ele_track_p;
683 TVector3 pos_track_p;
684 TVector3 ele_track_p_prefit;
685 TVector3 pos_track_p_prefit;
686 TVector3 ele_p_postfit;
687 TVector3 pos_p_postfit;
688 double ele_p_smear_ratio;
689 double pos_p_smear_ratio;
691 std::vector<PreselectedVertex> preselected_vtx;
692 std::vector<double> vtx_ele_smear_scale, vtx_pos_smear_scale;
700 double evt_pos_cl_min_dr = -9999.0;
701 double evt_pos_cl_min_dr_t = -9999.0;
703 for (
Vertex* vtx : vtxs) {
706 int i_ele{-1}, i_pos{-1};
707 for (
int ipart = 0; ipart < vtx->getParticles().GetEntries(); ++ipart) {
708 int pdg_id = ((
Particle*)vtx->getParticles().At(ipart))->getPDG();
711 }
else if (pdg_id == -11) {
715 if (i_ele < 0 or i_pos < 0) {
716 throw std::runtime_error(
"Vertex formed without either an electron or positron!");
736 double ele_z0_raw = ele_trk.
getZ0();
737 double pos_z0_raw = pos_trk.
getZ0();
743 TVector3 ele_p_postfit(vtx->getP1X(), vtx->getP1Y(), vtx->getP1Z());
744 TVector3 pos_p_postfit(vtx->getP2X(), vtx->getP2Y(), vtx->getP2Z());
754 ele_trk.
setMomentum(vtx->getP1X(), vtx->getP1Y(), vtx->getP1Z());
755 pos_trk.
setMomentum(vtx->getP2X(), vtx->getP2Y(), vtx->getP2Z());
760 double ele_p_smear_ratio = 1.0;
761 double pos_p_smear_ratio = 1.0;
762 const double ele_omega_before = ele_trk.
getOmega();
763 const double pos_omega_before = pos_trk.
getOmega();
765 auto corr =
corrector_->correct({&ele_trk, &pos_trk}, {-1, +1});
766 ele_p_smear_ratio = corr[0].pRatio();
767 pos_p_smear_ratio = corr[1].pRatio();
770 std::cout <<
"[TrackCorrector] ele ratio " << ele_p_smear_ratio <<
" pos ratio " << pos_p_smear_ratio
771 <<
" ele |p| " << ele_trk.
getP() <<
" pos |p| " << pos_trk.
getP() << std::endl;
774 vtx_ele_smear_scale.push_back(ele_trk.
getOmega() != 0. ? ele_omega_before / ele_trk.
getOmega() : 1.);
775 vtx_pos_smear_scale.push_back(pos_trk.
getOmega() != 0. ? pos_omega_before / pos_trk.
getOmega() : 1.);
792 std::cout <<
"Tracker hit counts (vertex " << ivtx <<
"):" << std::endl;
794 <<
", nhits (after scaling)=" << ele_nhits << std::endl;
796 <<
", nhits (after scaling)=" << pos_nhits << std::endl;
804 TVector3 psum = ele_mom + pos_mom;
813 bool pos_has_cluster = (posClE > -9000.0);
814 bool pos_has_track = (pos.
getTrack().getTrackerHitCount() > 0);
815 bool ele_has_track = (ele.
getTrack().getTrackerHitCount() > 0);
819 double pos_cl_min_dr = -9999.0;
820 double pos_cl_min_dr_t = -9999.0;
821 if (not pos_has_cluster) {
823 double min_dr = 9999.0;
824 for (
const auto* cl : allClusters) {
825 auto clPos = cl->getPosition();
826 double dx = clPos[0] - posAtEcal[0];
827 double dy = clPos[1] - posAtEcal[1];
828 double dr = std::sqrt(dx*dx + dy*dy);
834 pos_cl_min_dr = min_dr;
836 if (not pos_has_cluster &&
837 (evt_pos_cl_min_dr < 0.0 || pos_cl_min_dr < evt_pos_cl_min_dr)) {
838 evt_pos_cl_min_dr = pos_cl_min_dr;
839 evt_pos_cl_min_dr_t = pos_cl_min_dr_t;
842 if (not (pos_has_track && pos_has_cluster && ele_has_track)) {
849 vertex_cf_.apply(
"positron_clusterE_above_0pt2GeV", posClE >= 0.2);
865 double vtxmaxp = ele_mom.Mag() + pos_mom.Mag();
866 vertex_cf_.apply(
"vtx_max_p_4pt0GeV", psum.Mag() <= 4.0);
868 vertex_cf_.fill_nm1(
"positron_clusterE_above_0pt2GeV", posClE);
874 vertex_cf_.fill_nm1(
"ele_min_hits", ele_nhits);
875 vertex_cf_.fill_nm1(
"pos_min_hits", pos_nhits);
879 vertex_cf_.fill_nm1(
"vertex_chi2", vtx->getChi2());
881 vertex_cf_.fill_nm1(
"vtx_max_p_4pt0GeV", vtxmaxp);
884 preselected_vtx.push_back(PreselectedVertex{*vtx, ele, pos, ele_z0_raw, pos_z0_raw,
885 ele_track_p, pos_track_p,
886 ele_p_prefit, pos_p_prefit,
887 ele_p_postfit, pos_p_postfit,
888 ele_p_smear_ratio, pos_p_smear_ratio});
895 bus_.set(
"vtx_ele_smear_scale", vtx_ele_smear_scale);
896 bus_.set(
"vtx_pos_smear_scale", vtx_pos_smear_scale);
897 bus_.set(
"pos_cl_min_dr", evt_pos_cl_min_dr);
898 bus_.set(
"pos_cl_min_dr_t", evt_pos_cl_min_dr_t);
902 std::size_t i_best_vtx = 0;
903 for (std::size_t i = 1; i < preselected_vtx.size(); ++i) {
904 if (preselected_vtx[i].vtx.getChi2() < preselected_vtx[i_best_vtx].vtx.getChi2()) {
910 if (preselected_vtx.size() >= 2) {
911 for (std::size_t i = 0; i < preselected_vtx.size(); ++i) {
912 double chi2 = preselected_vtx[i].vtx.getChi2();
921 event_cf_.fill_nm1(
"at_least_one_vertex", preselected_vtx.size());
922 event_cf_.fill_nm1(
"no_extra_vertices", preselected_vtx.size());
927 bool single2{
false}, single3{
false};
928 if (tsbank.isSingle3Trigger() == 1) single3 =
true;
929 if (tsbank.isSingle2Trigger() == 1) single2 =
true;
930 bus_.set(
"single2", single2);
931 bus_.set(
"single3", single3);
937 if (preselected_vtx.empty())
return true;
938 auto selected = preselected_vtx.at(i_best_vtx);
939 Vertex& vtx = selected.vtx;
942 const double ele_z0_raw = selected.ele_z0_raw;
943 const double pos_z0_raw = selected.pos_z0_raw;
946 bus_.set(
"ele_track_p", selected.ele_track_p);
947 bus_.set(
"pos_track_p", selected.pos_track_p);
948 bus_.set(
"ele_track_p_prefit", selected.ele_track_p_prefit);
949 bus_.set(
"pos_track_p_prefit", selected.pos_track_p_prefit);
950 for (
const auto& [prefix, prefit, postfit] : {
951 std::make_tuple(
"ele_", selected.ele_track_p_prefit, selected.ele_p_postfit),
952 std::make_tuple(
"pos_", selected.pos_track_p_prefit, selected.pos_p_postfit)}) {
953 const std::string pre{prefix};
954 bus_.set(pre +
"p_prefit", prefit.Mag());
955 bus_.set(pre +
"px_prefit", prefit.X());
956 bus_.set(pre +
"py_prefit", prefit.Y());
957 bus_.set(pre +
"pz_prefit", prefit.Z());
958 bus_.set(pre +
"p_postfit", postfit.Mag());
959 bus_.set(pre +
"px_postfit", postfit.X());
960 bus_.set(pre +
"py_postfit", postfit.Y());
961 bus_.set(pre +
"pz_postfit", postfit.Z());
965 constexpr double electron_mass{0.000510999};
966 const TVector3& pe{selected.ele_track_p_prefit};
967 const TVector3& pp{selected.pos_track_p_prefit};
968 ROOT::Math::PxPyPzMVector ele_p4(pe.X(), pe.Y(), pe.Z(), electron_mass);
969 ROOT::Math::PxPyPzMVector pos_p4(pp.X(), pp.Y(), pp.Z(), electron_mass);
970 bus_.set(
"trk_invM", (ele_p4 + pos_p4).M());
972 bus_.set(
"ele_p_smear_ratio", selected.ele_p_smear_ratio);
973 bus_.set(
"pos_p_smear_ratio", selected.pos_p_smear_ratio);
976 bool eleL1{
false}, eleL2{
false}, eleL3{
false}, eleL4{
false};
977 bool posL1{
false}, posL2{
false}, posL3{
false}, posL4{
false};
979 auto ele_layers =
_ah->GetTrackHitLayers(&ele_trk);
980 auto pos_layers =
_ah->GetTrackHitLayers(&pos_trk);
982 if (ele_layers.at(0) == 1 && ele_layers.at(1) == 1) eleL1 =
true;
983 if (ele_layers.at(2) == 1 && ele_layers.at(3) == 1) eleL2 =
true;
984 if (ele_layers.at(4) == 1 && ele_layers.at(5) == 1) eleL3 =
true;
985 if (ele_layers.at(6) == 1 && ele_layers.at(7) == 1) eleL4 =
true;
986 if (pos_layers.at(0) == 1 && pos_layers.at(1) == 1) posL1 =
true;
987 if (pos_layers.at(2) == 1 && pos_layers.at(3) == 1) posL2 =
true;
988 if (pos_layers.at(4) == 1 && pos_layers.at(5) == 1) posL3 =
true;
989 if (pos_layers.at(6) == 1 && pos_layers.at(7) == 1) posL4 =
true;
991 bus_.set(
"eleL1", eleL1);
992 bus_.set(
"eleL2", eleL2);
993 bus_.set(
"eleL3", eleL3);
994 bus_.set(
"eleL4", eleL4);
995 bus_.set(
"posL1", posL1);
996 bus_.set(
"posL2", posL2);
997 bus_.set(
"posL3", posL3);
998 bus_.set(
"posL4", posL4);
1001 bool ele_L1 = eleL1 && eleL2 && eleL3;
1002 bool ele_L2 = !eleL1 && eleL2 && eleL3;
1003 bool ele_L3 = !eleL1 && !eleL2 && eleL3;
1004 bool pos_L1 = posL1 && posL2 && posL3;
1005 bool pos_L2 = !posL1 && posL2 && posL3;
1006 bool pos_L3 = !posL1 && !posL2 && posL3;
1008 bus_.set(
"isL1L1", ele_L1 && pos_L1);
1009 bus_.set(
"isL2L2", ele_L2 && pos_L2);
1010 bus_.set(
"isL3L3", ele_L3 && pos_L3);
1011 bus_.set(
"isL1L2", (ele_L1 && pos_L2) || (pos_L1 && ele_L2));
1012 bus_.set(
"isL2L3", (ele_L2 && pos_L3) || (pos_L2 && ele_L3));
1016 bool pos_isTop = pos_trk.getTanLambda() > 0;
1017 bus_.set(
"ele_isTop", ele_isTop);
1018 bus_.set(
"pos_isTop", pos_isTop);
1024 auto setLayerHits = [&](
const std::vector<int>& layers,
bool isTop,
const std::string& prefix) {
1025 for (
int iL = 0; iL < 4; iL++) {
1026 int idx_even = 2 * iL;
1027 int idx_odd = 2 * iL + 1;
1028 bool hit_axial = isTop ? (layers.at(idx_even) == 1) : (layers.at(idx_odd) == 1);
1029 bool hit_stereo = isTop ? (layers.at(idx_odd) == 1) : (layers.at(idx_even) == 1);
1030 bus_.set(prefix +
"L" + std::to_string(iL + 1) +
"_axial", hit_axial);
1031 bus_.set(prefix +
"L" + std::to_string(iL + 1) +
"_stereo", hit_stereo);
1034 setLayerHits(ele_layers, ele_isTop,
"ele");
1035 setLayerHits(pos_layers, pos_isTop,
"pos");
1037 double ele_L1_iso{9999.0}, pos_L1_iso{9999.0};
1038 if (eleL1 && eleL2 && posL1 && posL2) {
1040 pos_L1_iso = pos_trk.getIsolation(0);
1042 bus_.set(
"ele_L1_iso", ele_L1_iso);
1043 bus_.set(
"pos_L1_iso", pos_L1_iso);
1046 double ele_L1_iso_significance{9999.0}, pos_L1_iso_significance{9999.0};
1049 std::cout <<
"[iso_sig debug] eleL1=" << eleL1 <<
" eleL2=" << eleL2
1050 <<
" posL1=" << posL1 <<
" posL2=" << posL2 << std::endl;
1051 std::cout <<
"[iso_sig debug] ele_L1_iso=" << ele_L1_iso
1052 <<
" pos_L1_iso=" << pos_L1_iso << std::endl;
1055 if (eleL1 && eleL2 && posL1 && posL2) {
1056 if (ele_L1_iso < 9999.0) {
1057 double ele_py_sign = TMath::Sign(1, ele_trk.
getMomentum()[1]);
1058 double ele_z0 = ele_trk.
getZ0();
1059 double ele_z0err = ele_trk.
getZ0Err();
1060 ele_L1_iso_significance = (2 * ele_L1_iso + ele_py_sign * ele_z0) / ele_z0err;
1062 std::cout <<
"[iso_sig debug] ele: iso=" << ele_L1_iso
1063 <<
" py_sign=" << ele_py_sign
1065 <<
" z0err=" << ele_z0err
1066 <<
" numerator=(2*iso + sign*z0)=" << (2 * ele_L1_iso + ele_py_sign * ele_z0)
1067 <<
" significance=" << ele_L1_iso_significance << std::endl;
1070 std::cout <<
"[iso_sig debug] ele: iso=9999 (no L1 hit), significance not calculated" << std::endl;
1073 if (pos_L1_iso < 9999.0) {
1074 double pos_py_sign = TMath::Sign(1, pos_trk.getMomentum()[1]);
1075 double pos_z0 = pos_trk.getZ0();
1076 double pos_z0err = pos_trk.getZ0Err();
1077 pos_L1_iso_significance = (2 * pos_L1_iso + pos_py_sign * pos_z0) / pos_z0err;
1079 std::cout <<
"[iso_sig debug] pos: iso=" << pos_L1_iso
1080 <<
" py_sign=" << pos_py_sign
1082 <<
" z0err=" << pos_z0err
1083 <<
" numerator=(2*iso + sign*z0)=" << (2 * pos_L1_iso + pos_py_sign * pos_z0)
1084 <<
" significance=" << pos_L1_iso_significance << std::endl;
1087 std::cout <<
"[iso_sig debug] pos: iso=9999 (no L1 hit), significance not calculated" << std::endl;
1090 std::cout <<
"[iso_sig debug] L1L2 hit requirement not met, significance left at 9999" << std::endl;
1092 bus_.set(
"ele_L1_iso_significance", ele_L1_iso_significance);
1093 bus_.set(
"pos_L1_iso_significance", pos_L1_iso_significance);
1096 double ele_L1_iso_significance_raw{9999.0}, pos_L1_iso_significance_raw{9999.0};
1098 std::cout <<
"[iso_sig debug] raw z0: ele_z0_raw=" << ele_z0_raw
1099 <<
" pos_z0_raw=" << pos_z0_raw << std::endl;
1101 if (eleL1 && eleL2 && posL1 && posL2) {
1102 if (ele_L1_iso < 9999.0) {
1103 double ele_py_sign = TMath::Sign(1, ele_trk.
getMomentum()[1]);
1104 ele_L1_iso_significance_raw = (2 * ele_L1_iso + ele_py_sign * ele_z0_raw) / ele_trk.
getZ0Err();
1106 std::cout <<
"[iso_sig debug] ele raw: iso=" << ele_L1_iso
1107 <<
" py_sign=" << ele_py_sign
1108 <<
" z0_raw=" << ele_z0_raw
1110 <<
" numerator=" << (2 * ele_L1_iso + ele_py_sign * ele_z0_raw)
1111 <<
" significance_raw=" << ele_L1_iso_significance_raw << std::endl;
1114 if (pos_L1_iso < 9999.0) {
1115 double pos_py_sign = TMath::Sign(1, pos_trk.getMomentum()[1]);
1116 pos_L1_iso_significance_raw = (2 * pos_L1_iso + pos_py_sign * pos_z0_raw) / pos_trk.getZ0Err();
1118 std::cout <<
"[iso_sig debug] pos raw: iso=" << pos_L1_iso
1119 <<
" py_sign=" << pos_py_sign
1120 <<
" z0_raw=" << pos_z0_raw
1121 <<
" z0err=" << pos_trk.getZ0Err()
1122 <<
" numerator=" << (2 * pos_L1_iso + pos_py_sign * pos_z0_raw)
1123 <<
" significance_raw=" << pos_L1_iso_significance_raw << std::endl;
1127 bus_.set(
"ele_L1_iso_significance_raw", ele_L1_iso_significance_raw);
1128 bus_.set(
"pos_L1_iso_significance_raw", pos_L1_iso_significance_raw);
1131 TVector3 pos_mom(pos_trk.getMomentum()[0], pos_trk.getMomentum()[1], pos_trk.getMomentum()[2]);
1132 TVector3 psum = ele_mom + pos_mom;
1135 std::cout <<
"Preselection psum calculation:" << std::endl;
1136 std::cout <<
" Electron: px=" << ele_mom.X() <<
" py=" << ele_mom.Y() <<
" pz=" << ele_mom.Z()
1137 <<
" |p|=" << ele_mom.Mag() << std::endl;
1138 std::cout <<
" Positron: px=" << pos_mom.X() <<
" py=" << pos_mom.Y() <<
" pz=" << pos_mom.Z()
1139 <<
" |p|=" << pos_mom.Mag() << std::endl;
1140 std::cout <<
" Psum: px=" << psum.X() <<
" py=" << psum.Y() <<
" pz=" << psum.Z()
1141 <<
" |psum|=" << psum.Mag() << std::endl;
1144 bus_.set(
"psum", psum.Mag());
1145 bus_.set(
"psum_scalar", ele_mom.Mag() + pos_mom.Mag());
1146 bus_.set(
"epem_opening_angle", ele_mom.Angle(pos_mom));
1153 double vtx_proj_x{-1.0}, vtx_proj_y{-1.0};
1154 double vtx_proj_x_sig{-1.0}, vtx_proj_y_sig{-1.0};
1155 double vtx_proj_x_centered{-999.0}, vtx_proj_y_centered{-999.0};
1156 double vtx_proj_sig{-1.0};
1158 TVector3 vtx_p = vtx.getP();
1160 vtx_proj_y, vtx_proj_x_sig, vtx_proj_y_sig,
1161 vtx_proj_x_centered, vtx_proj_y_centered,
1162 vtx.getX(), vtx.getY(), vtx.getZ(),
1163 vtx_p.X(), vtx_p.Y(), vtx_p.Z(),
1168 bus_.set(
"vtx_proj_sig", vtx_proj_sig);
1169 bus_.set(
"vtx_proj_x", vtx_proj_x);
1170 bus_.set(
"vtx_proj_x_sig", vtx_proj_x_sig);
1171 bus_.set(
"vtx_proj_y", vtx_proj_y);
1172 bus_.set(
"vtx_proj_y_sig", vtx_proj_y_sig);
1173 bus_.set(
"vtx_proj_x_centered", vtx_proj_x_centered);
1174 bus_.set(
"vtx_proj_y_centered", vtx_proj_y_centered);
1176 double vtx_proj_x_lcio{-1.0}, vtx_proj_y_lcio{-1.0};
1177 double vtx_proj_x_sig_lcio{-1.0}, vtx_proj_y_sig_lcio{-1.0};
1178 double vtx_proj_x_err_lcio{-1.0}, vtx_proj_y_err_lcio{-1.0};
1179 double vtx_proj_x_centered_lcio{-999.0}, vtx_proj_y_centered_lcio{-999.0};
1182 vtx_proj_x_lcio, vtx_proj_y_lcio,
1183 vtx_proj_x_sig_lcio, vtx_proj_y_sig_lcio,
1184 &vtx, vtx_proj_x_err_lcio, vtx_proj_y_err_lcio,
1185 vtx_proj_x_centered_lcio, vtx_proj_y_centered_lcio,
debug_);
1187 bus_.set(
"vtx_proj_sig_lcio", vtx_proj_sig_lcio);
1188 bus_.set(
"vtx_proj_x_lcio", vtx_proj_x_lcio);
1189 bus_.set(
"vtx_proj_x_sig_lcio", vtx_proj_x_sig_lcio);
1190 bus_.set(
"vtx_proj_y_lcio", vtx_proj_y_lcio);
1191 bus_.set(
"vtx_proj_y_sig_lcio", vtx_proj_y_sig_lcio);
1192 bus_.set(
"vtx_proj_x_err_lcio", vtx_proj_x_err_lcio);
1193 bus_.set(
"vtx_proj_y_err_lcio", vtx_proj_y_err_lcio);
1194 bus_.set(
"vtx_proj_x_centered_lcio", vtx_proj_x_centered_lcio);
1195 bus_.set(
"vtx_proj_y_centered_lcio", vtx_proj_y_centered_lcio);
1199 double min_y0{9999.0}, max_y0err{-1.0}, min_y0err{-1.0};
1201 if (fabs(ele_trk.
getZ0()) < fabs(pos_trk.getZ0())) {
1202 min_y0 = ele_trk.
getZ0();
1204 min_y0 = pos_trk.getZ0();
1206 min_y0 = fabs(min_y0);
1208 max_y0err = std::max(ele_trk.
getZ0Err(), pos_trk.getZ0Err());
1209 min_y0err = std::min(ele_trk.
getZ0Err(), pos_trk.getZ0Err());
1212 double vtx_y = vtx.getY();
1213 double min_y0_vtx = std::min(fabs(ele_trk.
getZ0() - vtx_y), fabs(pos_trk.getZ0() - vtx_y));
1217 TVector3 vtx_mom = vtx.getP();
1218 double vtx_y_at_zero = (vtx_mom.Z() != 0.0)
1219 ? vtx_y - (vtx_mom.Y() / vtx_mom.Z()) * vtx.getZ()
1221 double ele_y0_proj = fabs(ele_trk.
getZ0() - vtx_y_at_zero);
1222 double pos_y0_proj = fabs(pos_trk.getZ0() - vtx_y_at_zero);
1223 double min_y0_vtx_proj = std::min(ele_y0_proj, pos_y0_proj);
1224 double delta_y0_vtx_proj = ele_y0_proj - pos_y0_proj;
1226 bus_.set(
"min_y0", min_y0);
1227 bus_.set(
"max_y0err", max_y0err);
1228 bus_.set(
"min_y0err", min_y0err);
1230 bus_.set(
"pos_y0err", pos_trk.getZ0Err());
1231 bus_.set(
"min_y0_vtx", min_y0_vtx);
1232 bus_.set(
"min_y0_vtx_proj", min_y0_vtx_proj);
1233 bus_.set(
"vtx_y_at_zero", vtx_y_at_zero);
1234 bus_.set(
"delta_y0_vtx_proj", delta_y0_vtx_proj);
1237 bus_.set(
"weight", eh.getWeight());
1238 bus_.set(
"vertex", vtx);
1239 bus_.set(
"ele", ele);
1240 bus_.set(
"pos", pos);
1241 bus_.set(
"third_track", thirdTrack);
1245 const auto& all_tracks =
bus_.get<std::vector<Track*>>(
trkColl_);
1249 const auto& all_tracks =
bus_.get<std::vector<Track*>>(
trkColl_);
1250 std::vector<Track> all_good_tracks;
1252 for (
auto* trk : all_tracks) {
1254 all_good_tracks.push_back(*trk);
1258 bus_.set(
"all_preselected_tracks", all_good_tracks);
1271 bus_.set(
"ele_truth_p", TVector3(0., 0., 0.));
1272 bus_.set(
"pos_truth_p", TVector3(0., 0., 0.));
1279 std::map<int, int> count_per_particle_id;
1280 for (
const auto& [layer_id, particle_id] : ele_trk.
getMcpHits()) {
1281 if (count_per_particle_id.find(particle_id) == count_per_particle_id.end()) {
1282 count_per_particle_id[particle_id] = 0;
1284 count_per_particle_id[particle_id]++;
1286 int truth_ele_id{-1}, max_nhits{0};
1287 for (
const auto& [particle_id, count] : count_per_particle_id) {
1288 if (count > max_nhits) {
1289 truth_ele_id = particle_id;
1303 const auto& mc_ptr{
bus_.get<std::vector<MCParticle*>>(
mcColl_)};
1306 ROOT::Math::PxPyPzEVector trueEleP;
1307 ROOT::Math::PxPyPzEVector truePosP;
1311 bool ele_is_rad_ele{
false};
1313 std::vector<double> lP = ptr->getMomentum();
1315 if (ptr->getPDG() == 625) {
1318 }
else if (ptr->getID() == truth_ele_id) {
1319 ele_is_rad_ele = (ptr->getMomPDG() == 625);
1320 trueEleP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1321 }
else if (ptr->getPDG() == -11 && ptr->getMomPDG() == 625) {
1322 truePosP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1325 if (ptr->getPDG() ==
apPDG_) {
1328 }
else if (ptr->getID() == truth_ele_id) {
1329 ele_is_rad_ele = (ptr->getMomPDG() ==
apPDG_);
1330 trueEleP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1331 }
else if (ptr->getPDG() == -11 && ptr->getMomPDG() ==
apPDG_) {
1332 truePosP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1335 if (ptr->getID() == truth_ele_id) {
1336 ele_is_rad_ele = (ptr->getMomPDG() == 623);
1338 if (ptr->getPDG() == 11 && ptr->getMomPDG() == 623) {
1339 trueEleP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1340 }
else if (ptr->getPDG() == -11 && ptr->getMomPDG() == 623) {
1341 truePosP = ROOT::Math::PxPyPzEVector(lP.at(0), lP.at(1), lP.at(2), ptr->getEnergy());
1347 std::cout <<
"[AP debug] MCParticle PDGs in event (run=" << run_number <<
"):" << std::endl;
1349 std::cout <<
" PDG=" << ptr->getPDG()
1350 <<
" momPDG=" << ptr->getMomPDG()
1351 <<
" id=" << ptr->getID()
1352 <<
" p=" << ptr->getMomentum()[2] << std::endl;
1354 std::cout <<
"[AP debug] searching for apPDG=" <<
apPDG_ <<
" n_ap=" << n_ap <<
" ap=" << (ap ?
"found" :
"null") << std::endl;
1357 bus_.set(
"ele_truth_p", TVector3(trueEleP.Px(), trueEleP.Py(), trueEleP.Pz()));
1358 bus_.set(
"pos_truth_p", TVector3(truePosP.Px(), truePosP.Py(), truePosP.Pz()));
1370 event_cf_.apply(
"at_least_one_true_vd", n_vd > 0);
1371 event_cf_.apply(
"no_extra_true_vd", n_vd < 2);
1376 throw std::runtime_error(
"ERROR: Logic error: checked for VD earlier but there isn't one.");
1378 bus_.set(
"true_vd", *vd);
1380 std::vector<double> vdMom = vd->getMomentum();
1381 double vd_p = std::sqrt(vdMom[0]*vdMom[0] + vdMom[1]*vdMom[1] + vdMom[2]*vdMom[2]);
1382 bus_.set(
"true_vd_betagamma", vd_p / vd->getMass());
1385 event_cf_.apply(
"at_least_one_true_ap", n_ap > 0);
1386 event_cf_.apply(
"no_extra_true_ap", n_ap < 2);
1391 throw std::runtime_error(
"ERROR: Logic error: checked for AP earlier but there isn't one.");
1393 bus_.set(
"true_ap", *ap);
1396 std::vector<double> vtxPos = ap->getVertexPosition();
1397 std::vector<double> endPos = ap->getEndPoint();
1398 double dx = endPos[0] - vtxPos[0];
1399 double dy = endPos[1] - vtxPos[1];
1400 double dz = endPos[2] - vtxPos[2];
1401 bus_.set(
"true_decay_len", std::sqrt(dx*dx + dy*dy + dz*dz));
1403 std::vector<double> apMom = ap->getMomentum();
1404 double ap_p = std::sqrt(apMom[0]*apMom[0] + apMom[1]*apMom[1] + apMom[2]*apMom[2]);
1405 bus_.set(
"true_ap_betagamma", ap_p / ap->getMass());
1407 if (trueEleP.P() > 0 and truePosP.P() > 0) {
1408 bus_.set(
"true_vertex_invM", (trueEleP + truePosP).M());
1409 bus_.set(
"true_vertex_psum", trueEleP.P() + truePosP.P());
1412 bus_.set(
"isRadEle", ele_is_rad_ele);