RpcDigiTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef RPC_DIGITIZATIONR4_RPCDIGITOOL_H
#define RPC_DIGITIZATIONR4_RPCDIGITOOL_H
 
#include "Acts/Utilities/detail/Polynomials.hpp"
#include "CLHEP/Random/RandExponential.h"
#include "CLHEP/Random/RandFlat.h"
#include "CLHEP/Random/RandGaussZiggurat.h"
#include "GaudiKernel/PhysicalConstants.h"
#include "MuonCondData/DigitEffiData.h"
#include "MuonDigitContainer/RpcDigitContainer.h"
#include "MuonDigitizationR4/MuonDigitizationTool.h"
 
namespace MuonR4 {
class RpcDigiTool final : public MuonDigitizationTool {
public:
  using MuonDigitizationTool::MuonDigitizationTool;
 
  StatusCode initialize() override final;
  StatusCode finalize() override final;
 
protected:
  StatusCode
  digitize(const EventContext &ctx, const TimedHits &hitsToDigit,
           xAOD::MuonSimHitContainer *sdoContainer) const override final;
 
private:
  using EdgeSide = MuonGMR4::RpcReadoutElement::EdgeSide;

  bool digitizeHit(const TimedHit &simHit, const bool measuresPhi,
                   const Muon::DigitEffiData *effiMap,
                   RpcDigitCollection &outContainer,
                   CLHEP::HepRandomEngine *rndEngine,
                   DeadTimeMap &deadTimes) const;

  bool digitizeHitBI(const TimedHit &simHit, const Muon::DigitEffiData *effiMap,
                     RpcDigitCollection &outContainer,
                     CLHEP::HepRandomEngine *rndEngine,
                     DeadTimeMap &deadTimes) const;

  static double timeOverThreshold(CLHEP::HepRandomEngine *rndmEngine);
 
  using DigiCache = OutDigitCache_t<RpcDigitCollection>;
  SG::WriteHandleKey<RpcDigitContainer> m_writeKey{this, "OutputObjectName",
                                                   "RPC_DIGITS"};
 
  SG::ReadCondHandleKey<Muon::DigitEffiData> m_effiDataKey{
      this, "EffiDataKey", "RpcDigitEff",
      "Efficiency constants of the individual Rpc gasGaps"};
 
  mutable std::array<std::atomic<unsigned>, 2> m_allHits ATLAS_THREAD_SAFE{};
  mutable std::array<std::atomic<unsigned>, 2> m_acceptedHits
      ATLAS_THREAD_SAFE{};
 
  Gaudi::Property<double> m_propagationVelocity{
      this, "propSpeed", 0.5 * Gaudi::Units::c_light,
      "Propagation speed of the signal inside the strip"}; // in mm/ns
 
  Gaudi::Property<double> m_stripTimeResolution{
      this, "timeResolution", 0.6 * Gaudi::Units::nanosecond,
      "Estimated time resolution of the strip readout"};
 
  Gaudi::Property<double> m_deadTime{this, "deadTime",
                                     100. * Gaudi::Units::nanosecond};
 
  Gaudi::Property<bool> m_digitizeMuonOnly{
      this, "ProcessTrueMuonsOnly", false,
      "If set to true hit with pdgId != 13 are skipped"};
 
  // Methods for new BIRPC digitization
  //
  int determineClusterSizeBI(const Identifier &id,
                             CLHEP::HepRandomEngine *rndmEngine) const;

  double calculateChargeOnStrip(const TimedHit &simHit,
                                CLHEP::HepRandomEngine *rndmEngine,
                                const double gasGapSize) const;

  std::vector<double>
  divideChargeOnStrips(double totalCharge, int n_strips,
                       CLHEP::HepRandomEngine *rndmEngine) const;

  double getTOT(const double aCharge) const; 

  double getTOA(const double aCharge, const double aDistance) const;
};
 
} // namespace MuonR4
 
#endif