369 {
370
371
372 const EventContext &ctx = Gaudi::Hive::currentContext();
373
375
376
377
378 std::map<Identifier, long int> clusterIDMapIdx;
380
381 std::map<Identifier, long int> clusterIDMapSpacePointIdx;
382
383
384
385 std::map<std::pair<int, int>, std::pair<bool, int>> allTruthParticles;
386
389 if (not mcEventCollectionHandle.
isValid()) {
391 return StatusCode::FAILURE;
392 }
393 mcCollptr = mcEventCollectionHandle.
cptr();
394
395
397 SG::ReadHandle<xAOD::EventInfo> eventInfoHandle(
m_eventInfoKey, ctx);
398 if (not eventInfoHandle.isValid()) {
400 return StatusCode::FAILURE;
401 }
402 eventInfo = eventInfoHandle.cptr();
403
406
407 std::map<int, int> allSubEvents;
408
410
411 bool duplicateSubeventID = false;
412 for (
unsigned int cntr = 0; cntr < mcCollptr->
size(); ++cntr) {
413 int ID = mcCollptr->
at(cntr)->event_number();
416
419 break;
420 }
421 std::map<int, int>::iterator
it = allSubEvents.find(
ID);
422 if (it == allSubEvents.end())
423 allSubEvents.insert(std::make_pair(
ID, 1));
424 else {
426 duplicateSubeventID = true;
427 }
428 }
429
430 if (duplicateSubeventID) {
432 }
433
435
437 (*m_Part_vParentID).clear();
438 (*m_Part_vParentBarcode).clear();
439 }
440
441 for (
unsigned int cntr = 0; cntr < mcCollptr->
size(); ++cntr) {
442 const HepMC::GenEvent *genEvt = (mcCollptr->
at(cntr));
443
444
445
446
450
451 for (auto p : *genEvt) {
452
453 float px,
py,
pz,
pt,
eta, vx, vy, vz,
radius,
status,
charge = 0.;
454 std::vector<int> vParentID;
455 std::vector<int> vParentBarcode;
456
457 int vProdNin, vProdNout, vProdStatus, vProdBarcode;
458 bool passed =
isPassed(p, px, py, pz, pt,
eta, vx, vy, vz, radius, status,
charge, vParentID, vParentBarcode,
459 vProdNin, vProdNout, vProdStatus, vProdBarcode);
460 allTruthParticles.insert(std::make_pair(std::make_pair(genEvt->event_number(),
HepMC::barcode(p)),
461 std::make_pair(
passed, 0)));
462
483 (*m_Part_vParentID).push_back(vParentID);
484 (*m_Part_vParentBarcode).push_back(vParentBarcode);
485 }
486
490 break;
491 }
492 }
493 }
494
496 SG::ReadHandle<InDet::PixelClusterContainer> pixelClusterContainerHandle{
m_pixelClusterKey, ctx};
497 if (not pixelClusterContainerHandle.
isValid()) {
499 return StatusCode::FAILURE;
500 }
502
504 SG::ReadHandle<InDet::SCT_ClusterContainer> stripClusterContainerHandle{
m_stripClusterKey, ctx};
505 if (not stripClusterContainerHandle.
isValid()) {
507 return StatusCode::FAILURE;
508 }
509 SCT_ClusterContainer = stripClusterContainerHandle.
cptr();
510
511 auto cartesion_to_spherical = [](
const Amg::Vector3D &xyzVec,
float &eta_,
float &phi_) {
512 float r3 = 0;
513 for (
int idx = 0;
idx < 3; ++
idx) {
514 r3 += xyzVec[
idx] * xyzVec[
idx];
515 }
516 r3 = sqrt(r3);
517 phi_ = atan2(xyzVec[1], xyzVec[0]);
518 float theta_ = acos(xyzVec[2] / r3);
519 eta_ =
log(
tan(0.5 * theta_));
520 };
521
525
528 (*m_CLhardware).clear();
529 (*m_CLparticleLink_eventIndex).clear();
530 (*m_CLparticleLink_barcode).clear();
531 (*m_CLbarcodesLinked).clear();
532 (*m_CLparticle_charge).clear();
533 (*m_CLphis).clear();
534 (*m_CLetas).clear();
535 (*m_CLtots).clear();
536 (*m_CLlocal_cov).clear();
537 }
538
540
541 const InDetSimDataCollection *sdoCollection = 0;
542 SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{
m_pixelSDOKey, ctx};
543 if (not sdoCollectionHandle.
isValid()) {
545 return StatusCode::FAILURE;
546 }
547 sdoCollection = sdoCollectionHandle.
cptr();
548
549 for (const auto clusterCollection : *PixelClusterContainer) {
550
551 if (clusterCollection->empty())
552 continue;
553
554 int barrel_endcap =
m_pixelID->barrel_ec(clusterCollection->identify());
555 int layer_disk =
m_pixelID->layer_disk(clusterCollection->identify());
556 int eta_module =
m_pixelID->eta_module(clusterCollection->identify());
557 int phi_module =
m_pixelID->phi_module(clusterCollection->identify());
558
559 const InDetDD::SiDetectorElement *element =
m_pixelManager->getDetectorElement(clusterCollection->identify());
560
562 float norm_x = fabs(my_normal.x()) > 1
e-5 ? my_normal.x() : 0.;
563 float norm_y = fabs(my_normal.y()) > 1
e-5 ? my_normal.y() : 0.;
564 float norm_z = fabs(my_normal.z()) > 1
e-5 ? my_normal.z() : 0.;
565
566 const InDetDD::PixelModuleDesign *design(
dynamic_cast<const InDetDD::PixelModuleDesign *
>(&element->
design()));
567
568 if (not design) {
569 ATH_MSG_ERROR(
"Dynamic cast failed at " << __LINE__ <<
" of MergedPixelsTool.cxx.");
570 return StatusCode::FAILURE;
571 }
572
573
574 for (const auto cluster : *clusterCollection) {
575 Identifier clusterId = cluster->identify();
578 }
579
580 const Amg::MatrixX &local_cov = cluster->localCovariance();
581
582 std::vector<std::pair<int, int>>
barcodes = {};
583 std::vector<int> particleLink_eventIndex = {};
584 std::vector<int> particleLink_barcode = {};
585 std::vector<bool> barcodesLinked = {};
586 std::vector<float>
charge = {};
587 std::vector<int> phis = {};
588 std::vector<int>
etas = {};
589 std::vector<int> tots = {};
590 int min_eta = 999;
591 int min_phi = 999;
592 int max_eta = -999;
593 int max_phi = -999;
594
595 float charge_count = 0;
596 int pixel_count = 0;
597
598 for (unsigned int rdo = 0; rdo < cluster->rdoList().size(); rdo++) {
599 const auto &rdoID = cluster->rdoList().at(rdo);
610
611 ++pixel_count;
612 charge_count += cluster->totList().at(rdo);
613
616 tots.push_back(cluster->totList().at(rdo));
617
618 auto pos = sdoCollection->find(rdoID);
619 if (pos != sdoCollection->end()) {
620 for (
auto deposit :
pos->second.getdeposits()) {
621 const HepMcParticleLink &particleLink = deposit.first;
623
626 particleLink_eventIndex.push_back(particleLink.
eventIndex());
627 particleLink_barcode.push_back(particleLink.
barcode());
628 charge.push_back(deposit.second);
629 barcodesLinked.push_back(particleLink.
isValid());
630 }
631 }
632 }
633 }
634
635 InDetDD::SiLocalPosition localPos_entry = design->localPositionOfCell(InDetDD::SiCellId(min_phi, min_eta));
636 InDetDD::SiLocalPosition localPos_exit = design->localPositionOfCell(InDetDD::SiCellId(max_phi, max_eta));
637
643
644
645
646 Amg::Vector3D localDirection = localEndPosition - localStartPosition;
647
648 float loc_eta = 0, loc_phi = 0;
649 cartesion_to_spherical(localDirection, loc_eta, loc_phi);
650
653
654 Amg::Vector3D direction = globalEndPosition - globalStartPosition;
655 float glob_eta = 0, glob_phi = 0;
656 cartesion_to_spherical(direction, glob_eta, glob_phi);
657
660
661 float trkphicomp = direction.dot(my_phiax);
662 float trketacomp = direction.dot(my_etaax);
663 float trknormcomp = direction.dot(my_normal);
664 double phi_angle = atan2(trknormcomp, trkphicomp);
665 double eta_angle = atan2(trknormcomp, trketacomp);
666
667 clusterIDMapIdx[cluster->identify()] =
m_selected;
668 std::vector<double> v_local_cov;
669 if (local_cov.size() > 0) {
670 for (size_t i = 0, nRows = local_cov.rows(), nCols = local_cov.cols(); i < nRows; i++) {
671 for (
size_t j = 0; j <
nCols; ++j) {
672 v_local_cov.push_back(local_cov(i, j));
673 }
674 }
675 }
677
679 (*m_CLhardware).push_back("PIXEL");
689 (*m_CLparticleLink_eventIndex).push_back(particleLink_eventIndex);
690 (*m_CLparticleLink_barcode).push_back(particleLink_barcode);
691 (*m_CLbarcodesLinked).push_back(barcodesLinked);
692 (*m_CLparticle_charge).push_back(
charge);
693 (*m_CLetas).push_back(etas);
694 (*m_CLphis).push_back(phis);
695 (*m_CLtots).push_back(tots);
713 (*m_CLlocal_cov).push_back(v_local_cov);
714 }
719 break;
720 }
721 }
722 }
723 }
724
728
729 if (SCT_ClusterContainer->size() > 0) {
730 const InDetSimDataCollection *sdoCollection = 0;
731 SG::ReadHandle<InDetSimDataCollection> sdoCollectionHandle{
m_stripSDOKey, ctx};
732 if (not sdoCollectionHandle.
isValid()) {
734 return StatusCode::FAILURE;
735 }
736 sdoCollection = sdoCollectionHandle.
cptr();
737
738 for (const auto clusterCollection : *SCT_ClusterContainer) {
739
740 if (clusterCollection->empty())
741 continue;
742
743 int barrel_endcap =
m_SCT_ID->barrel_ec(clusterCollection->identify());
744 int layer_disk =
m_SCT_ID->layer_disk(clusterCollection->identify());
745 int eta_module =
m_SCT_ID->eta_module(clusterCollection->identify());
746 int phi_module =
m_SCT_ID->phi_module(clusterCollection->identify());
747 int side =
m_SCT_ID->side(clusterCollection->identify());
748
749 const InDetDD::SiDetectorElement *element =
m_SCT_Manager->getDetectorElement(clusterCollection->identify());
750
752 float norm_x = fabs(my_normal.x()) > 1
e-5 ? my_normal.x() : 0.;
753 float norm_y = fabs(my_normal.y()) > 1
e-5 ? my_normal.y() : 0.;
754 float norm_z = fabs(my_normal.z()) > 1
e-5 ? my_normal.z() : 0.;
755
756
757 for (const auto cluster : *clusterCollection) {
758 Identifier clusterId = cluster->identify();
761 }
762
763 const Amg::MatrixX &local_cov = cluster->localCovariance();
764
765 std::vector<std::pair<int, int>>
barcodes = {};
766 std::vector<int> particleLink_eventIndex = {};
767 std::vector<int> particleLink_barcode = {};
768 std::vector<bool> barcodesLinked = {};
769 std::vector<float>
charge = {};
770
771 std::vector<int> tots = {};
772 std::vector<int> strip_ids = {};
773 int min_strip = 999;
774 int max_strip = -999;
775
776 float charge_count = 0;
777 int pixel_count = 0;
778
779 for (unsigned int rdo = 0; rdo < cluster->rdoList().size(); rdo++) {
780 const auto &rdoID = cluster->rdoList().at(rdo);
781
783
784 if (min_strip >
strip)
786 if (max_strip <
strip)
788 strip_ids.push_back(
strip);
789
790 tots.push_back(0);
791 ++pixel_count;
792
793 auto pos = sdoCollection->find(rdoID);
794 if (pos != sdoCollection->end()) {
795 for (
auto deposit :
pos->second.getdeposits()) {
796 const HepMcParticleLink &particleLink = deposit.first;
798
799
802 particleLink_eventIndex.push_back(particleLink.
eventIndex());
803 particleLink_barcode.push_back(particleLink.
barcode());
804 charge.push_back(deposit.second);
805 barcodesLinked.push_back(particleLink.
isValid());
806 }
807 }
808 }
809 }
810
811
812 const InDetDD::SCT_ModuleSideDesign *design(
813 dynamic_cast<const InDetDD::SCT_ModuleSideDesign *
>(&element->
design()));
814 if (not design) {
815 ATH_MSG_ERROR(
"Failed at " << __LINE__ <<
" of accessing SCT ModuleSide Design");
816 return StatusCode::FAILURE;
817 }
818
820 std::pair<Amg::Vector3D, Amg::Vector3D> ends(
821 element->
endsOfStrip(InDetDD::SiLocalPosition(locpos.y(), locpos.x(), 0)));
822
824
825 InDetDD::SiLocalPosition localPos_entry = design->localPositionOfCell(InDetDD::SiCellId(min_strip));
826 InDetDD::SiLocalPosition localPos_exit = design->localPositionOfCell(InDetDD::SiCellId(max_strip));
827
833
834 Amg::Vector3D localDirection = localEndPosition - localStartPosition;
835 float loc_eta = 0, loc_phi = 0;
836 cartesion_to_spherical(localDirection, loc_eta, loc_phi);
837
840
841 Amg::Vector3D direction = globalEndPosition - globalStartPosition;
842 float glob_eta = 0, glob_phi = 0;
843 cartesion_to_spherical(direction, glob_eta, glob_phi);
844
847
848 float trkphicomp = direction.dot(my_phiax);
849 float trketacomp = direction.dot(my_etaax);
850 float trknormcomp = direction.dot(my_normal);
851 double phi_angle = atan2(trknormcomp, trkphicomp);
852 double eta_angle = atan2(trknormcomp, trketacomp);
853
854
855 clusterIDMapIdx[cluster->identify()] =
m_selected;
856
857 std::vector<int> cst;
859 cst.push_back(-1);
860 }
861 std::vector<double> v_local_cov;
862 if (local_cov.size() > 0) {
863 for (size_t i = 0, nRows = local_cov.rows(), nCols = local_cov.cols(); i < nRows; i++) {
864 for (
size_t j = 0; j <
nCols; ++j) {
865 v_local_cov.push_back(local_cov(i, j));
866 }
867 }
868 }
871 (*m_CLhardware).push_back("STRIP");
881 (*m_CLparticleLink_eventIndex).push_back(particleLink_eventIndex);
882 (*m_CLparticleLink_barcode).push_back(particleLink_barcode);
883 (*m_CLbarcodesLinked).push_back(barcodesLinked);
884 (*m_CLparticle_charge).push_back(
charge);
885 (*m_CLetas).push_back(strip_ids);
886 (*m_CLphis).push_back(cst);
887 (*m_CLtots).push_back(tots);
905 (*m_CLlocal_cov).push_back(v_local_cov);
906 }
907
912 break;
913 }
914 }
915 }
916 }
917
918
922
923 static const SG::Accessor< ElementLink<SpacePointCollection> > linkAcc("pixelSpacePointLink");
924 static const SG::Accessor< ElementLink< ::SpacePointCollection > > striplinkAcc("sctSpacePointLink");
925 static const SG::Accessor< ElementLink< ::SpacePointOverlapCollection > > stripOverlaplinkAcc("stripOverlapSpacePointLink");
926
927
929
931
932 if (not xAODPixelSpacePointContainerHandle.
isValid()) {
934 return StatusCode::FAILURE;
935 }
936
937 xAODPixelSPContainer = xAODPixelSpacePointContainerHandle.
cptr();
938
939
942 if (not xAODStripSpacePointContainerHandle.
isValid()) {
944 return StatusCode::FAILURE;
945 }
946 xAODStripSPContainer = xAODStripSpacePointContainerHandle.
cptr();
947
948
951 if (not xAODStripSpacePointOverlapContainerHandle.
isValid()) {
953 return StatusCode::FAILURE;
954 }
955 xAODStripSPOverlapContainer = xAODStripSpacePointOverlapContainerHandle.
cptr();
956
957 int sp_index = 0;
959
960 if (xAODPixelSPContainer && xAODPixelSPContainer->
size() > 0) {
961 for (
const auto sp : *xAODPixelSPContainer) {
962
963 if (not linkAcc.isAvailable(*
sp))
964 ATH_MSG_FATAL(
"no pixel SpacePoint link for xAOD::SpacePoint");
965
966
967 auto trk_sp = *linkAcc(*
sp);
968 const InDet::SiCluster *
cl =
static_cast<const InDet::SiCluster*
>(trk_sp->clusterList().first);
969
981 }
982
983 sp_index++;
987 break;
988 }
989 }
990 }
991
992 if (xAODStripSPContainer && xAODStripSPContainer->
size() > 0) {
993
994
995 for (
const auto sp : *xAODStripSPContainer) {
996
998
999 auto trk_sp = *striplinkAcc(*
sp);
1000 const InDet::SiCluster *cl_1 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().first);
1001 const InDet::SiCluster *cl_2 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().second);
1002
1004
1017
1018
1019 std::vector<float> topstripDir(
sp->topStripDirection().data(),
1020 sp->topStripDirection().data() +
1021 sp->topStripDirection().size());
1022
1023 std::vector<float> botstripDir(
sp->bottomStripDirection().data(),
1024 sp->bottomStripDirection().data() +
1025 sp->bottomStripDirection().size());
1026
1027 std::vector<float> DstripCnt(
sp->stripCenterDistance().data(),
1028 sp->stripCenterDistance().data() +
1029 sp->stripCenterDistance().size());
1030
1031 std::vector<float> topstripCnt(
sp->topStripCenter().data(),
1032 sp->topStripCenter().data() +
1033 sp->topStripCenter().size());
1034
1035 (*m_SPtopStripDirection).push_back(topstripDir);
1036 (*m_SPbottomStripDirection).push_back(botstripDir);
1037 (*m_SPstripCenterDistance).push_back(DstripCnt);
1038 (*m_SPtopStripCenterPosition).push_back(topstripCnt);
1039
1040 }
1041
1042 sp_index++;
1044
1047 break;
1048 }
1049 }
1050 }
1051
1052
1053 if (xAODStripSPOverlapContainer && xAODStripSPOverlapContainer->
size() > 0) {
1054
1055
1056 for (
const auto sp : *xAODStripSPOverlapContainer) {
1057
1059
1060 auto trk_sp = *stripOverlaplinkAcc(*
sp);
1061 const InDet::SiCluster *cl_1 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().first);
1062 const InDet::SiCluster *cl_2 = static_cast<const InDet::SiCluster *>(trk_sp->clusterList().second);
1063
1065
1075
1080
1081 if ( flag<1 || flag > 3 )
1083
1084
1088
1089
1090 std::vector<float> topstripDir(
sp->topStripDirection().data(),
1091 sp->topStripDirection().data() +
1092 sp->topStripDirection().size());
1093
1094 std::vector<float> botstripDir(
sp->bottomStripDirection().data(),
1095 sp->bottomStripDirection().data() +
1096 sp->bottomStripDirection().size());
1097
1098 std::vector<float> DstripCnt(
sp->stripCenterDistance().data(),
1099 sp->stripCenterDistance().data() +
1100 sp->stripCenterDistance().size());
1101
1102 std::vector<float> topstripCnt(
sp->topStripCenter().data(),
1103 sp->topStripCenter().data() +
1104 sp->topStripCenter().size());
1105
1106 (*m_SPtopStripDirection).push_back(topstripDir);
1107 (*m_SPbottomStripDirection).push_back(botstripDir);
1108 (*m_SPstripCenterDistance).push_back(DstripCnt);
1109 (*m_SPtopStripCenterPosition).push_back(topstripCnt);
1110
1111 }
1112
1113 sp_index++;
1117 break;
1118 }
1119 }
1120 }
1121
1122
1126
1128 SG::ReadHandle<TrackCollection> trackCollectionHandle{
m_tracksKey, ctx};
1129 if (not trackCollectionHandle.
isValid()) {
1131 return StatusCode::FAILURE;
1132 }
1133 trackCollection = trackCollectionHandle.
cptr();
1134
1135 const TrackTruthCollection *trackTruthCollection = 0;
1136 SG::ReadHandle<TrackTruthCollection> trackTruthCollectionHandle{
m_tracksTruthKey, ctx};
1137 if (not trackTruthCollectionHandle.
isValid()) {
1139 return StatusCode::FAILURE;
1140 }
1141 trackTruthCollection = trackTruthCollectionHandle.
cptr();
1142
1143 int trk_index = 0;
1144
1145
1149 (*m_TRKproperties).clear();
1150 (*m_TRKpattern).clear();
1151 (*m_TRKperigee_position).clear();
1152 (*m_TRKperigee_momentum).clear();
1153 (*m_TRKmeasurementsOnTrack_pixcl_sctcl_index).clear();
1154 (*m_TRKoutliersOnTrack_pixcl_sctcl_index).clear();
1155 }
1156
1157 for (; trackIterator < (*trackCollection).end(); ++trackIterator) {
1158 if (!((*trackIterator))) {
1160 continue;
1161 }
1162 const Trk::TrackInfo &
info = (*trackIterator)->info();
1163 const Trk::FitQuality *
fitQuality = (*trackIterator)->fitQuality();
1165 const DataVector<const Trk::MeasurementBase> *measurementsOnTrack = (*trackIterator)->measurementsOnTrack();
1166 const DataVector<const Trk::MeasurementBase> *outliersOnTrack = (*trackIterator)->outliersOnTrack();
1167
1168 ElementLink<TrackCollection> tracklink;
1169 tracklink.
setElement(
const_cast<Trk::Track *
>(*trackIterator));
1171 const ElementLink<TrackCollection> tracklink2 = tracklink;
1172 TrackTruthCollection::const_iterator
found = trackTruthCollection->find(tracklink2);
1173
1174 const std::bitset<Trk::TrackInfo::NumberOfTrackProperties> &
properties =
info.properties();
1175 std::vector<int> v_properties;
1177 if (properties[i]) {
1178 v_properties.push_back(i);
1179 }
1180 }
1181
1182 const std::bitset<Trk::TrackInfo::NumberOfTrackRecoInfo> &
pattern =
info.patternRecognition();
1183 std::vector<int> v_pattern;
1184 for (std::size_t i = 0;
i <
pattern.size();
i++) {
1185 if (pattern[i]) {
1186 v_pattern.push_back(i);
1187 }
1188 }
1189
1191 float chiSq = 0;
1192 if (fitQuality) {
1195 }
1196 std::vector<double> position,
momentum;
1198 if (perigeeParameters) {
1206 } else {
1207 position.push_back(0);
1208 position.push_back(0);
1209 position.push_back(0);
1213 }
1214 int mot = 0;
1215 int oot = 0;
1216 if (measurementsOnTrack)
1217 mot = measurementsOnTrack->
size();
1218 if (outliersOnTrack)
1219 oot = outliersOnTrack->
size();
1220 std::vector<int> measurementsOnTrack_pixcl_sctcl_index, outliersOnTrack_pixcl_sctcl_index;
1221 int TTCindex, TTCevent_index, TTCparticle_link;
1222 float TTCprobability;
1223 if (measurementsOnTrack) {
1224 for (
size_t i = 0;
i < measurementsOnTrack->
size();
i++) {
1225 const Trk::MeasurementBase *
mb = (*measurementsOnTrack)[
i];
1226 const InDet::PixelClusterOnTrack *pixcl =
dynamic_cast<const InDet::PixelClusterOnTrack *
>(
mb);
1227 const InDet::SCT_ClusterOnTrack *sctcl =
dynamic_cast<const InDet::SCT_ClusterOnTrack *
>(
mb);
1228 if (pixcl) {
1229 measurementsOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[pixcl->
prepRawData()->
identify()]);
1230 }
1231 else if (sctcl) {
1232 measurementsOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[sctcl->
prepRawData()->
identify()]);
1233 } else {
1234 measurementsOnTrack_pixcl_sctcl_index.push_back(-1);
1235 }
1236 }
1237 }
1238 if (outliersOnTrack) {
1239 for (
size_t i = 0;
i < outliersOnTrack->
size();
i++) {
1240 const Trk::MeasurementBase *
mb = (*outliersOnTrack)[
i];
1241 const InDet::PixelClusterOnTrack *pixcl =
dynamic_cast<const InDet::PixelClusterOnTrack *
>(
mb);
1242 const InDet::SCT_ClusterOnTrack *sctcl =
dynamic_cast<const InDet::SCT_ClusterOnTrack *
>(
mb);
1243 if (pixcl) {
1244 outliersOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[pixcl->
prepRawData()->
identify()]);
1245 } else if (sctcl) {
1246 outliersOnTrack_pixcl_sctcl_index.push_back(clusterIDMapIdx[sctcl->
prepRawData()->
identify()]);
1247 } else {
1248 outliersOnTrack_pixcl_sctcl_index.push_back(-1);
1249 }
1250 }
1251 }
1252 if (found != trackTruthCollection->end()) {
1253 TTCindex =
found->first.index();
1254 TTCevent_index =
found->second.particleLink().eventIndex();
1255 TTCparticle_link =
found->second.particleLink().barcode();
1256 TTCprobability =
found->second.probability();
1257 } else {
1258 TTCindex = TTCevent_index = TTCparticle_link = -999;
1259 TTCprobability = -1;
1260 }
1261
1267 (*m_TRKproperties).push_back(v_properties);
1268 (*m_TRKpattern).push_back(v_pattern);
1271 (*m_TRKmeasurementsOnTrack_pixcl_sctcl_index).push_back(measurementsOnTrack_pixcl_sctcl_index);
1272 (*m_TRKoutliersOnTrack_pixcl_sctcl_index).push_back(outliersOnTrack_pixcl_sctcl_index);
1274 (*m_TRKperigee_position).push_back(position);
1275 (*m_TRKperigee_momentum).push_back(momentum);
1282 }
1283
1284 trk_index++;
1285
1289 break;
1290 }
1291 }
1292
1295 if (not detailedTrackTruthCollectionHandle.
isValid()) {
1297 return StatusCode::FAILURE;
1298 }
1299 detailedTrackTruthCollection = detailedTrackTruthCollectionHandle.
cptr();
1300
1303 (*m_DTTtrajectory_eventindex).clear();
1304 (*m_DTTtrajectory_barcode).clear();
1305 (*m_DTTstTruth_subDetType).clear();
1306 (*m_DTTstTrack_subDetType).clear();
1307 (*m_DTTstCommon_subDetType).clear();
1308 }
1309
1310
1311 DetailedTrackTruthCollection::const_iterator detailedTrackTruthIterator = (*detailedTrackTruthCollection).begin();
1312 for (; detailedTrackTruthIterator != (*detailedTrackTruthCollection).end(); ++detailedTrackTruthIterator) {
1313 std::vector<int> DTTtrajectory_eventindex, DTTtrajectory_barcode, DTTstTruth_subDetType, DTTstTrack_subDetType,
1314 DTTstCommon_subDetType;
1315 const TruthTrajectory &traj = detailedTrackTruthIterator->second.trajectory();
1316 for (size_t j = 0; j < traj.size(); j++) {
1317 DTTtrajectory_eventindex.push_back(traj[j].
eventIndex());
1318 DTTtrajectory_barcode.push_back(traj[j].
barcode());
1319 }
1320 const SubDetHitStatistics &stTruth = detailedTrackTruthIterator->second.statsTruth();
1321 const SubDetHitStatistics &stTrack = detailedTrackTruthIterator->second.statsTrack();
1322 const SubDetHitStatistics &stCommon = detailedTrackTruthIterator->second.statsCommon();
1325 }
1328 }
1331 }
1332
1336 (*m_DTTtrajectory_eventindex).push_back(DTTtrajectory_eventindex);
1337 (*m_DTTtrajectory_barcode).push_back(DTTtrajectory_barcode);
1338 (*m_DTTstTruth_subDetType).push_back(DTTstTruth_subDetType);
1339 (*m_DTTstTrack_subDetType).push_back(DTTstTrack_subDetType);
1340 (*m_DTTstCommon_subDetType).push_back(DTTstCommon_subDetType);
1341 }
1342
1344 }
1345
1346
1347
1350
1351 return StatusCode::SUCCESS;
1352}
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)
std::vector< Identifier > ID
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 to point to an element.
bool setStorableObject(BaseConstReference data, bool replace=false, IProxyDict *sg=0)
Set link to point to a new container (storable).
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
thread_local event_number_t eventIndex
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
const double mb
1mb to cm2
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
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
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.14.0