#include <sTgcDigitMaker.h>

Inheritance diagram for MuonR4::sTgcDigitMaker:

Collaboration diagram for MuonR4::sTgcDigitMaker:

Classes
struct	DigiConditions
	Holds necessary conditions and data for digitization. More...
struct	DigiInput
	Helper struct to carry the digit information around. More...
struct	GammaParameter
	Stores gamma distribution parameters for estimating digit time. More...
struct	Ionization
	Holds information about ionization points in the gas volume. More...

Public Types
enum class	digitMode : std::uint8_t { StripsOnly = 1 , StripsAndPads = 2 , AllChType = 3 }
	Constructor initializing digitization parameters. More...
using	TimedHit = TimedHitPtr<xAOD::MuonSimHit>
using	ReadoutChannelType = sTgcIdHelper::sTgcChannelTypes
using	sTgcDigitVec = std::vector<std::unique_ptr<sTgcDigit>>
	Digitize a given hit.

Public Member Functions
	sTgcDigitMaker (const MuonGMR4::MuonDetectorManager *detMgr, digitMode mode, double meanGasGain, bool doPadChargeSharing)
virtual	~sTgcDigitMaker ()
	Destructor.
StatusCode	initialize ()
	Initialize digitization parameters, including reading necessary data files.
sTgcDigitVec	executeDigi (const DigiConditions &condContainers, const TimedHit &hit) const
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
bool	getIonizationPoint (const TimedHit &hit, const DigiConditions &condContainers, Ionization &ionization) const
	Computes the ionization point for a hit.
double	calculateTotalCharge (double energyDeposit, CLHEP::HepRandomEngine *rndEngine) const
	Calculates total charge from energy deposit, including gas gain.
sTgcDigitVec	processStripDigitization (const DigiConditions &condContainers, const DigiInput &digiInput) const
	Processes strip digitization for a given hit.
sTgcDigitVec	processPadDigitization (const DigiInput &digiInput) const
	Processes pad digitization for a given hit.
sTgcDigitVec	processWireDigitization (const DigiInput &digiInput) const
	Processes wire digitization for a given hit.
sTgcDigitVec	processStripChargeSharing (const DigiInput &digiInput, const double peak_position, const int stripNumber) const
	Handles charge sharing for strip clusters.
sTgcDigitVec	processPadChargeSharing (const DigiInput &digiInput, const int padEta, const int padPhi) const
	Handles charge sharing for pad clusters.
StatusCode	readFileOfTimeArrival ()
	Reads time arrival data file.
StatusCode	readFileOfTimeOffsetStrip ()
	Reads strip time offset data file.
Ionization	pointClosestApproach (const MuonGMR4::StripLayer &stripLayer, int wireNumber, const Amg::Vector3D &locHitPos, const Amg::Vector3D &locHitDir, const double stepLength) const
	Computes the closest approach between a trajectory and a wire segment.
double	getTimeOffsetStrip (size_t neighbor_index) const
	Gets the time offset for a strip cluster.
GammaParameter	getGammaParameter (double distance) const
	Retrieves gamma distribution parameters based on distance.
double	getMostProbableArrivalTime (double distance) const
	Computes the most probable arrival time based on the distance of closest approach.
double	chargeIntegral (double N, double M) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static void	addDigit (sTgcDigitVec &digits, const Identifier &id, double digittime, double charge)
	Adds a digit to the appropriate cache.
static double	getPadChargeFraction (double distance)
	Computes charge fraction shared among pads.

Private Attributes
std::vector< GammaParameter >	m_gammaParameter
std::array< double, 5 >	m_mostProbableArrivalTime {make_array<double, 5>(0.)}
std::array< double, 6 >	m_timeOffsetStrip {make_array<double, 6>(0.)}
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
const Muon::IMuonIdHelperSvc *	m_idHelperSvc {m_detMgr->idHelperSvc()}
const sTgcIdHelper &	m_idHelper {m_idHelperSvc->stgcIdHelper()}
digitMode	m_digitMode {digitMode::AllChType}
	define offsets and widths of time windows for signals from wiregroups and strips.
double	m_theta {10}
double	m_meanGasGain {5.e4}
bool	m_doPadSharing {false}
bool	m_doTimeOffsetStrip {false}
double	m_StripResolution {0.0949}
double	m_posResIncident {1.}
double	m_posResAngular {0.305/m_StripResolution}
double	m_chargeAngularFactor {4.0}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Static Private Attributes
static constexpr std::array< double, 2 >	m_clusterParams {0.573, 1.092}

Detailed Description

Definition at line 36 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

Member Typedef Documentation

◆ ReadoutChannelType

using MuonR4::sTgcDigitMaker::ReadoutChannelType = sTgcIdHelper::sTgcChannelTypes

Definition at line 72 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

◆ sTgcDigitVec

using MuonR4::sTgcDigitMaker::sTgcDigitVec = std::vector<std::unique_ptr<sTgcDigit>>

Digitize a given hit.

Parameters

condContainers	Conditions required for digitization.
hit	The simulated hit to be digitized.

Definition at line 79 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

◆ TimedHit

using MuonR4::sTgcDigitMaker::TimedHit = TimedHitPtr<xAOD::MuonSimHit>

Definition at line 71 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

Member Enumeration Documentation

◆ digitMode

enum class MuonR4::sTgcDigitMaker::digitMode : std::uint8_t

strong

Constructor initializing digitization parameters.

Enumerator
StripsOnly
StripsAndPads
AllChType

Definition at line 41 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

                      : std::uint8_t  {
    StripsOnly = 1,
    StripsAndPads = 2,
    AllChType = 3,
  };

Constructor & Destructor Documentation

◆ sTgcDigitMaker()

