279 {
280
281
282
283
284
285 std::unique_ptr<const Trk::TrackParameters> returnParameters = nullptr;
287 const Trk::TrackingVolume *currVol = nullptr;
288 const Trk::TrackingVolume *nextVol = nullptr;
289 std::vector<unsigned int> solutions;
290 const Trk::TrackingVolume *assocVol = nullptr;
291 unsigned int iDest = 0;
292 const EventContext& ctx = Gaudi::Hive::currentContext();
294
295 if (destVol &&
m_navigator->atVolumeBoundary(currPar, destVol, dir, nextVol,
m_tolerance) && nextVol != destVol) {
297 }
298
299 if (!
cache.m_highestVolume) {
301 }
302
304
307 }
308 cache.m_navigSurfs.clear();
309
310
311 if (destVol) {
312 const Trk::TrackingVolume *tgVol =
m_navigator->trackingGeometry(ctx)->trackingVolume(destVol->
volumeName());
313 if (!tgVol || tgVol != destVol) {
315 for (
unsigned int ib = 0;
ib < bounds.size();
ib++) {
316 const Trk::Surface &surf = (bounds[
ib])->surfaceRepresentation();
317 cache.m_navigSurfs.emplace_back(&surf,
true);
318 }
319 iDest = bounds.size();
320 }
321 }
322
323
324 bool updateStatic = false;
326
328 cache.m_currentStatic =
m_navigator->trackingGeometry(ctx)->lowestStaticTrackingVolume(gp);
329 updateStatic = true;
330 }
331 if (
m_navigator->atVolumeBoundary(currPar,
cache.m_currentStatic, dir, nextVol,
333
334 if (!nextVol) {
338 }
339 cache.m_currentStatic = nextVol;
340 updateStatic = true;
341 }
342
343
344 nextGeoID =
cache.m_currentStatic->geometrySignature();
345
346
348 const Trk::AlignableTrackingVolume *alignTV =
dynamic_cast<const Trk::AlignableTrackingVolume *
> (
cache.m_currentStatic);
349 if (alignTV) {
351 alignTV);
353 if (!aPar) {
354 return returnParameters;
355 }
357
359 }
360 }
361
362
363 if (updateStatic) {
364 cache.m_staticBoundaries.clear();
365 const auto& bounds =
cache.m_currentStatic->boundarySurfaces();
366 for (
unsigned int ib = 0;
ib < bounds.size();
ib++) {
367 const Trk::Surface &surf = (bounds[
ib])->surfaceRepresentation();
368 cache.m_staticBoundaries.emplace_back(&surf,
true);
369 }
370
371 cache.m_detachedVols.clear();
372 cache.m_detachedBoundaries.clear();
373 cache.m_denseVols.clear();
374 cache.m_denseBoundaries.clear();
375 cache.m_layers.clear();
376 cache.m_navigLays.clear();
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
398 if (!detVols.empty()) {
399 Trk::ArraySpan<const Trk::DetachedTrackingVolume* const>::iterator iTer = detVols.begin();
400 for (; iTer != detVols.end(); ++iTer) {
401
402 const Trk::Layer *layR = (*iTer)->layerRepresentation();
404 const auto& detBounds = (*iTer)->trackingVolume()->boundarySurfaces();
406 cache.m_detachedVols.emplace_back(*iTer,
407 detBounds.size());
408 for (unsigned int ibb = 0; ibb < detBounds.size(); ibb++) {
409 const Trk::Surface &surf = (detBounds[ibb])->surfaceRepresentation();
410 cache.m_detachedBoundaries.emplace_back(&surf,
true);
411 }
412 }
else if (
cache.m_currentStatic->geometrySignature() !=
Trk::MS ||
414 (*iTer)->name().substr((*iTer)->name().size() - 4, 4) ==
415 "PERM") {
416
417
418
419
420
421 if ((*iTer)->trackingVolume()->zOverAtimesRho() != 0. &&
422 ((*iTer)->trackingVolume()->confinedDenseVolumes().empty())
423 && (*iTer)->trackingVolume()->confinedArbitraryLayers().empty()) {
424 cache.m_denseVols.emplace_back((*iTer)->trackingVolume(), detBounds.size());
425 for (unsigned int ibb = 0; ibb < detBounds.size(); ibb++) {
426 const Trk::Surface &surf = (detBounds[ibb])->surfaceRepresentation();
427 cache.m_denseBoundaries.emplace_back(&surf,
true);
428 }
429 }
431 if (!(*iTer)->trackingVolume()->confinedDenseVolumes().empty() || (confLays.size() > detBounds.size())) {
432 cache.m_detachedVols.emplace_back(*iTer, detBounds.size());
433 for (unsigned int ibb = 0; ibb < detBounds.size(); ibb++) {
434 const Trk::Surface &surf = (detBounds[ibb])->surfaceRepresentation();
435 cache.m_detachedBoundaries.emplace_back(&surf,
true);
436 }
437 } else if (!confLays.empty()) {
438 for (const Trk::Layer* const lIt : confLays) {
439 cache.m_layers.emplace_back(&(lIt->surfaceRepresentation()),
440 true);
441 cache.m_navigLays.emplace_back((*iTer)->trackingVolume(), lIt);
442 }
443 }
444 }
445 }
446 }
447 cache.m_denseResolved = std::pair<unsigned int, unsigned int> (
cache.m_denseVols.size(),
cache.m_denseBoundaries.size());
448 cache.m_layerResolved =
cache.m_layers.size();
449 }
450
451 cache.m_navigSurfs.insert(
cache.m_navigSurfs.end(),
cache.m_staticBoundaries.begin(),
cache.m_staticBoundaries.end());
452
453
456
457
459 cache.m_navigBoundaries.clear();
460 if (
cache.m_denseVols.size() >
cache.m_denseResolved.first) {
461 cache.m_denseVols.resize(
cache.m_denseResolved.first);
462 }
463 while (
cache.m_denseBoundaries.size() >
cache.m_denseResolved.second) {
464 cache.m_denseBoundaries.pop_back();
465 }
466 if (
cache.m_layers.size() >
cache.m_layerResolved) {
467 cache.m_navigLays.resize(
cache.m_layerResolved);
468 }
469 while (
cache.m_layers.size() >
cache.m_layerResolved) {
470 cache.m_layers.pop_back();
471 }
472
473
474
476
477 std::vector<std::pair<const Trk::TrackingVolume *, unsigned int> > navigVols;
478
480 std::vector<const Trk::DetachedTrackingVolume *> detVols =
481 m_navigator->trackingGeometry(ctx)->lowestDetachedTrackingVolumes(gp);
482 std::vector<const Trk::DetachedTrackingVolume *>::iterator dIter = detVols.begin();
483 for (; dIter != detVols.end(); ++dIter) {
484 const Trk::Layer *layR = (*dIter)->layerRepresentation();
487 continue;
488 }
490 m_useMuonMatApprox && (*dIter)->name().substr((*dIter)->name().size() - 4, 4) !=
"PERM") {
491 continue;
492 }
493 const Trk::TrackingVolume *dVol = (*dIter)->trackingVolume();
494
496 if (dExit) {
497 continue;
498 }
499
502
503 if (!
active && confinedDense.empty() && confinedLays.empty()) {
504 continue;
505 }
507 if (!
active && confinedDense.empty() && confinedLays.size() <= bounds.size()) {
508 continue;
509 }
510 if (!confinedDense.empty() || !confinedLays.empty()) {
511 navigVols.emplace_back(dVol, bounds.size());
512 for (
unsigned int ib = 0;
ib < bounds.size();
ib++) {
513 const Trk::Surface &surf = (bounds[
ib])->surfaceRepresentation();
514 cache.m_navigBoundaries.emplace_back(&surf,
true);
515 }
516
517 if (!confinedDense.empty()) {
518 auto vIter = confinedDense.begin();
519 for (; vIter != confinedDense.end(); ++vIter) {
520 const auto& bounds = (*vIter)->boundarySurfaces();
521 cache.m_denseVols.emplace_back(*vIter, bounds.size());
522 for (
unsigned int ib = 0;
ib < bounds.size();
ib++) {
523 const Trk::Surface &surf = (bounds[
ib])->surfaceRepresentation();
524 cache.m_denseBoundaries.emplace_back(&surf,
true);
525 }
526 }
527 }
528
529 if (!confinedLays.empty()) {
530 for (const auto *confinedLay : confinedLays) {
531 cache.m_layers.emplace_back(&(confinedLay->surfaceRepresentation()),
true);
532 cache.m_navigLays.emplace_back(dVol, confinedLay);
533 }
534 }
535 } else {
539 for (const auto *subvol : subvols) {
541 detVol = subvol;
542 break;
543 }
544 }
545 }
546
547 if (!detVol) {
548 detVol = dVol;
549 }
550 bool vExit =
m_navigator->atVolumeBoundary(currPar, detVol, dir, nextVol,
m_tolerance) && nextVol != detVol;
552 detVol = nextVol;
553 vExit = false;
554 }
555 if (!vExit) {
557 navigVols.emplace_back(detVol, bounds.size());
558 for (
unsigned int ib = 0;
ib < bounds.size();
ib++) {
559 const Trk::Surface &surf = (bounds[
ib])->surfaceRepresentation();
560 cache.m_navigBoundaries.emplace_back(&surf,
true);
561 }
563 cache.m_denseVols.emplace_back(detVol, bounds.size());
564 for (
unsigned int ib = 0;
ib < bounds.size();
ib++) {
565 const Trk::Surface &surf = (bounds[
ib])->surfaceRepresentation();
566 cache.m_denseBoundaries.emplace_back(&surf,
true);
567 }
568 }
569
573 for (const auto *cLay : cLays) {
574 if (cLay->layerType() > 0 || cLay->layerMaterialProperties()) {
575 cache.m_layers.emplace_back(&(cLay->surfaceRepresentation()),
true);
576 cache.m_navigLays.emplace_back(
cache.m_currentStatic,
577 cLay);
578 }
579 }
580 } else {
582
583
584 if (lay) {
586 true);
587 cache.m_navigLays.emplace_back(detVol, lay);
588 }
590 dir * currPar->
momentum().normalized(),
true);
591 if (nextLayer && nextLayer != lay) {
593 cache.m_navigLays.emplace_back(detVol, nextLayer);
594 }
595 }
598 for (const auto *layer : layers) {
599 cache.m_layers.emplace_back(&(
layer->surfaceRepresentation()),
true);
600 cache.m_navigLays.emplace_back(detVol, layer);
601 }
602 }
603 }
604 }
605 }
606
607
608 if (
cache.m_currentStatic->confinedLayers() && updateStatic) {
609
611 std::span<Trk::Layer const * const> cLays =
cache.m_currentStatic->confinedLayers()->arrayObjects();
612 for (const auto *cLay : cLays) {
613 if (cLay->layerType() > 0 || cLay->layerMaterialProperties()) {
614 cache.m_layers.emplace_back(&(cLay->surfaceRepresentation()),
615 true);
616 cache.m_navigLays.emplace_back(
cache.m_currentStatic, cLay);
617 }
618 }
619 } else {
620
621 const Trk::Layer *lay =
cache.m_currentStatic->associatedLayer(gp);
622
623
624
625
626 if (lay) {
628 Trk::BoundaryCheck(false));
629 cache.m_navigLays.emplace_back(
cache.m_currentStatic, lay);
631 if (nextLayer && nextLayer != lay) {
633 Trk::BoundaryCheck(false));
634 cache.m_navigLays.emplace_back(
cache.m_currentStatic,
635 nextLayer);
636 }
638 if (backLayer && backLayer != lay) {
640 Trk::BoundaryCheck(false));
641 cache.m_navigLays.emplace_back(
cache.m_currentStatic,
642 backLayer);
643 }
644 }
645 }
646 }
647
648
649
650
651 if (!
cache.m_layers.empty()) {
652 cache.m_navigSurfs.insert(
cache.m_navigSurfs.end(),
cache.m_layers.begin(),
cache.m_layers.end());
653 }
654 if (!
cache.m_denseBoundaries.empty()) {
655 cache.m_navigSurfs.insert(
cache.m_navigSurfs.end(),
cache.m_denseBoundaries.begin(),
cache.m_denseBoundaries.end());
656 }
657 if (!
cache.m_navigBoundaries.empty()) {
658 cache.m_navigSurfs.insert(
cache.m_navigSurfs.end(),
cache.m_navigBoundaries.begin(),
cache.m_navigBoundaries.end());
659 }
660 if (!
cache.m_detachedBoundaries.empty()) {
661 cache.m_navigSurfs.insert(
cache.m_navigSurfs.end(),
cache.m_detachedBoundaries.begin(),
cache.m_detachedBoundaries.end());
662 }
663
664
665
667 if (
cache.m_dense &&
cache.m_denseVols.empty()) {
669 } else {
670 for (
unsigned int i = 0;
i <
cache.m_denseVols.size();
i++) {
671 const Trk::TrackingVolume *dVol =
cache.m_denseVols[
i].first;
674 cache.m_currentDense = dVol;
675 }
676 }
677 }
678 }
679
680
681 if (
cache.m_hitVector) {
682 for (
unsigned int i = 0;
i <
cache.m_navigLays.size();
i++) {
683 if (
cache.m_navigLays[i].second->layerType() > 0 &&
cache.m_navigLays[i].second->isOnLayer(currPar->
position())) {
684 if (
cache.m_navigLays[i].second->surfaceArray()) {
685
688 particle);
689 } else {
690 ATH_MSG_VERBOSE(
" [o] Collecting intersection with active input layer.");
691 cache.m_hitVector->emplace_back(currPar->
uniqueClone(), timeLim.time,
cache.m_navigLays[i].second->layerType(), 0.);
692 }
693 }
694 }
695 }
696
697
698
699
700
701 nextVol = nullptr;
702 while (currPar) {
703 std::vector<unsigned int> solutions;
704
705
707 <<
" (current momentum: " << currPar->
momentum().mag() <<
708 ")");
709 ATH_MSG_DEBUG(
" [+] " <<
cache.m_navigSurfs.size() <<
" target surfaces in '" <<
cache.m_currentDense->volumeName() <<
"'.");
710
711
712
713
714
715
719 }
721 ->propagateT(ctx,
722 *currPar,
724 dir,
726 particle,
727 solutions,
729 timeLim,
730 true,
731 cache.m_currentDense,
733 .release();
735 if (nextPar) {
737 nextPar->
position()) <<
", timed at " << timeLim.time);
738 }
739
740 if (!nextPar) {
742 cache.m_parametersAtBoundary.boundaryInformation(
cache.m_currentStatic, nextPar, nextPar);
743 return returnParameters;
744 }
745
747
748
749 if (
cache.m_path.x0Max > 0. &&
750 ((
cache.m_path.process < 100 &&
cache.m_path.x0Collected >=
cache.m_path.x0Max) ||
751 (
cache.m_path.process > 100 &&
cache.m_path.l0Collected >=
cache.m_path.x0Max))) {
752
753
755 const Trk::Material *extMprop =
cache.m_path.process > 100 ?
cache.m_currentDense :
nullptr;
756
759 ->interact(
761 .release();
762
763 if (!iPar) {
764 return returnParameters;
765 }
766
769 }
770 return returnParameters;
771
772 }
773
774 if (timeLim.tMax > 0. && timeLim.time >= timeLim.tMax) {
775
777
780 ->interact(timeLim.time, nextPar->
position(), nextPar->
momentum(), particle, timeLim.process)
781 .release();
782 if (!iPar) {
783 return returnParameters;
784 }
787 }
788 return returnParameters;
789
790 }
791
792
795 ATH_MSG_DEBUG(
" [!] ERROR: missing volume boundary for volume" <<
cache.m_currentDense->volumeName());
796 }
797
798
799 ATH_MSG_DEBUG(
" [+] Number of intersection solutions: " << solutions.size());
800
801 unsigned int iSol = 0;
802 while (iSol < solutions.size()) {
803 if (solutions[iSol] < iDest) {
805 }
if (solutions[iSol] < iDest +
cache.m_staticBoundaries.size()) {
806
807 const Trk::Layer *
mb =
cache.m_navigSurfs[solutions[iSol]].first->materialLayer();
809 if (
mb->layerMaterialProperties() &&
mb->layerMaterialProperties()->fullMaterial(nextPar->
position())) {
811 nextPar = currentUpdator ? currentUpdator
812 ->update(nextPar,
813 *mb,
814 timeLim,
816 cache.m_currentStatic->geometrySignature(),
817 dir,
818 particle)
819 .release()
820 : nextPar;
821
822 if (!nextPar) {
823 ATH_MSG_VERBOSE(
" [+] Update may have killed neutral track - return.");
824 cache.m_parametersAtBoundary.resetBoundaryInformation();
825 return returnParameters;
826 }
828 } else {
830 }
831 }
832
833
834 unsigned int index = solutions[iSol] - iDest;
835
836
837 nextVol = (
cache.m_currentStatic->boundarySurfaces())[
index]->attachedVolume(
839
840 if (nextVol && !(nextVol->
inside(nextPar->
position() + 0.01 * dir * nextPar->
momentum().normalized(), 0.))) {
842 " [!] WARNING: wrongly assigned static volume ?" <<
cache.m_currentStatic->volumeName() <<
"->" <<
844 nextVol =
m_navigator->trackingGeometry(ctx)->lowestStaticTrackingVolume(
846 if (nextVol) {
848 }
849 }
850
851 if (nextVol !=
cache.m_currentStatic) {
852 cache.m_parametersAtBoundary.boundaryInformation(nextVol, nextPar, nextPar);
853 ATH_MSG_DEBUG(
" [+] StaticVol boundary reached of '" <<
cache.m_currentStatic->volumeName() <<
"'.");
854 if (
m_navigator->atVolumeBoundary(nextPar,
cache.m_currentStatic, dir, assocVol,
856 cache.m_currentDense =
cache.m_dense ? nextVol :
cache.m_highestVolume;
857 }
858
859 if (!nextVol) {
861 nextPar->
position()) <<
", timed at " << timeLim.time);
863 if (!destVol) {
865 }
866 }
867
868 if (nextVol ) {
874 }
875 }
877 }
878 }
else if (solutions[iSol] < iDest +
cache.m_staticBoundaries.size() +
cache.m_layers.size()) {
879
880 unsigned int index = solutions[iSol] - iDest -
cache.m_staticBoundaries.size();
881 const Trk::Layer *nextLayer =
cache.m_navigLays[
index].second;
882
883
884
887
889 if (matUp) {
890 double pIn = nextPar->
momentum().mag();
891 nextPar = currentUpdator ? currentUpdator->update(nextPar, *nextLayer, timeLim,
cache.m_path,
892 cache.m_currentStatic->geometrySignature(), dir,
893 particle).release() : nextPar;
894 if (!nextPar) {
896 cache.m_parametersAtBoundary.resetBoundaryInformation();
897 return returnParameters;
898 }
900 " Layer energy loss:" << nextPar->
momentum().mag() - pIn <<
"at position:" << nextPar->
position() <<
", current momentum:" <<
903
904 }
905
908
914 }
915 }
916
917
919 if (
cache.m_navigLays[index].first &&
cache.m_navigLays[index].first->confinedLayers()) {
921 dir * nextPar->
momentum().normalized());
922 if (newLayer && newLayer != nextLayer) {
925 for (
unsigned int i = 0;
i <
cache.m_navigLays.size();
i++) {
926 if (
cache.m_navigLays[i].second == newLayer) {
928 break;
929 }
930 if (
cache.m_navigLays[i].second != nextLayer) {
932 }
933 }
934 if (!found) {
938 } else {
939
941 }
942 }
943 }
944 }
945 }
946 currPar = nextPar;
947 }
else if (solutions[iSol] < iDest +
cache.m_staticBoundaries.size() +
cache.m_layers.size() +
cache.m_denseBoundaries.size()) {
948
949 unsigned int index = solutions[iSol] - iDest -
cache.m_staticBoundaries.size() -
cache.m_layers.size();
950 std::vector< std::pair<const Trk::TrackingVolume *, unsigned int> >::iterator dIter =
cache.m_denseVols.begin();
951 while (dIter !=
cache.m_denseVols.end() && index >= (*dIter).second) {
952 index -= (*dIter).second;
953 ++dIter;
954 }
955 if (dIter !=
cache.m_denseVols.end()) {
956 currVol = (*dIter).first;
958
962 if (
cache.m_dense &&
cache.m_denseVols.empty()) {
964 } else {
965 for (
unsigned int i = 0;
i <
cache.m_denseVols.size();
i++) {
966 const Trk::TrackingVolume *dVol =
cache.m_denseVols[
i].first;
968 cache.m_currentDense = dVol;
969 ATH_MSG_DEBUG(
" [+] Next dense volume found: '" <<
cache.m_currentDense->volumeName() <<
"'.");
970 break;
971 }
972 }
973 }
974 } else {
975 cache.m_currentDense = nextVol;
976 ATH_MSG_DEBUG(
" [+] Next dense volume: '" <<
cache.m_currentDense->volumeName() <<
"'.");
977 }
978 }
979 }
else if (solutions[iSol] < iDest +
cache.m_staticBoundaries.size() +
cache.m_layers.size() +
cache.m_denseBoundaries.size()
980 +
cache.m_navigBoundaries.size()) {
981
982 unsigned int index = solutions[iSol] - iDest -
cache.m_staticBoundaries.size() -
cache.m_layers.size() -
983 cache.m_denseBoundaries.size();
984 std::vector< std::pair<const Trk::TrackingVolume *, unsigned int> >::iterator nIter = navigVols.begin();
985 while (nIter != navigVols.end() && index >= (*nIter).second) {
986 index -= (*nIter).second;
987 ++nIter;
988 }
989 if (nIter != navigVols.end()) {
990 currVol = (*nIter).first;
991 nextVol = ((*nIter).first->boundarySurfaces())[
index]->attachedVolume(*nextPar, dir);
992 if (!nextVol) {
993 ATH_MSG_DEBUG(
" [+] Navigation volume boundary, leaving volume '"
995 } else {
997 }
998 currPar = nextPar;
999
1000
1001 if (nextVol) {
1003 }
1004 }
1005 }
else if (solutions[iSol] < iDest +
cache.m_staticBoundaries.size() +
cache.m_layers.size() +
cache.m_denseBoundaries.size()
1006 +
cache.m_navigBoundaries.size() +
cache.m_detachedBoundaries.size()) {
1007
1008 unsigned int index = solutions[iSol] - iDest -
cache.m_staticBoundaries.size() -
cache.m_layers.size()
1009 -
cache.m_denseBoundaries.size() -
cache.m_navigBoundaries.size();
1010 std::vector< std::pair<const Trk::DetachedTrackingVolume *,
1011 unsigned int> >::iterator dIter =
cache.m_detachedVols.begin();
1012 while (dIter !=
cache.m_detachedVols.end() && index >= (*dIter).second) {
1013 index -= (*dIter).second;
1014 ++dIter;
1015 }
1016 if (dIter !=
cache.m_detachedVols.end()) {
1017 currVol = (*dIter).first->trackingVolume();
1018 nextVol =
1019 ((*dIter).first->trackingVolume()->boundarySurfaces())[
index]->attachedVolume(*nextPar, dir);
1020 if (!nextVol) {
1022 } else {
1024 }
1025 currPar = nextPar;
1026
1027 if (nextVol) {
1029 }
1030 }
1031 }
1032 iSol++;
1033 }
1034 currPar = nextPar;
1035 }
1036
1037 return returnParameters;
1038}
virtual std::span< T *const > arrayObjects()=0
Return all objects of the Array non-const we can still modify the T.
int layerType() const
get the Layer coding
virtual const Surface & surfaceRepresentation() const =0
Transforms the layer into a Surface representation for extrapolation.
const MaterialProperties * fullUpdateMaterialProperties(const TrackParameters &par) const
getting the MaterialProperties back - for full update
virtual bool isOnLayer(const Amg::Vector3D &gp, const BoundaryCheck &bcheck=BoundaryCheck(true)) const
isOnLayer() method, using isOnSurface() with Layer specific tolerance
const Layer * nextLayer(const Amg::Vector3D &gp, const Amg::Vector3D &udir) const
getting the next/previous Layer if registered - unit for direction vector required
const SurfaceArray * surfaceArray() const
Return the entire SurfaceArray, returns nullptr if no SurfaceArray.
float zOverAtimesRho() const
access to members
const LayerArray * confinedLayers() const
Return the subLayer array.
GeometrySignature geometrySignature() const
return the Signature
const Layer * associatedLayer(const Amg::Vector3D &gp) const
Return the associated Layer.
const TrackingVolumeArray * confinedVolumes() const
Return the subLayer array.
const TrackingVolume * associatedSubVolume(const Amg::Vector3D &gp) const
Return the associated sub Volume, returns THIS if no subVolume exists.
const Layer * nextLayer(const Amg::Vector3D &gp, const Amg::Vector3D &mom, bool asres=true, bool skipNavLayer=false) const
Return the next Layer if existing, NULL if no next layer corresponds.
ArraySpan< Layer const *const > confinedArbitraryLayers() const
Return the confined subLayer array.
ArraySpan< TrackingVolume const *const > confinedDenseVolumes() const
Return unordered subVolumes - not the ownership.
std::string replace(std::string s, const std::string &s2, const std::string &s3)
const double mb
1mb to cm2
const TrackParameters * trPar
1.17.0