ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
PassThroughTool Class Reference

#include <PassThroughTool.h>

Inheritance diagram for PassThroughTool:
Collaboration diagram for PassThroughTool:

Public Member Functions

StatusCode initialize () override
 
StatusCode runPassThrough (EFTrackingTransient::StripClusterAuxInput &scAux, EFTrackingTransient::PixelClusterAuxInput &pxAux, EFTrackingTransient::SpacePointAuxInput &stripSpAux, EFTrackingTransient::SpacePointAuxInput &pixelSpAux, EFTrackingTransient::Metadata *metadata, const EventContext &ctx) const
 Call this function at the DataPreparationPipeline to run the pass-through kernels. More...
 
StatusCode getInputClusterData (const xAOD::StripClusterContainer *sc, std::vector< EFTrackingTransient::StripCluster > &ef_sc, unsigned long N) const
 Convert the strip cluster from xAOD container to simple std::vector of EFTrackingTransient::StripCluster. More...
 
StatusCode getInputClusterData (const xAOD::PixelClusterContainer *pc, std::vector< EFTrackingTransient::PixelCluster > &ef_pc, unsigned long N) const
 Convert the pixel cluster from xAOD container to simple std::vector of EFTrackingTransient::PixelCluster. More...
 
StatusCode getInputSpacePointData (const xAOD::SpacePointContainer *sp, std::vector< EFTrackingTransient::SpacePoint > &ef_sp, std::vector< std::vector< const xAOD::UncalibratedMeasurement * >> &sp_meas, unsigned long N, bool isStrip) const
 Convert the space point from xAOD container to simple std::vector of EFTrackingTransient::SpacePoint. More...
 
StatusCode passThroughSW (const std::vector< EFTrackingTransient::StripCluster > &inputSC, EFTrackingTransient::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingTransient::PixelCluster > &inputPC, EFTrackingTransient::PixelClusterOutput &ef_pcOutput, const std::vector< EFTrackingTransient::SpacePoint > &inputSSP, EFTrackingTransient::SpacePointOutput &ef_sspOutput, const std::vector< EFTrackingTransient::SpacePoint > &inputPSP, EFTrackingTransient::SpacePointOutput &ef_pspOutput, EFTrackingTransient::Metadata *metadata) const
 Software version of the pass-through kernel. More...
 
StatusCode passThroughSW_clusterOnly (const std::vector< EFTrackingTransient::StripCluster > &inputSC, EFTrackingTransient::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingTransient::PixelCluster > &inputPC, EFTrackingTransient::PixelClusterOutput &ef_pcOutput, EFTrackingTransient::Metadata *metadata) const
 This is a cluster-only version (sw) of the pass-through kernel This is used for cluter level studies. More...
 
bool runSW () const
 A getter for the m_runSW property. More...
 

Private Attributes

Gaudi::Property< bool > m_runSW {this, "RunSW", true, "Run software mode"}
 Software mode, not running on the FPGA. More...
 
Gaudi::Property< bool > m_doSpacepoints {this, "DoSpacepoints", false, "Do spacepoints"}
 Temporary flag before spacepoints are ready. More...
 
Gaudi::Property< bool > m_clusterOnlyPassThrough
 Use the cluster-only pass through tool
More...
 
Gaudi::Property< unsigned int > m_maxClusterNum
 
Gaudi::Property< unsigned int > m_maxSpacePointNum
 
SG::ReadHandleKey< xAOD::StripClusterContainer > m_stripClustersKey
 
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_pixelClustersKey
 
SG::ReadHandleKey< xAOD::SpacePointContainer > m_spacePointsKey
 

Detailed Description

Definition at line 23 of file PassThroughTool.h.

Member Function Documentation

◆ getInputClusterData() [1/2]

StatusCode PassThroughTool::getInputClusterData ( const xAOD::PixelClusterContainer *  pc,
std::vector< EFTrackingTransient::PixelCluster > &  ef_pc,
unsigned long  N 
) const

Convert the pixel cluster from xAOD container to simple std::vector of EFTrackingTransient::PixelCluster.

This is needed for the kernel input.

Definition at line 489 of file PassThroughTool.cxx.

493 {
494  if (N > pc->size())
495  {
496  ATH_MSG_ERROR("You want to get the "
497  << N << "th pixel cluster, but there are only " << pc->size()
498  << " pixel clusters in the container.");
499  return StatusCode::FAILURE;
500  }
501  ATH_MSG_DEBUG("Making vector of pixel clusters...");
502  for (unsigned long i = 0; i < N; i++)
503  {
504  EFTrackingTransient::PixelCluster cache;
505  // Get the data from the input xAOD::PixelClusterContainer and set it to the
506  // cache
507  cache.id = pc->at(i)->identifier();
508  cache.idHash = pc->at(i)->identifierHash();
509  cache.localPosition[0] = pc->at(i)->localPosition<2>()(0, 0);
510  cache.localPosition[1] = pc->at(i)->localPosition<2>()(1, 0);
511  cache.localCovariance[0] = pc->at(i)->localCovariance<2>()(0, 0);
512  cache.localCovariance[1] = pc->at(i)->localCovariance<2>()(1, 1);
513  cache.globalPosition[0] = pc->at(i)->globalPosition()[0];
514  cache.globalPosition[1] = pc->at(i)->globalPosition()[1];
515  cache.globalPosition[2] = pc->at(i)->globalPosition()[2];
516 
517  for (long unsigned int j = 0; j < pc->at(i)->rdoList().size(); j++)
518  {
519  cache.rdoList[j] = pc->at(i)->rdoList().at(j).get_compact();
520  }
521 
522  cache.channelsInPhi = pc->at(i)->channelsInPhi();
523  cache.channelsInEta = pc->at(i)->channelsInEta();
524  cache.widthInEta = pc->at(i)->widthInEta();
525 
526  for (long unsigned int j = 0; j < pc->at(i)->totList().size(); j++)
527  {
528  cache.totList[j] = pc->at(i)->totList().at(j);
529  }
530 
531  cache.totalToT = pc->at(i)->totalToT();
532 
533  for (long unsigned int j = 0; j < pc->at(i)->chargeList().size(); j++)
534  {
535  cache.chargeList[j] = pc->at(i)->chargeList().at(j);
536  }
537 
538  cache.totalCharge = pc->at(i)->totalCharge();
539  cache.energyLoss = pc->at(i)->energyLoss();
540  cache.isSplit = pc->at(i)->isSplit();
541  cache.splitProbability1 = pc->at(i)->splitProbability1();
542  cache.splitProbability2 = pc->at(i)->splitProbability2();
543  cache.lvl1a = pc->at(i)->lvl1a();
544  cache.sizeOfRDOList = pc->at(i)->rdoList().size();
545  cache.sizeOfTotList = pc->at(i)->totList().size();
546  cache.sizeOfChargeList = pc->at(i)->chargeList().size();
547 
548  ef_pc.push_back(cache);
549  }
550 
551  ATH_MSG_DEBUG("Made " << ef_pc.size() << " pixel clusters in the vector");
552  return StatusCode::SUCCESS;
553 }

◆ getInputClusterData() [2/2]

StatusCode PassThroughTool::getInputClusterData ( const xAOD::StripClusterContainer *  sc,
std::vector< EFTrackingTransient::StripCluster > &  ef_sc,
unsigned long  N 
) const

Convert the strip cluster from xAOD container to simple std::vector of EFTrackingTransient::StripCluster.

This is needed for the kernel input.

Definition at line 448 of file PassThroughTool.cxx.

452 {
453  if (N > sc->size())
454  {
455  ATH_MSG_ERROR("You want to get the "
456  << N << "th strip cluster, but there are only " << sc->size()
457  << " strip clusters in the container.");
458  return StatusCode::FAILURE;
459  }
460  ATH_MSG_DEBUG("Making vector of strip clusters...");
461  for (unsigned long i = 0; i < N; i++)
462  {
463  EFTrackingTransient::StripCluster cache;
464  // Get the data from the input xAOD::StripClusterContainer and set it to the
465  // cache
466  cache.localPosition = sc->at(i)->localPosition<1>()(0, 0);
467  cache.localCovariance = sc->at(i)->localCovariance<1>()(0, 0);
468  cache.idHash = sc->at(i)->identifierHash();
469  cache.id = sc->at(i)->identifier();
470  cache.globalPosition[0] = sc->at(i)->globalPosition()[0];
471  cache.globalPosition[1] = sc->at(i)->globalPosition()[1];
472  cache.globalPosition[2] = sc->at(i)->globalPosition()[2];
473 
474  for (unsigned long j = 0; j < sc->at(i)->rdoList().size(); j++)
475  {
476  cache.rdoList[j] = sc->at(i)->rdoList().at(j).get_compact();
477  }
478 
479  cache.channelsInPhi = sc->at(i)->channelsInPhi();
480  cache.sizeOfRDOList = sc->at(i)->rdoList().size();
481 
482  ef_sc.push_back(cache);
483  }
484 
485  ATH_MSG_DEBUG("Made " << ef_sc.size() << " strip clusters in the vector");
486  return StatusCode::SUCCESS;
487 }

◆ getInputSpacePointData()

StatusCode PassThroughTool::getInputSpacePointData ( const xAOD::SpacePointContainer *  sp,
std::vector< EFTrackingTransient::SpacePoint > &  ef_sp,
std::vector< std::vector< const xAOD::UncalibratedMeasurement * >> &  sp_meas,
unsigned long  N,
bool  isStrip 
) const

Convert the space point from xAOD container to simple std::vector of EFTrackingTransient::SpacePoint.

This is needed for the kernel input.

Definition at line 555 of file PassThroughTool.cxx.

