Execute method.
357 {
358
359
361
362
363
364 std::map<Identifier, long int> clusterIDMapIdx;
366
367 std::map<Identifier, long int> clusterIDMapSpacePointIdx;
368
369
370
371 std::map<std::pair<int, int>, std::pair<bool, int>> allTruthParticles;
372
375 if (not mcEventCollectionHandle.
isValid()) {
377 return StatusCode::FAILURE;
378 }
379 mcCollptr = mcEventCollectionHandle.
cptr();
380
381
383 SG::ReadHandle<xAOD::EventInfo> eventInfoHandle(
m_eventInfoKey, ctx);
384 if (not eventInfoHandle.isValid()) {
386 return StatusCode::FAILURE;
387 }
388 eventInfo = eventInfoHandle.cptr();
389
392
393 std::map<int, int> allSubEvents;
394
396
397 bool duplicateSubeventID = false;
398 for (
unsigned int cntr = 0; cntr < mcCollptr->
size(); ++cntr) {
399 int ID = mcCollptr->
at(cntr)->event_number();
402
405 break;
406 }
407 std::map<int, int>::iterator
it = allSubEvents.find(ID);
408 if (it == allSubEvents.end())
409 allSubEvents.insert(std::make_pair(ID, 1));
410 else {
412 duplicateSubeventID = true;
413 }
414 }
415
416 if (duplicateSubeventID) {
418 }
419
421
423 (*m_Part_vParentID).clear();
424 (*m_Part_vParentBarcode).clear();
425 }
426
427 for (
unsigned int cntr = 0; cntr < mcCollptr->
size(); ++cntr) {
429
430
431
432
436
437 for (auto p : *genEvt) {
438
439 float px,
py,
pz,
pt,
eta, vx, vy, vz,
radius,
status,
charge = 0.;
440 std::vector<int> vParentID;
441 std::vector<int> vParentBarcode;
442
443 int vProdNin, vProdNout, vProdStatus, vProdBarcode;
444 bool passed =
isPassed(p, px, py, pz, pt,
eta, vx, vy, vz, radius, status,
charge, vParentID, vParentBarcode,
445 vProdNin, vProdNout, vProdStatus, vProdBarcode);
446 allTruthParticles.insert(std::make_pair(std::make_pair(genEvt->event_number(),
HepMC::barcode(p)),
447 std::make_pair(
passed, 0)));
448
469 (*m_Part_vParentID).push_back(vParentID);
470 (*m_Part_vParentBarcode).push_back(vParentBarcode);
471 }
472
476 break;
477 }
478 }
479 }
480
482 SG::ReadHandle<InDet::PixelClusterContainer> pixelClusterContainerHandle{
m_pixelClusterKey, ctx};
483 if (not pixelClusterContainerHandle.
isValid()) {
485 return StatusCode::FAILURE;
486 }
488
490 SG::ReadHandle<InDet::SCT_ClusterContainer> stripClusterContainerHandle{
m_stripClusterKey, ctx};
491 if (not stripClusterContainerHandle.
isValid()) {
493 return StatusCode::FAILURE;
494 }
495 SCT_ClusterContainer = stripClusterContainerHandle.
cptr();
496
497 auto cartesion_to_spherical = [](
const Amg::Vector3D &xyzVec,
float &eta_,
float &phi_) {
498 float r3 = 0;
499 for (
int idx = 0;
idx < 3; ++
idx) {
500 r3 += xyzVec[
idx] * xyzVec[
idx];
501 }
502 r3 = sqrt(r3);
503 phi_ = atan2(xyzVec[1], xyzVec[0]);
504 float theta_ = acos(xyzVec[2] / r3);
505 eta_ =
log(
tan(0.5 * theta_));
506 };
507
511
514 (*m_CLhardware).clear();
515 (*m_CLparticleLink_eventIndex).clear();
516 (*m_CLparticleLink_barcode).clear();
517 (*m_CLbarcodesLinked).clear();
518 (*m_CLparticle_charge).clear();
519 (*m_CLphis).clear();
520 (*m_CLetas).clear();
521 (*m_CLtots).clear();
522 (*m_CLlocal_cov).clear();
523 }
524
526
527 const InDetSimDataCollection *sdoCollection = 0;
528 SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{
m_pixelSDOKey, ctx};
529 if (not sdoCollectionHandle.
isValid()) {
531 return StatusCode::FAILURE;
532 }
533 sdoCollection = sdoCollectionHandle.
cptr();
534
535 for (const auto clusterCollection : *PixelClusterContainer) {
536
537 if (clusterCollection->empty())
538 continue;
539
540 int barrel_endcap =
m_pixelID->barrel_ec(clusterCollection->identify());
541 int layer_disk =
m_pixelID->layer_disk(clusterCollection->identify());
542 int eta_module =
m_pixelID->eta_module(clusterCollection->identify());
543 int phi_module =
m_pixelID->phi_module(clusterCollection->identify());
544
545 const InDetDD::SiDetectorElement *element =
m_pixelManager->getDetectorElement(clusterCollection->identify());
546
548 float norm_x = fabs(my_normal.x()) > 1
e-5 ? my_normal.x() : 0.;
549 float norm_y = fabs(my_normal.y()) > 1
e-5 ? my_normal.y() : 0.;
550 float norm_z = fabs(my_normal.z()) > 1
e-5 ? my_normal.z() : 0.;
551
552 const InDetDD::PixelModuleDesign *design(
dynamic_cast<const InDetDD::PixelModuleDesign *
>(&element->
design()));
553
554 if (not design) {
555 ATH_MSG_ERROR(
"Dynamic cast failed at " << __LINE__ <<
" of MergedPixelsTool.cxx.");
556 return StatusCode::FAILURE;
557 }
558
559
560 for (const auto cluster : *clusterCollection) {
561 Identifier clusterId = cluster->identify();
564 }
565
566 const Amg::MatrixX &local_cov = cluster->localCovariance();
567
568 std::vector<std::pair<int, int>>
barcodes = {};
569 std::vector<int> particleLink_eventIndex = {};
570 std::vector<int> particleLink_barcode = {};
571 std::vector<bool> barcodesLinked = {};
572 std::vector<float>
charge = {};
573 std::vector<int> phis = {};
574 std::vector<int>
etas = {};
575 std::vector<int> tots = {};
576 int min_eta = 999;
577 int min_phi = 999;
578 int max_eta = -999;
579 int max_phi = -999;
580
581 float charge_count = 0;
582 int pixel_count = 0;
583
584 for (
unsigned int rdo = 0; rdo < cluster->rdoList().
size(); rdo++) {
585 const auto &rdoID = cluster->rdoList().at(rdo);
596
597 ++pixel_count;
598 charge_count += cluster->totList().at(rdo);
599
602 tots.push_back(cluster->totList().at(rdo));
603
604 auto pos = sdoCollection->find(rdoID);
605 if (pos != sdoCollection->end()) {
606 for (
auto deposit :
pos->second.getdeposits()) {
607 const HepMcParticleLink &particleLink = deposit.first;
609
612 particleLink_eventIndex.push_back(particleLink.
eventIndex());
613 particleLink_barcode.push_back(particleLink.
barcode());
614 charge.push_back(deposit.second);
615 barcodesLinked.push_back(particleLink.
isValid());
616 }
617 }
618 }
619 }
620
621 InDetDD::SiLocalPosition localPos_entry = design->localPositionOfCell(InDetDD::SiCellId(min_phi, min_eta));
622 InDetDD::SiLocalPosition localPos_exit = design->localPositionOfCell(InDetDD::SiCellId(max_phi, max_eta));
623
629
630
631
632 Amg::Vector3D localDirection = localEndPosition - localStartPosition;
633
634 float loc_eta = 0, loc_phi = 0;
635 cartesion_to_spherical(localDirection, loc_eta, loc_phi);
636
639
641 float glob_eta = 0, glob_phi = 0;
642 cartesion_to_spherical(direction, glob_eta, glob_phi);
643
646
647 float trkphicomp =
direction.dot(my_phiax);
648 float trketacomp =
direction.dot(my_etaax);
649 float trknormcomp =
direction.dot(my_normal);
650 double phi_angle = atan2(trknormcomp, trkphicomp);
651 double eta_angle = atan2(trknormcomp, trketacomp);
652
653 clusterIDMapIdx[cluster->identify()] =
m_selected;
654 std::vector<double> v_local_cov;
655 if (local_cov.size() > 0) {
656 for (size_t i = 0, nRows = local_cov.rows(), nCols = local_cov.cols(); i < nRows; i++) {
657 for (
size_t j = 0;
j <
nCols; ++
j) {
658 v_local_cov.push_back(local_cov(i, j));
659 }
660 }
661 }
663
665 (*m_CLhardware).push_back("PIXEL");
675 (*m_CLparticleLink_eventIndex).push_back(particleLink_eventIndex);
676 (*m_CLparticleLink_barcode).push_back(particleLink_barcode);
677 (*m_CLbarcodesLinked).push_back(barcodesLinked);
678 (*m_CLparticle_charge).push_back(
charge);
679 (*m_CLetas).push_back(etas);
680 (*m_CLphis).push_back(phis);
681 (*m_CLtots).push_back(tots);
699 (*m_CLlocal_cov).push_back(v_local_cov);
700 }
705 break;
706 }
707 }
708 }
709 }
710
714
715 if (SCT_ClusterContainer->size() > 0) {
716 const InDetSimDataCollection *sdoCollection = 0;
717 SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{
m_stripSDOKey, ctx};
718 if (not sdoCollectionHandle.
isValid()) {
720 return StatusCode::FAILURE;
721 }
722 sdoCollection = sdoCollectionHandle.
cptr();
723
724 for (const auto clusterCollection : *SCT_ClusterContainer) {
725
726 if (clusterCollection->empty())
727 continue;
728
729 int barrel_endcap =
m_SCT_ID->barrel_ec(clusterCollection->identify());
730 int layer_disk =
m_SCT_ID->layer_disk(clusterCollection->identify());
731 int eta_module =
m_SCT_ID->eta_module(clusterCollection->identify());
732 int phi_module =
m_SCT_ID->phi_module(clusterCollection->identify());
733 int side =
m_SCT_ID->side(clusterCollection->identify());
734
735 const InDetDD::SiDetectorElement *element =
m_SCT_Manager->getDetectorElement(clusterCollection->identify());
736
738 float norm_x = fabs(my_normal.x()) > 1
e-5 ? my_normal.x() : 0.;
739 float norm_y = fabs(my_normal.y()) > 1
e-5 ? my_normal.y() : 0.;
740 float norm_z = fabs(my_normal.z()) > 1
e-5 ? my_normal.z() : 0.;
741
742
743 for (const auto cluster : *clusterCollection) {
744 Identifier clusterId = cluster->identify();
747 }
748
749 const Amg::MatrixX &local_cov = cluster->localCovariance();
750
751 std::vector<std::pair<int, int>>
barcodes = {};
752 std::vector<int> particleLink_eventIndex = {};
753 std::vector<int> particleLink_barcode = {};
754 std::vector<bool> barcodesLinked = {};
755 std::vector<float>
charge = {};
756
757 std::vector<int> tots = {};
758 std::vector<int> strip_ids = {};
759 int min_strip = 999;
760 int max_strip = -999;
761
762 float charge_count = 0;
763 int pixel_count = 0;
764
765 for (
unsigned int rdo = 0; rdo < cluster->rdoList().
size(); rdo++) {
766 const auto &rdoID = cluster->rdoList().at(rdo);
767
769
770 if (min_strip >
strip)
772 if (max_strip <
strip)
774 strip_ids.push_back(
strip);
775
776 tots.push_back(0);
777 ++pixel_count;
778
779 auto pos = sdoCollection->find(rdoID);
780 if (pos != sdoCollection->end()) {
781 for (
auto deposit :
pos->second.getdeposits()) {
782 const HepMcParticleLink &particleLink = deposit.first;
784
785
788 particleLink_eventIndex.push_back(particleLink.
eventIndex());
789 particleLink_barcode.push_back(particleLink.
barcode());
790 charge.push_back(deposit.second);
791 barcodesLinked.push_back(particleLink.
isValid());
792 }
793 }
794 }
795 }
796
797
798 const InDetDD::SCT_ModuleSideDesign *design(
799 dynamic_cast<const InDetDD::SCT_ModuleSideDesign *
>(&element->
design()));
800 if (not design) {
801 ATH_MSG_ERROR(
"Failed at " << __LINE__ <<
" of accessing SCT ModuleSide Design");
802 return StatusCode::FAILURE;
803 }
804
806 std::pair<Amg::Vector3D, Amg::Vector3D> ends(
807 element->
endsOfStrip(InDetDD::SiLocalPosition(locpos.y(), locpos.x(), 0)));
808
810
811 InDetDD::SiLocalPosition localPos_entry = design->localPositionOfCell(InDetDD::SiCellId(min_strip));
812 InDetDD::SiLocalPosition localPos_exit = design->localPositionOfCell(InDetDD::SiCellId(max_strip));
813
819
820 Amg::Vector3D localDirection = localEndPosition - localStartPosition;
821 float loc_eta = 0, loc_phi = 0;
822 cartesion_to_spherical(localDirection, loc_eta, loc_phi);
823
826
828 float glob_eta = 0, glob_phi = 0;
829 cartesion_to_spherical(direction, glob_eta, glob_phi);
830
833
834 float trkphicomp =
direction.dot(my_phiax);
835 float trketacomp =
direction.dot(my_etaax);
836 float trknormcomp =
direction.dot(my_normal);
837 double phi_angle = atan2(trknormcomp, trkphicomp);
838 double eta_angle = atan2(trknormcomp, trketacomp);
839
840
841 clusterIDMapIdx[cluster->identify()] =
m_selected;
842
843 std::vector<int> cst;
845 cst.push_back(-1);
846 }
847 std::vector<double> v_local_cov;
848 if (local_cov.size() > 0) {
849 for (size_t i = 0, nRows = local_cov.rows(), nCols = local_cov.cols(); i < nRows; i++) {
850 for (
size_t j = 0;
j <
nCols; ++
j) {
851 v_local_cov.push_back(local_cov(i, j));
852 }
853 }
854 }
857 (*m_CLhardware).push_back("STRIP");
867 (*m_CLparticleLink_eventIndex).push_back(particleLink_eventIndex);
868 (*m_CLparticleLink_barcode).push_back(particleLink_barcode);
869 (*m_CLbarcodesLinked).push_back(barcodesLinked);
870 (*m_CLparticle_charge).push_back(
charge);
871 (*m_CLetas).push_back(strip_ids);
872 (*m_CLphis).push_back(cst);
873 (*m_CLtots).push_back(tots);
891 (*m_CLlocal_cov).push_back(v_local_cov);
892 }
893
898 break;
899 }
900 }
901 }
902 }
903
904
908
912
913
915
917
918 if (not xAODPixelSpacePointContainerHandle.
isValid()) {
920 return StatusCode::FAILURE;
921 }
922
923 xAODPixelSPContainer = xAODPixelSpacePointContainerHandle.
cptr();
924
925
928 if (not xAODStripSpacePointContainerHandle.
isValid()) {
930 return StatusCode::FAILURE;
931 }
932 xAODStripSPContainer = xAODStripSpacePointContainerHandle.
cptr();
933
934
937 if (not xAODStripSpacePointOverlapContainerHandle.
isValid()) {
939 return StatusCode::FAILURE;
940 }
941 xAODStripSPOverlapContainer = xAODStripSpacePointOverlapContainerHandle.
cptr();
942
943 int sp_index = 0;
945
946 if (xAODPixelSPContainer && xAODPixelSPContainer->
size() > 0) {
947 for (
const auto sp : *xAODPixelSPContainer) {
948
949 if (not linkAcc.isAvailable(*
sp))
950 ATH_MSG_FATAL(
"no pixel SpacePoint link for xAOD::SpacePoint");
951
952
953 auto trk_sp = *linkAcc(*
sp);
954 const InDet::SiCluster *
cl =
static_cast<const InDet::SiCluster*
>(trk_sp->clusterList().first);
955
967 }
968
969 sp_index++;
973 break;
974 }
975 }
976 }
977
978 if (xAODStripSPContainer && xAODStripSPContainer->
size() > 0) {
979
980
981 for (
const auto sp : *xAODStripSPContainer) {
982
984
985 auto trk_sp = *striplinkAcc(*
sp);
986 const InDet::SiCluster *cl_1 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().first);
987 const InDet::SiCluster *cl_2 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().second);
988
990
1003
1004
1005 std::vector<float> topstripDir(
sp->topStripDirection().data(),
1006 sp->topStripDirection().data() +
1007 sp->topStripDirection().size());
1008
1009 std::vector<float> botstripDir(
sp->bottomStripDirection().data(),
1010 sp->bottomStripDirection().data() +
1011 sp->bottomStripDirection().size());
1012
1013 std::vector<float> DstripCnt(
sp->stripCenterDistance().data(),
1014 sp->stripCenterDistance().data() +
1015 sp->stripCenterDistance().size());
1016
1017 std::vector<float> topstripCnt(
sp->topStripCenter().data(),
1018 sp->topStripCenter().data() +
1019 sp->topStripCenter().size());
1020
1021 (*m_SPtopStripDirection).push_back(topstripDir);
1022 (*m_SPbottomStripDirection).push_back(botstripDir);
1023 (*m_SPstripCenterDistance).push_back(DstripCnt);
1024 (*m_SPtopStripCenterPosition).push_back(topstripCnt);
1025
1026 }
1027
1028 sp_index++;
1030
1033 break;
1034 }
1035 }
1036 }
1037
1038
1039 if (xAODStripSPOverlapContainer && xAODStripSPOverlapContainer->
size() > 0) {
1040
1041
1042 for (
const auto sp : *xAODStripSPOverlapContainer) {
1043
1045
1046 auto trk_sp = *stripOverlaplinkAcc(*
sp);
1047 const InDet::SiCluster *cl_1 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().first);
1048 const InDet::SiCluster *cl_2 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().second);
1049
1051
1061
1066
1067 if ( flag<1 || flag > 3 )
1069
1070
1074
1075
1076 std::vector<float> topstripDir(
sp->topStripDirection().data(),
1077 sp->topStripDirection().data() +
1078 sp->topStripDirection().size());
1079
1080 std::vector<float> botstripDir(
sp->bottomStripDirection().data(),
1081 sp->bottomStripDirection().data() +
1082 sp->bottomStripDirection().size());
1083
1084 std::vector<float> DstripCnt(
sp->stripCenterDistance().data(),
1085 sp->stripCenterDistance().data() +
1086 sp->stripCenterDistance().size());
1087
1088 std::vector<float> topstripCnt(
sp->topStripCenter().data(),
1089 sp->topStripCenter().data() +
1090 sp->topStripCenter().size());
1091
1092 (*m_SPtopStripDirection).push_back(topstripDir);
1093 (*m_SPbottomStripDirection).push_back(botstripDir);
1094 (*m_SPstripCenterDistance).push_back(DstripCnt);
1095 (*m_SPtopStripCenterPosition).push_back(topstripCnt);
1096
1097 }
1098
1099 sp_index++;
1103 break;
1104 }
1105 }
1106 }
1107
1108
1112
1114 SG::ReadHandle<TrackCollection> trackCollectionHandle{
m_tracksKey, ctx};
1115 if (not trackCollectionHandle.
isValid()) {
1117 return StatusCode::FAILURE;
1118 }
1119 trackCollection = trackCollectionHandle.
cptr();
1120
1121 const TrackTruthCollection *trackTruthCollection = 0;
1122 SG::ReadHandle<TrackTruthCollection> trackTruthCollectionHandle{
m_tracksTruthKey, ctx};
1123 if (not trackTruthCollectionHandle.
isValid()) {
1125 return StatusCode::FAILURE;
1126 }
1127 trackTruthCollection = trackTruthCollectionHandle.
cptr();
1128
1129 int trk_index = 0;
1130
1131
1135 (*m_TRKproperties).clear();
1136 (*m_TRKpattern).clear();
1137 (*m_TRKperigee_position).clear();
1138 (*m_TRKperigee_momentum).clear();
1139 (*m_TRKmeasurementsOnTrack_pixcl_sctcl_index).clear();
1140 (*m_TRKoutliersOnTrack_pixcl_sctcl_index).clear();
1141 }
1142
1143 for (; trackIterator < (*trackCollection).end(); ++trackIterator) {
1144 if (!((*trackIterator))) {
1146 continue;
1147 }
1148 const Trk::TrackInfo &
info = (*trackIterator)->info();
1149 const Trk::FitQuality *
fitQuality = (*trackIterator)->fitQuality();
1151 const DataVector<const Trk::MeasurementBase> *measurementsOnTrack = (*trackIterator)->measurementsOnTrack();
1152 const DataVector<const Trk::MeasurementBase> *outliersOnTrack = (*trackIterator)->outliersOnTrack();
1153
1154 ElementLink<TrackCollection> tracklink;
1155 tracklink.
setElement(
const_cast<Trk::Track *
>(*trackIterator));
1157 const ElementLink<TrackCollection> tracklink2 = tracklink;
1158 TrackTruthCollection::const_iterator
found = trackTruthCollection->find(tracklink2);
1159
1160 const std::bitset<Trk::TrackInfo::NumberOfTrackProperties> &
properties =
info.properties();
1161 std::vector<int> v_properties;
1163 if (properties[i]) {
1164 v_properties.push_back(i);
1165 }
1166 }
1167
1168 const std::bitset<Trk::TrackInfo::NumberOfTrackRecoInfo> &
pattern =
info.patternRecognition();
1169 std::vector<int> v_pattern;
1170 for (std::size_t i = 0;
i <
pattern.size();
i++) {
1171 if (pattern[i]) {
1172 v_pattern.push_back(i);
1173 }
1174 }
1175
1177 float chiSq = 0;
1178 if (fitQuality) {
1181 }
1184 if (perigeeParameters) {
1192 } else {
1199 }
1200 int mot = 0;
1201 int oot = 0;
1202 if (measurementsOnTrack)
1203 mot = measurementsOnTrack->
size();
1204 if (outliersOnTrack)
1205 oot = outliersOnTrack->
size();
1206 std::vector<int> measurementsOnTrack_pixcl_sctcl_index, outliersOnTrack_pixcl_sctcl_index;
1207 int TTCindex, TTCevent_index, TTCparticle_link;
1208 float TTCprobability;
1209 if (measurementsOnTrack) {
1210 for (
size_t i = 0;
i < measurementsOnTrack->
size();
i++) {
1211 const Trk::MeasurementBase *
mb = (*measurementsOnTrack)[
i];
1212 const InDet::PixelClusterOnTrack *pixcl =
dynamic_cast<const InDet::PixelClusterOnTrack *
>(
mb);
1213 const InDet::SCT_ClusterOnTrack *sctcl =
dynamic_cast<const InDet::SCT_ClusterOnTrack *
>(
mb);
1214 if (pixcl) {
1215 measurementsOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[pixcl->
prepRawData()->
identify()]);
1216 }
1217 else if (sctcl) {
1218 measurementsOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[sctcl->
prepRawData()->
identify()]);
1219 } else {
1220 measurementsOnTrack_pixcl_sctcl_index.push_back(-1);
1221 }
1222 }
1223 }
1224 if (outliersOnTrack) {
1225 for (
size_t i = 0;
i < outliersOnTrack->
size();
i++) {
1226 const Trk::MeasurementBase *
mb = (*outliersOnTrack)[
i];
1227 const InDet::PixelClusterOnTrack *pixcl =
dynamic_cast<const InDet::PixelClusterOnTrack *
>(
mb);
1228 const InDet::SCT_ClusterOnTrack *sctcl =
dynamic_cast<const InDet::SCT_ClusterOnTrack *
>(
mb);
1229 if (pixcl) {
1230 outliersOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[pixcl->
prepRawData()->
identify()]);
1231 } else if (sctcl) {
1232 outliersOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[sctcl->
prepRawData()->
identify()]);
1233 } else {
1234 outliersOnTrack_pixcl_sctcl_index.push_back(-1);
1235 }
1236 }
1237 }
1238 if (found != trackTruthCollection->end()) {
1239 TTCindex =
found->first.index();
1240 TTCevent_index =
found->second.particleLink().eventIndex();
1241 TTCparticle_link =
found->second.particleLink().barcode();
1242 TTCprobability =
found->second.probability();
1243 } else {
1244 TTCindex = TTCevent_index = TTCparticle_link = -999;
1245 TTCprobability = -1;
1246 }
1247
1253 (*m_TRKproperties).push_back(v_properties);
1254 (*m_TRKpattern).push_back(v_pattern);
1257 (*m_TRKmeasurementsOnTrack_pixcl_sctcl_index).push_back(measurementsOnTrack_pixcl_sctcl_index);
1258 (*m_TRKoutliersOnTrack_pixcl_sctcl_index).push_back(outliersOnTrack_pixcl_sctcl_index);
1260 (*m_TRKperigee_position).push_back(position);
1261 (*m_TRKperigee_momentum).push_back(momentum);
1268 }
1269
1270 trk_index++;
1271
1275 break;
1276 }
1277 }
1278
1281 if (not detailedTrackTruthCollectionHandle.
isValid()) {
1283 return StatusCode::FAILURE;
1284 }
1285 detailedTrackTruthCollection = detailedTrackTruthCollectionHandle.
cptr();
1286
1289 (*m_DTTtrajectory_eventindex).clear();
1290 (*m_DTTtrajectory_barcode).clear();
1291 (*m_DTTstTruth_subDetType).clear();
1292 (*m_DTTstTrack_subDetType).clear();
1293 (*m_DTTstCommon_subDetType).clear();
1294 }
1295
1296
1297 DetailedTrackTruthCollection::const_iterator detailedTrackTruthIterator = (*detailedTrackTruthCollection).begin();
1298 for (; detailedTrackTruthIterator != (*detailedTrackTruthCollection).end(); ++detailedTrackTruthIterator) {
1299 std::vector<int> DTTtrajectory_eventindex, DTTtrajectory_barcode, DTTstTruth_subDetType, DTTstTrack_subDetType,
1300 DTTstCommon_subDetType;
1301 const TruthTrajectory &traj = detailedTrackTruthIterator->second.trajectory();
1302 for (
size_t j = 0;
j < traj.size();
j++) {
1303 DTTtrajectory_eventindex.push_back(traj[j].
eventIndex());
1304 DTTtrajectory_barcode.push_back(traj[j].
barcode());
1305 }
1306 const SubDetHitStatistics &stTruth = detailedTrackTruthIterator->second.statsTruth();
1307 const SubDetHitStatistics &stTrack = detailedTrackTruthIterator->second.statsTrack();
1308 const SubDetHitStatistics &stCommon = detailedTrackTruthIterator->second.statsCommon();
1311 }
1314 }
1317 }
1318
1322 (*m_DTTtrajectory_eventindex).push_back(DTTtrajectory_eventindex);
1323 (*m_DTTtrajectory_barcode).push_back(DTTtrajectory_barcode);
1324 (*m_DTTstTruth_subDetType).push_back(DTTstTruth_subDetType);
1325 (*m_DTTstTrack_subDetType).push_back(DTTstTrack_subDetType);
1326 (*m_DTTstCommon_subDetType).push_back(DTTstCommon_subDetType);
1327 }
1328
1330 }
1331
1332
1333
1336
1337 return StatusCode::SUCCESS;
1338}
Scalar eta() const
pseudorapidity method
Scalar phi() const
phi method
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_WARNING(x)
double charge(const T &p)
size_t size() const
Number of registered mappings.
DataVector< Trk::Track > TrackCollection
This typedef represents a collection of Trk::Track objects.
DetailedTrackTruthCollection
DataModel_detail::const_iterator< DataVector > const_iterator
const T * at(size_type n) const
Access an element, as an rvalue.
size_type size() const noexcept
Returns the number of elements in the collection.
bool setElement(ElementType element)
Set link to point to an Element (slowest).
bool setStorableObject(BaseConstReference data, bool replace=false)
Set link storable to data object pointed by data (slower).
bool isValid() const
Validity check.
index_type eventIndex() const
Return the event number of the referenced GenEvent.
int barcode() const
Return the barcode of the target particle.
bool is_valid() const
Check if id is in a valid state.
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
double phiPitch() const
Pitch (inline methods).
std::pair< Amg::Vector3D, Amg::Vector3D > endsOfStrip(const Amg::Vector2D &position) const
Special method for SCT to retrieve the two ends of a "strip" Returned coordinates are in global frame...
double xPhi() const
position along phi direction:
double xEta() const
position along eta direction:
const Amg::Vector3D & etaAxis() const
virtual const Amg::Vector3D & normal() const override final
Get reconstruction local normal axes in global frame.
HepGeom::Point3D< double > globalPosition(const HepGeom::Point3D< double > &localPos) const
transform a reconstruction local position into a global position (inline):
const Amg::Vector3D & phiAxis() const
double etaPitch() const
Pitch (inline methods).
double * m_CLloc_direction3
SG::ReadHandleKey< DetailedTrackTruthCollection > m_detailedTracksTruthKey
bool isPassed(HepMC::ConstGenParticlePtr particle, float &px, float &py, float &pz, float &pt, float &eta, float &vx, float &vy, float &vz, float &radius, float &status, float &charge, std::vector< int > &vParentID, std::vector< int > &vParentBarcode, int &vProdNin, int &vProdNout, int &vProdStatus, int &vProdBarcode)
unsigned int m_run_number
double * m_CLloc_direction2
SG::ReadHandleKey< InDet::SCT_ClusterContainer > m_stripClusterKey
SG::ReadHandleKey< TrackTruthCollection > m_tracksTruthKey
SG::ReadHandleKey< TrackCollection > m_tracksKey
unsigned long long m_event_number
double * m_CLJan_loc_direction3
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
double * m_CLJan_loc_direction2
int * m_TRKparticle_hypothesis
const InDetDD::SCT_DetectorManager * m_SCT_Manager
int * m_Part_event_number
const PixelID * m_pixelID
double * m_CLloc_direction1
double * m_CLJan_loc_direction1
SG::ReadHandleKey< McEventCollection > m_mcEventCollectionKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_xaodPixelSpacePointContainerKey
SG::ReadHandleKey< InDetSimDataCollection > m_stripSDOKey
const InDetDD::PixelDetectorManager * m_pixelManager
int * m_Part_vProdBarcode
SG::ReadHandleKey< xAOD::SpacePointContainer > m_xaodStripSpacePointContainerKey
SG::ReadHandleKey< InDetSimDataCollection > m_pixelSDOKey
SG::ReadHandleKey< InDet::PixelClusterContainer > m_pixelClusterKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_xaodStripSpacePointOverlapContainerKey
virtual const PixelCluster * prepRawData() const override final
returns the PrepRawData - is a SiCluster in this scope
virtual const InDet::SCT_Cluster * prepRawData() const override final
returns the PrepRawData - is a SCT_Cluster in this scope
Trk::PrepRawDataContainer< SCT_ClusterCollection > SCT_ClusterContainer
Trk::PrepRawDataContainer< PixelClusterCollection > PixelClusterContainer
virtual bool isValid() override final
Can the handle be successfully dereferenced?
const_pointer_type cptr()
Dereference the pointer.
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
double chiSquared() const
returns the of the overall track fit
Identifier identify() const
return the identifier
uint32_t runNumber() const
The current event's run number.
uint64_t eventNumber() const
The current event's event number.
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Eigen::Matrix< double, 2, 1 > Vector2D
Eigen::Matrix< double, 3, 1 > Vector3D
event_number_t eventIndex
const std::string barcode
const std::string barcodes
HepMC3::GenEvent GenEvent
int compute_overlap_SP_flag(const int &eta_module_cl1, const int &phi_module_cl1, const int &eta_module_cl2, const int &phi_module_cl2)
unsigned int constexpr nCols
SG::Accessor< T, ALLOC > Accessor
const double mb
1mb to cm2
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)
FitQualityOnSurface fitQuality(const MultiComponentState &, const MeasurementBase &)
Method for determining the chi2 of the multi-component state and the number of degrees of freedom.
ParametersT< TrackParametersDim, Charged, PerigeeSurface > Perigee
const Amg::Vector3D & direction() const
Method to retrieve the direction at the Intersection.
const Amg::Vector3D & position() const
Method to retrieve the position of the Intersection.
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
ID
//////////////////////////////////////// JetAlgorithmType::ID defines most common physics jet finding...
PixelClusterContainer_v1 PixelClusterContainer
Define the version of the pixel cluster container.
EventInfo_v1 EventInfo
Definition of the latest event info version.
SpacePointContainer_v1 SpacePointContainer
Define the version of the space point container.
1.16.1