31 return StatusCode::FAILURE;
36 return StatusCode::FAILURE;
48 ATH_MSG_ERROR(
"Path to NN-based track extension ONNX file is empty! If you want to run this pipeline, you need to provide an input file.");
49 return StatusCode::FAILURE;
55 return StatusCode::SUCCESS;
60 m_tree =
new TTree(
"NNPathFinderMonitoring",
"NNPathFinderMonitoring");
71 return StatusCode::SUCCESS;
76 const std::vector<std::shared_ptr<const FPGATrackSimTrack>> & tracks,
77 std::vector<std::shared_ptr<const FPGATrackSimRoad>> & roads) {
87 for (
int ireg = 0; ireg < rmap_2nd->
getNRegions(); ireg++) {
100 for (std::shared_ptr<const FPGATrackSimTrack>
track : tracks) {
103 if (
track->passedOR() == 0) {
107 const std::vector<FPGATrackSimHit> hitsOnTrack =
track->getFPGATrackSimHits();
111 for (
const auto &thit : hitsOnTrack) {
112 road.
addHit(std::make_shared<const FPGATrackSimHit>(thit));
117 for (
const std::shared_ptr<const FPGATrackSimHit>& hit:
hits) {
118 ATH_MSG_DEBUG(
"Hit " <<
" X: " << hit->getX() <<
" Y: " << hit->getY() <<
" Z: " << hit->getZ() <<
" R: " << hit->getR() <<
" hitType: " << hit->getHitType() <<
" getDetType: " << hit->getDetType());
122 std::vector<miniRoad> roadsToExtrapolate;
123 roadsToExtrapolate.push_back(road);
125 std::vector<miniRoad> completedRoads;
127 std::vector<unsigned long> currentRoadHitFineIDs;
128 std::vector<std::vector<unsigned long>> tmp_predictedHitsFineID;
129 std::vector<unsigned int> currentRoadHitITkLayer;
130 std::vector<std::vector<unsigned int>> tmp_foundHitITkLayer;
131 std::vector<float> currentRoadHitDistancePredFound;
132 std::vector<std::vector<float>> tmp_foundHitDistancePredFound;
134 for (
unsigned int i = 0;
i < roadsToExtrapolate.size();
i++){
135 tmp_predictedHitsFineID.push_back(currentRoadHitFineIDs);
136 tmp_foundHitITkLayer.push_back(currentRoadHitITkLayer);
137 tmp_foundHitDistancePredFound.push_back(currentRoadHitDistancePredFound);
141 while(roadsToExtrapolate.size() > 0) {
142 miniRoad currentRoad = *roadsToExtrapolate.begin();
143 std::vector<unsigned long> tmp_currentRoadHitFineIDs = *tmp_predictedHitsFineID.begin();
144 std::vector<unsigned int> tmp_currentRoadHitITkLayer = *tmp_foundHitITkLayer.begin();
145 std::vector<float> tmp_currentRoadHitDistancePredFound = *tmp_foundHitDistancePredFound.begin();
147 roadsToExtrapolate.erase(roadsToExtrapolate.begin());
148 tmp_predictedHitsFineID.erase(tmp_predictedHitsFineID.begin());
149 tmp_foundHitITkLayer.erase(tmp_foundHitITkLayer.begin());
150 tmp_foundHitDistancePredFound.erase(tmp_foundHitDistancePredFound.begin());
154 ATH_MSG_DEBUG(
"\033[1;31m-------------------------- extraploating road "<<
count <<
"------------------ \033[0m");
160 completedRoads.push_back(currentRoad);
167 std::vector<float> inputTensorValues;
172 std::vector<float> predhit;
182 if (abs(predhit[0]) < 25 && abs(predhit[1]) < 25) {
183 completedRoads.push_back(currentRoad);
193 double rad = std::sqrt(predhit[0] * predhit[0] + predhit[1] * predhit[1]);
194 if (abs(predhit[0]) > 1024 || abs(predhit[1]) > 1024 ||
rad > 1024 || abs(predhit[2]) > 3000) {
195 completedRoads.push_back(currentRoad);
204 ATH_MSG_DEBUG(
"Predicted hit at: " << predhit[0] <<
" " << predhit[1] <<
" " << predhit[2]);
208 bool foundhitForRoad =
false;
211 completedRoads.push_back(currentRoad);
216 unsigned lastLayerInRoad = 0;
217 std::shared_ptr<const FPGATrackSimHit> lastHit;
218 if(!
getLastLayer(currentRoad, lastLayerInRoad, lastHit) or !lastHit) {
222 unsigned layer = lastLayerInRoad+1;
223 bool lastHitWasReal = lastHit->
isReal();
224 float lastHitR = lastHit->
getR();
226 completedRoads.push_back(currentRoad);
230 unsigned int hitsInWindow = 0;
233 std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>> listofHitsFound;
235 for (
const std::shared_ptr<const FPGATrackSimHit>& hit:
hits) {
238 if ((hit->getHitType() ==
HitType::spacepoint) && ((hit->getPhysLayer(
true)) %2 == 1))
continue;
240 ATH_MSG_DEBUG(
"In the hit loop hit at: " << hit->getX() <<
" " << hit->getY() <<
" " << hit->getZ());
244 if (
getFineID(*hit) == fineID && hit->isReal()) {
246 double hitz = hit->getZ();
247 double hitr = hit->getR();
248 double predr = sqrt(predhit[0] * predhit[0] + predhit[1] * predhit[1]);
249 double predz = predhit[2];
268 if (abs(hitr - predr) < windowR && abs(hitz - predz) < windowZ) {
269 std::vector<std::shared_ptr<const FPGATrackSimHit>> theseHits {hit};
270 hitsInWindow = hitsInWindow + 1;
280 std::shared_ptr<FPGATrackSimHit> guessedSecondHitPtr = std::make_shared<FPGATrackSimHit>();
281 guessedSecondHitPtr->
setX(0);
282 guessedSecondHitPtr->
setY(0);
283 guessedSecondHitPtr->
setZ(0);
289 theseHits.push_back(guessedSecondHitPtr);
293 listofHitsFound.push_back(theseHits);
299 std::sort(listofHitsFound.begin(), listofHitsFound.end(), [&predhit](
auto&
a,
auto&
b){
300 double predr = sqrt(predhit[0] * predhit[0] + predhit[1] * predhit[1]);
301 double predz = predhit[2];
304 double hitz = a[0]->getZ();
305 double hitr = a[0]->getR();
306 float distance_a = sqrt((hitr - predr)*(hitr - predr) + (hitz - predz)*(hitz - predz));
311 float distance_b = sqrt((hitr - predr)*(hitr - predr) + (hitz - predz)*(hitz - predz));
313 return distance_a < distance_b;
317 std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>> cleanHitsToGrow;
322 cleanHitsToGrow.reserve(nHitsToChoose);
323 std::copy(listofHitsFound.begin(), listofHitsFound.begin() + nHitsToChoose, std::back_inserter(cleanHitsToGrow));
326 cleanHitsToGrow = std::move(listofHitsFound);
330 for (
auto& hitsFound: cleanHitsToGrow) {
332 auto hit = hitsFound[0];
335 double hitz = hit->getZ();
336 double hitr = hit->getR();
337 double predr = sqrt(predhit[0] * predhit[0] + predhit[1] * predhit[1]);
338 double predz = predhit[2];
339 float distancePredFound = sqrt((hitr - predr)*(hitr - predr) + (hitz - predz)*(hitz - predz));
343 if(!
addHitToRoad(newRoad, currentRoad, std::move(hitsFound))) {
347 roadsToExtrapolate.push_back(newRoad);
348 foundhitForRoad =
true;
349 tmp_currentRoadHitFineIDs.push_back(fineID);
350 tmp_predictedHitsFineID.push_back(tmp_currentRoadHitFineIDs);
351 tmp_currentRoadHitITkLayer.push_back(hit->getLayerDisk());
352 tmp_foundHitITkLayer.push_back(tmp_currentRoadHitITkLayer);
353 tmp_currentRoadHitDistancePredFound.push_back(distancePredFound);
354 tmp_foundHitDistancePredFound.push_back(tmp_currentRoadHitDistancePredFound);
362 if (!foundhitForRoad) {
370 std::vector<std::shared_ptr<const FPGATrackSimHit>> theseHits;
372 if (!
getFakeHit(currentRoad, predhit, fineID, theseHits)) {
382 if (!
addHitToRoad(newroad, currentRoad, std::move(theseHits))) {
386 roadsToExtrapolate.push_back(newroad);
387 tmp_predictedHitsFineID.push_back(tmp_currentRoadHitFineIDs);
388 tmp_foundHitITkLayer.push_back(tmp_currentRoadHitITkLayer);
389 tmp_foundHitDistancePredFound.push_back(tmp_currentRoadHitDistancePredFound);
396 for (
const auto &miniroad : completedRoads) {
410 std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>> roadhits = miniroad.getVecHits();
412 if (roadhits.size() > nexpected) {
413 roadhits.resize(nexpected);
415 else if (roadhits.size() < nexpected) {
417 std::shared_ptr<FPGATrackSimHit> emptyHitPtr = std::make_shared<FPGATrackSimHit>();
418 emptyHitPtr->
setX(0);
419 emptyHitPtr->
setY(0);
420 emptyHitPtr->
setZ(0);
423 std::vector<std::shared_ptr<const FPGATrackSimHit>> hitVec;
424 hitVec.push_back(emptyHitPtr);
425 roadhits.push_back(hitVec);
427 wclayers |= (1 <<
layer);
431 road.
setHits(std::move(roadhits));
436 currentRoadHitFineIDs.clear();
437 tmp_predictedHitsFineID.clear();
438 currentRoadHitITkLayer.clear();
439 tmp_foundHitITkLayer.clear();
440 currentRoadHitDistancePredFound.clear();
441 tmp_foundHitDistancePredFound.clear();
449 roads.emplace_back(std::make_shared<const FPGATrackSimRoad>(
r));
451 ATH_MSG_DEBUG(
"Found " << roads.size() <<
" new roads in second stage.");
460 return StatusCode::SUCCESS;
465 std::vector<std::shared_ptr<const FPGATrackSimHit>> hitsR;
467 std::vector<std::shared_ptr<const FPGATrackSimHit>>
hits = thisroad.
getHits();
470 for (
unsigned ihit = 0; ihit <
hits.size(); ihit++) {
472 hitsR.push_back(
hits[ihit]);
475 std::sort(hitsR.begin(), hitsR.end(), [](
auto&
a,
auto&
b){
476 return a->getR() < b->getR();
480 for (
auto thit : hitsR)
486 std::vector<std::shared_ptr<const FPGATrackSimHit>> cleanHits;
487 bool skipHit =
false;
488 for (
auto thit : hitsR)
497 cleanHits.push_back(thit);
502 cleanHits.push_back(thit);
508 cleanHits.push_back(thit);
516 else if (thit->isStrip() && thit->isReal())
519 cleanHits.push_back(thit);
523 ATH_MSG_WARNING(
"No clue how to deal with this hit in the NN predicition ");
535 std::vector<std::shared_ptr<const FPGATrackSimHit>> hitsToEncode;
539 for (
auto thit : cleanHits)
548 for (
auto thit : hitsToEncode)
550 inputTensorValues.push_back(thit->getX()/
getXScale());
551 inputTensorValues.push_back(thit->getY()/
getYScale());
552 inputTensorValues.push_back(thit->getZ()/
getZScale());
557 return StatusCode::SUCCESS;
565 fineID =
std::distance(NNVoloutput.begin(),std::max_element(NNVoloutput.begin(), NNVoloutput.end()));
567 inputTensorValues.insert(inputTensorValues.end(), NNVoloutput.begin(), NNVoloutput.end());
577 return StatusCode::SUCCESS;
584 return StatusCode::SUCCESS;
589 unsigned guessedLayer(0);
591 std::shared_ptr<FPGATrackSimHit> guessedHitPtr = std::make_shared<FPGATrackSimHit>();
592 guessedHitPtr->
setX(predhit[0]);
593 guessedHitPtr->
setY(predhit[1]);
594 guessedHitPtr->
setZ(predhit[2]);
600 guessedLayer = currentRoad.
getNHits();
603 guessedHitPtr->
setLayer(guessedLayer);
616 hits.push_back(guessedHitPtr);
621 std::shared_ptr<FPGATrackSimHit> guessedSecondHitPtr = std::make_shared<FPGATrackSimHit>();
622 guessedSecondHitPtr->
setX(0);
623 guessedSecondHitPtr->
setY(0);
624 guessedSecondHitPtr->
setZ(0);
625 guessedSecondHitPtr->
setLayer( guessedLayer + 1 );
633 hits.push_back(guessedSecondHitPtr);
639 return StatusCode::SUCCESS;
646 for (
const std::shared_ptr<const FPGATrackSimHit>& hit: hitList)
651 return StatusCode::SUCCESS;
658 return StatusCode::FAILURE;
668 std::vector<std::shared_ptr<const FPGATrackSimHit>> hitsR;
669 for (
auto &hit : currentRoad.
getHits()) {
670 hitsR.push_back(hit);
676 std::sort(hitsR.begin(), hitsR.end(), [](
auto&
a,
auto&
b){
677 if(a->getR() == b->getR()) return a->getLayer() < b->getLayer();
678 return a->getR() < b->getR();
683 std::sort(hitsR.begin(), hitsR.end(), [](
auto&
a,
auto&
b){
684 return a->getR() > b->getR();
688 for (
unsigned long i = 0;
i < hitsR.size();
i++)
690 ATH_MSG_DEBUG(
"Hit i "<<
i<<
" X: "<<hitsR[
i]->getX()<<
" Y: "<<hitsR[
i]->getY()<<
" Z: "<<hitsR[
i]->getZ()<<
" R: "<<hitsR[
i]->getR()<<
" hitType: "<<hitsR[
i]->getHitType()<<
" getDetType: "<<hitsR[
i]->getDetType());
698 lastHitLayer = currentRoad.
getNHits()-1;
699 lastHit = currentRoad.
getHit(lastHitLayer);
700 return StatusCode::SUCCESS;