sTgcDigitMaker::sTgcDigitMaker	(	const MuonGMR4::MuonDetectorManager *	detMgr,
		digitMode	mode,
		double	meanGasGain,
		bool	doPadChargeSharing )

Definition at line 27 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

  : AthMessaging("sTgcDigitMaker"),
    m_detMgr{detMgr},
    m_digitMode(mode),
    m_meanGasGain{meanGasGain},
    m_doPadSharing{doPadChargeSharing}{}

◆ ~sTgcDigitMaker()

sTgcDigitMaker::~sTgcDigitMaker ( )

virtualdefault

Destructor.

Member Function Documentation

◆ addDigit()

void sTgcDigitMaker::addDigit	(	sTgcDigitVec &	digits,
		const Identifier &	id,
		double	digittime,
		double	charge )

staticprivate

Adds a digit to the appropriate cache.

Definition at line 576 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                   {
  
  constexpr double tolerance = 0.1;
  if (!std::ranges::any_of(digits, [&](std::unique_ptr<sTgcDigit>& known) {
      return known->identify() == id && std::abs(digittime - known->time()) < tolerance;
  })) {
    digits.push_back(std::make_unique<sTgcDigit>(id, 0, digittime, charge, 0, 0));
  }
}

◆ calculateTotalCharge()

double sTgcDigitMaker::calculateTotalCharge	(	double	energyDeposit,
		CLHEP::HepRandomEngine *	rndEngine ) const

private

Calculates total charge from energy deposit, including gas gain.

Definition at line 146 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                                                       {
  // Ionized charge in pC per keV deposited
  const double ionized_charge = (5.65E-6) * energyDeposit / CLHEP::keV;
 
  // Calculate avalanche gain using gamma distribution (Polya function approximation)
  const double gain = CLHEP::RandGamma::shoot(rndEngine, 1. + m_theta, (1. + m_theta) / m_meanGasGain);
 
  return gain * ionized_charge;
}

◆ chargeIntegral()

double sTgcDigitMaker::chargeIntegral	(	double	N,
		double	M ) const

private

Definition at line 655 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                              {
 
    double term1 = 0.25 * std::erf( M / (std::sqrt(2) * m_clusterParams[0]));
    double term2 = 0.25 * std::erf( N / (std::sqrt(2) * m_clusterParams[0]));
    double term3 = 0.25 * std::erf( M / (std::sqrt(2) * m_clusterParams[1]));
    double term4 = 0.25 * std::erf( N / (std::sqrt(2) * m_clusterParams[1]));
 
    return (term1 - term2 + term3 - term4);
}

◆ executeDigi()

sTgcDigitVec sTgcDigitMaker::executeDigi	(	const DigiConditions &	condContainers,
		const TimedHit &	hit ) const

Definition at line 159 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                    {
  sTgcDigitVec allDigits{};
  // Extract energy deposit from the hit
  const double energyDeposit = hit->energyDeposit();
  if (energyDeposit < std::numeric_limits<float>::epsilon()) {
    return allDigits;  // Ignore hits with no energy deposit
  }
 
   // Retrieve the detector element for the given hit
  const Identifier hitId = hit->identify();
 
  // HV efficiency correction
  if (condContainers.efficiencies) {
    const double efficiency = condContainers.efficiencies->getEfficiency(hitId);
    if (CLHEP::RandFlat::shoot(condContainers.rndEngine,0.0,1.0) > efficiency) {
      return allDigits;
    }
  }
 
  
  ATH_MSG_DEBUG("Retrieving detector element for: "<< m_idHelperSvc->toStringDetEl(hitId) 
              << " energyDeposit "<< energyDeposit );
  
  
  // Get ionization point and time
  Ionization ionization{};
  if (!getIonizationPoint(hit, condContainers, ionization)) {
    ATH_MSG_DEBUG("Failed to get ionization point for hit "<< m_idHelperSvc->toStringDetEl(hitId));
    return allDigits;
  }
 
  DigiInput digiInput{};
  digiInput.hitId = hitId;
  digiInput.totalCharge = calculateTotalCharge(energyDeposit, condContainers.rndEngine);
  digiInput.time = ionization.time;
  digiInput.posOnSurf = ionization.posOnWire;
  digiInput.hitDir = xAOD::toEigen(hit->localDirection());
  digiInput.reEle = m_detMgr->getsTgcReadoutElement(hitId);
  
  
  //##################################################################################
  //######################################### strip readout ##########################
  //##################################################################################
  sTgcDigitVec stripDigits = processStripDigitization(condContainers, digiInput);
 
  if(m_digitMode == digitMode::StripsOnly) {
    ATH_MSG_WARNING("Only digitize strip response !");
    return stripDigits;
  }
  allDigits.insert(allDigits.end(),
                   std::make_move_iterator(stripDigits.begin()), 
                   std::make_move_iterator(stripDigits.end()));
 
  //##################################################################################
  //######################################### pad readout ############################
  //##################################################################################
  sTgcDigitVec padDigits = processPadDigitization(digiInput);
 
  allDigits.insert(allDigits.end(), 
                   std::make_move_iterator(padDigits.begin()),
                   std::make_move_iterator(padDigits.end()));
 
  if(m_digitMode == digitMode::StripsAndPads) {
    ATH_MSG_WARNING("Only digitize strip/pad response !");
    return allDigits;
  }
 
  //##################################################################################
  //######################################### wire readout ###########################
  //##################################################################################
  sTgcDigitVec wireDigits = processWireDigitization(digiInput);
  allDigits.insert(allDigits.end(), 
                   std::make_move_iterator(wireDigits.begin()),
                   std::make_move_iterator(wireDigits.end()));
 
  return allDigits;
}

