BCM_DigitizationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef BCM_DIGITIZATION_BCM_DIGITIZATIONTOOL_H
#define BCM_DIGITIZATION_BCM_DIGITIZATIONTOOL_H
 
#include "PileUpTools/PileUpToolBase.h"
#include "AthenaKernel/IAthRNGSvc.h"
 
#include "GaudiKernel/ServiceHandle.h"
 
#include "PileUpTools/PileUpMergeSvc.h"
 
#include "InDetSimData/InDetSimData.h"
#include "InDetSimData/InDetSimDataCollection.h"
#include "InDetSimEvent/SiHitCollection.h"
#include "InDetSimEvent/SiHit.h"
 
#include "InDetBCM_RawData/BCM_RDO_Container.h"
#include "InDetBCM_RawData/InDetBCM_RawDataCLASS_DEF.h"
 
#include "CLHEP/Geometry/Point3D.h"
 
#include <bitset>
 
namespace CLHEP
{
  class HepRandomEngine;
}
 

class BCM_DigitizationTool : public PileUpToolBase {
 
 public:

  BCM_DigitizationTool(const std::string& type, const std::string& name,const IInterface* parent);
 
  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 bunchXing,
                                      SubEventIterator bSubEvents,
                                      SubEventIterator eSubEvents) override final;
  virtual StatusCode mergeEvent(const EventContext& ctx) override final;
 
 private:
  StatusCode createOutputContainers(const EventContext& ctx);
  void processSiHit(const SiHit &currentHit, double eventTime, unsigned int evtIndex, const EventContext& ctx);
  void createRDOsAndSDOs(const EventContext& ctx);

  float computeEnergy(float simEner, const HepGeom::Point3D<double>& startPos, const HepGeom::Point3D<double>& endPos);

  std::vector<float> createAnalog(int mod, const std::vector<float>& enerVect, const std::vector<float>& timeVect);

  void addNoise(int mod, std::vector<float> &analog, CLHEP::HepRandomEngine *randomEngine);

  std::bitset<64> applyThreshold(int chan, const std::vector<float>& analog);

  static void applyFilter(std::bitset<64> &digital);

  static void findPulses(const std::bitset<64>& digital, int &p1x, int &p1w, int &p2x, int &p2w);

  void fillRDO(unsigned int chan, int p1x, int p1w, int p2x, int p2w);
 
  // Digitization parameters
  std::vector<float> m_modNoise;  
  std::vector<float> m_modSignal; 
  std::vector<float> m_ninoThr;   
  Gaudi::Property<float> m_mipDeposit{this, "MIPDeposit", 0.0f, "Most probable MIP deposit in BCM pad"};
  Gaudi::Property<float> m_effPrmDistance{this, "EffDistanceParam", 0.0f, "Distance parameter for efficiency calculation"};
  Gaudi::Property<float> m_effPrmSharpness{this, "EffSharpnessParam", 0.0f, "Sharpness parameter for efficiency calculation"};
  Gaudi::Property<float> m_timeDelay{this, "TimeDelay", 0.0f, "Pulse time delay"};
 
  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, "HitCollName", "BCMHits", "Input simulation hits collection name"};
  std::string m_inputObjectName{""};
 
  // Write handle keys
  SG::WriteHandleKey<BCM_RDO_Container> m_outputKey{this, "OutputRDOKey", "BCM_RDOs", ""};
  SG::WriteHandleKey<InDetSimDataCollection> m_outputSDOKey{this, "OutputSDOKey", "BCM_SDO_Map", ""};
 
  // Output objects
  BCM_RDO_Container* m_rdoContainer{}; 
  InDetSimDataCollection* m_simDataCollMap{}; 
 
  ServiceHandle <PileUpMergeSvc> m_mergeSvc{this, "MergeSvc", "PileUpMergeSvc", "Merge service used in digitization"}; 
  ServiceHandle<IAthRNGSvc> m_rndmGenSvc{this, "RndmSvc", "AthRNGSvc", ""};  
 
  // Vectors to store G4 hit information
  std::vector<float> m_enerVect[8]; 
  std::vector<float> m_timeVect[8]; 
  std::vector<InDetSimData::Deposit> m_depositVect[8]; 
};
 
#endif // BCM_DIGITIZATION_BCM_DIGITIZATIONTOOL_H