560 {
561  if (N > sp->size())
562  {
563  ATH_MSG_ERROR("You want to get the "
564  << N << "th space point, but there are only " << sp->size()
565  << " SpacePoint in the container.");
566  return StatusCode::FAILURE;
567  }
568  ATH_MSG_DEBUG("Making vector of space point...");
569  for (unsigned long i = 0; i < N; i++)
570  {
571  EFTrackingTransient::SpacePoint cache;
572  // Get the data from the input xAOD::SpacePointContainer and set it to the
573  // cache
574  cache.idHash[0] = sp->at(i)->elementIdList()[0];
575  cache.globalPosition[0] = sp->at(i)->x();
576  cache.globalPosition[1] = sp->at(i)->y();
577  cache.globalPosition[2] = sp->at(i)->z();
578  cache.radius = sp->at(i)->radius();
579  cache.cov_r = sp->at(i)->varianceR();
580  cache.cov_z = sp->at(i)->varianceZ();
581 
582  // Pass the uncalibrated measurement for later stage of xAOD container
583  // creation for spacepoint
584  std::vector<const xAOD::UncalibratedMeasurement *> temp_vec(
585  sp->at(i)->measurements().size());
586  std::copy(sp->at(i)->measurements().begin(),
587  sp->at(i)->measurements().end(), temp_vec.begin());
588 
589  sp_meas.push_back(temp_vec);
590 
591  if (isStrip)
592  {
593  cache.idHash[1] = sp->at(i)->elementIdList()[1];
594  cache.topHalfStripLength = sp->at(i)->topHalfStripLength();
595  cache.bottomHalfStripLength = sp->at(i)->bottomHalfStripLength();
596  std::copy(sp->at(i)->topStripDirection().data(),
597  sp->at(i)->topStripDirection().data() +
598  sp->at(i)->topStripDirection().size(),
599  cache.topStripDirection);
600  std::copy(sp->at(i)->bottomStripDirection().data(),
601  sp->at(i)->bottomStripDirection().data() +
602  sp->at(i)->bottomStripDirection().size(),
603  cache.bottomStripDirection);
604  std::copy(sp->at(i)->stripCenterDistance().data(),
605  sp->at(i)->stripCenterDistance().data() +
606  sp->at(i)->stripCenterDistance().size(),
607  cache.stripCenterDistance);
608  std::copy(sp->at(i)->topStripCenter().data(),
609  sp->at(i)->topStripCenter().data() +
610  sp->at(i)->topStripCenter().size(),
611  cache.topStripCenter);
612  }
613  ef_sp.push_back(cache);
614  }
615 
616  ATH_MSG_DEBUG("Made " << ef_sp.size() << " space points in the vector");
617  return StatusCode::SUCCESS;
618 }

◆ initialize()

StatusCode PassThroughTool::initialize ( )
override

Definition at line 13 of file PassThroughTool.cxx.

14 {
15  ATH_MSG_INFO("Initializing PassThroughTool tool");
16  ATH_CHECK(m_stripClustersKey.initialize());
17  ATH_CHECK(m_pixelClustersKey.initialize());
18  ATH_CHECK(m_spacePointsKey.initialize());
19 
20  return StatusCode::SUCCESS;
21 }

◆ passThroughSW()

StatusCode PassThroughTool::passThroughSW ( const std::vector< EFTrackingTransient::StripCluster > &  inputSC,
EFTrackingTransient::StripClusterOutput &  ef_scOutput,
const std::vector< EFTrackingTransient::PixelCluster > &  inputPC,
EFTrackingTransient::PixelClusterOutput &  ef_pcOutput,
const std::vector< EFTrackingTransient::SpacePoint > &  inputSSP,
EFTrackingTransient::SpacePointOutput &  ef_sspOutput,
const std::vector< EFTrackingTransient::SpacePoint > &  inputPSP,
EFTrackingTransient::SpacePointOutput &  ef_pspOutput,
EFTrackingTransient::Metadata *  metadata 
) const

Software version of the pass-through kernel.

The purse of this function is to mimic the FPGA output at software level.

It takes the EFTrackingTransient::StripCluster EFTrackingTransient::PixelCluster, and EFTrackingDataFormat::SpacePoints as input arguments and mimic the transfer kernel by giving array output.

Definition at line 622 of file PassThroughTool.cxx.

635 {
636  // Add error checking at the beginning of the passThroughSW method
637  if (inputSC.empty()) {
638  ATH_MSG_DEBUG("No strip clusters found.");
639  // Set strip-related metadata to 0
640  metadata->numOfStripClusters = 0;
641  metadata->numOfStripSpacePoints = 0;
642  return StatusCode::SUCCESS;
643  }
644 
645  if (inputPC.empty()) {
646  ATH_MSG_DEBUG("No pixel clusters found.");
647  // Set pixel-related metadata to 0
648  metadata->numOfPixelClusters = 0;
649  metadata->numOfPixelSpacePoints = 0;
650  return StatusCode::SUCCESS;
651  }
652 
653  int rdoIndex_counter = 0;
654 
655  unsigned int inputscRdoIndexSize = 0;
656  unsigned int inputpcRdoIndexSize = 0;
657 
658  // transfer inputStripClusters
659  ATH_MSG_DEBUG("Transfering strip clusters...");
660  for (size_t i = 0; i < inputSC.size(); i++)
661  {
662  ef_scOutput.scLocalPosition[i] = inputSC[i].localPosition;
663  ef_scOutput.scLocalCovariance[i] = inputSC[i].localCovariance;
664  ef_scOutput.scIdHash[i] = inputSC[i].idHash;
665  ef_scOutput.scId[i] = inputSC[i].id;
666  ef_scOutput.scGlobalPosition[i * 3] = inputSC[i].globalPosition[0];
667  ef_scOutput.scGlobalPosition[i * 3 + 1] = inputSC[i].globalPosition[1];
668  ef_scOutput.scGlobalPosition[i * 3 + 2] = inputSC[i].globalPosition[2];
669 
670  inputscRdoIndexSize += inputSC[i].sizeOfRDOList;
671 
672  for (int j = 0; j < inputSC[i].sizeOfRDOList; j++)
673  {
674  ef_scOutput.scRdoList[rdoIndex_counter + j] = inputSC[i].rdoList[j];
675  }
676  // update the index counter
677  ef_scOutput.scChannelsInPhi[i] = inputSC[i].channelsInPhi;
678  rdoIndex_counter += inputSC[i].sizeOfRDOList;
679  metadata[0].scRdoIndex[i] = inputSC[i].sizeOfRDOList;
680  }
681 
682  // transfer inputPC
683  rdoIndex_counter = 0;
684  int totIndex_counter = 0;
685  int chargeIndex_counter = 0;
686 
687  unsigned int inputpcTotListsize = 0;
688  unsigned int inputpcChargeListsize = 0;
689 
690  // trasnsfer_pc:
691  for (size_t i = 0; i < inputPC.size(); i++)
692  {
693  ef_pcOutput.pcLocalPosition[i * 2] = inputPC[i].localPosition[0];
694  ef_pcOutput.pcLocalPosition[i * 2 + 1] = inputPC[i].localPosition[1];
695  ef_pcOutput.pcLocalCovariance[i * 2] = inputPC[i].localCovariance[0];
696  ef_pcOutput.pcLocalCovariance[i * 2 + 1] = inputPC[i].localCovariance[1];
697  ef_pcOutput.pcIdHash[i] = inputPC[i].idHash;
698  ef_pcOutput.pcId[i] = inputPC[i].id;
699  ef_pcOutput.pcGlobalPosition[i * 3] = inputPC[i].globalPosition[0];
700  ef_pcOutput.pcGlobalPosition[i * 3 + 1] = inputPC[i].globalPosition[1];
701  ef_pcOutput.pcGlobalPosition[i * 3 + 2] = inputPC[i].globalPosition[2];
702 
703  inputpcRdoIndexSize += inputPC[i].sizeOfRDOList;
704 
705  for (int j = 0; j < inputPC[i].sizeOfRDOList; j++)
706  {
707  ef_pcOutput.pcRdoList[rdoIndex_counter + j] = inputPC[i].rdoList[j];
708  }
709  ef_pcOutput.pcChannelsInPhi[i] = inputPC[i].channelsInPhi;
710  ef_pcOutput.pcChannelsInEta[i] = inputPC[i].channelsInEta;
711  ef_pcOutput.pcWidthInEta[i] = inputPC[i].widthInEta;
712 
713  inputpcTotListsize += inputPC[i].sizeOfTotList;
714 
715  for (int j = 0; j < inputPC[i].sizeOfTotList; j++)
716  {
717  ef_pcOutput.pcTotList[totIndex_counter + j] = inputPC[i].totList[j];
718  }
719  ef_pcOutput.pcTotalToT[i] = inputPC[i].totalToT;
720 
721  inputpcChargeListsize += inputPC[i].sizeOfChargeList;
722 
723  for (int j = 0; j < inputPC[i].sizeOfChargeList; j++)
724  {
725  ef_pcOutput.pcChargeList[chargeIndex_counter + j] =
726  inputPC[i].chargeList[j];
727  }
728  ef_pcOutput.pcTotalCharge[i] = inputPC[i].totalCharge;
729  ef_pcOutput.pcEnergyLoss[i] = inputPC[i].energyLoss;
730  ef_pcOutput.pcIsSplit[i] = inputPC[i].isSplit;
731  ef_pcOutput.pcSplitProbability1[i] = inputPC[i].splitProbability1;
732  ef_pcOutput.pcSplitProbability2[i] = inputPC[i].splitProbability2;
733  ef_pcOutput.pcLvl1a[i] = inputPC[i].lvl1a;
734 
735  // update the index counter
736  rdoIndex_counter += inputPC[i].sizeOfRDOList;
737  totIndex_counter += inputPC[i].sizeOfTotList;
738  chargeIndex_counter += inputPC[i].sizeOfChargeList;
739  metadata[0].pcRdoIndex[i] = inputPC[i].sizeOfRDOList;
740  metadata[0].pcTotIndex[i] = inputPC[i].sizeOfTotList;
741  metadata[0].pcChargeIndex[i] = inputPC[i].sizeOfChargeList;
742  }
743 
744  // transfer metadata for clusters
745  metadata[0].numOfStripClusters = inputSC.size();
746  metadata[0].numOfPixelClusters = inputPC.size();
747  metadata[0].scRdoIndexSize = inputscRdoIndexSize;
748  metadata[0].pcRdoIndexSize = inputpcRdoIndexSize;
749  metadata[0].pcTotIndexSize = inputpcTotListsize;
750  metadata[0].pcChargeIndexSize = inputpcChargeListsize;
751 
752  // Now handle space points if not in cluster-only mode
753  if (!m_clusterOnlyPassThrough) {
754  // Process pixel space points
755  ATH_MSG_DEBUG("Processing " << inputPSP.size() << " pixel space points");
756 
757  // loop over the pixel space points and transfer the data to the output
758  for (size_t i = 0; i < inputPSP.size(); i++) {
759  ef_pspOutput.spElementIdList[i] = inputPSP[i].idHash[0];
760  ef_pspOutput.spGlobalPosition[i * 3] = inputPSP[i].globalPosition[0];
761  ef_pspOutput.spGlobalPosition[i * 3 + 1] = inputPSP[i].globalPosition[1];
762  ef_pspOutput.spGlobalPosition[i * 3 + 2] = inputPSP[i].globalPosition[2];
763  ef_pspOutput.spVarianceR[i] = inputPSP[i].cov_r;
764  ef_pspOutput.spVarianceZ[i] = inputPSP[i].cov_z;
765  ef_pspOutput.spMeasurementIndexes[i] = i; // Index for linking
766  }
767 
768  // Process strip space points
769  ATH_MSG_DEBUG("Processing " << inputSSP.size() << " strip space points");
770 
771  // loop over the strip space points and transfer the data to the output
772  for (size_t i = 0; i < inputSSP.size(); i++) {
773  // For strip space points, we need two element IDs per space point
774  ef_sspOutput.spElementIdList[i * 2] = inputSSP[i].idHash[0];
775  ef_sspOutput.spElementIdList[i * 2 + 1] = inputSSP[i].idHash[1];
776 
777  // Position (x,y,z for each point)
778  ef_sspOutput.spGlobalPosition[i * 3] = inputSSP[i].globalPosition[0];
779  ef_sspOutput.spGlobalPosition[i * 3 + 1] = inputSSP[i].globalPosition[1];
780  ef_sspOutput.spGlobalPosition[i * 3 + 2] = inputSSP[i].globalPosition[2];
781 
782  // Two measurement indexes for strip space points
783  // placeholder values
784  ef_sspOutput.spMeasurementIndexes[i * 2] = i * 2;
785  ef_sspOutput.spMeasurementIndexes[i * 2 + 1] = i * 2 + 1;
786 
787  // Variance values
788  ef_sspOutput.spVarianceR[i] = inputSSP[i].cov_r;
789  ef_sspOutput.spVarianceZ[i] = inputSSP[i].cov_z;
790  }
791 
792  // Update metadata for space points
793  metadata[0].numOfPixelSpacePoints = inputPSP.size();
794  metadata[0].numOfStripSpacePoints = inputSSP.size();
795  } else {
796  // If we're processing clusters only, ensure space point counts are zero
797  metadata[0].numOfPixelSpacePoints = 0;
798  metadata[0].numOfStripSpacePoints = 0;
799  }
800 
801  ATH_MSG_DEBUG("Metadata: ");
802  ATH_MSG_DEBUG("numOfStripClusters: " << metadata[0].numOfStripClusters);
803  ATH_MSG_DEBUG("numOfPixelClusters: " << metadata[0].numOfPixelClusters);
804  ATH_MSG_DEBUG("numOfStripSpacePoints: " << metadata[0].numOfStripSpacePoints);
805  ATH_MSG_DEBUG("numOfPixelSpacePoints: " << metadata[0].numOfPixelSpacePoints);
806 
807  if (msgLvl(MSG::DEBUG)) {
808  // Print pixel space points
809  // add guard to prevent out of bounds access
810  // in instances of not having any/enough pixel space points
811  const int maxToPrintPixelSp = std::min<int>(3,
812  static_cast<int>(inputPSP.size()));
813  ATH_MSG_DEBUG("Printing first few pixel space points:");
814  for (int i = 0; i < maxToPrintPixelSp; i++) {
815  ATH_MSG_DEBUG("PixelSpacePoint[" << i << "]: "
816  << "position=(" << inputPSP[i].globalPosition[0] << ", "
817  << inputPSP[i].globalPosition[1] << ", "
818  << inputPSP[i].globalPosition[2] << ")"
819  << ", varianceR=" << inputPSP[i].cov_r
820  << ", varianceZ=" << inputPSP[i].cov_z);
821  }
822 
823  // Print strip space points
824  // add guard to prevent out of bounds access
825  // in instances of not having any/enough strip space points
826  const int maxToPrintStripSp = std::min<int>(3,
827  static_cast<int>(inputSSP.size()));
828  ATH_MSG_DEBUG("Printing first few strip space points:");
829  for (int i = 0; i < maxToPrintStripSp; i++) {
830  ATH_MSG_DEBUG("StripSpacePoint[" << i << "]: "
831  << "position=(" << inputSSP[i].globalPosition[0] << ", "
832  << inputSSP[i].globalPosition[1] << ", "
833  << inputSSP[i].globalPosition[2] << ")"
834  << ", varianceR=" << inputSSP[i].cov_r
835  << ", varianceZ=" << inputSSP[i].cov_z);
836  }
837  }
838 
839  return StatusCode::SUCCESS;
840 }