◆ getGammaParameter()

sTgcDigitMaker::GammaParameter sTgcDigitMaker::getGammaParameter ( double distance ) const

private

Retrieves gamma distribution parameters based on distance.

Definition at line 629 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                                    {
  const double d = std::abs(distance); 
  // Find the parameters assuming the container is sorted in ascending order of 'lowEdge'
  if (d < m_gammaParameter.front().lowEdge) {
    return m_gammaParameter.front();
  }
  int index{-1};
  for (const auto& par: m_gammaParameter) {
    if (d < par.lowEdge) {
      break;
    }
    ++index;
  }
  return m_gammaParameter.at(index);
}

◆ getIonizationPoint()

bool sTgcDigitMaker::getIonizationPoint	(	const TimedHit &	hit,
		const DigiConditions &	condContainers,
		Ionization &	ionization ) const

private

Computes the ionization point for a hit.

Definition at line 57 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                      {
  const MuonGMR4::sTgcReadoutElement* reEle = m_detMgr->getsTgcReadoutElement(hit->identify());
 
  // Projecting the hit position on wire surface
  const Amg::Vector3D locHitDir = xAOD::toEigen(hit->localDirection());
  const Amg::Vector3D locHitPos = xAOD::toEigen(hit->localPosition());
  ATH_MSG_VERBOSE("sTgc hit:  time " << hit->globalTime() 
              << " position " << Amg::toString(locHitPos, 2) << " direction" << Amg::toString(locHitDir, 2) 
              << " mclink " << hit->genParticleLink() << " PDG ID " << hit->pdgId() );
  
  const double scale = Amg::intersect<3>(locHitPos, locHitDir, Amg::Vector3D::UnitZ(), 0.).value_or(0);
  Amg::Vector3D hitOnWireSurf = locHitPos + scale * locHitDir;
 
  const Identifier hitId = hit->identify();
  const IdentifierHash wireLayHash = reEle->createHash(m_idHelper.gasGap(hitId),
                                                       ReadoutChannelType::Wire, 1);
  const MuonGMR4::WireGroupDesign& wireDesign{reEle->wireDesign(wireLayHash)};
  const MuonGMR4::StripLayer& stripLayer = reEle->stripLayer(wireLayHash);
  const Amg::Vector2D hitOnWire2D = stripLayer.to2D(hitOnWireSurf, true);
  
  if(!wireDesign.insideTrapezoid(hitOnWire2D)) {
    return false;
  }
 
  std::pair<int, int> wireGrpWireNum = wireDesign.wireNumber(hitOnWire2D);
  if (wireGrpWireNum.first < 0) {
    ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Unable to retrieve the wire number, skipping the hit: " 
                 << m_idHelperSvc->toString(hitId)<<" @"<<Amg::toString(hitOnWire2D));
    return false;  
  }
  int wireNumber = wireDesign.numPitchesToGroup(wireGrpWireNum.first) + wireGrpWireNum.second;
  const int numWires = wireDesign.nAllWires();
  
  if((wireNumber < 1) || (wireNumber > numWires)) {
    ATH_MSG_WARNING(__func__<<"() "<<__LINE__<<" - Unable to retrieve the wire number, skipping the hit: " 
                 << m_idHelperSvc->toString(hitId)<<" @"<<Amg::toString(hitOnWire2D));
    return false;  
  }
 
  // Compute the position of the ionization and its distance to the closest wire
  ionization = pointClosestApproach(stripLayer, wireNumber, locHitPos, locHitDir, hit->stepLength());
  double distToWire = ionization.distance;
  
  if(distToWire > 0.) {
    // Determine on which side of the wire does the particle cross
    int adjacent = Acts::copySign(1, ionization.posOnSegment.y() - ionization.posOnWire.y());
    
    Ionization ionizationAdj = pointClosestApproach(stripLayer, wireNumber+adjacent, locHitPos, locHitDir, hit->stepLength());
    double distToWireAdj = ionizationAdj.distance;
    
    if ((distToWireAdj > 0.) && (distToWireAdj < distToWire)) {
      distToWire = distToWireAdj;
      wireNumber += adjacent;
      ionization = std::move(ionizationAdj);
    }
  } else {
    ATH_MSG_DEBUG("Failed to get the distance between the wire and hit");
    return false;
  }
 
  // Do not digitize hits that are too far from the nearest wire
  if (distToWire > wireDesign.stripPitch()) {
    return false;
  }
 
  // Get the gamma pdf parameters and calculate digit time
  const GammaParameter gamParam = getGammaParameter(distToWire);
  const double most_prob_time = getMostProbableArrivalTime(distToWire);
  const double gamma_mpv = std::max((gamParam.kParameter - 1) * gamParam.thetaParameter, 0.);
  const double t0_par = most_prob_time - gamma_mpv;
  const double inv_theta = 1./gamParam.thetaParameter;
 
  double digitTime = t0_par + CLHEP::RandGamma::shoot(condContainers.rndEngine, gamParam.kParameter, inv_theta);
 
  constexpr unsigned shoot_limit = 4;
  unsigned shoot_counter = 0;
  while (digitTime < 0. && ++shoot_counter <= shoot_limit) {
    digitTime = t0_par + CLHEP::RandGamma::shoot(condContainers.rndEngine, gamParam.kParameter,inv_theta);
  }
  
  ionization.time = std::max(0., digitTime);
  return true;
}

◆ getMostProbableArrivalTime()

double sTgcDigitMaker::getMostProbableArrivalTime ( double distance ) const

private

Computes the most probable arrival time based on the distance of closest approach.

Definition at line 648 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                       {
  return Acts::detail::polynomialSum(std::abs(distance), m_mostProbableArrivalTime);
}

