DataPreparationPipeline.h

Go to the documentation of this file.

/*
    Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EFTRACKING_FPGA_INTEGRATION_DATAPREPARATIONPIPELINE_H
#define EFTRACKING_FPGA_INTEGRATION_DATAPREPARATIONPIPELINE_H
 
// EFTracking include
#include "EFTrackingDataFormats.h"
#include "IntegrationBase.h"
#include "xAODContainerMaker.h"
 
// Athena include
#include "StoreGate/ReadHandleKey.h"
#include "xAODInDetMeasurement/PixelClusterContainer.h"
#include "xAODInDetMeasurement/SpacePointContainer.h"
#include "xAODInDetMeasurement/StripClusterContainer.h"
 
class DataPreparationPipeline : public IntegrationBase {
 public:
  using IntegrationBase::IntegrationBase;
  StatusCode initialize() override final;
  StatusCode execute(const EventContext &ctx) const override final;
 
  StatusCode getInputClusterData(
      const xAOD::StripClusterContainer *sc,
      std::vector<EFTrackingDataFormats::StripCluster> &ef_sc,
      long unsigned int N) const;
 
  StatusCode getInputClusterData(
      const xAOD::PixelClusterContainer *pc,
      std::vector<EFTrackingDataFormats::PixelCluster> &ef_pc,
      long unsigned int N) const;
 
  StatusCode getInputSpacePointData(
      const xAOD::SpacePointContainer *sp,
      std::vector<EFTrackingDataFormats::SpacePoint> &ef_sp,
      std::vector<std::vector<const xAOD::UncalibratedMeasurement *>> &sp_meas,
      long unsigned int N, bool isStrip) const;
 
  StatusCode runSW(
      const std::vector<EFTrackingDataFormats::StripCluster> &ef_sc,
      const std::vector<EFTrackingDataFormats::PixelCluster> &ef_pc,
      const std::vector<EFTrackingDataFormats::SpacePoint> &ef_ssp,
      const std::vector<std::vector<const xAOD::UncalibratedMeasurement *>>
          &ssp_mes,
      const std::vector<EFTrackingDataFormats::SpacePoint> &ef_psp,
      const std::vector<std::vector<const xAOD::UncalibratedMeasurement *>>
          &psp_mes,
      const EventContext &ctx) const;
 
  StatusCode runHW(
      const std::vector<EFTrackingDataFormats::StripCluster> &ef_sc,
      const std::vector<EFTrackingDataFormats::PixelCluster> &ef_pc,
      const std::vector<EFTrackingDataFormats::SpacePoint> &ef_ssp,
      const std::vector<std::vector<const xAOD::UncalibratedMeasurement *>>
          &ssp_mes,
      const std::vector<EFTrackingDataFormats::SpacePoint> &ef_psp,
      const std::vector<std::vector<const xAOD::UncalibratedMeasurement *>>
          &psp_mes) const;
 
  StatusCode transferSW(
      const std::vector<EFTrackingDataFormats::StripCluster> &inputSC,
      EFTrackingDataFormats::StripClusterOutput &outputSC,
      // PixelCluster
      const std::vector<EFTrackingDataFormats::PixelCluster> &inputPC,
      EFTrackingDataFormats::PixelClusterOutput &outputPC,
      // Strip SpacePoint
      const std::vector<EFTrackingDataFormats::SpacePoint> &inputSSP,
      EFTrackingDataFormats::SpacePointOutput &outputSSP,
      // Pixel SpacePoint
      const std::vector<EFTrackingDataFormats::SpacePoint> &inputPSP,
      EFTrackingDataFormats::SpacePointOutput &outputPSP,
      // Metadata
      EFTrackingDataFormats::Metadata *metadata)
      const;  // mimic the tranfser kernel
 
 private:
  // At this stage of development we need
  // xAOD::Strip/PixelCluster/SpacePointContainer as our input
  SG::ReadHandleKey<xAOD::StripClusterContainer> m_stripClustersKey{
      this, "StripClusterContainerKey", "FPGAITkStripClusters",
      "Key for Strip Cluster Containers"};
  SG::ReadHandleKey<xAOD::PixelClusterContainer> m_pixelClustersKey{
      this, "PixelClusterContainerKey", "FPGAITkPixelClusters",
      "Key for Pixel Cluster Containers"};
  SG::ReadHandleKey<xAOD::SpacePointContainer> m_stripSpacePointsKey{
      this, "StripSpacePointContainerKey", "FPGAITkStripSpacePoints",
      "Key for Strip SpacePoint Containers"};
  SG::ReadHandleKey<xAOD::SpacePointContainer> m_pixelSpacePointsKey{
      this, "PixelSpacePointContainerKey", "FPGAITkPixelSpacePoints",
      "Key for Pixel SpacePoint Containers"};
  Gaudi::Property<std::string> m_xclbin{
      this, "xclbin", "",
      "xclbin path and name"};  
  Gaudi::Property<std::string> m_kernelName{this, "KernelName", "",
                                            "Kernel name"};  
  Gaudi::Property<bool> m_runSW{
      this, "RunSW", true,
      "Run software mode"};  
 
  // Conver kernel outputs into xAOD containers
  ToolHandle<xAODContainerMaker> m_xAODContainerMaker{
      this, "xAODMaker", "xAODContainerMaker",
      "tool to make cluster"};  
};
 
#endif  // EFTRACKING_FPGA_INTEGRATION_DATAPREPARATIONPIPELINE_H