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 (EFTrackingDataFormats::StripClusterAuxInput &scAux, EFTrackingDataFormats::PixelClusterAuxInput &pxAux, EFTrackingDataFormats::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< EFTrackingDataFormats::StripCluster > &ef_sc, unsigned long N) const
 Convert the strip cluster from xAOD container to simple std::vector of EFTrackingDataFormats::StripCluster. More...
 
StatusCode getInputClusterData (const xAOD::PixelClusterContainer *pc, std::vector< EFTrackingDataFormats::PixelCluster > &ef_pc, unsigned long N) const
 Convert the pixel cluster from xAOD container to simple std::vector of EFTrackingDataFormats::PixelCluster. More...
 
StatusCode getInputSpacePointData (const xAOD::SpacePointContainer *sp, std::vector< EFTrackingDataFormats::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 EFTrackingDataFormats::SpacePoint. More...
 
StatusCode passThroughSW (const std::vector< EFTrackingDataFormats::StripCluster > &inputSC, EFTrackingDataFormats::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingDataFormats::PixelCluster > &inputPC, EFTrackingDataFormats::PixelClusterOutput &ef_pcOutput, const std::vector< EFTrackingDataFormats::SpacePoint > &inputSSP, EFTrackingDataFormats::SpacePointOutput &ef_sspOutput, const std::vector< EFTrackingDataFormats::SpacePoint > &inputPSP, EFTrackingDataFormats::SpacePointOutput &ef_pspOutput, EFTrackingDataFormats::Metadata *metadata) const
 Software version of the pass-through kernel. More...
 
StatusCode passThroughSW_clusterOnly (const std::vector< EFTrackingDataFormats::StripCluster > &inputSC, EFTrackingDataFormats::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingDataFormats::PixelCluster > &inputPC, EFTrackingDataFormats::PixelClusterOutput &ef_pcOutput, EFTrackingDataFormats::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_clusterOnlyPassThrouth
 Use the cluster-only pass through tool. More...
 
SG::ReadHandleKey< xAOD::StripClusterContainer > m_stripClustersKey
 
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_pixelClustersKey
 

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< EFTrackingDataFormats::PixelCluster > &  ef_pc,
unsigned long  N 
) const

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

This is needed for the kernel input.

Definition at line 364 of file PassThroughTool.cxx.

368 {
369  if (N > pc->size())
370  {
371  ATH_MSG_ERROR("You want to get the "
372  << N << "th pixel cluster, but there are only " << pc->size()
373  << " pixel clusters in the container.");
374  return StatusCode::FAILURE;
375  }
376  ATH_MSG_DEBUG("Making vector of pixel clusters...");
377  for (unsigned long i = 0; i < N; i++)
378  {
379  EFTrackingDataFormats::PixelCluster cache;
380  // Get the data from the input xAOD::PixelClusterContainer and set it to the
381  // cache
382  cache.id = pc->at(i)->identifier();
383  cache.idHash = pc->at(i)->identifierHash();
384  cache.localPosition[0] = pc->at(i)->localPosition<2>()(0, 0);
385  cache.localPosition[1] = pc->at(i)->localPosition<2>()(1, 0);
386  cache.localCovariance[0] = pc->at(i)->localCovariance<2>()(0, 0);
387  cache.localCovariance[1] = pc->at(i)->localCovariance<2>()(1, 1);
388  cache.globalPosition[0] = pc->at(i)->globalPosition()[0];
389  cache.globalPosition[1] = pc->at(i)->globalPosition()[1];
390  cache.globalPosition[2] = pc->at(i)->globalPosition()[2];
391 
392  for (long unsigned int j = 0; j < pc->at(i)->rdoList().size(); j++)
393  {
394  cache.rdoList[j] = pc->at(i)->rdoList().at(j).get_compact();
395  }
396 
397  cache.channelsInPhi = pc->at(i)->channelsInPhi();
398  cache.channelsInEta = pc->at(i)->channelsInEta();
399  cache.widthInEta = pc->at(i)->widthInEta();
400  cache.omegaX = pc->at(i)->omegaX();
401  cache.omegaY = pc->at(i)->omegaY();
402 
403  for (long unsigned int j = 0; j < pc->at(i)->totList().size(); j++)
404  {
405  cache.totList[j] = pc->at(i)->totList().at(j);
406  }
407 
408  cache.totalToT = pc->at(i)->totalToT();
409 
410  for (long unsigned int j = 0; j < pc->at(i)->chargeList().size(); j++)
411  {
412  cache.chargeList[j] = pc->at(i)->chargeList().at(j);
413  }
414 
415  cache.totalCharge = pc->at(i)->totalCharge();
416  cache.energyLoss = pc->at(i)->energyLoss();
417  cache.isSplit = pc->at(i)->isSplit();
418  cache.splitProbability1 = pc->at(i)->splitProbability1();
419  cache.splitProbability2 = pc->at(i)->splitProbability2();
420  cache.lvl1a = pc->at(i)->lvl1a();
421  cache.sizeOfRDOList = pc->at(i)->rdoList().size();
422  cache.sizeOfTotList = pc->at(i)->totList().size();
423  cache.sizeOfChargeList = pc->at(i)->chargeList().size();
424 
425  ef_pc.push_back(cache);
426  }
427 
428  ATH_MSG_DEBUG("Made " << ef_pc.size() << " pixel clusters in the vector");
429  return StatusCode::SUCCESS;
430 }

◆ getInputClusterData() [2/2]

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

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

This is needed for the kernel input.

Definition at line 323 of file PassThroughTool.cxx.

327 {
328  if (N > sc->size())
329  {
330  ATH_MSG_ERROR("You want to get the "
331  << N << "th strip cluster, but there are only " << sc->size()
332  << " strip clusters in the container.");
333  return StatusCode::FAILURE;
334  }
335  ATH_MSG_DEBUG("Making vector of strip clusters...");
336  for (unsigned long i = 0; i < N; i++)
337  {
338  EFTrackingDataFormats::StripCluster cache;
339  // Get the data from the input xAOD::StripClusterContainer and set it to the
340  // cache
341  cache.localPosition = sc->at(i)->localPosition<1>()(0, 0);
342  cache.localCovariance = sc->at(i)->localCovariance<1>()(0, 0);
343  cache.idHash = sc->at(i)->identifierHash();
344  cache.id = sc->at(i)->identifier();
345  cache.globalPosition[0] = sc->at(i)->globalPosition()[0];
346  cache.globalPosition[1] = sc->at(i)->globalPosition()[1];
347  cache.globalPosition[2] = sc->at(i)->globalPosition()[2];
348 
349  for (unsigned long j = 0; j < sc->at(i)->rdoList().size(); j++)
350  {
351  cache.rdoList[j] = sc->at(i)->rdoList().at(j).get_compact();
352  }
353 
354  cache.channelsInPhi = sc->at(i)->channelsInPhi();
355  cache.sizeOfRDOList = sc->at(i)->rdoList().size();
356 
357  ef_sc.push_back(cache);
358  }
359 
360  ATH_MSG_DEBUG("Made " << ef_sc.size() << " strip clusters in the vector");
361  return StatusCode::SUCCESS;
362 }

◆ getInputSpacePointData()

StatusCode PassThroughTool::getInputSpacePointData ( const xAOD::SpacePointContainer *  sp,
std::vector< EFTrackingDataFormats::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 EFTrackingDataFormats::SpacePoint.

This is needed for the kernel input.

Definition at line 432 of file PassThroughTool.cxx.

437 {
438  if (N > sp->size())
439  {
440  ATH_MSG_ERROR("You want to get the "
441  << N << "th space point, but there are only " << sp->size()
442  << " SpacePoint in the container.");
443  return StatusCode::FAILURE;
444  }
445  ATH_MSG_DEBUG("Making vector of space point...");
446  for (unsigned long i = 0; i < N; i++)
447  {
448  EFTrackingDataFormats::SpacePoint cache;
449  // Get the data from the input xAOD::SpacePointContainer and set it to the
450  // cache
451  cache.idHash[0] = sp->at(i)->elementIdList()[0];
452  cache.globalPosition[0] = sp->at(i)->x();
453  cache.globalPosition[1] = sp->at(i)->y();
454  cache.globalPosition[2] = sp->at(i)->z();
455  cache.radius = sp->at(i)->radius();
456  cache.cov_r = sp->at(i)->varianceR();
457  cache.cov_z = sp->at(i)->varianceZ();
458 
459  // Pass the uncalibrated measurement for later stage of xAOD container
460  // creation for spacepoint
461  std::vector<const xAOD::UncalibratedMeasurement *> temp_vec(
462  sp->at(i)->measurements().size());
463  std::copy(sp->at(i)->measurements().begin(),
464  sp->at(i)->measurements().end(), temp_vec.begin());
465 
466  sp_meas.push_back(temp_vec);
467 
468  if (isStrip)
469  {
470  cache.idHash[1] = sp->at(i)->elementIdList()[1];
471  cache.topHalfStripLength = sp->at(i)->topHalfStripLength();
472  cache.bottomHalfStripLength = sp->at(i)->bottomHalfStripLength();
473  std::copy(sp->at(i)->topStripDirection().data(),
474  sp->at(i)->topStripDirection().data() +
475  sp->at(i)->topStripDirection().size(),
476  cache.topStripDirection);
477  std::copy(sp->at(i)->bottomStripDirection().data(),
478  sp->at(i)->bottomStripDirection().data() +
479  sp->at(i)->bottomStripDirection().size(),
480  cache.bottomStripDirection);
481  std::copy(sp->at(i)->stripCenterDistance().data(),
482  sp->at(i)->stripCenterDistance().data() +
483  sp->at(i)->stripCenterDistance().size(),
484  cache.stripCenterDistance);
485  std::copy(sp->at(i)->topStripCenter().data(),
486  sp->at(i)->topStripCenter().data() +
487  sp->at(i)->topStripCenter().size(),
488  cache.topStripCenter);
489  }
490  ef_sp.push_back(cache);
491  }
492 
493  ATH_MSG_DEBUG("Made " << ef_sp.size() << " space points in the vector");
494  return StatusCode::SUCCESS;
495 }

◆ initialize()

StatusCode PassThroughTool::initialize ( )
override

Definition at line 17 of file PassThroughTool.cxx.

18 {
19  ATH_MSG_INFO("Initializing PassThroughTool tool");
20  ATH_CHECK(m_stripClustersKey.initialize());
21  ATH_CHECK(m_pixelClustersKey.initialize());
22 
23  return StatusCode::SUCCESS;
24 }

◆ passThroughSW()

StatusCode PassThroughTool::passThroughSW ( const std::vector< EFTrackingDataFormats::StripCluster > &  inputSC,
EFTrackingDataFormats::StripClusterOutput &  ef_scOutput,
const std::vector< EFTrackingDataFormats::PixelCluster > &  inputPC,
EFTrackingDataFormats::PixelClusterOutput &  ef_pcOutput,
const std::vector< EFTrackingDataFormats::SpacePoint > &  inputSSP,
EFTrackingDataFormats::SpacePointOutput &  ef_sspOutput,
const std::vector< EFTrackingDataFormats::SpacePoint > &  inputPSP,
EFTrackingDataFormats::SpacePointOutput &  ef_pspOutput,
EFTrackingDataFormats::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 EFTrackingDataFormats::StripCluster EFTrackingDataFormats::PixelCluster, and EFTrackingDataFormat::SpacePoints as input arguments and mimic the transfer kernel by giving array output.

Definition at line 499 of file PassThroughTool.cxx.

513 {
514  // return input
515  int rdoIndex_counter = 0;
516 
517  unsigned int inputscRdoIndexSize = 0;
518  unsigned int inputpcRdoIndexSize = 0;
519 
520  // transfer inputSC
521  // trasnsfer_sc:
522  for (size_t i = 0; i < inputSC.size(); i++)
523  {
524  ef_scOutput.scLocalPosition[i] = inputSC[i].localPosition;
525  ef_scOutput.scLocalCovariance[i] = inputSC[i].localCovariance;
526  ef_scOutput.scIdHash[i] = inputSC[i].idHash;
527  ef_scOutput.scId[i] = inputSC[i].id;
528  ef_scOutput.scGlobalPosition[i * 3] = inputSC[i].globalPosition[0];
529  ef_scOutput.scGlobalPosition[i * 3 + 1] = inputSC[i].globalPosition[1];
530  ef_scOutput.scGlobalPosition[i * 3 + 2] = inputSC[i].globalPosition[2];
531 
532  inputscRdoIndexSize += inputSC[i].sizeOfRDOList;
533 
534  for (int j = 0; j < inputSC[i].sizeOfRDOList; j++)
535  {
536  ef_scOutput.scRdoList[rdoIndex_counter + j] = inputSC[i].rdoList[j];
537  }
538  // update the index counter
539  ef_scOutput.scChannelsInPhi[i] = inputSC[i].channelsInPhi;
540  rdoIndex_counter += inputSC[i].sizeOfRDOList;
541  metadata[0].scRdoIndex[i] = inputSC[i].sizeOfRDOList;
542  }
543 
544  // transfer inputPC
545  rdoIndex_counter = 0;
546  int totIndex_counter = 0;
547  int chargeIndex_counter = 0;
548 
549  unsigned int inputpcTotListsize = 0;
550  unsigned int inputpcChargeListsize = 0;
551 
552  // trasnsfer_pc:
553  for (size_t i = 0; i < inputPC.size(); i++)
554  {
555  ef_pcOutput.pcLocalPosition[i * 2] = inputPC[i].localPosition[0];
556  ef_pcOutput.pcLocalPosition[i * 2 + 1] = inputPC[i].localPosition[1];
557  ef_pcOutput.pcLocalCovariance[i * 2] = inputPC[i].localCovariance[0];
558  ef_pcOutput.pcLocalCovariance[i * 2 + 1] = inputPC[i].localCovariance[1];
559  ef_pcOutput.pcIdHash[i] = inputPC[i].idHash;
560  ef_pcOutput.pcId[i] = inputPC[i].id;
561  ef_pcOutput.pcGlobalPosition[i * 3] = inputPC[i].globalPosition[0];
562  ef_pcOutput.pcGlobalPosition[i * 3 + 1] = inputPC[i].globalPosition[1];
563  ef_pcOutput.pcGlobalPosition[i * 3 + 2] = inputPC[i].globalPosition[2];
564 
565  inputpcRdoIndexSize += inputPC[i].sizeOfRDOList;
566 
567  for (int j = 0; j < inputPC[i].sizeOfRDOList; j++)
568  {
569  ef_pcOutput.pcRdoList[rdoIndex_counter + j] = inputPC[i].rdoList[j];
570  }
571  ef_pcOutput.pcChannelsInPhi[i] = inputPC[i].channelsInPhi;
572  ef_pcOutput.pcChannelsInEta[i] = inputPC[i].channelsInEta;
573  ef_pcOutput.pcWidthInEta[i] = inputPC[i].widthInEta;
574  ef_pcOutput.pcOmegaX[i] = inputPC[i].omegaX;
575  ef_pcOutput.pcOmegaY[i] = inputPC[i].omegaY;
576 
577  inputpcTotListsize += inputPC[i].sizeOfTotList;
578 
579  for (int j = 0; j < inputPC[i].sizeOfTotList; j++)
580  {
581  ef_pcOutput.pcTotList[totIndex_counter + j] = inputPC[i].totList[j];
582  }
583  ef_pcOutput.pcTotalToT[i] = inputPC[i].totalToT;
584 
585  inputpcChargeListsize += inputPC[i].sizeOfChargeList;
586 
587  for (int j = 0; j < inputPC[i].sizeOfChargeList; j++)
588  {
589  ef_pcOutput.pcChargeList[chargeIndex_counter + j] =
590  inputPC[i].chargeList[j];
591  }
592  ef_pcOutput.pcTotalCharge[i] = inputPC[i].totalCharge;
593  ef_pcOutput.pcEnergyLoss[i] = inputPC[i].energyLoss;
594  ef_pcOutput.pcIsSplit[i] = inputPC[i].isSplit;
595  ef_pcOutput.pcSplitProbability1[i] = inputPC[i].splitProbability1;
596  ef_pcOutput.pcSplitProbability2[i] = inputPC[i].splitProbability2;
597  ef_pcOutput.pcLvl1a[i] = inputPC[i].lvl1a;
598 
599  // update the index counter
600  rdoIndex_counter += inputPC[i].sizeOfRDOList;
601  totIndex_counter += inputPC[i].sizeOfTotList;
602  chargeIndex_counter += inputPC[i].sizeOfChargeList;
603  metadata[0].pcRdoIndex[i] = inputPC[i].sizeOfRDOList;
604  metadata[0].pcTotIndex[i] = inputPC[i].sizeOfTotList;
605  metadata[0].pcChargeIndex[i] = inputPC[i].sizeOfChargeList;
606  }
607 
608  // transfer strip space points
609  for (size_t i = 0; i < inputSSP.size(); i++)
610  {
611  ef_sspOutput.spIdHash[i * 2] = inputSSP[i].idHash[0];
612  ef_sspOutput.spIdHash[i * 2 + 1] = inputSSP[i].idHash[1];
613  ef_sspOutput.spGlobalPosition[i * 3] = inputSSP[i].globalPosition[0];
614  ef_sspOutput.spGlobalPosition[i * 3 + 1] = inputSSP[i].globalPosition[1];
615  ef_sspOutput.spGlobalPosition[i * 3 + 2] = inputSSP[i].globalPosition[2];
616  ef_sspOutput.spRadius[i] = inputSSP[i].radius;
617  ef_sspOutput.spVarianceR[i] = inputSSP[i].cov_r;
618  ef_sspOutput.spVarianceZ[i] = inputSSP[i].cov_z;
619  ef_sspOutput.spTopHalfStripLength[i] = inputSSP[i].topHalfStripLength;
620  ef_sspOutput.spBottomHalfStripLength[i] = inputSSP[i].bottomHalfStripLength;
621  ef_sspOutput.spTopStripDirection[i * 3] = inputSSP[i].topStripDirection[0];
622  ef_sspOutput.spTopStripDirection[i * 3 + 1] =
623  inputSSP[i].topStripDirection[1];
624  ef_sspOutput.spTopStripDirection[i * 3 + 2] =
625  inputSSP[i].topStripDirection[2];
626  ef_sspOutput.spBottomStripDirection[i * 3] =
627  inputSSP[i].bottomStripDirection[0];
628  ef_sspOutput.spBottomStripDirection[i * 3 + 1] =
629  inputSSP[i].bottomStripDirection[1];
630  ef_sspOutput.spBottomStripDirection[i * 3 + 2] =
631  inputSSP[i].bottomStripDirection[2];
632  ef_sspOutput.spStripCenterDistance[i * 3] =
633  inputSSP[i].stripCenterDistance[0];
634  ef_sspOutput.spStripCenterDistance[i * 3 + 1] =
635  inputSSP[i].stripCenterDistance[1];
636  ef_sspOutput.spStripCenterDistance[i * 3 + 2] =
637  inputSSP[i].stripCenterDistance[2];
638  ef_sspOutput.spTopStripCenter[i * 3] = inputSSP[i].topStripCenter[0];
639  ef_sspOutput.spTopStripCenter[i * 3 + 1] = inputSSP[i].topStripCenter[1];
640  ef_sspOutput.spTopStripCenter[i * 3 + 2] = inputSSP[i].topStripCenter[2];
641  }
642 
643  // transfer pixel space points
644  for (size_t i = 0; i < inputPSP.size(); i++)
645  {
646  ef_pspOutput.spIdHash[i] = inputPSP[i].idHash[0];
647  ef_pspOutput.spGlobalPosition[i * 3] = inputPSP[i].globalPosition[0];
648  ef_pspOutput.spGlobalPosition[i * 3 + 1] = inputPSP[i].globalPosition[1];
649  ef_pspOutput.spGlobalPosition[i * 3 + 2] = inputPSP[i].globalPosition[2];
650  ef_pspOutput.spRadius[i] = inputPSP[i].radius;
651  ef_pspOutput.spVarianceR[i] = inputPSP[i].cov_r;
652  ef_pspOutput.spVarianceZ[i] = inputPSP[i].cov_z;
653  }
654 
655  // transfer metadata
656  metadata[0].numOfStripClusters = inputSC.size();
657  metadata[0].numOfPixelClusters = inputPC.size();
658  metadata[0].numOfStripSpacePoints = inputSSP.size();
659  metadata[0].numOfPixelSpacePoints = inputPSP.size();
660  metadata[0].scRdoIndexSize = inputscRdoIndexSize;
661  metadata[0].pcRdoIndexSize = inputpcRdoIndexSize;
662  metadata[0].pcTotIndexSize = inputpcTotListsize;
663  metadata[0].pcChargeIndexSize = inputpcChargeListsize;
664 
665  return StatusCode::SUCCESS;
666 }

◆ passThroughSW_clusterOnly()

StatusCode PassThroughTool::passThroughSW_clusterOnly ( const std::vector< EFTrackingDataFormats::StripCluster > &  inputSC,
EFTrackingDataFormats::StripClusterOutput &  ef_scOutput,
const std::vector< EFTrackingDataFormats::PixelCluster > &  inputPC,
EFTrackingDataFormats::PixelClusterOutput &  ef_pcOutput,
EFTrackingDataFormats::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 669 of file PassThroughTool.cxx.

678 {
679  int rdoIndex_counter = 0;
680 
681  unsigned int inputscRdoIndexSize = 0;
682 
683  // transfer inputStripClusters
684  ATH_MSG_DEBUG("Transfering strip clusters...");
685  for (size_t i = 0; i < inputSC.size(); i++)
686  {
687  ef_scOutput.scLocalPosition[i] = inputSC[i].localPosition;
688  ef_scOutput.scLocalCovariance[i] = inputSC[i].localCovariance;
689  ef_scOutput.scIdHash[i] = inputSC[i].idHash;
690  ef_scOutput.scId[i] = inputSC[i].id;
691  ef_scOutput.scGlobalPosition[i * 3] = inputSC[i].globalPosition[0];
692  ef_scOutput.scGlobalPosition[i * 3 + 1] = inputSC[i].globalPosition[1];
693  ef_scOutput.scGlobalPosition[i * 3 + 2] = inputSC[i].globalPosition[2];
694 
695  inputscRdoIndexSize += inputSC[i].sizeOfRDOList;
696 
697  for (int j = 0; j < inputSC[i].sizeOfRDOList; j++)
698  {
699  ef_scOutput.scRdoList[rdoIndex_counter + j] = inputSC[i].rdoList[j];
700  }
701  // update the index counter
702  ef_scOutput.scChannelsInPhi[i] = inputSC[i].channelsInPhi;
703  rdoIndex_counter += inputSC[i].sizeOfRDOList;
704  metadata[0].scRdoIndex[i] = inputSC[i].sizeOfRDOList;
705  }
706 
707  // transfer inputPC
708  rdoIndex_counter = 0;
709  int totIndex_counter = 0;
710  int chargeIndex_counter = 0;
711 
712  unsigned int inputpcRdoIndexSize = 0;
713  unsigned int inputpcTotListsize = 0;
714  unsigned int inputpcChargeListsize = 0;
715 
716  // trasnsfer_pc:
717  ATH_MSG_DEBUG("Transfering pixel clusters...");
718  for (size_t i = 0; i < inputPC.size(); i++)
719  {
720  ef_pcOutput.pcLocalPosition[i * 2] = inputPC[i].localPosition[0];
721  ef_pcOutput.pcLocalPosition[i * 2 + 1] = inputPC[i].localPosition[1];
722  ef_pcOutput.pcLocalCovariance[i * 2] = inputPC[i].localCovariance[0];
723  ef_pcOutput.pcLocalCovariance[i * 2 + 1] = inputPC[i].localCovariance[1];
724  ef_pcOutput.pcIdHash[i] = inputPC[i].idHash;
725  ef_pcOutput.pcId[i] = inputPC[i].id;
726  ef_pcOutput.pcGlobalPosition[i * 3] = inputPC[i].globalPosition[0];
727  ef_pcOutput.pcGlobalPosition[i * 3 + 1] = inputPC[i].globalPosition[1];
728  ef_pcOutput.pcGlobalPosition[i * 3 + 2] = inputPC[i].globalPosition[2];
729 
730  inputpcRdoIndexSize += inputPC[i].sizeOfRDOList;
731 
732  for (int j = 0; j < inputPC[i].sizeOfRDOList; j++)
733  {
734  ef_pcOutput.pcRdoList[rdoIndex_counter + j] = inputPC[i].rdoList[j];
735  }
736  ef_pcOutput.pcChannelsInPhi[i] = inputPC[i].channelsInPhi;
737  ef_pcOutput.pcChannelsInEta[i] = inputPC[i].channelsInEta;
738  ef_pcOutput.pcWidthInEta[i] = inputPC[i].widthInEta;
739  ef_pcOutput.pcOmegaX[i] = inputPC[i].omegaX;
740  ef_pcOutput.pcOmegaY[i] = inputPC[i].omegaY;
741 
742  inputpcTotListsize += inputPC[i].sizeOfTotList;
743 
744  for (int j = 0; j < inputPC[i].sizeOfTotList; j++)
745  {
746  ef_pcOutput.pcTotList[totIndex_counter + j] = inputPC[i].totList[j];
747  }
748  ef_pcOutput.pcTotalToT[i] = inputPC[i].totalToT;
749 
750  inputpcChargeListsize += inputPC[i].sizeOfChargeList;
751 
752  for (int j = 0; j < inputPC[i].sizeOfChargeList; j++)
753  {
754  ef_pcOutput.pcChargeList[chargeIndex_counter + j] =
755  inputPC[i].chargeList[j];
756  }
757  ef_pcOutput.pcTotalCharge[i] = inputPC[i].totalCharge;
758  ef_pcOutput.pcEnergyLoss[i] = inputPC[i].energyLoss;
759  ef_pcOutput.pcIsSplit[i] = inputPC[i].isSplit;
760  ef_pcOutput.pcSplitProbability1[i] = inputPC[i].splitProbability1;
761  ef_pcOutput.pcSplitProbability2[i] = inputPC[i].splitProbability2;
762  ef_pcOutput.pcLvl1a[i] = inputPC[i].lvl1a;
763 
764  // update the index counter
765  rdoIndex_counter += inputPC[i].sizeOfRDOList;
766  totIndex_counter += inputPC[i].sizeOfTotList;
767  chargeIndex_counter += inputPC[i].sizeOfChargeList;
768  metadata[0].pcRdoIndex[i] = inputPC[i].sizeOfRDOList;
769  metadata[0].pcTotIndex[i] = inputPC[i].sizeOfTotList;
770  metadata[0].pcChargeIndex[i] = inputPC[i].sizeOfChargeList;
771  }
772  // transfer metadata
773  metadata[0].numOfStripClusters = inputSC.size();
774  metadata[0].numOfPixelClusters = inputPC.size();
775  metadata[0].scRdoIndexSize = inputscRdoIndexSize;
776  metadata[0].pcRdoIndexSize = inputpcRdoIndexSize;
777  metadata[0].pcTotIndexSize = inputpcTotListsize;
778  metadata[0].pcChargeIndexSize = inputpcChargeListsize;
779  return StatusCode::SUCCESS;
780 }

◆ runPassThrough()

StatusCode PassThroughTool::runPassThrough ( EFTrackingDataFormats::StripClusterAuxInput &  scAux,
EFTrackingDataFormats::PixelClusterAuxInput &  pxAux,
EFTrackingDataFormats::Metadata *  metadata,
const EventContext &  ctx 
) const

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

Definition at line 26 of file PassThroughTool.cxx.

30 {
31  // Retrieve the strip and pixel cluster container from the event store
32  SG::ReadHandle<xAOD::StripClusterContainer> inputStripClusters(
33  m_stripClustersKey, ctx);
34  SG::ReadHandle<xAOD::PixelClusterContainer> inputPixelClusters(
35  m_pixelClustersKey, ctx);
36 
37  // Check if the strip cluster container is valid
38  if (!inputStripClusters.isValid())
39  {
40  ATH_MSG_ERROR("Failed to retrieve: " << m_stripClustersKey);
41  return StatusCode::FAILURE;
42  }
43 
44  // Check if the pixel cluster container is valid
45  if (!inputPixelClusters.isValid())
46  {
47  ATH_MSG_ERROR("Failed to retrieve: " << m_pixelClustersKey);
48  return StatusCode::FAILURE;
49  }
50  if (msgLvl(MSG::DEBUG))
51  {
52  ATH_MSG_DEBUG("StripClusterContainer is valid");
53  ATH_MSG_DEBUG("PixelClusterContainer is valid");
54  ATH_MSG_DEBUG("Size of pixel clusters is : " << inputPixelClusters->size());
55  ATH_MSG_DEBUG("Size of strip clusters is : " << inputStripClusters->size());
56  }
57 
58  // Prepare the input data for the kernel
59  // This is to "remake" the cluster but in a kernel compatible format using
60  // the struct defined in EFTrackingDataFormats.h
61  std::vector<EFTrackingDataFormats::StripCluster> ef_stripClusters; // Strip clusters as kernel input argument
62  std::vector<EFTrackingDataFormats::PixelCluster> ef_pixelClusters; // Pixel clusters as kernel input argument
63 
64  ATH_CHECK(getInputClusterData(inputStripClusters.get(), ef_stripClusters, inputStripClusters->size()));
65  ATH_CHECK(getInputClusterData(inputPixelClusters.get(), ef_pixelClusters, inputPixelClusters->size()));
66 
67  if (msgLvl(MSG::DEBUG))
68  {
69  // Print a few clusters to verify the conversion
70  for (int i = 0; i < 3; i++)
71  {
72  ATH_MSG_DEBUG("StripCluster["
73  << i << "]: " << ef_stripClusters.at(i).localPosition
74  << ", " << ef_stripClusters.at(i).localCovariance << ", "
75  << ef_stripClusters.at(i).idHash << ", "
76  << ef_stripClusters.at(i).id << ", "
77  << ef_stripClusters.at(i).globalPosition[0] << ", "
78  << ef_stripClusters.at(i).globalPosition[1] << ", "
79  << ef_stripClusters.at(i).globalPosition[2] << ", "
80  << ef_stripClusters.at(i).rdoList[0] << ", "
81  << ef_stripClusters.at(i).channelsInPhi);
82  }
83  // Pixel clusters
84  for (int i = 0; i < 3; i++)
85  {
86  ATH_MSG_DEBUG("PixelCluster["
87  << i << "]: " << ef_pixelClusters.at(i).id << ", "
88  << ef_pixelClusters.at(i).idHash << ", "
89  << ef_pixelClusters.at(i).localPosition[0] << ", "
90  << ef_pixelClusters.at(i).localPosition[1] << ", "
91  << ef_pixelClusters.at(i).localCovariance[0] << ", "
92  << ef_pixelClusters.at(i).localCovariance[1] << ", "
93  << ef_pixelClusters.at(i).globalPosition[0] << ", "
94  << ef_pixelClusters.at(i).globalPosition[1] << ", "
95  << ef_pixelClusters.at(i).globalPosition[2] << ", "
96  << ef_pixelClusters.at(i).rdoList[0] << ", "
97  << ef_pixelClusters.at(i).channelsInPhi << ", "
98  << ef_pixelClusters.at(i).channelsInEta << ", "
99  << ef_pixelClusters.at(i).widthInEta << ", "
100  << ef_pixelClusters.at(i).omegaX << ", "
101  << ef_pixelClusters.at(i).omegaY << ", "
102  << ef_pixelClusters.at(i).totList[0] << ", "
103  << ef_pixelClusters.at(i).totalToT << ", "
104  << ef_pixelClusters.at(i).chargeList[0] << ", "
105  << ef_pixelClusters.at(i).totalCharge << ", "
106  << ef_pixelClusters.at(i).energyLoss << ", "
107  << ef_pixelClusters.at(i).isSplit << ", "
108  << ef_pixelClusters.at(i).splitProbability1 << ", "
109  << ef_pixelClusters.at(i).splitProbability2 << ", "
110  << ef_pixelClusters.at(i).lvl1a);
111  }
112  }
113 
114  // Determine if we are running sw or hw
115  if (m_runSW)
116  {
117  ATH_MSG_INFO("Running the sw ver of the pass-through kernel");
118  // Strip cluster
119  std::vector<float> scLocalPosition((static_cast<unsigned long>(MAX_CLUSTER_NUM)));
120  std::vector<float> scLocalCovariance((static_cast<unsigned long>(MAX_CLUSTER_NUM)));
121  std::vector<unsigned int> scIdHash((static_cast<unsigned long>(MAX_CLUSTER_NUM)));
122  std::vector<long unsigned int> scId((static_cast<unsigned long>(MAX_CLUSTER_NUM)));
123  std::vector<float> scGlobalPosition((static_cast<unsigned long>(MAX_CLUSTER_NUM)) * 3);
124  std::vector<unsigned long long> scRdoList((static_cast<unsigned long>(MAX_CLUSTER_NUM)) * 5000);
125  std::vector<int> scChannelsInPhi(static_cast<unsigned long>(MAX_CLUSTER_NUM));
126 
127  EFTrackingDataFormats::StripClusterOutput ef_scOutput;
128 
129  ef_scOutput.scLocalPosition = scLocalPosition.data();
130  ef_scOutput.scLocalCovariance = scLocalCovariance.data();
131  ef_scOutput.scIdHash = scIdHash.data();
132  ef_scOutput.scId = scId.data();
133  ef_scOutput.scGlobalPosition = scGlobalPosition.data();
134  ef_scOutput.scRdoList = scRdoList.data();
135  ef_scOutput.scChannelsInPhi = scChannelsInPhi.data();
136 
137  // Pixel cluster
138  std::vector<float> pcLocalPosition(static_cast<unsigned long>(MAX_CLUSTER_NUM) * 2);
139  std::vector<float> pcLocalCovariance(static_cast<unsigned long>(MAX_CLUSTER_NUM) * 2);
140  std::vector<unsigned int> pcIdHash(static_cast<unsigned long>(MAX_CLUSTER_NUM));
141  std::vector<long unsigned int> pcId(static_cast<unsigned long>(MAX_CLUSTER_NUM));
142  std::vector<float> pcGlobalPosition(static_cast<unsigned long>(MAX_CLUSTER_NUM) * 3);
143  std::vector<unsigned long long> pcRdoList(static_cast<unsigned long>(MAX_CLUSTER_NUM) * 5000);
144  std::vector<int> pcChannelsInPhi(static_cast<unsigned long>(MAX_CLUSTER_NUM));
145  std::vector<int> pcChannelsInEta(static_cast<unsigned long>(MAX_CLUSTER_NUM));
146  std::vector<float> pcWidthInEta(static_cast<unsigned long>(MAX_CLUSTER_NUM));
147  std::vector<float> pcOmegaX(static_cast<unsigned long>(MAX_CLUSTER_NUM));
148  std::vector<float> pcOmegaY(static_cast<unsigned long>(MAX_CLUSTER_NUM));
149  std::vector<int> pcTotList(static_cast<unsigned long>(MAX_CLUSTER_NUM) * 5000);
150  std::vector<int> pcTotalToT(static_cast<unsigned long>(MAX_CLUSTER_NUM));
151  std::vector<float> pcChargeList(static_cast<unsigned long>(MAX_CLUSTER_NUM) * 5000);
152  std::vector<float> pcTotalCharge(static_cast<unsigned long>(MAX_CLUSTER_NUM));
153  std::vector<float> pcEnergyLoss(static_cast<unsigned long>(MAX_CLUSTER_NUM));
154  std::vector<char> pcIsSplit(static_cast<unsigned long>(MAX_CLUSTER_NUM));
155  std::vector<float> pcSplitProbability1(static_cast<unsigned long>(MAX_CLUSTER_NUM));
156  std::vector<float> pcSplitProbability2(static_cast<unsigned long>(MAX_CLUSTER_NUM));
157  std::vector<int> pcLvl1a(static_cast<unsigned long>(MAX_CLUSTER_NUM));
158 
159  EFTrackingDataFormats::PixelClusterOutput ef_pcOutput;
160 
161  ef_pcOutput.pcLocalPosition = pcLocalPosition.data();
162  ef_pcOutput.pcLocalCovariance = pcLocalCovariance.data();
163  ef_pcOutput.pcIdHash = pcIdHash.data();
164  ef_pcOutput.pcId = pcId.data();
165  ef_pcOutput.pcGlobalPosition = pcGlobalPosition.data();
166  ef_pcOutput.pcRdoList = pcRdoList.data();
167  ef_pcOutput.pcChannelsInPhi = pcChannelsInPhi.data();
168  ef_pcOutput.pcChannelsInEta = pcChannelsInEta.data();
169  ef_pcOutput.pcWidthInEta = pcWidthInEta.data();
170  ef_pcOutput.pcOmegaX = pcOmegaX.data();
171  ef_pcOutput.pcOmegaY = pcOmegaY.data();
172  ef_pcOutput.pcTotList = pcTotList.data();
173  ef_pcOutput.pcTotalToT = pcTotalToT.data();
174  ef_pcOutput.pcChargeList = pcChargeList.data();
175  ef_pcOutput.pcTotalCharge = pcTotalCharge.data();
176  ef_pcOutput.pcEnergyLoss = pcEnergyLoss.data();
177  ef_pcOutput.pcIsSplit = pcIsSplit.data();
178  ef_pcOutput.pcSplitProbability1 = pcSplitProbability1.data();
179  ef_pcOutput.pcSplitProbability2 = pcSplitProbability2.data();
180  ef_pcOutput.pcLvl1a = pcLvl1a.data();
181 
182  // Before the spacepoint link problem is solved
183  // we will stick with cluster-only version
184  if(m_clusterOnlyPassThrouth){
185  ATH_CHECK(passThroughSW_clusterOnly(ef_stripClusters, ef_scOutput, ef_pixelClusters, ef_pcOutput, metadata));
186  }
187  else{
188  ATH_MSG_ERROR("Full pass-through kernel is not implemented yet");
189  return StatusCode::FAILURE;
190  }
191 
192  // resize the vector to be the length of the cluster
193  scLocalPosition.resize(metadata->numOfStripClusters);
194  scLocalCovariance.resize(metadata->numOfStripClusters);
195  scIdHash.resize(metadata->numOfStripClusters);
196  scId.resize(metadata->numOfStripClusters);
197  scGlobalPosition.resize(metadata->numOfStripClusters * 3);
198  scRdoList.resize(metadata->scRdoIndexSize);
199  scChannelsInPhi.resize(metadata->numOfStripClusters);
200 
201  pcLocalPosition.resize(metadata->numOfPixelClusters * 2);
202  pcLocalCovariance.resize(metadata->numOfPixelClusters * 2);
203  pcIdHash.resize(metadata->numOfPixelClusters);
204  pcId.resize(metadata->numOfPixelClusters);
205  pcGlobalPosition.resize(metadata->numOfPixelClusters * 3);
206  pcRdoList.resize(metadata->pcRdoIndexSize);
207  pcChannelsInPhi.resize(metadata->numOfPixelClusters);
208  pcChannelsInEta.resize(metadata->numOfPixelClusters);
209  pcWidthInEta.resize(metadata->numOfPixelClusters);
210  pcOmegaX.resize(metadata->numOfPixelClusters);
211  pcOmegaY.resize(metadata->numOfPixelClusters);
212  pcTotList.resize(metadata->pcTotIndexSize);
213  pcTotalToT.resize(metadata->numOfPixelClusters);
214  pcChargeList.resize(metadata->pcChargeIndexSize);
215  pcTotalCharge.resize(metadata->numOfPixelClusters);
216  pcEnergyLoss.resize(metadata->numOfPixelClusters);
217  pcIsSplit.resize(metadata->numOfPixelClusters);
218  pcSplitProbability1.resize(metadata->numOfPixelClusters);
219  pcSplitProbability2.resize(metadata->numOfPixelClusters);
220  pcLvl1a.resize(metadata->numOfPixelClusters);
221 
222  if (msgLvl(MSG::DEBUG))
223  {
224  // print 3 strip clusters
225  for (unsigned i = 0; i < 3; i++)
226  {
227  ATH_MSG_DEBUG("scLocalPosition["
228  << i << "] = " << ef_scOutput.scLocalPosition[i]);
229  ATH_MSG_DEBUG("scLocalCovariance["
230  << i << "] = " << ef_scOutput.scLocalCovariance[i]);
231  ATH_MSG_DEBUG("scIdHash[" << i << "] = " << ef_scOutput.scIdHash[i]);
232  ATH_MSG_DEBUG("scId[" << i << "] = " << ef_scOutput.scId[i]);
233  ATH_MSG_DEBUG("scGlobalPosition["
234  << i << "] = " << ef_scOutput.scGlobalPosition[i * 3] << ", "
235  << ef_scOutput.scGlobalPosition[i * 3 + 1] << ", "
236  << ef_scOutput.scGlobalPosition[i * 3 + 2]);
237  ATH_MSG_DEBUG("scRdoList[" << i << "] = " << ef_scOutput.scRdoList[i]);
238  ATH_MSG_DEBUG("scChannelsInPhi["
239  << i << "] = " << ef_scOutput.scChannelsInPhi[i]);
240  }
241  // print 3 pixel clusters
242  for (unsigned i = 0; i < 3; i++)
243  {
244  ATH_MSG_DEBUG("pcLocalPosition["
245  << i << "] = " << ef_pcOutput.pcLocalPosition[i * 2] << ", "
246  << ef_pcOutput.pcLocalPosition[i * 2 + 1]);
247  ATH_MSG_DEBUG("pcLocalCovariance["
248  << i << "] = " << ef_pcOutput.pcLocalCovariance[i * 2] << ", "
249  << ef_pcOutput.pcLocalCovariance[i * 2 + 1]);
250  ATH_MSG_DEBUG("pcIdHash[" << i << "] = " << ef_pcOutput.pcIdHash[i]);
251  ATH_MSG_DEBUG("pcId[" << i << "] = " << ef_pcOutput.pcId[i]);
252  ATH_MSG_DEBUG("pcGlobalPosition["
253  << i << "] = " << ef_pcOutput.pcGlobalPosition[i * 3] << ", "
254  << ef_pcOutput.pcGlobalPosition[i * 3 + 1] << ", "
255  << ef_pcOutput.pcGlobalPosition[i * 3 + 2]);
256  ATH_MSG_DEBUG("pcRdoList[" << i << "] = " << ef_pcOutput.pcRdoList[i]);
257  ATH_MSG_DEBUG("pcChannelsInPhi["
258  << i << "] = " << ef_pcOutput.pcChannelsInPhi[i]);
259  ATH_MSG_DEBUG("pcChannelsInEta["
260  << i << "] = " << ef_pcOutput.pcChannelsInEta[i]);
261  ATH_MSG_DEBUG("pcWidthInEta["
262  << i << "] = " << ef_pcOutput.pcWidthInEta[i]);
263  ATH_MSG_DEBUG("pcOmegaX[" << i << "] = " << ef_pcOutput.pcOmegaX[i]);
264  ATH_MSG_DEBUG("pcOmegaY[" << i << "] = " << ef_pcOutput.pcOmegaY[i]);
265  ATH_MSG_DEBUG("pcTotList[" << i << "] = " << ef_pcOutput.pcTotList[i]);
266  ATH_MSG_DEBUG("pcTotalToT["
267  << i << "] = " << ef_pcOutput.pcTotalToT[i]);
268  ATH_MSG_DEBUG("pcChargeList["
269  << i << "] = " << ef_pcOutput.pcChargeList[i]);
270  ATH_MSG_DEBUG("pcTotalCharge["
271  << i << "] = " << ef_pcOutput.pcTotalCharge[i]);
272  ATH_MSG_DEBUG("pcEnergyLoss["
273  << i << "] = " << ef_pcOutput.pcEnergyLoss[i]);
274  ATH_MSG_DEBUG("pcIsSplit[" << i << "] = " << ef_pcOutput.pcIsSplit[i]);
275  ATH_MSG_DEBUG("pcSplitProbability1["
276  << i << "] = " << ef_pcOutput.pcSplitProbability1[i]);
277  ATH_MSG_DEBUG("pcSplitProbability2["
278  << i << "] = " << ef_pcOutput.pcSplitProbability2[i]);
279  ATH_MSG_DEBUG("pcLvl1a[" << i << "] = " << ef_pcOutput.pcLvl1a[i]);
280  }
281  }
282 
283  // Group data to make the strip cluster container
284  scAux.localPosition = scLocalPosition;
285  scAux.localCovariance = scLocalCovariance;
286  scAux.idHash = scIdHash;
287  scAux.id = scId;
288  scAux.globalPosition = scGlobalPosition;
289  scAux.rdoList = scRdoList;
290  scAux.channelsInPhi = scChannelsInPhi;
291 
292  // Group data to make the pixel cluster container
293  pxAux.id = pcId;
294  pxAux.idHash = pcIdHash;
295  pxAux.localPosition = pcLocalPosition;
296  pxAux.localCovariance = pcLocalCovariance;
297  pxAux.globalPosition = pcGlobalPosition;
298  pxAux.rdoList = pcRdoList;
299  pxAux.channelsInPhi = pcChannelsInPhi;
300  pxAux.channelsInEta = pcChannelsInEta;
301  pxAux.widthInEta = pcWidthInEta;
302  pxAux.omegaX = pcOmegaX;
303  pxAux.omegaY = pcOmegaY;
304  pxAux.totList = pcTotList;
305  pxAux.totalToT = pcTotalToT;
306  pxAux.chargeList = pcChargeList;
307  pxAux.totalCharge = pcTotalCharge;
308  pxAux.energyLoss = pcEnergyLoss;
309  pxAux.isSplit = pcIsSplit;
310  pxAux.splitProbability1 = pcSplitProbability1;
311  pxAux.splitProbability2 = pcSplitProbability2;
312  pxAux.lvl1a = pcLvl1a;
313  }
314  else
315  {
316  ATH_MSG_INFO("FPGA mode is not implemented yet");
317  return StatusCode::SUCCESS;
318  }
319 
320  return StatusCode::SUCCESS;
321 }

◆ 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 116 of file PassThroughTool.h.

116 { return m_runSW; }

Member Data Documentation

◆ m_clusterOnlyPassThrouth

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

Use the cluster-only pass through tool.

Definition at line 121 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 120 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 127 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 119 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 124 of file PassThroughTool.h.

The documentation for this class was generated from the following files:
EFTrackingDataFormats::PixelClusterOutput::pcTotList
int * pcTotList
Definition: EFTrackingDataFormats.h:149
EFTrackingDataFormats::PixelClusterAuxInput::localCovariance
std::vector< float > localCovariance
Definition: EFTrackingDataFormats.h:204
EFTrackingDataFormats::SpacePointOutput::spRadius
float * spRadius
Definition: EFTrackingDataFormats.h:170
EFTrackingDataFormats::StripClusterOutput::scLocalCovariance
float * scLocalCovariance
Definition: EFTrackingDataFormats.h:124
EFTrackingDataFormats::StripClusterAuxInput::localPosition
std::vector< float > localPosition
Definition: EFTrackingDataFormats.h:187
MAX_CLUSTER_NUM
#define MAX_CLUSTER_NUM
Definition: PassThroughTool.cxx:9
EFTrackingDataFormats::StripClusterAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingDataFormats.h:191
EFTrackingDataFormats::PixelCluster::totalToT
int totalToT
Definition: EFTrackingDataFormats.h:61
PassThroughTool::m_runSW
Gaudi::Property< bool > m_runSW
Software mode, not running on the FPGA.
Definition: PassThroughTool.h:119
EFTrackingDataFormats::PixelCluster::widthInEta
float widthInEta
Definition: EFTrackingDataFormats.h:57
EFTrackingDataFormats::StripCluster::id
long unsigned int id
Definition: EFTrackingDataFormats.h:35
EFTrackingDataFormats::PixelCluster::splitProbability1
float splitProbability1
Definition: EFTrackingDataFormats.h:66
EFTrackingDataFormats::PixelClusterOutput::pcChannelsInEta
int * pcChannelsInEta
Definition: EFTrackingDataFormats.h:145
EFTrackingDataFormats::PixelClusterOutput::pcLvl1a
int * pcLvl1a
Definition: EFTrackingDataFormats.h:157
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
EFTrackingDataFormats::PixelClusterOutput::pcOmegaX
float * pcOmegaX
Definition: EFTrackingDataFormats.h:147
EFTrackingDataFormats::SpacePoint::topStripCenter
float topStripCenter[3]
Definition: EFTrackingDataFormats.h:94
EFTrackingDataFormats::SpacePointOutput::spVarianceZ
float * spVarianceZ
Definition: EFTrackingDataFormats.h:172
EFTrackingDataFormats::PixelCluster::channelsInPhi
int channelsInPhi
Definition: EFTrackingDataFormats.h:55
EFTrackingDataFormats::SpacePoint::stripCenterDistance
float stripCenterDistance[3]
Definition: EFTrackingDataFormats.h:93
EFTrackingDataFormats::PixelCluster::lvl1a
int lvl1a
Definition: EFTrackingDataFormats.h:68
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
EFTrackingDataFormats::PixelCluster::totalCharge
float totalCharge
Definition: EFTrackingDataFormats.h:63
EFTrackingDataFormats::PixelClusterAuxInput::energyLoss
std::vector< float > energyLoss
Definition: EFTrackingDataFormats.h:216
EFTrackingDataFormats::PixelClusterOutput::pcTotalToT
int * pcTotalToT
Definition: EFTrackingDataFormats.h:150
EFTrackingDataFormats::PixelClusterOutput::pcChargeList
float * pcChargeList
Definition: EFTrackingDataFormats.h:151
EFTrackingDataFormats::PixelCluster::isSplit
char isSplit
Definition: EFTrackingDataFormats.h:65
EFTrackingDataFormats::PixelCluster::omegaX
float omegaX
Definition: EFTrackingDataFormats.h:58
EFTrackingDataFormats::SpacePointOutput::spBottomHalfStripLength
float * spBottomHalfStripLength
Definition: EFTrackingDataFormats.h:175
EFTrackingDataFormats::PixelClusterAuxInput::localPosition
std::vector< float > localPosition
Definition: EFTrackingDataFormats.h:203
EFTrackingDataFormats::PixelCluster::rdoList
unsigned long long rdoList[1000]
Definition: EFTrackingDataFormats.h:54
EFTrackingDataFormats::StripCluster
The StripClusters struct contains all xAOD::StripCluster data members.
Definition: EFTrackingDataFormats.h:31
EFTrackingDataFormats::StripCluster::localPosition
float localPosition
Definition: EFTrackingDataFormats.h:32
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
PassThroughTool::m_stripClustersKey
SG::ReadHandleKey< xAOD::StripClusterContainer > m_stripClustersKey
Definition: PassThroughTool.h:124
EFTrackingDataFormats::PixelClusterAuxInput::idHash
std::vector< unsigned int > idHash
Definition: EFTrackingDataFormats.h:202
EFTrackingDataFormats::PixelClusterAuxInput::totalCharge
std::vector< float > totalCharge
Definition: EFTrackingDataFormats.h:215
EFTrackingDataFormats::PixelCluster::splitProbability2
float splitProbability2
Definition: EFTrackingDataFormats.h:67
EFTrackingDataFormats::SpacePoint::cov_r
float cov_r
Definition: EFTrackingDataFormats.h:85
EFTrackingDataFormats::PixelCluster::localCovariance
float localCovariance[2]
Definition: EFTrackingDataFormats.h:52
PassThroughTool::passThroughSW_clusterOnly
StatusCode passThroughSW_clusterOnly(const std::vector< EFTrackingDataFormats::StripCluster > &inputSC, EFTrackingDataFormats::StripClusterOutput &ef_scOutput, const std::vector< EFTrackingDataFormats::PixelCluster > &inputPC, EFTrackingDataFormats::PixelClusterOutput &ef_pcOutput, EFTrackingDataFormats::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:669
EFTrackingDataFormats::SpacePoint::cov_z
float cov_z
Definition: EFTrackingDataFormats.h:86
EFTrackingDataFormats::PixelCluster::sizeOfChargeList
int sizeOfChargeList
Definition: EFTrackingDataFormats.h:71
EFTrackingDataFormats::StripCluster::rdoList
unsigned long long rdoList[1000]
Definition: EFTrackingDataFormats.h:37
EFTrackingDataFormats::PixelClusterAuxInput::splitProbability2
std::vector< float > splitProbability2
Definition: EFTrackingDataFormats.h:219
EFTrackingDataFormats::StripClusterAuxInput::localCovariance
std::vector< float > localCovariance
Definition: EFTrackingDataFormats.h:188
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
EFTrackingDataFormats::StripCluster::idHash
unsigned int idHash
Definition: EFTrackingDataFormats.h:34
PassThroughTool::getInputClusterData
StatusCode getInputClusterData(const xAOD::StripClusterContainer *sc, std::vector< EFTrackingDataFormats::StripCluster > &ef_sc, unsigned long N) const
Convert the strip cluster from xAOD container to simple std::vector of EFTrackingDataFormats::StripCl...
Definition: PassThroughTool.cxx:323
EFTrackingDataFormats::PixelClusterOutput::pcEnergyLoss
float * pcEnergyLoss
Definition: EFTrackingDataFormats.h:153
EFTrackingDataFormats::PixelClusterOutput::pcRdoList
unsigned long long * pcRdoList
Definition: EFTrackingDataFormats.h:143
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
EFTrackingDataFormats::PixelClusterAuxInput::channelsInPhi
std::vector< int > channelsInPhi
Definition: EFTrackingDataFormats.h:207
EFTrackingDataFormats::StripCluster::localCovariance
float localCovariance
Definition: EFTrackingDataFormats.h:33
EFTrackingDataFormats::PixelCluster::chargeList
float chargeList[1000]
Definition: EFTrackingDataFormats.h:62
EFTrackingDataFormats::PixelClusterAuxInput::isSplit
std::vector< char > isSplit
Definition: EFTrackingDataFormats.h:217
EFTrackingDataFormats::PixelCluster::idHash
unsigned int idHash
Definition: EFTrackingDataFormats.h:50
EFTrackingDataFormats::StripClusterAuxInput::id
std::vector< long unsigned int > id
Definition: EFTrackingDataFormats.h:190
EFTrackingDataFormats::PixelCluster::localPosition
float localPosition[2]
Definition: EFTrackingDataFormats.h:51
EFTrackingDataFormats::PixelCluster::channelsInEta
int channelsInEta
Definition: EFTrackingDataFormats.h:56
EFTrackingDataFormats::PixelCluster::omegaY
float omegaY
Definition: EFTrackingDataFormats.h:59
EFTrackingDataFormats::PixelClusterAuxInput::globalPosition
std::vector< float > globalPosition
Definition: EFTrackingDataFormats.h:205
EFTrackingDataFormats::PixelClusterAuxInput::rdoList
std::vector< unsigned long long > rdoList
Definition: EFTrackingDataFormats.h:206
EFTrackingDataFormats::StripClusterOutput::scRdoList
unsigned long long * scRdoList
Definition: EFTrackingDataFormats.h:128
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
EFTrackingDataFormats::SpacePointOutput::spTopStripDirection
float * spTopStripDirection
Definition: EFTrackingDataFormats.h:176
EFTrackingDataFormats::PixelClusterAuxInput::omegaY
std::vector< float > omegaY
Definition: EFTrackingDataFormats.h:211
EFTrackingDataFormats::PixelClusterAuxInput::omegaX
std::vector< float > omegaX
Definition: EFTrackingDataFormats.h:210
lumiFormat.i
int i
Definition: lumiFormat.py:85
EFTrackingDataFormats::SpacePointOutput::spTopStripCenter
float * spTopStripCenter
Definition: EFTrackingDataFormats.h:179
EFTrackingDataFormats::PixelClusterOutput::pcSplitProbability2
float * pcSplitProbability2
Definition: EFTrackingDataFormats.h:156
EFTrackingDataFormats::PixelCluster
The PixelClusters struct contains all xAOD::PixelCluster data members.
Definition: EFTrackingDataFormats.h:48
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
EFTrackingDataFormats::PixelClusterOutput
The PixelClusters struct contains the output arrays from the FPGA.
Definition: EFTrackingDataFormats.h:136
EFTrackingDataFormats::SpacePointOutput::spBottomStripDirection
float * spBottomStripDirection
Definition: EFTrackingDataFormats.h:177
EFTrackingDataFormats::SpacePoint::globalPosition
float globalPosition[3]
Definition: EFTrackingDataFormats.h:83
EFTrackingDataFormats::SpacePointOutput::spGlobalPosition
float * spGlobalPosition
Definition: EFTrackingDataFormats.h:169
EFTrackingDataFormats::PixelCluster::sizeOfTotList
int sizeOfTotList
Definition: EFTrackingDataFormats.h:70
EFTrackingDataFormats::StripClusterOutput::scGlobalPosition
float * scGlobalPosition
Definition: EFTrackingDataFormats.h:127
EFTrackingDataFormats::SpacePointOutput::spIdHash
unsigned int * spIdHash
Definition: EFTrackingDataFormats.h:168
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
EFTrackingDataFormats::PixelCluster::globalPosition
float globalPosition[3]
Definition: EFTrackingDataFormats.h:53
EFTrackingDataFormats::StripClusterOutput
The StripClusters struct contains the output arrays from the FPGA.
Definition: EFTrackingDataFormats.h:121
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
EFTrackingDataFormats::PixelClusterAuxInput::channelsInEta
std::vector< int > channelsInEta
Definition: EFTrackingDataFormats.h:208
EFTrackingDataFormats::PixelClusterOutput::pcLocalPosition
float * pcLocalPosition
Definition: EFTrackingDataFormats.h:138
EFTrackingDataFormats::SpacePoint::bottomStripDirection
float bottomStripDirection[3]
Definition: EFTrackingDataFormats.h:92
PassThroughTool::m_clusterOnlyPassThrouth
Gaudi::Property< bool > m_clusterOnlyPassThrouth
Use the cluster-only pass through tool.
Definition: PassThroughTool.h:121
EFTrackingDataFormats::PixelClusterOutput::pcId
long unsigned int * pcId
Definition: EFTrackingDataFormats.h:141
EFTrackingDataFormats::StripClusterAuxInput::rdoList
std::vector< unsigned long long > rdoList
Definition: EFTrackingDataFormats.h:192
EFTrackingDataFormats::SpacePoint::radius
float radius
Definition: EFTrackingDataFormats.h:84
EFTrackingDataFormats::PixelClusterAuxInput::totList
std::vector< int > totList
Definition: EFTrackingDataFormats.h:212
EFTrackingDataFormats::SpacePoint::bottomHalfStripLength
float bottomHalfStripLength
Definition: EFTrackingDataFormats.h:90
EFTrackingDataFormats::SpacePointOutput::spTopHalfStripLength
float * spTopHalfStripLength
Definition: EFTrackingDataFormats.h:174
dumpTgcDigiThreshold.isStrip
list isStrip
Definition: dumpTgcDigiThreshold.py:33
EFTrackingDataFormats::PixelClusterOutput::pcSplitProbability1
float * pcSplitProbability1
Definition: EFTrackingDataFormats.h:155
EFTrackingDataFormats::StripClusterOutput::scId
long unsigned int * scId
Definition: EFTrackingDataFormats.h:126
EFTrackingDataFormats::PixelClusterAuxInput::id
std::vector< long unsigned int > id
Definition: EFTrackingDataFormats.h:201
EFTrackingDataFormats::PixelClusterOutput::pcLocalCovariance
float * pcLocalCovariance
Definition: EFTrackingDataFormats.h:139
EFTrackingDataFormats::PixelCluster::sizeOfRDOList
int sizeOfRDOList
Definition: EFTrackingDataFormats.h:69
EFTrackingDataFormats::SpacePointOutput::spVarianceR
float * spVarianceR
Definition: EFTrackingDataFormats.h:171
EFTrackingDataFormats::PixelClusterOutput::pcWidthInEta
float * pcWidthInEta
Definition: EFTrackingDataFormats.h:146
EFTrackingDataFormats::PixelClusterAuxInput::lvl1a
std::vector< int > lvl1a
Definition: EFTrackingDataFormats.h:220
EFTrackingDataFormats::StripClusterOutput::scIdHash
unsigned int * scIdHash
Definition: EFTrackingDataFormats.h:125
EFTrackingDataFormats::PixelClusterOutput::pcOmegaY
float * pcOmegaY
Definition: EFTrackingDataFormats.h:148
EFTrackingDataFormats::PixelClusterOutput::pcTotalCharge
float * pcTotalCharge
Definition: EFTrackingDataFormats.h:152
EFTrackingDataFormats::StripCluster::channelsInPhi
int channelsInPhi
Definition: EFTrackingDataFormats.h:38
EFTrackingDataFormats::PixelClusterOutput::pcIdHash
unsigned int * pcIdHash
Definition: EFTrackingDataFormats.h:140
EFTrackingDataFormats::SpacePointOutput::spStripCenterDistance
float * spStripCenterDistance
Definition: EFTrackingDataFormats.h:178
EFTrackingDataFormats::StripClusterAuxInput::channelsInPhi
std::vector< int > channelsInPhi
Definition: EFTrackingDataFormats.h:193
DEBUG
#define DEBUG
Definition: page_access.h:11
EFTrackingDataFormats::PixelClusterAuxInput::splitProbability1
std::vector< float > splitProbability1
Definition: EFTrackingDataFormats.h:218
PassThroughTool::m_pixelClustersKey
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_pixelClustersKey
Definition: PassThroughTool.h:127
EFTrackingDataFormats::PixelClusterOutput::pcChannelsInPhi
int * pcChannelsInPhi
Definition: EFTrackingDataFormats.h:144
EFTrackingDataFormats::SpacePoint::idHash
unsigned int idHash[2]
Definition: EFTrackingDataFormats.h:82
EFTrackingDataFormats::PixelCluster::energyLoss
float energyLoss
Definition: EFTrackingDataFormats.h:64
EFTrackingDataFormats::PixelClusterAuxInput::chargeList
std::vector< float > chargeList
Definition: EFTrackingDataFormats.h:214
EFTrackingDataFormats::SpacePoint::topStripDirection
float topStripDirection[3]
Definition: EFTrackingDataFormats.h:91
EFTrackingDataFormats::PixelClusterAuxInput::widthInEta
std::vector< float > widthInEta
Definition: EFTrackingDataFormats.h:209
EFTrackingDataFormats::StripCluster::sizeOfRDOList
int sizeOfRDOList
Definition: EFTrackingDataFormats.h:39
EFTrackingDataFormats::PixelClusterOutput::pcGlobalPosition
float * pcGlobalPosition
Definition: EFTrackingDataFormats.h:142
calibdata.copy
bool copy
Definition: calibdata.py:27
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
EFTrackingDataFormats::SpacePoint
The SpacePoint struct contains all xAOD::SpacePoint data members.
Definition: EFTrackingDataFormats.h:80
EFTrackingDataFormats::StripCluster::globalPosition
float globalPosition[3]
Definition: EFTrackingDataFormats.h:36
EFTrackingDataFormats::PixelCluster::totList
int totList[1000]
Definition: EFTrackingDataFormats.h:60
EFTrackingDataFormats::PixelClusterAuxInput::totalToT
std::vector< int > totalToT
Definition: EFTrackingDataFormats.h:213
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
EFTrackingDataFormats::PixelClusterOutput::pcIsSplit
char * pcIsSplit
Definition: EFTrackingDataFormats.h:154
EFTrackingDataFormats::StripClusterOutput::scChannelsInPhi
int * scChannelsInPhi
Definition: EFTrackingDataFormats.h:129
EFTrackingDataFormats::PixelCluster::id
long unsigned int id
Definition: EFTrackingDataFormats.h:49
python.SystemOfUnits.pc
float pc
Definition: SystemOfUnits.py:99
EFTrackingDataFormats::StripClusterAuxInput::idHash
std::vector< unsigned int > idHash
Definition: EFTrackingDataFormats.h:189
EFTrackingDataFormats::StripClusterOutput::scLocalPosition
float * scLocalPosition
Definition: EFTrackingDataFormats.h:123
EFTrackingDataFormats::SpacePoint::topHalfStripLength
float topHalfStripLength
Definition: EFTrackingDataFormats.h:89
Generated on Mon Dec 23 2024 21:42:38 for ATLAS Offline Software by   doxygen 1.8.18