Execute method.
362 {
363
364
366
367
368
369 std::map<Identifier, long int> clusterIDMapIdx;
371
372 std::map<Identifier, long int> clusterIDMapSpacePointIdx;
373
374
375
376 std::map<std::pair<int, int>, std::pair<bool, int>> allTruthParticles;
377
380 if (not mcEventCollectionHandle.
isValid()) {
382 return StatusCode::FAILURE;
383 }
384 mcCollptr = mcEventCollectionHandle.
cptr();
385
386
388 SG::ReadHandle<xAOD::EventInfo> eventInfoHandle(
m_eventInfoKey, ctx);
389 if (not eventInfoHandle.isValid()) {
391 return StatusCode::FAILURE;
392 }
393 eventInfo = eventInfoHandle.cptr();
394
397
398 std::map<int, int> allSubEvents;
399
401
402 bool duplicateSubeventID = false;
403 for (
unsigned int cntr = 0; cntr < mcCollptr->
size(); ++cntr) {
404 int ID = mcCollptr->
at(cntr)->event_number();
407
410 break;
411 }
412 std::map<int, int>::iterator
it = allSubEvents.find(ID);
413 if (it == allSubEvents.end())
414 allSubEvents.insert(std::make_pair(ID, 1));
415 else {
417 duplicateSubeventID = true;
418 }
419 }
420
421 if (duplicateSubeventID) {
423 }
424
426
428 (*m_Part_vParentID).clear();
429 (*m_Part_vParentBarcode).clear();
430 }
431
432 for (
unsigned int cntr = 0; cntr < mcCollptr->
size(); ++cntr) {
434
435
436
437
441
442 for (auto p : *genEvt) {
443
444 float px,
py,
pz,
pt,
eta, vx, vy, vz,
radius,
status,
charge = 0.;
445 std::vector<int> vParentID;
446 std::vector<int> vParentBarcode;
447
448 int vProdNin, vProdNout, vProdStatus, vProdBarcode;
449 bool passed =
isPassed(p, px, py, pz, pt,
eta, vx, vy, vz, radius, status,
charge, vParentID, vParentBarcode,
450 vProdNin, vProdNout, vProdStatus, vProdBarcode);
451 allTruthParticles.insert(std::make_pair(std::make_pair(genEvt->event_number(),
HepMC::barcode(p)),
452 std::make_pair(
passed, 0)));
453
474 (*m_Part_vParentID).push_back(std::move(vParentID));
475 (*m_Part_vParentBarcode).push_back(std::move(vParentBarcode));
476 }
477
481 break;
482 }
483 }
484 }
485
487 SG::ReadHandle<InDet::PixelClusterContainer> pixelClusterContainerHandle{
m_pixelClusterKey, ctx};
488 if (not pixelClusterContainerHandle.
isValid()) {
490 return StatusCode::FAILURE;
491 }
493
495 SG::ReadHandle<InDet::SCT_ClusterContainer> stripClusterContainerHandle{
m_stripClusterKey, ctx};
496 if (not stripClusterContainerHandle.
isValid()) {
498 return StatusCode::FAILURE;
499 }
500 SCT_ClusterContainer = stripClusterContainerHandle.
cptr();
501
502 auto cartesion_to_spherical = [](
const Amg::Vector3D &xyzVec,
float &eta_,
float &phi_) {
503 float r3 = 0;
504 for (
int idx = 0;
idx < 3; ++
idx) {
505 r3 += xyzVec[
idx] * xyzVec[
idx];
506 }
507 r3 = sqrt(r3);
508 phi_ = atan2(xyzVec[1], xyzVec[0]);
509 float theta_ = acos(xyzVec[2] / r3);
510 eta_ =
log(
tan(0.5 * theta_));
511 };
512
516
519 (*m_CLhardware).clear();
520 (*m_CLparticleLink_eventIndex).clear();
521 (*m_CLparticleLink_barcode).clear();
522 (*m_CLbarcodesLinked).clear();
523 (*m_CLparticle_charge).clear();
524 (*m_CLphis).clear();
525 (*m_CLetas).clear();
526 (*m_CLtots).clear();
527 (*m_CLlocal_cov).clear();
528 }
529
531
532 const InDetSimDataCollection *sdoCollection = 0;
533 SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{
m_pixelSDOKey, ctx};
534 if (not sdoCollectionHandle.
isValid()) {
536 return StatusCode::FAILURE;
537 }
538 sdoCollection = sdoCollectionHandle.
cptr();
539
540 for (const auto clusterCollection : *PixelClusterContainer) {
541
542 if (clusterCollection->empty())
543 continue;
544
545 int barrel_endcap =
m_pixelID->barrel_ec(clusterCollection->identify());
546 int layer_disk =
m_pixelID->layer_disk(clusterCollection->identify());
547 int eta_module =
m_pixelID->eta_module(clusterCollection->identify());
548 int phi_module =
m_pixelID->phi_module(clusterCollection->identify());
549
550 const InDetDD::SiDetectorElement *element =
m_pixelManager->getDetectorElement(clusterCollection->identify());
551
553 float norm_x = fabs(my_normal.x()) > 1
e-5 ? my_normal.x() : 0.;
554 float norm_y = fabs(my_normal.y()) > 1
e-5 ? my_normal.y() : 0.;
555 float norm_z = fabs(my_normal.z()) > 1
e-5 ? my_normal.z() : 0.;
556
557 const InDetDD::PixelModuleDesign *design(
dynamic_cast<const InDetDD::PixelModuleDesign *
>(&element->
design()));
558
559 if (not design) {
560 ATH_MSG_ERROR(
"Dynamic cast failed at " << __LINE__ <<
" of MergedPixelsTool.cxx.");
561 return StatusCode::FAILURE;
562 }
563
564
565 for (const auto cluster : *clusterCollection) {
566 Identifier clusterId = cluster->identify();
569 }
570
571 const Amg::MatrixX &local_cov = cluster->localCovariance();
572
573 std::vector<std::pair<int, int>>
barcodes = {};
574 std::vector<int> particleLink_eventIndex = {};
575 std::vector<int> particleLink_barcode = {};
576 std::vector<bool> barcodesLinked = {};
577 std::vector<float>
charge = {};
578 std::vector<int> phis = {};
579 std::vector<int>
etas = {};
580 std::vector<int> tots = {};
581 int min_eta = 999;
582 int min_phi = 999;
583 int max_eta = -999;
584 int max_phi = -999;
585
586 float charge_count = 0;
587 int pixel_count = 0;
588
589 for (
unsigned int rdo = 0; rdo < cluster->rdoList().
size(); rdo++) {
590 const auto &rdoID = cluster->rdoList().at(rdo);
601
602 ++pixel_count;
603 charge_count += cluster->totList().at(rdo);
604
607 tots.push_back(cluster->totList().at(rdo));
608
609 auto pos = sdoCollection->find(rdoID);
610 if (pos != sdoCollection->end()) {
611 for (
const auto & deposit :
pos->second.getdeposits()) {
612 const HepMcParticleLink &particleLink = deposit.first;
614
617 particleLink_eventIndex.push_back(particleLink.
eventIndex());
618 particleLink_barcode.push_back(particleLink.
barcode());
619 charge.push_back(deposit.second);
620 barcodesLinked.push_back(particleLink.
isValid());
621 }
622 }
623 }
624 }
625
626 InDetDD::SiLocalPosition localPos_entry = design->localPositionOfCell(InDetDD::SiCellId(min_phi, min_eta));
627 InDetDD::SiLocalPosition localPos_exit = design->localPositionOfCell(InDetDD::SiCellId(max_phi, max_eta));
628
634
635
636
637 Amg::Vector3D localDirection = localEndPosition - localStartPosition;
638
639 float loc_eta = 0, loc_phi = 0;
640 cartesion_to_spherical(localDirection, loc_eta, loc_phi);
641
644
646 float glob_eta = 0, glob_phi = 0;
647 cartesion_to_spherical(direction, glob_eta, glob_phi);
648
651
652 float trkphicomp =
direction.dot(my_phiax);
653 float trketacomp =
direction.dot(my_etaax);
654 float trknormcomp =
direction.dot(my_normal);
655 double phi_angle = atan2(trknormcomp, trkphicomp);
656 double eta_angle = atan2(trknormcomp, trketacomp);
657
658 clusterIDMapIdx[cluster->identify()] =
m_selected;
659 std::vector<double> v_local_cov;
660 if (local_cov.size() > 0) {
661 for (size_t i = 0, nRows = local_cov.rows(), nCols = local_cov.cols(); i < nRows; i++) {
662 for (
size_t j = 0;
j <
nCols; ++
j) {
663 v_local_cov.push_back(local_cov(i, j));
664 }
665 }
666 }
668
670 (*m_CLhardware).push_back("PIXEL");
680 (*m_CLparticleLink_eventIndex).push_back(std::move(particleLink_eventIndex));
681 (*m_CLparticleLink_barcode).push_back(std::move(particleLink_barcode));
682 (*m_CLbarcodesLinked).push_back(std::move(barcodesLinked));
683 (*m_CLparticle_charge).push_back(std::move(
charge));
684 (*m_CLetas).push_back(std::move(etas));
685 (*m_CLphis).push_back(std::move(phis));
686 (*m_CLtots).push_back(std::move(tots));
704 (*m_CLlocal_cov).push_back(std::move(v_local_cov));
705 }
710 break;
711 }
712 }
713 }
714 }
715
719
720 if (SCT_ClusterContainer->size() > 0) {
721 const InDetSimDataCollection *sdoCollection = 0;
722 SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{
m_stripSDOKey, ctx};
723 if (not sdoCollectionHandle.
isValid()) {
725 return StatusCode::FAILURE;
726 }
727 sdoCollection = sdoCollectionHandle.
cptr();
728
729 for (const auto clusterCollection : *SCT_ClusterContainer) {
730
731 if (clusterCollection->empty())
732 continue;
733
734 int barrel_endcap =
m_SCT_ID->barrel_ec(clusterCollection->identify());
735 int layer_disk =
m_SCT_ID->layer_disk(clusterCollection->identify());
736 int eta_module =
m_SCT_ID->eta_module(clusterCollection->identify());
737 int phi_module =
m_SCT_ID->phi_module(clusterCollection->identify());
738 int side =
m_SCT_ID->side(clusterCollection->identify());
739
740 const InDetDD::SiDetectorElement *element =
m_SCT_Manager->getDetectorElement(clusterCollection->identify());
741
743 float norm_x = fabs(my_normal.x()) > 1
e-5 ? my_normal.x() : 0.;
744 float norm_y = fabs(my_normal.y()) > 1
e-5 ? my_normal.y() : 0.;
745 float norm_z = fabs(my_normal.z()) > 1
e-5 ? my_normal.z() : 0.;
746
747
748 for (const auto cluster : *clusterCollection) {
749 Identifier clusterId = cluster->identify();
752 }
753
754 const Amg::MatrixX &local_cov = cluster->localCovariance();
755
756 std::vector<std::pair<int, int>>
barcodes = {};
757 std::vector<int> particleLink_eventIndex = {};
758 std::vector<int> particleLink_barcode = {};
759 std::vector<bool> barcodesLinked = {};
760 std::vector<float>
charge = {};
761
762 std::vector<int> tots = {};
763 std::vector<int> strip_ids = {};
764 int min_strip = 999;
765 int max_strip = -999;
766
767 float charge_count = 0;
768 int pixel_count = 0;
769
770 for (
unsigned int rdo = 0; rdo < cluster->rdoList().
size(); rdo++) {
771 const auto &rdoID = cluster->rdoList().at(rdo);
772
774
775 if (min_strip >
strip)
777 if (max_strip <
strip)
779 strip_ids.push_back(
strip);
780
781 tots.push_back(0);
782 ++pixel_count;
783
784 auto pos = sdoCollection->find(rdoID);
785 if (pos != sdoCollection->end()) {
786 for (
auto deposit :
pos->second.getdeposits()) {
787 const HepMcParticleLink &particleLink = deposit.first;
789
790
793 particleLink_eventIndex.push_back(particleLink.
eventIndex());
794 particleLink_barcode.push_back(particleLink.
barcode());
795 charge.push_back(deposit.second);
796 barcodesLinked.push_back(particleLink.
isValid());
797 }
798 }
799 }
800 }
801
802
803 const InDetDD::SCT_ModuleSideDesign *design(
804 dynamic_cast<const InDetDD::SCT_ModuleSideDesign *
>(&element->
design()));
805 if (not design) {
806 ATH_MSG_ERROR(
"Failed at " << __LINE__ <<
" of accessing SCT ModuleSide Design");
807 return StatusCode::FAILURE;
808 }
809
811 std::pair<Amg::Vector3D, Amg::Vector3D> ends(
812 element->
endsOfStrip(InDetDD::SiLocalPosition(locpos.y(), locpos.x(), 0)));
813
815
816 InDetDD::SiLocalPosition localPos_entry = design->localPositionOfCell(InDetDD::SiCellId(min_strip));
817 InDetDD::SiLocalPosition localPos_exit = design->localPositionOfCell(InDetDD::SiCellId(max_strip));
818
824
825 Amg::Vector3D localDirection = localEndPosition - localStartPosition;
826 float loc_eta = 0, loc_phi = 0;
827 cartesion_to_spherical(localDirection, loc_eta, loc_phi);
828
831
833 float glob_eta = 0, glob_phi = 0;
834 cartesion_to_spherical(direction, glob_eta, glob_phi);
835
838
839 float trkphicomp =
direction.dot(my_phiax);
840 float trketacomp =
direction.dot(my_etaax);
841 float trknormcomp =
direction.dot(my_normal);
842 double phi_angle = atan2(trknormcomp, trkphicomp);
843 double eta_angle = atan2(trknormcomp, trketacomp);
844
845
846 clusterIDMapIdx[cluster->identify()] =
m_selected;
847
848 std::vector<int> cst;
850 cst.push_back(-1);
851 }
852 std::vector<double> v_local_cov;
853 if (local_cov.size() > 0) {
854 for (size_t i = 0, nRows = local_cov.rows(), nCols = local_cov.cols(); i < nRows; i++) {
855 for (
size_t j = 0;
j <
nCols; ++
j) {
856 v_local_cov.push_back(local_cov(i, j));
857 }
858 }
859 }
862 (*m_CLhardware).push_back("STRIP");
872 (*m_CLparticleLink_eventIndex).push_back(std::move(particleLink_eventIndex));
873 (*m_CLparticleLink_barcode).push_back(std::move(particleLink_barcode));
874 (*m_CLbarcodesLinked).push_back(std::move(barcodesLinked));
875 (*m_CLparticle_charge).push_back(std::move(
charge));
876 (*m_CLetas).push_back(std::move(strip_ids));
877 (*m_CLphis).push_back(std::move(cst));
878 (*m_CLtots).push_back(std::move(tots));
896 (*m_CLlocal_cov).push_back(v_local_cov);
897 }
898
903 break;
904 }
905 }
906 }
907 }
908
909
913
917
918
920
922
923 if (not xAODPixelSpacePointContainerHandle.
isValid()) {
925 return StatusCode::FAILURE;
926 }
927
928 xAODPixelSPContainer = xAODPixelSpacePointContainerHandle.
cptr();
929
930
933 if (not xAODStripSpacePointContainerHandle.
isValid()) {
935 return StatusCode::FAILURE;
936 }
937 xAODStripSPContainer = xAODStripSpacePointContainerHandle.
cptr();
938
939
942 if (not xAODStripSpacePointOverlapContainerHandle.
isValid()) {
944 return StatusCode::FAILURE;
945 }
946 xAODStripSPOverlapContainer = xAODStripSpacePointOverlapContainerHandle.
cptr();
947
948 int sp_index = 0;
950
951 if (xAODPixelSPContainer && xAODPixelSPContainer->
size() > 0) {
952 for (
const auto sp : *xAODPixelSPContainer) {
953
954 if (not linkAcc.isAvailable(*
sp))
955 ATH_MSG_FATAL(
"no pixel SpacePoint link for xAOD::SpacePoint");
956
957
958 auto trk_sp = *linkAcc(*
sp);
959 const InDet::SiCluster *
cl =
static_cast<const InDet::SiCluster*
>(trk_sp->clusterList().first);
960
972 }
973
974 sp_index++;
978 break;
979 }
980 }
981 }
982
983 if (xAODStripSPContainer && xAODStripSPContainer->
size() > 0) {
984
985
986 for (
const auto sp : *xAODStripSPContainer) {
987
989
990 auto trk_sp = *striplinkAcc(*
sp);
991 const InDet::SiCluster *cl_1 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().first);
992 const InDet::SiCluster *cl_2 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().second);
993
995
1008
1009
1010 std::vector<float> topstripDir(
sp->topStripDirection().data(),
1011 sp->topStripDirection().data() +
1012 sp->topStripDirection().size());
1013
1014 std::vector<float> botstripDir(
sp->bottomStripDirection().data(),
1015 sp->bottomStripDirection().data() +
1016 sp->bottomStripDirection().size());
1017
1018 std::vector<float> DstripCnt(
sp->stripCenterDistance().data(),
1019 sp->stripCenterDistance().data() +
1020 sp->stripCenterDistance().size());
1021
1022 std::vector<float> topstripCnt(
sp->topStripCenter().data(),
1023 sp->topStripCenter().data() +
1024 sp->topStripCenter().size());
1025
1026 (*m_SPtopStripDirection).push_back(std::move(topstripDir));
1027 (*m_SPbottomStripDirection).push_back(std::move(botstripDir));
1028 (*m_SPstripCenterDistance).push_back(std::move(DstripCnt));
1029 (*m_SPtopStripCenterPosition).push_back(std::move(topstripCnt));
1030
1031 }
1032
1033 sp_index++;
1035
1038 break;
1039 }
1040 }
1041 }
1042
1043
1044 if (xAODStripSPOverlapContainer && xAODStripSPOverlapContainer->
size() > 0) {
1045
1046
1047 for (
const auto sp : *xAODStripSPOverlapContainer) {
1048
1050
1051 auto trk_sp = *stripOverlaplinkAcc(*
sp);
1052 const InDet::SiCluster *cl_1 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().first);
1053 const InDet::SiCluster *cl_2 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().second);
1054
1056
1066
1071
1072 if ( flag<1 || flag > 3 )
1074
1075
1079
1080
1081 std::vector<float> topstripDir(
sp->topStripDirection().data(),
1082 sp->topStripDirection().data() +
1083 sp->topStripDirection().size());
1084
1085 std::vector<float> botstripDir(
sp->bottomStripDirection().data(),
1086 sp->bottomStripDirection().data() +
1087 sp->bottomStripDirection().size());
1088
1089 std::vector<float> DstripCnt(
sp->stripCenterDistance().data(),
1090 sp->stripCenterDistance().data() +
1091 sp->stripCenterDistance().size());
1092
1093 std::vector<float> topstripCnt(
sp->topStripCenter().data(),
1094 sp->topStripCenter().data() +
1095 sp->topStripCenter().size());
1096
1097 (*m_SPtopStripDirection).push_back(topstripDir);
1098 (*m_SPbottomStripDirection).push_back(botstripDir);
1099 (*m_SPstripCenterDistance).push_back(DstripCnt);
1100 (*m_SPtopStripCenterPosition).push_back(topstripCnt);
1101
1102 }
1103
1104 sp_index++;
1108 break;
1109 }
1110 }
1111 }
1112
1113
1117
1119 SG::ReadHandle<TrackCollection> trackCollectionHandle{
m_tracksKey, ctx};
1120 if (not trackCollectionHandle.
isValid()) {
1122 return StatusCode::FAILURE;
1123 }
1124 trackCollection = trackCollectionHandle.
cptr();
1125
1126 const TrackTruthCollection *trackTruthCollection = 0;
1127 SG::ReadHandle<TrackTruthCollection> trackTruthCollectionHandle{
m_tracksTruthKey, ctx};
1128 if (not trackTruthCollectionHandle.
isValid()) {
1130 return StatusCode::FAILURE;
1131 }
1132 trackTruthCollection = trackTruthCollectionHandle.
cptr();
1133
1134 int trk_index = 0;
1135
1136
1140 (*m_TRKproperties).clear();
1141 (*m_TRKpattern).clear();
1142 (*m_TRKperigee_position).clear();
1143 (*m_TRKperigee_momentum).clear();
1144 (*m_TRKmeasurementsOnTrack_pixcl_sctcl_index).clear();
1145 (*m_TRKoutliersOnTrack_pixcl_sctcl_index).clear();
1146 }
1147
1148 for (; trackIterator < (*trackCollection).end(); ++trackIterator) {
1149 if (!((*trackIterator))) {
1151 continue;
1152 }
1153 const Trk::TrackInfo &
info = (*trackIterator)->info();
1154 const Trk::FitQuality *
fitQuality = (*trackIterator)->fitQuality();
1156 const DataVector<const Trk::MeasurementBase> *measurementsOnTrack = (*trackIterator)->measurementsOnTrack();
1157 const DataVector<const Trk::MeasurementBase> *outliersOnTrack = (*trackIterator)->outliersOnTrack();
1158
1159 ElementLink<TrackCollection> tracklink;
1160 tracklink.
setElement(
const_cast<Trk::Track *
>(*trackIterator));
1162 const ElementLink<TrackCollection> tracklink2 = tracklink;
1163 TrackTruthCollection::const_iterator
found = trackTruthCollection->find(tracklink2);
1164
1165 const std::bitset<Trk::TrackInfo::NumberOfTrackProperties> &
properties =
info.properties();
1166 std::vector<int> v_properties;
1168 if (properties[i]) {
1169 v_properties.push_back(i);
1170 }
1171 }
1172
1173 const std::bitset<Trk::TrackInfo::NumberOfTrackRecoInfo> &
pattern =
info.patternRecognition();
1174 std::vector<int> v_pattern;
1175 for (std::size_t i = 0;
i <
pattern.size();
i++) {
1176 if (pattern[i]) {
1177 v_pattern.push_back(i);
1178 }
1179 }
1180
1182 float chiSq = 0;
1183 if (fitQuality) {
1186 }
1189 if (perigeeParameters) {
1197 } else {
1204 }
1205 int mot = 0;
1206 int oot = 0;
1207 if (measurementsOnTrack)
1208 mot = measurementsOnTrack->
size();
1209 if (outliersOnTrack)
1210 oot = outliersOnTrack->
size();
1211 std::vector<int> measurementsOnTrack_pixcl_sctcl_index, outliersOnTrack_pixcl_sctcl_index;
1212 int TTCindex, TTCevent_index, TTCparticle_link;
1213 float TTCprobability;
1214 if (measurementsOnTrack) {
1215 for (
size_t i = 0;
i < measurementsOnTrack->
size();
i++) {
1216 const Trk::MeasurementBase *
mb = (*measurementsOnTrack)[
i];
1217 const InDet::PixelClusterOnTrack *pixcl =
dynamic_cast<const InDet::PixelClusterOnTrack *
>(
mb);
1218 const InDet::SCT_ClusterOnTrack *sctcl =
dynamic_cast<const InDet::SCT_ClusterOnTrack *
>(
mb);
1219 if (pixcl) {
1220 measurementsOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[pixcl->
prepRawData()->
identify()]);
1221 }
1222 else if (sctcl) {
1223 measurementsOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[sctcl->
prepRawData()->
identify()]);
1224 } else {
1225 measurementsOnTrack_pixcl_sctcl_index.push_back(-1);
1226 }
1227 }
1228 }
1229 if (outliersOnTrack) {
1230 for (
size_t i = 0;
i < outliersOnTrack->
size();
i++) {
1231 const Trk::MeasurementBase *
mb = (*outliersOnTrack)[
i];
1232 const InDet::PixelClusterOnTrack *pixcl =
dynamic_cast<const InDet::PixelClusterOnTrack *
>(
mb);
1233 const InDet::SCT_ClusterOnTrack *sctcl =
dynamic_cast<const InDet::SCT_ClusterOnTrack *
>(
mb);
1234 if (pixcl) {
1235 outliersOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[pixcl->
prepRawData()->
identify()]);
1236 } else if (sctcl) {
1237 outliersOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[sctcl->
prepRawData()->
identify()]);
1238 } else {
1239 outliersOnTrack_pixcl_sctcl_index.push_back(-1);
1240 }
1241 }
1242 }
1243 if (found != trackTruthCollection->end()) {
1244 TTCindex =
found->first.index();
1245 TTCevent_index =
found->second.particleLink().eventIndex();
1246 TTCparticle_link =
found->second.particleLink().barcode();
1247 TTCprobability =
found->second.probability();
1248 } else {
1249 TTCindex = TTCevent_index = TTCparticle_link = -999;
1250 TTCprobability = -1;
1251 }
1252
1258 (*m_TRKproperties).push_back(std::move(v_properties));
1259 (*m_TRKpattern).push_back(std::move(v_pattern));
1262 (*m_TRKmeasurementsOnTrack_pixcl_sctcl_index).push_back(std::move(measurementsOnTrack_pixcl_sctcl_index));
1263 (*m_TRKoutliersOnTrack_pixcl_sctcl_index).push_back(std::move(outliersOnTrack_pixcl_sctcl_index));
1265 (*m_TRKperigee_position).push_back(std::move(position));
1266 (*m_TRKperigee_momentum).push_back(std::move(momentum));
1273 }
1274
1275 trk_index++;
1276
1280 break;
1281 }
1282 }
1283
1286 if (not detailedTrackTruthCollectionHandle.
isValid()) {
1288 return StatusCode::FAILURE;
1289 }
1290 detailedTrackTruthCollection = detailedTrackTruthCollectionHandle.
cptr();
1291
1294 (*m_DTTtrajectory_eventindex).clear();
1295 (*m_DTTtrajectory_barcode).clear();
1296 (*m_DTTstTruth_subDetType).clear();
1297 (*m_DTTstTrack_subDetType).clear();
1298 (*m_DTTstCommon_subDetType).clear();
1299 }
1300
1301
1302 DetailedTrackTruthCollection::const_iterator detailedTrackTruthIterator = (*detailedTrackTruthCollection).begin();
1303 for (; detailedTrackTruthIterator != (*detailedTrackTruthCollection).end(); ++detailedTrackTruthIterator) {
1304 std::vector<int> DTTtrajectory_eventindex, DTTtrajectory_barcode, DTTstTruth_subDetType, DTTstTrack_subDetType,
1305 DTTstCommon_subDetType;
1306 const TruthTrajectory &traj = detailedTrackTruthIterator->second.trajectory();
1307 for (
size_t j = 0;
j < traj.size();
j++) {
1308 DTTtrajectory_eventindex.push_back(traj[j].
eventIndex());
1309 DTTtrajectory_barcode.push_back(traj[j].
barcode());
1310 }
1311 const SubDetHitStatistics &stTruth = detailedTrackTruthIterator->second.statsTruth();
1312 const SubDetHitStatistics &stTrack = detailedTrackTruthIterator->second.statsTrack();
1313 const SubDetHitStatistics &stCommon = detailedTrackTruthIterator->second.statsCommon();
1316 }
1319 }
1322 }
1323
1327 (*m_DTTtrajectory_eventindex).push_back(std::move(DTTtrajectory_eventindex));
1328 (*m_DTTtrajectory_barcode).push_back(std::move(DTTtrajectory_barcode));
1329 (*m_DTTstTruth_subDetType).push_back(std::move(DTTstTruth_subDetType));
1330 (*m_DTTstTrack_subDetType).push_back(std::move(DTTstTrack_subDetType));
1331 (*m_DTTstCommon_subDetType).push_back(std::move(DTTstCommon_subDetType));
1332 }
1333
1335 }
1336
1337
1338
1341
1342 return StatusCode::SUCCESS;
1343}
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