HGTD_DigitizationTool.h

Go to the documentation of this file.

 
#ifndef HGTD_DIGITZATION_HGTD_DIGITZATIONTOOL_H
#define HGTD_DIGITZATION_HGTD_DIGITZATIONTOOL_H
 
#include "PileUpTools/PileUpToolBase.h"
#include "PileUpTools/PileUpMergeSvc.h"
 
#include "AthenaKernel/IAthRNGSvc.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "IHGTD_SurfaceChargesGenerator.h"
#include "HGTD_ReadoutGeometry/HGTD_DetectorElementCollection.h"
#include "HGTD_RawData/HGTD_RDO_Collection.h"
#include "HGTD_RawData/HGTD_RDO_Container.h"
#include "HGTD_RawData/HGTD_ALTIROC_RDO_Collection.h"
#include "HGTD_RawData/HGTD_ALTIROC_RDO_Container.h"
#include "HitManagement/TimedHitCollection.h"
#include "InDetSimData/InDetSimDataCollection.h"
#include "InDetSimEvent/SiHitCollection.h"
#include "HGTD_Calibration/HGTD_TdcCalibrationTool.h"
 
#include <memory>
#include <string>
 
class HGTD_ID;
class SiChargedDiodeCollection;
class InDetSimDataCollection;
class IFrontEnd;
class ISiChargedDiodesProcessorTool;
 
namespace CLHEP {
class HepRandomEngine;
}
 
class HGTD_DigitizationTool : virtual public IPileUpTool,
                              public PileUpToolBase {
public:
  static const InterfaceID& interfaceID();
 
  HGTD_DigitizationTool(const std::string& type, const std::string& name,
                        const IInterface* parent);

  /*** Methods completing the IPileUpTool interfaces ***/
 
  virtual StatusCode initialize() override final;
 
  virtual StatusCode processAllSubEvents(const EventContext& ctx) override final;
 
  virtual StatusCode prepareEvent(const EventContext& ctx, unsigned int) override final;
 
  virtual StatusCode processBunchXing(int bunch_xing,
                                      SubEventIterator sub_event_itr,
                                      SubEventIterator sub_event_itr_end) override final;
 
  virtual StatusCode mergeEvent(const EventContext& ctx) override final;
 
private:

  StatusCode retrieveHitCollection(const EventContext& ctx);
 
  StatusCode digitizeHitsPerDetectorElement(const EventContext& ctx, CLHEP::HepRandomEngine* rndmEngine);

  // StatusCode simulateNoisePerDetectorElement();

  void applyProcessorTools(SiChargedDiodeCollection*, CLHEP::HepRandomEngine* rndmEngine) const;
 
  StatusCode createAndStoreRDO(SiChargedDiodeCollection*, const InDetDD::SolidStateDetectorElementBase*) ;
 
  // inserts the created SDO elements into the m_sdo_collection_map object.
  void createAndStoreSDO(SiChargedDiodeCollection* collection);

 
  FloatProperty m_charge_threshold{this, "ChargeThreshold", 625., "Minimum charge threshold in ASIC"};
 
  BooleanProperty 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", "HGTD_Hits", "Input HITS collection name"};
  std::string m_inputObjectName{""};
 
  SG::WriteHandle<HGTD_RDO_Container> m_hgtd_rdo_container; 
  SG::WriteHandleKey<HGTD_RDO_Container> m_output_rdo_cont_key{this, "OutputObjectName", "HGTD_RDOs", "Output Object name"};
  
  SG::WriteHandle<HGTD_ALTIROC_RDO_Container> m_hgtd_altiroc_rdo_container; 
  SG::WriteHandleKey<HGTD_ALTIROC_RDO_Container> m_output_altiroc_rdo_cont_key{this, "AltirocOutputObject", "", "Key of HGTD_ALTIROC_RDO container"};
 
  SG::WriteHandle<InDetSimDataCollection> m_sdo_collection_map; 
  SG::WriteHandleKey<InDetSimDataCollection> m_output_sdo_coll_key{this, "OutputSDOName", "HGTD_SDO_Map", "Output SDO container name"};
  SG::ReadCondHandleKey<InDetDD::HGTD_DetectorElementCollection> m_HGTDDetEleCollKey{this, "HGTDDetEleCollKey", "HGTD_DetectorElementCollection", "Key of HGTD_DetectorElementCollection for HGTD"};
 
  ServiceHandle<PileUpMergeSvc> m_merge_svc{this, "MergeSvc", "PileUpMergeSvc", "Merge service used in Pixel & HGTD digitization"}; 
  ServiceHandle<IAthRNGSvc> m_rndm_svc{this, "RndmSvc", "AthRNGSvc", "Random Number Service used in HGTD & Pixel digitization"};  
  std::list<ISiChargedDiodesProcessorTool*> m_diode_processor_tools;
  ToolHandle<IFrontEnd> m_hgtd_front_end_tool{this, "FrontEnd", "HGTD_FrontEndTool", "Tool for pulse shape simulation"};
  ToolHandle<IHGTD_SurfaceChargesGenerator> m_hgtd_surf_charge_gen{this, "SurfaceChargesGenerator", "HGTD_SurfaceChargesGenerator", "Choice of using a more detailed charge drift model"};
  ToolHandle<HGTD_TdcCalibrationTool> m_hgtd_tdc_calib_tool{this, "HGTD_TdcCalibrationTool","HGTD_TdcCalibrationTool", "Tool that handles the Time to Digital Converter (TDC)"};
 
  const HGTD_ID* m_id_helper{nullptr}; 
  // NB: even though it is a flat collection, it acts more like a container,
  // since the actual collections can be retrieved one by one with the
  // nextDetectorElement method.
  std::unique_ptr<TimedHitCollection<SiHit>> m_timed_hit_coll{nullptr};
  std::vector<bool> m_processed_elements; 
  // FIXME is this meant as a "keapalive" vector?
  std::vector<std::unique_ptr<SiHitCollection>> m_hit_coll_ptrs{};
};
 
static const InterfaceID IID_IHGTD_DigitizationTool("HGTD_DigitizationTool", 1, 0);
inline const InterfaceID& HGTD_DigitizationTool::interfaceID() {
  return IID_IHGTD_DigitizationTool;
}
 
#endif // HGTD_DIGITZATION_HGTD_DIGITZATIONTOOL_H