◆ getPadChargeFraction()

double sTgcDigitMaker::getPadChargeFraction ( double distance )

staticprivate

Computes charge fraction shared among pads.

Definition at line 712 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                           {
  // The charge fraction that is found past a distance x away from the
  // centre of a 2D gaussian distribution of width of cluster profile is
  // described by a modified error function.
 
  // The modified error function perfectly describes
  // the pad charge sharing distribution figure 16 of the sTGC
  // testbeam paper https://arxiv.org/pdf/1509.06329.pdf
  return 0.5 * (1.0 - std::erf( distance / (std::sqrt(2) * m_clusterParams[1])));
}

◆ getTimeOffsetStrip()

double sTgcDigitMaker::getTimeOffsetStrip ( size_t neighbor_index ) const

private

Gets the time offset for a strip cluster.

Get digit time offset of a strip depending on its relative position to the strip at the centre of the cluster. It returns 0 ns by default, as well as when it fails or container is empty.

Definition at line 705 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                     {
    return m_timeOffsetStrip.at(std::min(neighbor_index, m_timeOffsetStrip.size() -1));
}

◆ initialize()

StatusCode sTgcDigitMaker::initialize ( )

Initialize digitization parameters, including reading necessary data files.

Definition at line 42 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                      {
  // Read arrival time data
  ATH_CHECK(readFileOfTimeArrival());
 
  // Read strip time correction if enabled
  if (m_doTimeOffsetStrip) {
    ATH_CHECK(readFileOfTimeOffsetStrip());
  }
 
  return StatusCode::SUCCESS;
}

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

179{ return msg() << lvl; }

AthMessaging::msg

MsgStream & msg() const

The standard message stream.

Definition AthMessaging.h:163

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns: boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

◆ pointClosestApproach()

sTgcDigitMaker::Ionization sTgcDigitMaker::pointClosestApproach	(	const MuonGMR4::StripLayer &	stripLayer,
		int	wireNumber,
		const Amg::Vector3D &	locHitPos,
		const Amg::Vector3D &	locHitDir,
		const double	stepLength ) const

private

Computes the closest approach between a trajectory and a wire segment.

Given two segments, e.g. a particle trajectory and a sTGC wire, solve for the two points, the point on the trajectory and the point on the wire, where the distance between the two segments is the smallest.

Positions returned are in the local coordinate frame of the wire plane. Returns an object with distance of -9.99 in case of error.

Definition at line 511 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                                               {
 
  constexpr double angular_tolerance = 1e-3;
  // Position of the ionization
  Ionization ionization;
  // Finding smallest distance and the points at the smallest distance.
  //  The smallest distance between two lines is perpendicular to both lines.
  // Previous logic was to find the perpendicular distance between two lines using projection geometry
  //  We can construct two lines in the wire surface local coordinate frame:
  //  - one for the hit segment with equation h0 + t * v_h, where h0 is a point
  //    and v_h is the unit vector of the hit segment
  //  - another for the wire with similar equation w0 + s * v_w, where w0 is a
  //    point and v_w is the unit vector of the wire line
  //  Then it is possible to determine the closest points on each line
  //  by requiring that the vector between them is perpendicular to both:
  //   1. (h0 + t*v_h - w0 - s*v_w) · v_h = 0
  //   2. (h0 + t*v_h - w0 - s*v_w) · v_w = 0
 
  // We have replaced this logic with using Amg::intersect<3> method
  const MuonGMR4::WireGroupDesign& wireDesign = static_cast<const MuonGMR4::WireGroupDesign&>(stripLayer.design(true));
  // Geometry setup defined in the eta surface local coordinate frame
  const double wirePitch = wireDesign.stripPitch();
  const double wirePosX = wireDesign.firstStripPos().x() + (wireNumber - 1) * wirePitch;
  const Amg::Vector3D wireDir{stripLayer.to3D(wireDesign.stripDir(),true)};
  const Amg::Vector3D wirePos(locHitPos.x(), wirePosX, 0.);
 
  // Use Amg::intersect to find closest point on hit segment to wire plane
  std::optional<double> scaleHit = Amg::intersect<3>(locHitPos, locHitDir, Amg::Vector3D::UnitZ(), 0);
  if (!scaleHit || std::abs(std::abs(wireDir.dot(locHitDir)) - 1.0) < angular_tolerance) {
    ATH_MSG_DEBUG("The track segment is parallel to the wire, position of digit is undefined");
    ionization.posOnSegment = locHitPos;
    ionization.posOnWire = wirePos;
    ionization.distance = std::hypot(locHitPos.y() - wirePosX, locHitPos.z());
    return ionization;
  }
  // Position on hit segment
  Amg::Vector3D ionizationPos = locHitPos + scaleHit.value() * locHitDir;
 
  if (scaleHit.value() > stepLength) {
    ionization.posOnSegment = locHitPos;
    const Amg::Vector3D closestPointToWirePlane = locHitPos + stepLength * locHitDir;
    ionization.posOnWire = wirePos;
    ionization.distance = std::abs(closestPointToWirePlane.z());
    return ionization;
  }
 
  // Project ionization position onto the wire line
  const double scaleWire = (ionizationPos - wirePos).dot(wireDir);
  const Amg::Vector3D closestPointOnWire = wirePos + scaleWire * wireDir;
 
  // Fill ionization result
  ionization.posOnSegment = ionizationPos;
  ionization.posOnWire = closestPointOnWire;
  ionization.distance = (ionizationPos - closestPointOnWire).mag();
 
  return ionization;
}

◆ processPadChargeSharing()

sTgcDigitVec sTgcDigitMaker::processPadChargeSharing	(	const DigiInput &	digiInput,
		const int	padEta,
		const int	padPhi ) const