◆ passThroughSW_clusterOnly()

StatusCode PassThroughTool::passThroughSW_clusterOnly ( const std::vector< EFTrackingTransient::StripCluster > &  inputSC,
EFTrackingTransient::StripClusterOutput &  ef_scOutput,
const std::vector< EFTrackingTransient::PixelCluster > &  inputPC,
EFTrackingTransient::PixelClusterOutput &  ef_pcOutput,
EFTrackingTransient::Metadata *  metadata 
) const

This is a cluster-only version (sw) of the pass-through kernel This is used for cluter level studies.

Definition at line 843 of file PassThroughTool.cxx.

852 {
853  int rdoIndex_counter = 0;
854 
855  unsigned int inputscRdoIndexSize = 0;
856 
857  // transfer inputStripClusters
858  ATH_MSG_DEBUG("Transfering strip clusters...");
859  for (size_t i = 0; i < inputSC.size(); i++)
860  {
861  ef_scOutput.scLocalPosition[i] = inputSC[i].localPosition;
862  ef_scOutput.scLocalCovariance[i] = inputSC[i].localCovariance;
863  ef_scOutput.scIdHash[i] = inputSC[i].idHash;
864  ef_scOutput.scId[i] = inputSC[i].id;
865  ef_scOutput.scGlobalPosition[i * 3] = inputSC[i].globalPosition[0];
866  ef_scOutput.scGlobalPosition[i * 3 + 1] = inputSC[i].globalPosition[1];
867  ef_scOutput.scGlobalPosition[i * 3 + 2] = inputSC[i].globalPosition[2];
868 
869  inputscRdoIndexSize += inputSC[i].sizeOfRDOList;
870 
871  for (int j = 0; j < inputSC[i].sizeOfRDOList; j++)
872  {
873  ef_scOutput.scRdoList[rdoIndex_counter + j] = inputSC[i].rdoList[j];
874  }
875  // update the index counter
876  ef_scOutput.scChannelsInPhi[i] = inputSC[i].channelsInPhi;
877  rdoIndex_counter += inputSC[i].sizeOfRDOList;
878  metadata[0].scRdoIndex[i] = inputSC[i].sizeOfRDOList;
879  }
880 
881  // transfer inputPC
882  rdoIndex_counter = 0;
883  int totIndex_counter = 0;
884  int chargeIndex_counter = 0;
885 
886  unsigned int inputpcRdoIndexSize = 0;
887  unsigned int inputpcTotListsize = 0;
888  unsigned int inputpcChargeListsize = 0;
889 
890  // trasnsfer_pc:
891  ATH_MSG_DEBUG("Transfering pixel clusters...");
892  for (size_t i = 0; i < inputPC.size(); i++)
893  {
894  ef_pcOutput.pcLocalPosition[i * 2] = inputPC[i].localPosition[0];
895  ef_pcOutput.pcLocalPosition[i * 2 + 1] = inputPC[i].localPosition[1];
896  ef_pcOutput.pcLocalCovariance[i * 2] = inputPC[i].localCovariance[0];
897  ef_pcOutput.pcLocalCovariance[i * 2 + 1] = inputPC[i].localCovariance[1];
898  ef_pcOutput.pcIdHash[i] = inputPC[i].idHash;
899  ef_pcOutput.pcId[i] = inputPC[i].id;
900  ef_pcOutput.pcGlobalPosition[i * 3] = inputPC[i].globalPosition[0];
901  ef_pcOutput.pcGlobalPosition[i * 3 + 1] = inputPC[i].globalPosition[1];
902  ef_pcOutput.pcGlobalPosition[i * 3 + 2] = inputPC[i].globalPosition[2];
903 
904  inputpcRdoIndexSize += inputPC[i].sizeOfRDOList;
905 
906  for (int j = 0; j < inputPC[i].sizeOfRDOList; j++)
907  {
908  ef_pcOutput.pcRdoList[rdoIndex_counter + j] = inputPC[i].rdoList[j];
909  }
910  ef_pcOutput.pcChannelsInPhi[i] = inputPC[i].channelsInPhi;
911  ef_pcOutput.pcChannelsInEta[i] = inputPC[i].channelsInEta;
912  ef_pcOutput.pcWidthInEta[i] = inputPC[i].widthInEta;
913 
914  inputpcTotListsize += inputPC[i].sizeOfTotList;
915 
916  for (int j = 0; j < inputPC[i].sizeOfTotList; j++)
917  {
918  ef_pcOutput.pcTotList[totIndex_counter + j] = inputPC[i].totList[j];
919  }
920  ef_pcOutput.pcTotalToT[i] = inputPC[i].totalToT;
921 
922  inputpcChargeListsize += inputPC[i].sizeOfChargeList;
923 
924  for (int j = 0; j < inputPC[i].sizeOfChargeList; j++)
925  {
926  ef_pcOutput.pcChargeList[chargeIndex_counter + j] =
927  inputPC[i].chargeList[j];
928  }
929  ef_pcOutput.pcTotalCharge[i] = inputPC[i].totalCharge;
930  ef_pcOutput.pcEnergyLoss[i] = inputPC[i].energyLoss;
931  ef_pcOutput.pcIsSplit[i] = inputPC[i].isSplit;
932  ef_pcOutput.pcSplitProbability1[i] = inputPC[i].splitProbability1;
933  ef_pcOutput.pcSplitProbability2[i] = inputPC[i].splitProbability2;
934  ef_pcOutput.pcLvl1a[i] = inputPC[i].lvl1a;
935 
936  // update the index counter
937  rdoIndex_counter += inputPC[i].sizeOfRDOList;
938  totIndex_counter += inputPC[i].sizeOfTotList;
939  chargeIndex_counter += inputPC[i].sizeOfChargeList;
940  metadata[0].pcRdoIndex[i] = inputPC[i].sizeOfRDOList;
941  metadata[0].pcTotIndex[i] = inputPC[i].sizeOfTotList;
942  metadata[0].pcChargeIndex[i] = inputPC[i].sizeOfChargeList;
943  }
944  // transfer metadata
945  metadata[0].numOfStripClusters = inputSC.size();
946  metadata[0].numOfPixelClusters = inputPC.size();
947  metadata[0].scRdoIndexSize = inputscRdoIndexSize;
948  metadata[0].pcRdoIndexSize = inputpcRdoIndexSize;
949  metadata[0].pcTotIndexSize = inputpcTotListsize;
950  metadata[0].pcChargeIndexSize = inputpcChargeListsize;
951 
952  ATH_MSG_DEBUG("Metadata: ");
953  ATH_MSG_DEBUG("numOfStripClusters: " << metadata[0].numOfStripClusters);
954  ATH_MSG_DEBUG("numOfPixelClusters: " << metadata[0].numOfPixelClusters);
955  ATH_MSG_DEBUG("numOfStripSpacePoints: " << metadata[0].numOfStripSpacePoints);
956  ATH_MSG_DEBUG("numOfPixelSpacePoints: " << metadata[0].numOfPixelSpacePoints);
957 
958  // If we're processing clusters, we should also set up space point metadata
959  // This ensures downstream code knows there are no space points yet
960  metadata[0].numOfPixelSpacePoints = 0;
961  metadata[0].numOfStripSpacePoints = 0;
962 
963  ATH_MSG_DEBUG("Updated Metadata: ");
964  ATH_MSG_DEBUG("numOfPixelSpacePoints: " << metadata[0].numOfPixelSpacePoints);
965  ATH_MSG_DEBUG("numOfStripSpacePoints: " << metadata[0].numOfStripSpacePoints);
966 
967  return StatusCode::SUCCESS;
968 }

