PixelDigitizationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef PIXELDIGITIZATION_PIXELDIGITIZATIONTOOL_H
#define PIXELDIGITIZATION_PIXELDIGITIZATIONTOOL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "PileUpTools/PileUpToolBase.h"
#include "AthenaKernel/IAthRNGSvc.h" //SvcHandle template parameter
#include "HitManagement/TimedHitCollection.h" //template
#include "InDetSimEvent/SiHitCollection.h" //ReadHandleKey template parameter
 
#include "InDetRawData/InDetRawDataCLASS_DEF.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
 
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/WriteHandle.h"
#include "StoreGate/WriteHandleKey.h"
#include "PileUpTools/PileUpMergeSvc.h" //SvcHandle template parameter
 
#include "InDetSimData/InDetSimDataCollection.h"  //WriteHandleKey template parameter
#include "SensorSimTool.h" //ToolHandleArray template parameter
#include "FrontEndSimTool.h"  //ToolHandleArray template parameter
#include "EnergyDepositionTool.h"  //ToolHandle template parameter
 
#include "InDetReadoutGeometry/SiDetectorElementCollection.h" //ReadCondHandle Template parameter
 
 
class PixelDigitizationTool: public PileUpToolBase {
protected:
   struct EventData;
public:
  PixelDigitizationTool(const std::string& type, const std::string& name, const IInterface* pIID);
 
  virtual StatusCode initialize() override;
  virtual StatusCode processAllSubEvents(const EventContext& ctx) override {
     return processAllSubEventsConst(ctx);
  }
  StatusCode processAllSubEventsConst(const EventContext& ctx) const;
  virtual StatusCode finalize() override;
 
  virtual StatusCode prepareEvent(const EventContext& ctx, unsigned int) override {
     if (!m_eventData) { m_eventData = std::make_unique<EventData>(); }
     return prepareEvent(ctx, *m_eventData);
  }
  virtual StatusCode mergeEvent(const EventContext& ctx) override;
  virtual StatusCode processBunchXing(int bunchXing, SubEventIterator bSubEvents,
                                      SubEventIterator eSubEvents) override final;
protected:
  StatusCode digitizeEvent(const EventContext& ctx, EventData &event_data) const;
  StatusCode prepareEvent(const EventContext& ctx, EventData &event_data) const;
  void addSDO(SiChargedDiodeCollection* collection, EventData &event_data) const;
private:
  PixelDigitizationTool();
  PixelDigitizationTool(const PixelDigitizationTool&);
  PixelDigitizationTool& operator = (const PixelDigitizationTool&);
 
  std::vector<SiHitCollection*> m_hitCollPtrs;
 
  Gaudi::Property<bool> m_onlyUseContainerName {
    this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."
  };
  SG::ReadHandleKey<SiHitCollection>         m_hitsContainerKey {
    this, "InputObjectName", "", "Input HITS collection name"
  };
  SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> m_pixelDetEleCollKey {
    this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"
  };
  std::string m_inputObjectName {
    ""
  };
  SG::WriteHandleKey<PixelRDO_Container>     m_rdoContainerKey {
    this, "RDOCollName", "PixelRDOs", "RDO collection name"
  };
  SG::WriteHandleKey<InDetSimDataCollection> m_simDataCollKey {
    this, "SDOCollName", "PixelSDO_Map", "SDO collection name"
  };
  Gaudi::Property<int>                       m_HardScatterSplittingMode {
    this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"
  };
 
protected:
  struct EventData {
     SG::WriteHandle<PixelRDO_Container>        m_rdoContainer {};
     SG::WriteHandle<InDetSimDataCollection>    m_simDataColl {};
     std::unique_ptr<TimedHitCollection<SiHit> > m_timedHits {};
     bool m_HardScatterSplittingSkipper {
        false
     };
  };
  // For old interface which stores the event data in class members
  EventData &getCurrentEventData() { assert(m_eventData); return *m_eventData; }
  std::unique_ptr<EventData> m_eventData;
private:
  Gaudi::Property<bool>                      m_onlyHitElements {
    this, "OnlyHitElements", false, "Process only elements with hits"
  };
 
  const PixelID* m_detID {};
  Gaudi::Property<std::string> m_pixelIDName
  {this, "PixelIDName", "PixelID", "Pixel ID name"};
 
 
  ToolHandleArray<SensorSimTool> m_chargeTool {
    this, "ChargeTools", {}, "List of charge tools"
  };
  ToolHandleArray<FrontEndSimTool> m_fesimTool {
    this, "FrontEndSimTools", {}, "List of Front-End simulation tools"
  };
  ToolHandle<EnergyDepositionTool> m_energyDepositionTool {
    this, "EnergyDepositionTool", "EnergyDepositionTool", "Energy deposition tool"
  };
protected:
  ServiceHandle<IAthRNGSvc> m_rndmSvc {
    this, "RndmSvc", "AthRNGSvc", ""
  };  
  ServiceHandle <PileUpMergeSvc> m_mergeSvc {
    this, "PileUpMergeSvc", "PileUpMergeSvc", ""
  };
 
  Gaudi::Property<bool> m_createNoiseSDO {
    this, "CreateNoiseSDO", false, "Set create noise SDO flag"
  };
 
};
 
#endif // PIXELDIGITIZATION_PIXELDIGITIZATIONTOOL_H