private

Handles charge sharing for pad clusters.

Definition at line 384 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                             {
  
  bool isValid = false;
  const int gasGap = m_idHelper.gasGap(digiInput.hitId);
  const Identifier padHitId = m_idHelper.padID(digiInput.hitId, 
                                              digiInput.reEle->multilayer(), 
                                              gasGap, ReadoutChannelType::Pad, padEta, padPhi, isValid);
  if(!isValid) {
    return {};
  }
  sTgcDigitVec digits{};
  
  const IdentifierHash padHitHash = digiInput.reEle->measurementHash(padHitId);
  const MuonGMR4::PadDesign& padDesign{digiInput.reEle->padDesign(padHitHash)};
 
  const Amg::Vector2D padPos = digiInput.reEle->localChannelPosition(padHitHash);
  const Amg::Vector2D hitOnPadSurf = digiInput.reEle->stripLayer(padHitHash).to2D(digiInput.posOnSurf, true);
  
  const Amg::Vector2D diff = hitOnPadSurf - padPos;
  const double halfPadHeight = 0.5 * digiInput.reEle->padHeight(padHitHash);
  
  const std::array<Amg::Vector2D, 4> padHitCorners = padDesign.padCorners(std::make_pair(padEta, padPhi));
  const double padBottomBase = (padHitCorners[0] - padHitCorners[1]).norm();
  const double padTopBase = (padHitCorners[2] - padHitCorners[3]).norm();
  const double halfPadWidth = 0.5 * padBottomBase + 0.25 * (1 + diff.y()/halfPadHeight) * (padTopBase - padBottomBase);
 
  double deltaX = halfPadWidth - std::abs(diff.x());
  double deltaY = halfPadHeight - std::abs(diff.y());
  const bool isNeighX = deltaX < 2.5*m_clusterParams[1];
  const bool isNeighY = deltaY < 2.5*m_clusterParams[1];
  
  if (deltaX < 0.) { 
    deltaX = 0.1; 
  }
  if (deltaY < 0.) { 
    deltaY = 0.1; 
  }
 
  if (m_doPadSharing && (isNeighX || isNeighY)) {
    unsigned newPhi = padPhi - Acts::copySign(1, diff.x());
    unsigned newEta = padEta  + Acts::copySign(1, diff.y());
    bool validEta = newEta > 0 && newEta <= digiInput.reEle->numPadEta(padHitHash);
    bool validPhi = newPhi > 0 && newPhi <= digiInput.reEle->numPadPhi(padHitHash);
 
    if (isNeighX && isNeighY && validEta && validPhi) {
      const Identifier neigh_ID_X = m_idHelper.padID(padHitId, digiInput.reEle->multilayer(), 
                                                     gasGap, ReadoutChannelType::Pad, 
                                                     padEta, newPhi);
      const Identifier neigh_ID_Y = m_idHelper.padID(padHitId, digiInput.reEle->multilayer(), gasGap,
                                                     ReadoutChannelType::Pad, newEta, padPhi);
      const Identifier neigh_ID_XY = m_idHelper.padID(padHitId, digiInput.reEle->multilayer(), gasGap,
                                                      ReadoutChannelType::Pad, newEta, newPhi);
      double xQfraction = getPadChargeFraction(deltaX);
      double yQfraction = getPadChargeFraction(deltaY);
 
      addDigit(digits, neigh_ID_X, digiInput.time, xQfraction*(1.-yQfraction)*0.5*digiInput.totalCharge);
      addDigit(digits, neigh_ID_Y, digiInput.time, yQfraction*(1.-xQfraction)*0.5*digiInput.totalCharge);
      addDigit(digits, neigh_ID_XY, digiInput.time, xQfraction*yQfraction*0.5*digiInput.totalCharge);
      addDigit(digits, padHitId, digiInput.time, (1.-xQfraction-yQfraction+xQfraction*yQfraction)*0.5*digiInput.totalCharge);
    } else if (isNeighX && validPhi){
      const Identifier neigh_ID = m_idHelper.padID(padHitId, digiInput.reEle->multilayer(), gasGap, 
                                                   ReadoutChannelType::Pad, padEta, newPhi);
      double xQfraction = getPadChargeFraction(deltaX);
      addDigit(digits, padHitId, digiInput.time, (1.-xQfraction)*0.5*digiInput.totalCharge);
      addDigit(digits, neigh_ID, digiInput.time, xQfraction*0.5*digiInput.totalCharge);
    }
    else if (isNeighY && validEta){
      const Identifier neigh_ID = m_idHelper.padID(padHitId, digiInput.reEle->multilayer(), gasGap, 
                                                   ReadoutChannelType::Pad, newEta, padPhi);
      double yQfraction = getPadChargeFraction(deltaY);
      addDigit(digits, padHitId, digiInput.time, (1.-yQfraction)*0.5*digiInput.totalCharge);
      addDigit(digits, neigh_ID, digiInput.time, yQfraction*0.5*digiInput.totalCharge);
    }
  } else{
    addDigit(digits, padHitId, digiInput.time, 0.5*digiInput.totalCharge);
  }
  return digits;
}

◆ processPadDigitization()

sTgcDigitVec sTgcDigitMaker::processPadDigitization ( const DigiInput & digiInput ) const

private

Processes pad digitization for a given hit.