◆ runPassThrough()

StatusCode PassThroughTool::runPassThrough ( EFTrackingTransient::StripClusterAuxInput &  scAux,
EFTrackingTransient::PixelClusterAuxInput &  pxAux,
EFTrackingTransient::SpacePointAuxInput &  stripSpAux,
EFTrackingTransient::SpacePointAuxInput &  pixelSpAux,
EFTrackingTransient::Metadata *  metadata,
const EventContext &  ctx 
) const

Call this function at the DataPreparationPipeline to run the pass-through kernels.

Definition at line 23 of file PassThroughTool.cxx.

29 {
30  // Retrieve the strip and pixel cluster container from the event store
31  SG::ReadHandle<xAOD::StripClusterContainer> inputStripClusters(
32  m_stripClustersKey, ctx);
33  SG::ReadHandle<xAOD::PixelClusterContainer> inputPixelClusters(
34  m_pixelClustersKey, ctx);
35 
36  // Retrieve the space point container from the event store
37  SG::ReadHandle<xAOD::SpacePointContainer> inputSpacePoints(
38  m_spacePointsKey, ctx);
39 
40  // Check if the strip cluster container is valid
41  if (!inputStripClusters.isValid())
42  {
43  ATH_MSG_ERROR("Failed to retrieve: " << m_stripClustersKey);
44  return StatusCode::FAILURE;
45  }
46 
47  // Check if the pixel cluster container is valid
48  if (!inputPixelClusters.isValid())
49  {
50  ATH_MSG_ERROR("Failed to retrieve: " << m_pixelClustersKey);
51  return StatusCode::FAILURE;
52  }
53 
54  // Check if the space point container is valid
55  if (!inputSpacePoints.isValid())
56  {
57  ATH_MSG_ERROR("Failed to retrieve: " << m_spacePointsKey);
58  return StatusCode::FAILURE;
59  }
60 
61  if (msgLvl(MSG::DEBUG))
62  {
63  ATH_MSG_DEBUG("StripClusterContainer is valid");
64  ATH_MSG_DEBUG("PixelClusterContainer is valid");
65  ATH_MSG_DEBUG("SpacePointContainer is valid");
66  ATH_MSG_DEBUG("Size of pixel clusters is : " << inputPixelClusters->size());
67  ATH_MSG_DEBUG("Size of strip clusters is : " << inputStripClusters->size());
68  ATH_MSG_DEBUG("Size of space points is : " << inputSpacePoints->size());
69  }
70 
71  // Prepare the input data for the kernel
72  std::vector<EFTrackingTransient::StripCluster> ef_stripClusters;
73  std::vector<EFTrackingTransient::PixelCluster> ef_pixelClusters;
74  std::vector<EFTrackingTransient::SpacePoint> ef_pixelSpacePoints;
75  std::vector<EFTrackingTransient::SpacePoint> ef_stripSpacePoints;
76 
77  // Store measurement pointers for space points
78  std::vector<std::vector<const xAOD::UncalibratedMeasurement*>> pixelSpMeasurements;
79  std::vector<std::vector<const xAOD::UncalibratedMeasurement*>> stripSpMeasurements;
80 
81  // Get the input cluster data
82  ATH_CHECK(getInputClusterData(inputStripClusters.get(), ef_stripClusters, inputStripClusters->size()));
83  ATH_CHECK(getInputClusterData(inputPixelClusters.get(), ef_pixelClusters, inputPixelClusters->size()));
84 
85  // Get the input space point data
86  ATH_CHECK(getInputSpacePointData(inputSpacePoints.get(), ef_pixelSpacePoints, pixelSpMeasurements,
87  inputSpacePoints->size(), false));
88 
89  if (msgLvl(MSG::DEBUG))
90  { // add a guard to prevent out of bounds access
91  const int maxToPrintStripCl = std::min<int>(3, ef_stripClusters.size());
92  // Print a few clusters to verify the conversion
93  for (int i = 0; i < maxToPrintStripCl; i++)
94  {
95  ATH_MSG_DEBUG("StripCluster["
96  << i << "]: " << ef_stripClusters.at(i).localPosition
97  << ", " << ef_stripClusters.at(i).localCovariance << ", "
98  << ef_stripClusters.at(i).idHash << ", "
99  << ef_stripClusters.at(i).id << ", "
100  << ef_stripClusters.at(i).globalPosition[0] << ", "
101  << ef_stripClusters.at(i).globalPosition[1] << ", "
102  << ef_stripClusters.at(i).globalPosition[2] << ", "
103  << ef_stripClusters.at(i).rdoList[0] << ", "
104  << ef_stripClusters.at(i).channelsInPhi);
105  }
106  // Pixel clusters
107  const int maxToPrintPixelCl = std::min<int>(3, ef_pixelClusters.size());
108  for (int i = 0; i < maxToPrintPixelCl; i++)
109  {
110  ATH_MSG_DEBUG("PixelCluster["
111  << i << "]: " << ef_pixelClusters.at(i).id << ", "
112  << ef_pixelClusters.at(i).idHash << ", "
113  << ef_pixelClusters.at(i).localPosition[0] << ", "
114  << ef_pixelClusters.at(i).localPosition[1] << ", "
115  << ef_pixelClusters.at(i).localCovariance[0] << ", "
116  << ef_pixelClusters.at(i).localCovariance[1] << ", "
117  << ef_pixelClusters.at(i).globalPosition[0] << ", "
118  << ef_pixelClusters.at(i).globalPosition[1] << ", "
119  << ef_pixelClusters.at(i).globalPosition[2] << ", "
120  << ef_pixelClusters.at(i).rdoList[0] << ", "
121  << ef_pixelClusters.at(i).channelsInPhi << ", "
122  << ef_pixelClusters.at(i).channelsInEta << ", "
123  << ef_pixelClusters.at(i).widthInEta << ", "
124  << ef_pixelClusters.at(i).totList[0] << ", "
125  << ef_pixelClusters.at(i).totalToT << ", "
126  << ef_pixelClusters.at(i).chargeList[0] << ", "
127  << ef_pixelClusters.at(i).totalCharge << ", "
128  << ef_pixelClusters.at(i).energyLoss << ", "
129  << ef_pixelClusters.at(i).isSplit << ", "
130  << ef_pixelClusters.at(i).splitProbability1 << ", "
131  << ef_pixelClusters.at(i).splitProbability2 << ", "
132  << ef_pixelClusters.at(i).lvl1a);
133  }
134  }
135 
136  // Determine if we are running sw or hw
137  if (m_runSW)
138  {
139  ATH_MSG_INFO("Running the sw ver of the pass-through kernel");
140  // Strip cluster
141  std::vector<float> scLocalPosition(m_maxClusterNum);
142  std::vector<float> scLocalCovariance(m_maxClusterNum);
143  std::vector<unsigned int> scIdHash(m_maxClusterNum);
144  std::vector<long unsigned int> scId(m_maxClusterNum);
145  std::vector<float> scGlobalPosition(m_maxClusterNum * 3);
146  std::vector<unsigned long long> scRdoList(m_maxClusterNum * 5000);
147  std::vector<int> scChannelsInPhi(m_maxClusterNum);
148 
149  EFTrackingTransient::StripClusterOutput ef_scOutput;
150 
151  ef_scOutput.scLocalPosition = scLocalPosition.data();
152  ef_scOutput.scLocalCovariance = scLocalCovariance.data();
153  ef_scOutput.scIdHash = scIdHash.data();
154  ef_scOutput.scId = scId.data();
155  ef_scOutput.scGlobalPosition = scGlobalPosition.data();
156  ef_scOutput.scRdoList = scRdoList.data();
157  ef_scOutput.scChannelsInPhi = scChannelsInPhi.data();
158 
159  // Pixel cluster
160  std::vector<float> pcLocalPosition(m_maxClusterNum * 2);
161  std::vector<float> pcLocalCovariance(m_maxClusterNum * 2);
162  std::vector<unsigned int> pcIdHash(m_maxClusterNum);
163  std::vector<long unsigned int> pcId(m_maxClusterNum);
164  std::vector<float> pcGlobalPosition(m_maxClusterNum * 3);
165  std::vector<unsigned long long> pcRdoList(m_maxClusterNum * 5000);
166  std::vector<int> pcChannelsInPhi(m_maxClusterNum);
167  std::vector<int> pcChannelsInEta(m_maxClusterNum);
168  std::vector<float> pcWidthInEta(m_maxClusterNum);
169  std::vector<int> pcTotList(m_maxClusterNum * 5000);
170  std::vector<int> pcTotalToT(m_maxClusterNum);
171  std::vector<float> pcChargeList(m_maxClusterNum * 5000);
172  std::vector<float> pcTotalCharge(m_maxClusterNum);
173  std::vector<float> pcEnergyLoss(m_maxClusterNum);
174  std::vector<char> pcIsSplit(m_maxClusterNum);
175  std::vector<float> pcSplitProbability1(m_maxClusterNum);
176  std::vector<float> pcSplitProbability2(m_maxClusterNum);
177  std::vector<int> pcLvl1a(m_maxClusterNum);
178 
179  EFTrackingTransient::PixelClusterOutput ef_pcOutput;
180 
181  ef_pcOutput.pcLocalPosition = pcLocalPosition.data();
182  ef_pcOutput.pcLocalCovariance = pcLocalCovariance.data();
183  ef_pcOutput.pcIdHash = pcIdHash.data();
184  ef_pcOutput.pcId = pcId.data();
185  ef_pcOutput.pcGlobalPosition = pcGlobalPosition.data();
186  ef_pcOutput.pcRdoList = pcRdoList.data();
187  ef_pcOutput.pcChannelsInPhi = pcChannelsInPhi.data();
188  ef_pcOutput.pcChannelsInEta = pcChannelsInEta.data();
189  ef_pcOutput.pcWidthInEta = pcWidthInEta.data();
190  ef_pcOutput.pcTotList = pcTotList.data();
191  ef_pcOutput.pcTotalToT = pcTotalToT.data();
192  ef_pcOutput.pcChargeList = pcChargeList.data();
193  ef_pcOutput.pcTotalCharge = pcTotalCharge.data();
194  ef_pcOutput.pcEnergyLoss = pcEnergyLoss.data();
195  ef_pcOutput.pcIsSplit = pcIsSplit.data();
196  ef_pcOutput.pcSplitProbability1 = pcSplitProbability1.data();
197  ef_pcOutput.pcSplitProbability2 = pcSplitProbability2.data();
198  ef_pcOutput.pcLvl1a = pcLvl1a.data();
199 
200  // Space point output structures
201  std::vector<unsigned int> pspIdHash(m_maxSpacePointNum);
202  std::vector<float> pspGlobalPosition(m_maxSpacePointNum * 3);
203  std::vector<float> pspRadius(m_maxSpacePointNum);
204  std::vector<float> pspVarianceR(m_maxSpacePointNum);
205  std::vector<float> pspVarianceZ(m_maxSpacePointNum);
206  std::vector<int> pspMeasurementIndexes(m_maxSpacePointNum);
207  std::vector<unsigned int> pspElementIdList(m_maxSpacePointNum);
208 
209  EFTrackingTransient::SpacePointOutput ef_pspOutput;
210  ef_pspOutput.spIdHash = pspIdHash.data();
211  ef_pspOutput.spGlobalPosition = pspGlobalPosition.data();
212  ef_pspOutput.spRadius = pspRadius.data();
213  ef_pspOutput.spVarianceR = pspVarianceR.data();
214  ef_pspOutput.spVarianceZ = pspVarianceZ.data();
215  ef_pspOutput.spMeasurementIndexes = pspMeasurementIndexes.data();
216  ef_pspOutput.spElementIdList = pspElementIdList.data();
217 
218  // Strip space point
219  std::vector<unsigned int> sspIdHash(m_maxSpacePointNum);
220  std::vector<float> sspGlobalPosition(m_maxSpacePointNum * 3);
221  std::vector<float> sspRadius(m_maxSpacePointNum);
222  std::vector<float> sspVarianceR(m_maxSpacePointNum);
223  std::vector<float> sspVarianceZ(m_maxSpacePointNum);
224  std::vector<int> sspMeasurementIndexes(m_maxSpacePointNum);
225  std::vector<unsigned int> sspElementIdList(m_maxSpacePointNum);
226 
227  EFTrackingTransient::SpacePointOutput ef_sspOutput;
228  ef_sspOutput.spIdHash = sspIdHash.data();
229  ef_sspOutput.spGlobalPosition = sspGlobalPosition.data();
230  ef_sspOutput.spRadius = sspRadius.data();
231  ef_sspOutput.spVarianceR = sspVarianceR.data();
232  ef_sspOutput.spVarianceZ = sspVarianceZ.data();
233  ef_sspOutput.spMeasurementIndexes = sspMeasurementIndexes.data();
234  ef_sspOutput.spElementIdList = sspElementIdList.data();
235 
236  // Process clusters and optionally space points if enabled
237  if (m_clusterOnlyPassThrough) {
238  ATH_CHECK(passThroughSW_clusterOnly(ef_stripClusters, ef_scOutput,
239  ef_pixelClusters, ef_pcOutput,
240  metadata));
241  } else {
242  ATH_CHECK(passThroughSW(ef_stripClusters, ef_scOutput,
243  ef_pixelClusters, ef_pcOutput,
244  ef_stripSpacePoints, ef_sspOutput,
245  ef_pixelSpacePoints, ef_pspOutput,
246  metadata));
247  }
248 
249  // resize the vector to be the length of the cluster
250  scLocalPosition.resize(metadata->numOfStripClusters);
251  scLocalCovariance.resize(metadata->numOfStripClusters);
252  scIdHash.resize(metadata->numOfStripClusters);
253  scId.resize(metadata->numOfStripClusters);
254  scGlobalPosition.resize(metadata->numOfStripClusters * 3);
255  scRdoList.resize(metadata->scRdoIndexSize);
256  scChannelsInPhi.resize(metadata->numOfStripClusters);
257 
258  pcLocalPosition.resize(metadata->numOfPixelClusters * 2);
259  pcLocalCovariance.resize(metadata->numOfPixelClusters * 2);
260  pcIdHash.resize(metadata->numOfPixelClusters);
261  pcId.resize(metadata->numOfPixelClusters);
262  pcGlobalPosition.resize(metadata->numOfPixelClusters * 3);
263  pcRdoList.resize(metadata->pcRdoIndexSize);
264  pcChannelsInPhi.resize(metadata->numOfPixelClusters);
265  pcChannelsInEta.resize(metadata->numOfPixelClusters);
266  pcWidthInEta.resize(metadata->numOfPixelClusters);
267  pcTotList.resize(metadata->pcTotIndexSize);
268  pcTotalToT.resize(metadata->numOfPixelClusters);
269  pcChargeList.resize(metadata->pcChargeIndexSize);
270  pcTotalCharge.resize(metadata->numOfPixelClusters);
271  pcEnergyLoss.resize(metadata->numOfPixelClusters);
272  pcIsSplit.resize(metadata->numOfPixelClusters);
273  pcSplitProbability1.resize(metadata->numOfPixelClusters);
274  pcSplitProbability2.resize(metadata->numOfPixelClusters);
275  pcLvl1a.resize(metadata->numOfPixelClusters);
276 
277  if (msgLvl(MSG::DEBUG)) {
278  // add guard to prevent out of bounds access
279  // in instances of not having any/enough stip clusters
280  const unsigned int nStripClustersToPrint = std::min(3u,
281  static_cast<unsigned int>(scLocalPosition.size()));
282  // print 3 strip clusters
283  for (unsigned i = 0; i < nStripClustersToPrint; i++)
284  {
285  ATH_MSG_DEBUG("scLocalPosition["
286  << i << "] = " << ef_scOutput.scLocalPosition[i]);
287  ATH_MSG_DEBUG("scLocalCovariance["
288  << i << "] = " << ef_scOutput.scLocalCovariance[i]);
289  ATH_MSG_DEBUG("scIdHash[" << i << "] = " << ef_scOutput.scIdHash[i]);
290  ATH_MSG_DEBUG("scId[" << i << "] = " << ef_scOutput.scId[i]);
291  ATH_MSG_DEBUG("scGlobalPosition["
292  << i << "] = " << ef_scOutput.scGlobalPosition[i * 3] << ", "
293  << ef_scOutput.scGlobalPosition[i * 3 + 1] << ", "
294  << ef_scOutput.scGlobalPosition[i * 3 + 2]);
295  ATH_MSG_DEBUG("scRdoList[" << i << "] = " << ef_scOutput.scRdoList[i]);
296  ATH_MSG_DEBUG("scChannelsInPhi["
297  << i << "] = " << ef_scOutput.scChannelsInPhi[i]);
298  }
299 
300  // print 3 pixel clusters
301  const unsigned int nPixelClustersToPrint = std::min(3u,
302  static_cast<unsigned int>(pcLocalPosition.size()));
303  // add guard to prevent out of bounds access; same logic as above
304  for (unsigned i = 0; i < nPixelClustersToPrint; i++)
305  {
306  ATH_MSG_DEBUG("pcLocalPosition["
307  << i << "] = " << ef_pcOutput.pcLocalPosition[i * 2] << ", "
308  << ef_pcOutput.pcLocalPosition[i * 2 + 1]);
309  ATH_MSG_DEBUG("pcLocalCovariance["
310  << i << "] = " << ef_pcOutput.pcLocalCovariance[i * 2] << ", "
311  << ef_pcOutput.pcLocalCovariance[i * 2 + 1]);
312  ATH_MSG_DEBUG("pcIdHash[" << i << "] = " << ef_pcOutput.pcIdHash[i]);
313  ATH_MSG_DEBUG("pcId[" << i << "] = " << ef_pcOutput.pcId[i]);
314  ATH_MSG_DEBUG("pcGlobalPosition["
315  << i << "] = " << ef_pcOutput.pcGlobalPosition[i * 3] << ", "
316  << ef_pcOutput.pcGlobalPosition[i * 3 + 1] << ", "
317  << ef_pcOutput.pcGlobalPosition[i * 3 + 2]);
318  ATH_MSG_DEBUG("pcRdoList[" << i << "] = " << ef_pcOutput.pcRdoList[i]);
319  ATH_MSG_DEBUG("pcChannelsInPhi["
320  << i << "] = " << ef_pcOutput.pcChannelsInPhi[i]);
321  ATH_MSG_DEBUG("pcChannelsInEta["
322  << i << "] = " << ef_pcOutput.pcChannelsInEta[i]);
323  ATH_MSG_DEBUG("pcWidthInEta["
324  << i << "] = " << ef_pcOutput.pcWidthInEta[i]);
325  ATH_MSG_DEBUG("pcTotList[" << i << "] = " << ef_pcOutput.pcTotList[i]);
326  ATH_MSG_DEBUG("pcTotalToT["
327  << i << "] = " << ef_pcOutput.pcTotalToT[i]);
328  ATH_MSG_DEBUG("pcChargeList["
329  << i << "] = " << ef_pcOutput.pcChargeList[i]);
330  ATH_MSG_DEBUG("pcTotalCharge["
331  << i << "] = " << ef_pcOutput.pcTotalCharge[i]);
332  ATH_MSG_DEBUG("pcEnergyLoss["
333  << i << "] = " << ef_pcOutput.pcEnergyLoss[i]);
334  ATH_MSG_DEBUG("pcIsSplit[" << i << "] = " << ef_pcOutput.pcIsSplit[i]);
335  ATH_MSG_DEBUG("pcSplitProbability1["
336  << i << "] = " << ef_pcOutput.pcSplitProbability1[i]);
337  ATH_MSG_DEBUG("pcSplitProbability2["
338  << i << "] = " << ef_pcOutput.pcSplitProbability2[i]);
339  ATH_MSG_DEBUG("pcLvl1a[" << i << "] = " << ef_pcOutput.pcLvl1a[i]);
340  }
341  }
342 
343  // Group data to make the strip cluster container
344  scAux.localPosition = std::move(scLocalPosition);
345  scAux.localCovariance = std::move(scLocalCovariance);
346  scAux.idHash = std::move(scIdHash);
347  scAux.id = std::move(scId);
348  scAux.globalPosition = std::move(scGlobalPosition);
349  scAux.rdoList = std::move(scRdoList);
350  scAux.channelsInPhi = std::move(scChannelsInPhi);
351 
352  // Group data to make the pixel cluster container
353  pxAux.id = std::move(pcId);
354  pxAux.idHash = std::move(pcIdHash);
355  pxAux.localPosition = std::move(pcLocalPosition);
356  pxAux.localCovariance = std::move(pcLocalCovariance);
357  pxAux.globalPosition = std::move(pcGlobalPosition);
358  pxAux.rdoList = std::move(pcRdoList);
359  pxAux.channelsInPhi = std::move(pcChannelsInPhi);
360  pxAux.channelsInEta = std::move(pcChannelsInEta);
361  pxAux.widthInEta = std::move(pcWidthInEta);
362  pxAux.totList = std::move(pcTotList);
363  pxAux.totalToT = std::move(pcTotalToT);
364  pxAux.chargeList = std::move(pcChargeList);
365  pxAux.totalCharge = std::move(pcTotalCharge);
366  pxAux.energyLoss = std::move(pcEnergyLoss);
367  pxAux.isSplit = std::move(pcIsSplit);
368  pxAux.splitProbability1 = std::move(pcSplitProbability1);
369  pxAux.splitProbability2 = std::move(pcSplitProbability2);
370  pxAux.lvl1a = std::move(pcLvl1a);
371 
372  // Transfer pixel space point data to pixelSpAux
373  for (unsigned int i = 0; i < metadata->numOfPixelSpacePoints; i++) {
374  pixelSpAux.elementIdList.push_back(ef_pspOutput.spElementIdList[i]);
375 
376  // Copy x,y,z position
377  pixelSpAux.globalPosition.push_back(ef_pspOutput.spGlobalPosition[i*3]);
378  pixelSpAux.globalPosition.push_back(ef_pspOutput.spGlobalPosition[i*3+1]);
379  pixelSpAux.globalPosition.push_back(ef_pspOutput.spGlobalPosition[i*3+2]);
380 
381  pixelSpAux.measurementIndexes.push_back(ef_pspOutput.spMeasurementIndexes[i]);
382  pixelSpAux.varianceR.push_back(ef_pspOutput.spVarianceR[i]);
383  pixelSpAux.varianceZ.push_back(ef_pspOutput.spVarianceZ[i]);
384  }
385 
386  // Transfer strip space point data to stripSpAux
387  for (unsigned int i = 0; i < metadata->numOfStripSpacePoints; i++) {
388  // For strip space points, add both element IDs
389  stripSpAux.elementIdList.push_back(ef_sspOutput.spElementIdList[i*2]);
390  stripSpAux.elementIdList.push_back(ef_sspOutput.spElementIdList[i*2+1]);
391 
392  // Add position data
393  stripSpAux.globalPosition.push_back(ef_sspOutput.spGlobalPosition[i*3]);
394  stripSpAux.globalPosition.push_back(ef_sspOutput.spGlobalPosition[i*3+1]);
395  stripSpAux.globalPosition.push_back(ef_sspOutput.spGlobalPosition[i*3+2]);
396 
397  // Add measurement indexes
398  stripSpAux.measurementIndexes.push_back(ef_sspOutput.spMeasurementIndexes[i*2]);
399  stripSpAux.measurementIndexes.push_back(ef_sspOutput.spMeasurementIndexes[i*2+1]);
400 
401  // Add variance data
402  stripSpAux.varianceR.push_back(ef_sspOutput.spVarianceR[i]);
403  stripSpAux.varianceZ.push_back(ef_sspOutput.spVarianceZ[i]);
404  }
405 
406 
407  if (msgLvl(MSG::DEBUG)) {
408  // add guard to prevent out of bounds access
409  // in instances of not having any/enough strip space points
410  const int maxToPrintStripSp = std::min<int>(3,
411  static_cast<int>(stripSpAux.elementIdList.size()));
412  // Print strip space points
413  ATH_MSG_DEBUG("Printing first few strip space points:");
414  for (int i = 0; i < maxToPrintStripSp; i++) {
415  ATH_MSG_DEBUG("StripSpacePoint[" << i << "]: "
416  << "position=(" << stripSpAux.globalPosition[i*3] << ", "
417  << stripSpAux.globalPosition[i*3+1] << ", "
418  << stripSpAux.globalPosition[i*3+2] << ")"
419  << ", varianceR=" << stripSpAux.varianceR[i]
420  << ", varianceZ=" << stripSpAux.varianceZ[i]);
421  }
422  // Print pixel space points
423  ATH_MSG_DEBUG("Printing first few pixel space points:");
424  // add guard to prevent out of bounds access
425  // in instances of not having any/enough pixel space points
426  const int maxToPrintPixelSp = std::min<int>(3,
427  static_cast<int>(pixelSpAux.elementIdList.size()));
428  for (int i = 0; i < maxToPrintPixelSp; i++) {
429  ATH_MSG_DEBUG("PixelSpacePoint[" << i << "]: "
430  << "position=(" << pixelSpAux.globalPosition[i*3] << ", "
431  << pixelSpAux.globalPosition[i*3+1] << ", "
432  << pixelSpAux.globalPosition[i*3+2] << ")"
433  << ", varianceR=" << pixelSpAux.varianceR[i]
434  << ", varianceZ=" << pixelSpAux.varianceZ[i]);
435  }
436 
437  }
438  }
439  else
440  {
441  ATH_MSG_INFO("FPGA mode is not implemented yet");
442  return StatusCode::SUCCESS;
443  }
444 
445  return StatusCode::SUCCESS;
446 }