Definition at line 348 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                                    {
  ATH_MSG_DEBUG("sTgcDigitMaker::pad response ");
  
  const int gasGap = m_idHelper.gasGap(digiInput.hitId);
  const IdentifierHash padLayHash = digiInput.reEle->createHash(gasGap,ReadoutChannelType::Pad, 1);
  const Amg::Vector2D hitOnPadSurf = digiInput.reEle->stripLayer(padLayHash).to2D(digiInput.posOnSurf, true);
  const MuonGMR4::PadDesign& padDesign{digiInput.reEle->padDesign(padLayHash)};
  if(!padDesign.insideTrapezoid(hitOnPadSurf)) {
    ATH_MSG_DEBUG(__func__<<"() -"<<__LINE__<<" Outside of the pad surface boundary :" 
                  << m_idHelperSvc->toString(digiInput.hitId)
                 << " local position " <<Amg::toString(hitOnPadSurf, 2));
    return {};
  }
 
  constexpr double tolerance_length = 0.01*Gaudi::Units::mm;
  auto [padEta, padPhi] = padDesign.channelNumber(hitOnPadSurf);
  
  if( padEta < 1 || padPhi < 1){
    const double newPosX = hitOnPadSurf.x() - std::copysign(tolerance_length, hitOnPadSurf.x());
    const double newPosY = hitOnPadSurf.y() - std::copysign(tolerance_length, hitOnPadSurf.y());
    const Amg::Vector2D newPosition(newPosX, newPosY);
    auto [newPadEta, newPadPhi] = padDesign.channelNumber(newPosition);
    padEta = newPadEta;
    padPhi = newPadPhi;
    if( padEta < 1 || padPhi < 1) {
      ATH_MSG_WARNING("Failed to obtain pad number for " << m_idHelperSvc->toString(digiInput.hitId) );
      return {};
    }
  }
  
  return processPadChargeSharing(digiInput, padEta, padPhi);
}

◆ processStripChargeSharing()

sTgcDigitVec sTgcDigitMaker::processStripChargeSharing	(	const DigiInput &	digiInput,
		const double	peak_position,
		const int	stripNumber ) const

private

Handles charge sharing for strip clusters.

Definition at line 286 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                                    {
  
  const double norm = 0.5 * digiInput.totalCharge;
 
  sTgcDigitVec digits{};
  const double tan_theta = digiInput.hitDir.perp() / digiInput.hitDir.z();
  
  constexpr double tolerance_charge = 0.0005;
  constexpr int max_neighbor = 10;
 
  const int gasGap = m_idHelper.gasGap(digiInput.hitId);
  const auto& design = digiInput.reEle->stripDesign(digiInput.reEle->measurementHash(digiInput.hitId));
  // Upper half of the strip cluster
  for (int iStrip = 0; iStrip <= max_neighbor; ++iStrip) {
    for (int sign : {-1 , 1}) {
      int currentStrip = stripNumber + sign*iStrip;
      if (currentStrip > design.numStrips() || currentStrip < 1) {
        ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" Breaking the upper half strip loop stripNumber: " 
                        << currentStrip << " > " << design.numStrips());
        break;
      }
      bool isValid = false;
      const Identifier currentStripId = m_idHelper.channelID(digiInput.hitId, 
                                                             digiInput.reEle->multilayer(), 
                                                             gasGap, ReadoutChannelType::Strip,
                                                             currentStrip, isValid);
      if (!isValid) {
          continue;
      }
      const Amg::Vector2D currentStripPos = digiInput.reEle->localChannelPosition(digiInput.reEle->measurementHash(currentStripId));
      const double x_relative = (currentStripPos.x() - peak_position);
      const double normX = x_relative / design.stripPitch();
      const double charge = std::hypot(1., m_chargeAngularFactor * tan_theta) * norm * 
                            chargeIntegral(normX - 0.5, normX + 0.5);
      
      if (charge < tolerance_charge) {
        ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" Breaking the upper half strip loop stripCharge: " 
                        << charge << " < " << tolerance_charge);
        break;
      }
 
      double strip_time = digiInput.time;
      if (m_doTimeOffsetStrip) {
        const bool shift = ((iStrip > 0) && ((x_relative + (0.5*0.75 - iStrip) * design.stripPitch()) < 0));
        strip_time += getTimeOffsetStrip(iStrip -  shift);
      }
 
      addDigit(digits, currentStripId, strip_time, charge);
      ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" Created a strip digit: strip number = " 
                    << currentStrip << ", charge = " << charge);
    }
  }
 
  return digits;
}

◆ processStripDigitization()

sTgcDigitVec sTgcDigitMaker::processStripDigitization	(	const DigiConditions &	condContainers,
		const DigiInput &	digiInput ) const

private

Processes strip digitization for a given hit.

Definition at line 241 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                                        {
  ATH_MSG_DEBUG("sTgcDigitMaker::strip response ");
  
  const int gasGap = m_idHelper.gasGap(digiInput.hitId);
  const IdentifierHash stripLayHash = digiInput.reEle->createHash(gasGap,
                                                                  ReadoutChannelType::Strip, 1);
  const Identifier stripLayId = digiInput.reEle->measurementId(stripLayHash);
  const MuonGMR4::StripDesign& stripDesign{digiInput.reEle->stripDesign(stripLayHash)};  
  const Amg::Vector2D hitOnStripSurf = digiInput.reEle->stripLayer(stripLayHash).to2D(digiInput.posOnSurf, false);
  
  if(!stripDesign.insideTrapezoid(hitOnStripSurf)) {
    ATH_MSG_DEBUG("Outside of the strip surface boundary : " 
               << m_idHelperSvc->toString(stripLayId) 
               << "; local position " <<Amg::toString(hitOnStripSurf, 2));
    return {};
  }
 
  constexpr double tolerance_length = 0.01*Gaudi::Units::mm;
  int stripNumber = stripDesign.stripNumber(hitOnStripSurf);
  if( stripNumber < 0){
    const double newPosX = hitOnStripSurf.x() - std::copysign(tolerance_length, hitOnStripSurf.x());
    const Amg::Vector2D newPos(newPosX, hitOnStripSurf.y());
    stripNumber = stripDesign.stripNumber(newPos);
    if (stripNumber < 0) {
      ATH_MSG_WARNING("Failed to obtain strip number " << m_idHelperSvc->toString(stripLayId) );
      return {};
    }
  }
  
  
  const double tan_theta = digiInput.hitDir.perp() / digiInput.hitDir.z();
  const double angle_dependency = std::hypot(m_posResIncident, m_posResAngular * tan_theta);
 
  const double peak_position = CLHEP::RandGaussZiggurat::shoot(condContainers.rndEngine, 
                                                               hitOnStripSurf.x(), m_StripResolution*angle_dependency);
  ATH_MSG_VERBOSE(__func__<<"() - "<<__LINE__<<" Smeared hit from "<<hitOnStripSurf.x()<<" -> "<<
                peak_position<<". Assign strip charges");
  return processStripChargeSharing(digiInput,
                                   peak_position,
                                   stripNumber);
}

◆ processWireDigitization()

sTgcDigitVec sTgcDigitMaker::processWireDigitization ( const DigiInput & digiInput ) const

private

Processes wire digitization for a given hit.

Definition at line 469 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                                                     {
  ATH_MSG_DEBUG("sTgcDigitMaker::wire response ");
  
  const int gasGap = m_idHelper.gasGap(digiInput.hitId);
  const IdentifierHash wireLayHash = digiInput.reEle->createHash(gasGap,
                                                                ReadoutChannelType::Wire, 1);
  const MuonGMR4::WireGroupDesign& wireDesign{digiInput.reEle->wireDesign(wireLayHash)};
  
  const Amg::Vector2D hitOnWireSurf = digiInput.reEle->stripLayer(wireLayHash).to2D(digiInput.posOnSurf, true);
  if(!wireDesign.insideTrapezoid(hitOnWireSurf)) {
    ATH_MSG_DEBUG("Outside of the wire surface boundary :" << m_idHelperSvc->toString(digiInput.hitId)
                 << " local position " <<Amg::toString(hitOnWireSurf, 2));
    return {};
  }
 
  constexpr double tolerance_length = 0.01*Gaudi::Units::mm;
  int wiregroupNumber = (wireDesign.wireNumber(hitOnWireSurf)).first;
  if( wiregroupNumber < 1) {
    const double newPosX = hitOnWireSurf.x() - std::copysign(tolerance_length, hitOnWireSurf.x());
    const Amg::Vector2D newPos{newPosX, hitOnWireSurf.y()};
    wiregroupNumber = (wireDesign.wireNumber(newPos)).first;
    if (wiregroupNumber < 1) {
      ATH_MSG_WARNING("Failed to obtain wire number " << m_idHelperSvc->toString(digiInput.hitId) );
      return {};
    }
  }
 
  bool isValid = false;
  const Identifier wireGroupHitId = m_idHelper.channelID(digiInput.hitId, digiInput.reEle->multilayer(), gasGap, 
                                                         ReadoutChannelType::Wire, wiregroupNumber, isValid);
 
  if(!isValid) {
    return {};
  }
  sTgcDigitVec digits{};
  addDigit(digits, wireGroupHitId, digiInput.time, digiInput.totalCharge);
  return digits;
}

◆ readFileOfTimeArrival()

StatusCode sTgcDigitMaker::readFileOfTimeArrival ( )

private

Reads time arrival data file.

Definition at line 592 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                 {
  const std::string file_name = "sTGC_Digitization_timeArrival.dat";
  std::string file_path = PathResolver::find_file(file_name, "DATAPATH");
  if(file_path.empty()) {
    ATH_MSG_FATAL("readFileOfTimeWindowOffset(): Could not find file " << file_name );
    return StatusCode::FAILURE;
  }
 
  std::ifstream ifs{file_path, std::ios::in};
  if(ifs.bad()) {
    ATH_MSG_FATAL("sTgcDigitMaker: Failed to open time of arrival file " << file_name );
    return StatusCode::FAILURE;
  }
 
  // Read the sTGC_Digitization_timeWindowOffset.dat file
  std::string line;
  GammaParameter param{};
  while (std::getline(ifs, line)) {
    std::string key;
    std::istringstream iss(line);
    iss >> key;
    if (key == "bin") {
      iss >> param.lowEdge >> param.kParameter >> param.thetaParameter;
      m_gammaParameter.push_back(param);
    } else if (key == "mpv")  {
      double mpt{};
      int idx{0};
      while (iss >> mpt) {m_mostProbableArrivalTime[idx++] = mpt;}
    }
  }
  ifs.close();
  return StatusCode::SUCCESS;
}

◆ readFileOfTimeOffsetStrip()

StatusCode sTgcDigitMaker::readFileOfTimeOffsetStrip ( )

private

Reads strip time offset data file.

Definition at line 667 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/src/sTgcDigitMaker.cxx.

                                                     {
  const std::string file_name = "sTGC_Digitization_timeOffsetStrip.dat";
  std::string file_path = PathResolver::find_file(file_name, "DATAPATH");
  if(file_path.empty()) {
    ATH_MSG_FATAL("readFileOfTimeWindowOffset(): Could not find file " << file_name );
    return StatusCode::FAILURE;
  }
 
  // Open the sTGC_Digitization_timeOffsetStrip.dat file
  std::ifstream ifs{file_path, std::ios::in};
  if(ifs.bad()) {
    ATH_MSG_FATAL("Failed to open time of arrival file " << file_name );
    return StatusCode::FAILURE;
  }
 
  // Initialize the container to store the time offset.
  // The number of parameters, 6, corresponds to the number of lines to be read
  // from sTGC_Digitization_timeOffsetStrip.dat.
  // Setting the default offset to 0 ns.
  std::string line;
  size_t index{0};
  double value{0.0};
  while (std::getline(ifs, line)) {
    std::string key;
    std::istringstream iss(line);
    iss >> key;
    if (key == "strip") {
      iss >> index >> value;
      if (index >= m_timeOffsetStrip.size()) continue;
      m_timeOffsetStrip.at(index) = value;
    }
  }
  return StatusCode::SUCCESS;
}

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_chargeAngularFactor