◆ runSW()

bool PassThroughTool::runSW ( ) const
inline

A getter for the m_runSW property.

Determine if the user set the tool to run at software level. If yes, the sw version of the pass-through kernel will be executed. If not, the FPGA (hw) version will be executed

Definition at line 119 of file PassThroughTool.h.

119 { return m_runSW; }

Member Data Documentation

◆ m_clusterOnlyPassThrough

Gaudi::Property<bool> PassThroughTool::m_clusterOnlyPassThrough
private
Initial value:
{this, "ClusterOnlyPassThrough", false,
"Use the cluster-only pass-through kernel"}

Use the cluster-only pass through tool

Definition at line 125 of file PassThroughTool.h.

◆ m_doSpacepoints

Gaudi::Property<bool> PassThroughTool::m_doSpacepoints {this, "DoSpacepoints", false, "Do spacepoints"}
private

Temporary flag before spacepoints are ready.

Definition at line 124 of file PassThroughTool.h.

◆ m_maxClusterNum

Gaudi::Property<unsigned int> PassThroughTool::m_maxClusterNum
private
Initial value:
{this, "MaxClusterNum", 500000,
"Maximum number of clusters that can be processed"}

Definition at line 127 of file PassThroughTool.h.

◆ m_maxSpacePointNum

Gaudi::Property<unsigned int> PassThroughTool::m_maxSpacePointNum
private
Initial value:
{this, "MaxSpacePointNum", 500000,
"Maximum number of space points that can be processed"}