double MuonR4::sTgcDigitMaker::m_chargeAngularFactor {4.0}

private

Definition at line 254 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

254{4.0};

◆ m_clusterParams

std::array<double, 2> MuonR4::sTgcDigitMaker::m_clusterParams {0.573, 1.092}

staticconstexprprivate

Definition at line 231 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

231{0.573, 1.092};

◆ m_detMgr

const MuonGMR4::MuonDetectorManager* MuonR4::sTgcDigitMaker::m_detMgr {nullptr}

private

Definition at line 222 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

222{nullptr};

◆ m_digitMode

digitMode MuonR4::sTgcDigitMaker::m_digitMode {digitMode::AllChType}

private

define offsets and widths of time windows for signals from wiregroups and strips.

The offsets are defined as relative time diffference with respect to the time after TOF and cable length corrections. Bunch crossing time is specified.

Definition at line 241 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

241{digitMode::AllChType};

MuonR4::sTgcDigitMaker::digitMode::AllChType

@ AllChType

Definition MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h:44

◆ m_doPadSharing

bool MuonR4::sTgcDigitMaker::m_doPadSharing {false}

private

Definition at line 244 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

244{false};

◆ m_doTimeOffsetStrip

bool MuonR4::sTgcDigitMaker::m_doTimeOffsetStrip {false}

private

Definition at line 247 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

247{false};

◆ m_gammaParameter

std::vector<GammaParameter> MuonR4::sTgcDigitMaker::m_gammaParameter

private

Definition at line 218 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

◆ m_idHelper

const sTgcIdHelper& MuonR4::sTgcDigitMaker::m_idHelper {m_idHelperSvc->stgcIdHelper()}

private

Definition at line 224 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

224{m_idHelperSvc->stgcIdHelper()};

◆ m_idHelperSvc

const Muon::IMuonIdHelperSvc* MuonR4::sTgcDigitMaker::m_idHelperSvc {m_detMgr->idHelperSvc()}

private

Definition at line 223 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

223{m_detMgr->idHelperSvc()};

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_meanGasGain

double MuonR4::sTgcDigitMaker::m_meanGasGain {5.e4}

private

Definition at line 243 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

243{5.e4}; // mean gain estimated from ATLAS note "ATL-MUON-PUB-2014-001"

◆ m_mostProbableArrivalTime

std::array<double, 5> MuonR4::sTgcDigitMaker::m_mostProbableArrivalTime {make_array<double, 5>(0.)}

private

Definition at line 219 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

219{make_array<double, 5>(0.)};

make_array

constexpr std::array< T, N > make_array(const T &def_val)

Helper function to initialize in-place arrays with non-zero values.

Definition ArrayHelper.h:10

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_posResAngular

double MuonR4::sTgcDigitMaker::m_posResAngular {0.305/m_StripResolution}

private

Definition at line 251 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

251{0.305/m_StripResolution};

◆ m_posResIncident

double MuonR4::sTgcDigitMaker::m_posResIncident {1.}

private

Definition at line 250 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

250{1.};

◆ m_StripResolution

double MuonR4::sTgcDigitMaker::m_StripResolution {0.0949}

private

Definition at line 249 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

249{0.0949};

◆ m_theta

double MuonR4::sTgcDigitMaker::m_theta {10}

private

Definition at line 242 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

242{10}; // theta=10 value best matches the PDF

◆ m_timeOffsetStrip

std::array<double, 6> MuonR4::sTgcDigitMaker::m_timeOffsetStrip {make_array<double, 6>(0.)}

private

Definition at line 220 of file MuonPhaseII/MuonDigitization/sTgcDigitizationR4/sTgcDigitizationR4/sTgcDigitMaker.h.

220{make_array<double, 6>(0.)};

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ ReadoutChannelType

◆ sTgcDigitVec

◆ TimedHit

Member Enumeration Documentation

◆ digitMode

Constructor & Destructor Documentation

◆ sTgcDigitMaker()

◆ ~sTgcDigitMaker()

Member Function Documentation

◆ addDigit()

◆ calculateTotalCharge()

◆ chargeIntegral()

◆ executeDigi()

◆ getGammaParameter()

◆ getIonizationPoint()

◆ getMostProbableArrivalTime()

◆ getPadChargeFraction()

◆ getTimeOffsetStrip()

◆ initialize()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ pointClosestApproach()

◆ processPadChargeSharing()

◆ processPadDigitization()

◆ processStripChargeSharing()

◆ processStripDigitization()

◆ processWireDigitization()

◆ readFileOfTimeArrival()

◆ readFileOfTimeOffsetStrip()

◆ setLevel()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_chargeAngularFactor

◆ m_clusterParams

◆ m_detMgr

◆ m_digitMode

◆ m_doPadSharing

◆ m_doTimeOffsetStrip

◆ m_gammaParameter

◆ m_idHelper

◆ m_idHelperSvc

◆ m_imsg

◆ m_lvl

◆ m_meanGasGain

◆ m_mostProbableArrivalTime

◆ m_msg_tls

◆ m_nm

◆ m_posResAngular

◆ m_posResIncident

◆ m_StripResolution

◆ m_theta

◆ m_timeOffsetStrip