Definition at line 129 of file PassThroughTool.h.

◆ m_pixelClustersKey

SG::ReadHandleKey<xAOD::PixelClusterContainer> PassThroughTool::m_pixelClustersKey
private
Initial value:
{
this, "PixelClusterContainerKey", "ITkPixelClusters",
"Key for Pixel Cluster Containers"}

Definition at line 136 of file PassThroughTool.h.

◆ m_runSW

Gaudi::Property<bool> PassThroughTool::m_runSW {this, "RunSW", true, "Run software mode"}
private

Software mode, not running on the FPGA.

Definition at line 123 of file PassThroughTool.h.

◆ m_spacePointsKey

SG::ReadHandleKey<xAOD::SpacePointContainer> PassThroughTool::m_spacePointsKey
private
Initial value:
{
this, "SpacePointContainerKey", "ITkPixelSpacePoints",
"Key for Space Point Containers"}

Definition at line 139 of file PassThroughTool.h.

◆ m_stripClustersKey

SG::ReadHandleKey<xAOD::StripClusterContainer> PassThroughTool::m_stripClustersKey
private
Initial value:
{
this, "StripClusterContainerKey", "ITkStripClusters",
"Key for Strip Cluster Containers"}

Definition at line 133 of file PassThroughTool.h.

The documentation for this class was generated from the following files:
EFTrackingTransient::PixelCluster::totList
int totList[1000]
Definition: EFTrackingTransient.h:80
EFTrackingTransient::StripClusterOutput::scRdoList
unsigned long long * scRdoList
Definition: EFTrackingTransient.h:151
EFTrackingTransient::PixelCluster
The PixelClusters struct contains all xAOD::PixelCluster data members.
Definition: EFTrackingTransient.h:70
EFTrackingTransient::SpacePointOutput::spGlobalPosition
float * spGlobalPosition
Definition: EFTrackingTransient.h:192
EFTrackingTransient::PixelClusterAuxInput::localPosition
std::vector< float > localPosition
Definition: EFTrackingTransient.h:229
EFTrackingTransient::PixelClusterAuxInput::channelsInEta
std::vector< int > channelsInEta
Definition: EFTrackingTransient.h:234
PassThroughTool::m_runSW
Gaudi::Property< bool > m_runSW
Software mode, not running on the FPGA.
Definition: PassThroughTool.h:123
EFTrackingTransient::PixelCluster::sizeOfRDOList
int sizeOfRDOList
Definition: EFTrackingTransient.h:89
EFTrackingTransient::PixelCluster::lvl1a
int lvl1a
Definition: EFTrackingTransient.h:88
EFTrackingTransient::PixelClusterAuxInput::chargeList
std::vector< float > chargeList
Definition: EFTrackingTransient.h:238
EFTrackingTransient::StripClusterAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingTransient.h:216
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
EFTrackingTransient::PixelClusterOutput::pcIdHash
unsigned int * pcIdHash
Definition: EFTrackingTransient.h:164
EFTrackingTransient::PixelClusterAuxInput::splitProbability2
std::vector< float > splitProbability2
Definition: EFTrackingTransient.h:243
EFTrackingTransient::PixelCluster::idHash
unsigned int idHash
Definition: EFTrackingTransient.h:72
EFTrackingTransient::PixelClusterOutput::pcSplitProbability2
float * pcSplitProbability2
Definition: EFTrackingTransient.h:178
EFTrackingTransient::PixelCluster::sizeOfChargeList
int sizeOfChargeList
Definition: EFTrackingTransient.h:91
EFTrackingTransient::PixelCluster::splitProbability2
float splitProbability2
Definition: EFTrackingTransient.h:87
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
EFTrackingTransient::PixelClusterOutput::pcSplitProbability1
float * pcSplitProbability1
Definition: EFTrackingTransient.h:177
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
EFTrackingTransient::PixelClusterOutput::pcEnergyLoss
float * pcEnergyLoss
Definition: EFTrackingTransient.h:175
EFTrackingTransient::PixelClusterAuxInput::totalCharge
std::vector< float > totalCharge
Definition: EFTrackingTransient.h:239
EFTrackingTransient::StripClusterAuxInput::localCovariance
std::vector< float > localCovariance
Definition: EFTrackingTransient.h:213
EFTrackingTransient::SpacePointOutput::spMeasurementIndexes
int * spMeasurementIndexes
Definition: EFTrackingTransient.h:196
PassThroughTool::passThroughSW_clusterOnly
StatusCode passThroughSW_clusterOnly(const std::vector< EFTrackingTransient::StripCluster > &inputSC, EFTrackingTransient::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingTransient::PixelCluster > &inputPC, EFTrackingTransient::PixelClusterOutput &ef_pcOutput, EFTrackingTransient::Metadata *metadata) const
This is a cluster-only version (sw) of the pass-through kernel This is used for cluter level studies.
Definition: PassThroughTool.cxx:843
PassThroughTool::m_spacePointsKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_spacePointsKey
Definition: PassThroughTool.h:139
EFTrackingTransient::PixelClusterOutput::pcTotalCharge
float * pcTotalCharge
Definition: EFTrackingTransient.h:174
EFTrackingTransient::PixelClusterOutput::pcChargeList
float * pcChargeList
Definition: EFTrackingTransient.h:173
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
PassThroughTool::m_stripClustersKey
SG::ReadHandleKey< xAOD::StripClusterContainer > m_stripClustersKey
Definition: PassThroughTool.h:133
EFTrackingTransient::SpacePoint::bottomStripDirection
float bottomStripDirection[3]
Definition: EFTrackingTransient.h:113
EFTrackingTransient::SpacePoint::topHalfStripLength
float topHalfStripLength
Definition: EFTrackingTransient.h:110
EFTrackingTransient::SpacePoint::bottomHalfStripLength
float bottomHalfStripLength
Definition: EFTrackingTransient.h:111
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
EFTrackingTransient::StripClusterAuxInput::rdoList
std::vector< unsigned long long > rdoList
Definition: EFTrackingTransient.h:217
EFTrackingTransient::StripCluster
The StripClusters struct contains all xAOD::StripCluster data members.
Definition: EFTrackingTransient.h:52
EFTrackingTransient::PixelClusterOutput::pcLocalCovariance
float * pcLocalCovariance
Definition: EFTrackingTransient.h:163
EFTrackingTransient::PixelClusterOutput::pcId
long unsigned int * pcId
Definition: EFTrackingTransient.h:165
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
EFTrackingTransient::SpacePointOutput::spVarianceR
float * spVarianceR
Definition: EFTrackingTransient.h:194
EFTrackingTransient::PixelCluster::sizeOfTotList
int sizeOfTotList
Definition: EFTrackingTransient.h:90
EFTrackingTransient::SpacePointOutput::spIdHash
unsigned int * spIdHash
Definition: EFTrackingTransient.h:191
EFTrackingTransient::SpacePointOutput::spVarianceZ
float * spVarianceZ
Definition: EFTrackingTransient.h:195
EFTrackingTransient::PixelCluster::channelsInPhi
int channelsInPhi
Definition: EFTrackingTransient.h:77
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
EFTrackingTransient::PixelCluster::rdoList
unsigned long long rdoList[1000]
Definition: EFTrackingTransient.h:76
EFTrackingTransient::StripCluster::globalPosition
float globalPosition[3]
Definition: EFTrackingTransient.h:57
EFTrackingTransient::SpacePoint::stripCenterDistance
float stripCenterDistance[3]
Definition: EFTrackingTransient.h:114
EFTrackingTransient::SpacePoint
The SpacePoint struct contains all xAOD::SpacePoint data members.
Definition: EFTrackingTransient.h:101
EFTrackingTransient::StripCluster::localCovariance
float localCovariance
Definition: EFTrackingTransient.h:54
EFTrackingTransient::StripClusterOutput::scIdHash
unsigned int * scIdHash
Definition: EFTrackingTransient.h:148
PassThroughTool::m_maxSpacePointNum
Gaudi::Property< unsigned int > m_maxSpacePointNum
Definition: PassThroughTool.h:129
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
PassThroughTool::getInputClusterData
StatusCode getInputClusterData(const xAOD::StripClusterContainer *sc, std::vector< EFTrackingTransient::StripCluster > &ef_sc, unsigned long N) const
Convert the strip cluster from xAOD container to simple std::vector of EFTrackingTransient::StripClus...
Definition: PassThroughTool.cxx:448
EFTrackingTransient::PixelClusterAuxInput::rdoList
std::vector< unsigned long long > rdoList
Definition: EFTrackingTransient.h:232
PassThroughTool::m_clusterOnlyPassThrough
Gaudi::Property< bool > m_clusterOnlyPassThrough
Use the cluster-only pass through tool
Definition: PassThroughTool.h:125
EFTrackingTransient::PixelCluster::chargeList
float chargeList[1000]
Definition: EFTrackingTransient.h:82
lumiFormat.i
int i
Definition: lumiFormat.py:85
EFTrackingTransient::PixelClusterAuxInput::localCovariance
std::vector< float > localCovariance
Definition: EFTrackingTransient.h:230
EFTrackingTransient::SpacePoint::cov_r
float cov_r
Definition: EFTrackingTransient.h:106
EFTrackingTransient::SpacePointAuxInput::varianceR
std::vector< float > varianceR
Definition: EFTrackingTransient.h:258
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
EFTrackingTransient::PixelClusterOutput::pcLocalPosition
float * pcLocalPosition
Definition: EFTrackingTransient.h:162
EFTrackingTransient::StripClusterOutput::scLocalCovariance
float * scLocalCovariance
Definition: EFTrackingTransient.h:147
EFTrackingTransient::SpacePointAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingTransient.h:256
EFTrackingTransient::StripClusterAuxInput::idHash
std::vector< unsigned int > idHash
Definition: EFTrackingTransient.h:214
EFTrackingTransient::StripClusterOutput::scId
long unsigned int * scId
Definition: EFTrackingTransient.h:149
EFTrackingTransient::PixelCluster::splitProbability1
float splitProbability1
Definition: EFTrackingTransient.h:86
EFTrackingTransient::SpacePointAuxInput::varianceZ
std::vector< float > varianceZ
Definition: EFTrackingTransient.h:259
EFTrackingTransient::PixelCluster::channelsInEta
int channelsInEta
Definition: EFTrackingTransient.h:78
EFTrackingTransient::PixelClusterAuxInput::totalToT
std::vector< int > totalToT
Definition: EFTrackingTransient.h:237
EFTrackingTransient::PixelClusterOutput::pcWidthInEta
float * pcWidthInEta
Definition: EFTrackingTransient.h:170
EFTrackingTransient::PixelClusterOutput::pcIsSplit
char * pcIsSplit
Definition: EFTrackingTransient.h:176
EFTrackingTransient::SpacePointOutput::spElementIdList
unsigned int * spElementIdList
Definition: EFTrackingTransient.h:197
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
EFTrackingTransient::PixelClusterOutput::pcRdoList
unsigned long long * pcRdoList
Definition: EFTrackingTransient.h:167
EFTrackingTransient::PixelCluster::widthInEta
float widthInEta
Definition: EFTrackingTransient.h:79
EFTrackingTransient::PixelCluster::totalCharge
float totalCharge
Definition: EFTrackingTransient.h:83
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
EFTrackingTransient::SpacePoint::topStripDirection
float topStripDirection[3]
Definition: EFTrackingTransient.h:112
EFTrackingTransient::SpacePointAuxInput::measurementIndexes
std::vector< int > measurementIndexes
Definition: EFTrackingTransient.h:266
EFTrackingTransient::StripCluster::id
long unsigned int id
Definition: EFTrackingTransient.h:56
EFTrackingTransient::StripClusterOutput::scLocalPosition
float * scLocalPosition
Definition: EFTrackingTransient.h:146
EFTrackingTransient::PixelClusterAuxInput::splitProbability1
std::vector< float > splitProbability1
Definition: EFTrackingTransient.h:242
EFTrackingTransient::PixelClusterAuxInput::idHash
std::vector< unsigned int > idHash
Definition: EFTrackingTransient.h:228
EFTrackingTransient::PixelClusterAuxInput::lvl1a
std::vector< int > lvl1a
Definition: EFTrackingTransient.h:244
EFTrackingTransient::SpacePointAuxInput::elementIdList
std::vector< unsigned int > elementIdList
Definition: EFTrackingTransient.h:255
dumpTgcDigiThreshold.isStrip
list isStrip
Definition: dumpTgcDigiThreshold.py:33
EFTrackingTransient::StripClusterOutput
The StripClusters struct contains the output arrays from the FPGA.
Definition: EFTrackingTransient.h:144
EFTrackingTransient::StripCluster::sizeOfRDOList
int sizeOfRDOList
Definition: EFTrackingTransient.h:60
EFTrackingTransient::StripClusterAuxInput::localPosition
std::vector< float > localPosition
Definition: EFTrackingTransient.h:212
EFTrackingTransient::PixelCluster::isSplit
char isSplit
Definition: EFTrackingTransient.h:85
PassThroughTool::getInputSpacePointData
StatusCode getInputSpacePointData(const xAOD::SpacePointContainer *sp, std::vector< EFTrackingTransient::SpacePoint > &ef_sp, std::vector< std::vector< const xAOD::UncalibratedMeasurement * >> &sp_meas, unsigned long N, bool isStrip) const
Convert the space point from xAOD container to simple std::vector of EFTrackingTransient::SpacePoint.
Definition: PassThroughTool.cxx:555
EFTrackingTransient::SpacePointOutput
The Pixel/Strip SpacePoints struct contains the output arrays from the FPGA.
Definition: EFTrackingTransient.h:189
EFTrackingTransient::StripCluster::idHash
unsigned int idHash
Definition: EFTrackingTransient.h:55
EFTrackingTransient::PixelClusterAuxInput::channelsInPhi
std::vector< int > channelsInPhi
Definition: EFTrackingTransient.h:233
PassThroughTool::passThroughSW
StatusCode passThroughSW(const std::vector< EFTrackingTransient::StripCluster > &inputSC, EFTrackingTransient::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingTransient::PixelCluster > &inputPC, EFTrackingTransient::PixelClusterOutput &ef_pcOutput, const std::vector< EFTrackingTransient::SpacePoint > &inputSSP, EFTrackingTransient::SpacePointOutput &ef_sspOutput, const std::vector< EFTrackingTransient::SpacePoint > &inputPSP, EFTrackingTransient::SpacePointOutput &ef_pspOutput, EFTrackingTransient::Metadata *metadata) const
Software version of the pass-through kernel.
Definition: PassThroughTool.cxx:622
EFTrackingTransient::PixelCluster::localCovariance
float localCovariance[2]
Definition: EFTrackingTransient.h:74
EFTrackingTransient::StripClusterOutput::scGlobalPosition
float * scGlobalPosition
Definition: EFTrackingTransient.h:150
EFTrackingTransient::PixelClusterOutput
The PixelClusters struct contains the output arrays from the FPGA.
Definition: EFTrackingTransient.h:160
EFTrackingTransient::PixelClusterOutput::pcChannelsInEta
int * pcChannelsInEta
Definition: EFTrackingTransient.h:169
EFTrackingTransient::SpacePoint::radius
float radius
Definition: EFTrackingTransient.h:105
EFTrackingTransient::PixelClusterOutput::pcGlobalPosition
float * pcGlobalPosition
Definition: EFTrackingTransient.h:166
EFTrackingTransient::PixelClusterAuxInput::id
std::vector< long unsigned int > id
Definition: EFTrackingTransient.h:227
EFTrackingTransient::PixelClusterAuxInput::widthInEta
std::vector< float > widthInEta
Definition: EFTrackingTransient.h:235
EFTrackingTransient::PixelClusterAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingTransient.h:231
EFTrackingTransient::StripCluster::channelsInPhi
int channelsInPhi
Definition: EFTrackingTransient.h:59
EFTrackingTransient::SpacePoint::topStripCenter
float topStripCenter[3]
Definition: EFTrackingTransient.h:115
DEBUG
#define DEBUG
Definition: page_access.h:11
EFTrackingTransient::PixelCluster::globalPosition
float globalPosition[3]
Definition: EFTrackingTransient.h:75
EFTrackingTransient::PixelClusterOutput::pcChannelsInPhi
int * pcChannelsInPhi
Definition: EFTrackingTransient.h:168
PassThroughTool::m_pixelClustersKey
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_pixelClustersKey
Definition: PassThroughTool.h:136
EFTrackingTransient::StripClusterAuxInput::id
std::vector< long unsigned int > id
Definition: EFTrackingTransient.h:215
EFTrackingTransient::StripClusterAuxInput::channelsInPhi
std::vector< int > channelsInPhi
Definition: EFTrackingTransient.h:218
EFTrackingTransient::PixelClusterOutput::pcLvl1a
int * pcLvl1a
Definition: EFTrackingTransient.h:179
EFTrackingTransient::PixelCluster::totalToT
int totalToT
Definition: EFTrackingTransient.h:81
PassThroughTool::m_maxClusterNum
Gaudi::Property< unsigned int > m_maxClusterNum
Definition: PassThroughTool.h:127
calibdata.copy
bool copy
Definition: calibdata.py:26
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
EFTrackingTransient::SpacePointOutput::spRadius
float * spRadius
Definition: EFTrackingTransient.h:193
EFTrackingTransient::StripCluster::rdoList
unsigned long long rdoList[1000]
Definition: EFTrackingTransient.h:58
EFTrackingTransient::PixelClusterAuxInput::energyLoss
std::vector< float > energyLoss
Definition: EFTrackingTransient.h:240
EFTrackingTransient::PixelClusterAuxInput::totList
std::vector< int > totList
Definition: EFTrackingTransient.h:236
EFTrackingTransient::PixelCluster::localPosition
float localPosition[2]
Definition: EFTrackingTransient.h:73
EFTrackingTransient::SpacePoint::globalPosition
float globalPosition[3]
Definition: EFTrackingTransient.h:104
EFTrackingTransient::StripCluster::localPosition
float localPosition
Definition: EFTrackingTransient.h:53
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
EFTrackingTransient::PixelClusterAuxInput::isSplit
std::vector< char > isSplit
Definition: EFTrackingTransient.h:241
python.SystemOfUnits.pc
float pc
Definition: SystemOfUnits.py:114
EFTrackingTransient::PixelClusterOutput::pcTotList
int * pcTotList
Definition: EFTrackingTransient.h:171
EFTrackingTransient::StripClusterOutput::scChannelsInPhi
int * scChannelsInPhi
Definition: EFTrackingTransient.h:152
EFTrackingTransient::PixelClusterOutput::pcTotalToT
int * pcTotalToT
Definition: EFTrackingTransient.h:172
EFTrackingTransient::PixelCluster::id
long unsigned int id
Definition: EFTrackingTransient.h:71
EFTrackingTransient::SpacePoint::cov_z
float cov_z
Definition: EFTrackingTransient.h:107
EFTrackingTransient::PixelCluster::energyLoss
float energyLoss
Definition: EFTrackingTransient.h:84
EFTrackingTransient::SpacePoint::idHash
unsigned int idHash[2]
Definition: EFTrackingTransient.h:103
Generated on Mon Sep 1 2025 21:43:30 for ATLAS Offline Software by   doxygen 1.8.18