MuonG4R4::MdtSensitiveDetector Class Reference

#include <MdtSensitiveDetector.h>

Inheritance diagram for MuonG4R4::MdtSensitiveDetector:

Collaboration diagram for MuonG4R4::MdtSensitiveDetector:

Public Member Functions
	~MdtSensitiveDetector ()=default
	Default destructor.
virtual G4bool	ProcessHits (G4Step *aStep, G4TouchableHistory *ROhist) override final
	MuonSensitiveDetector (const std::string &name, const std::string &output_key, const std::string &trf_storeKey, const MuonGMR4::MuonDetectorManager *detMgr)
	Recylce the constructor from the MuonSensitiveDetector.
virtual void	Initialize (G4HCofThisEvent *HCE) override final
	Create the output container at the beginning of the event.
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.

Protected Member Functions
xAOD::MuonSimHit *	lastSnapShot (const Identifier &gasGapId, const G4Step *hitStep)
	Returns the last snap shot of the traversing particle.
bool	processStep (const G4Step *step) const
	Checks whether the current step shall be processed at all.
const EventContext &	eventContext () const
	Returns the current event context recorded in the G4 event info.
ActsTrk::GeometryContext	getGeoContext () const
	Returns the current geometry context in the event.
HepMcParticleLink	genParticleLink (const G4Track *track) const
	Generates a HepMcParticleLink for the Geant4 track using the current event store.
xAOD::MuonSimHit *	propagateAndSaveStrip (const Identifier &hitId, const Amg::Transform3D &toGasGap, const G4Step *hitStep)
	Records the G4Step in the sim hit.
xAOD::MuonSimHit *	saveHit (const Identifier &hitId, const Amg::Vector3D &hitPos, const Amg::Vector3D &hitDir, const double globTime, const G4Step *hitStep)
	Saves the current Step as a xAOD::MuonSimHit snapshot.

Protected Attributes
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
	Pointer to the underlying detector manager.

Private Member Functions
const MuonGMR4::MdtReadoutElement *	getReadoutElement (const G4TouchableHistory *touchHist) const
	Retrieves the MuonReadoutElement associated to the multilayer in which the energy deposit is taking place.
Identifier	getIdentifier (const ActsTrk::GeometryContext &gctx, const MuonGMR4::MdtReadoutElement *reElement, const G4TouchableHistory *touchHist) const
	Constructs the identifier of the actual tube where the energy deposit is taking place.
AtlasG4EventUserInfo *	eventInfo () const
	Returns the event user info for the current G4 event, if available.
xAOD::MuonSimHit *	lastSnapShot (const Identifier &gasGapId, const G4Step *hitStep, const HepMcParticleLink &particleLink)
	Returns the last snap shot matching an already generated HepMcParticleLink.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_writeKey {}
	Key under which the output container is stored in the G4 event.
xAOD::MuonSimHitContainer *	m_outContainer {}
	Pointer to the MuonSimHit output container.
AtlasG4EventUserInfo *	m_g4UserEventInfo {}
	G4 event user information holding the current event store/context.
SG::ReadHandleKey< ActsTrk::DetectorAlignStore >	m_trfCacheKey
	ReadHandleKey to the DetectorAlignmentStore caching the relevant transformations needed in this event.
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).

Detailed Description

Definition at line 44 of file MdtSensitiveDetector.h.

Constructor & Destructor Documentation

~MdtSensitiveDetector()

MuonG4R4::MdtSensitiveDetector::~MdtSensitiveDetector ( )

default

Default destructor.

Member Function Documentation

eventContext()

const EventContext & MuonG4R4::MuonSensitiveDetector::eventContext ( ) const

protectedinherited

Returns the current event context recorded in the G4 event info.

Definition at line 54 of file MuonSensitiveDetector.cxx.

                                                                  {
        AtlasG4EventUserInfo* g4EventInfo = eventInfo();
        if (!g4EventInfo) {
            THROW_EXCEPTION("No AtlasG4EventUserInfo available");
        }
        return g4EventInfo->GetEventContext();
    }

eventInfo()

AtlasG4EventUserInfo * MuonG4R4::MuonSensitiveDetector::eventInfo ( ) const

privateinherited

Returns the event user info for the current G4 event, if available.

Definition at line 51 of file MuonSensitiveDetector.cxx.

                                                                 {
        return m_g4UserEventInfo ? m_g4UserEventInfo : AtlasG4EventUserInfo::GetEventUserInfo();
    }

genParticleLink()

HepMcParticleLink MuonG4R4::MuonSensitiveDetector::genParticleLink ( const G4Track * track ) const

protectedinherited

Generates a HepMcParticleLink for the Geant4 track using the current event store.

Parameters

track

the track for which particle link should be created

Definition at line 87 of file MuonSensitiveDetector.cxx.

                                                                                       {
        TrackHelper trHelper{track};
        AtlasG4EventUserInfo* g4EventInfo = eventInfo();
        return trHelper.GenerateParticleLink(g4EventInfo ? g4EventInfo->GetEventStore() : nullptr);
    }

getGeoContext()

ActsTrk::GeometryContext MuonG4R4::MuonSensitiveDetector::getGeoContext ( ) const

protectedinherited

Returns the current geometry context in the event.

Definition at line 61 of file MuonSensitiveDetector.cxx.

                                                                      {
        ActsTrk::GeometryContext gctx{};
        const ActsTrk::DetectorAlignStore* alignment{nullptr};
        if (!SG::get(alignment, m_trfCacheKey, eventContext()).isSuccess()) {
            THROW_EXCEPTION("Failed to retrieve "<<m_trfCacheKey.fullKey()<<".");
        }
        gctx.setStore(std::make_unique<DetectorAlignStore>(*alignment));
        return gctx;
    }

getIdentifier()

Identifier MuonG4R4::MdtSensitiveDetector::getIdentifier ( const ActsTrk::GeometryContext & gctx, const MuonGMR4::MdtReadoutElement * reElement, const G4TouchableHistory * touchHist ) const

private

Constructs the identifier of the actual tube where the energy deposit is taking place.

@gctx: Geometry context to access the local -> global transform of the readout element

Parameters

reElement	The readout element associated with the multi layer
touchHist	Touchable history of the G4 track to fetch the transform of the G4 volume

The Geant transform takes a hit global -> local --> inverse goes back to the global system Compose this one with the global to local transformation of the first tube in the layer -->

equilateral triangle

Update the reference tube position to be in the proper layer

It can happen that the tube is assigned to zero by numerical precision Catch these cases if the layer is fine

Definition at line 106 of file MdtSensitiveDetector.cxx.

                                                                                          {
   const Amg::Transform3D localToGlobal{getTransform(touchHist, 0)};
   Amg::Vector3D refTubePos = (readOutEle->globalToLocalTransform(gctx, readOutEle->measurementHash(1,1)) * localToGlobal).translation();
   ATH_MSG_VERBOSE("Position of the tube wire w.r.t. the first tube in the multi layer "<<Amg::toString(refTubePos, 2));
   static const double layerPitch = 1./ std::sin(60*Gaudi::Units::deg);
   const int layer = std::round(refTubePos.x() * layerPitch / readOutEle->tubePitch()) +1;
   if (layer <= 0) {
      THROW_EXCEPTION("Tube hit in nirvana -- It seems that the tube position "
                      <<Amg::toString(refTubePos, 2)<<", perp: "<<refTubePos.perp()
                      <<" is outside of the volume envelope "
                      <<m_detMgr->idHelperSvc()->toStringDetEl(readOutEle->identify())<<". ");      
   }
   refTubePos  = (readOutEle->globalToLocalTransform(gctx, readOutEle->measurementHash(layer,1)) * localToGlobal).translation();
   const double tubePitches = refTubePos.y() / readOutEle->tubePitch();
   unsigned int tube = std::round(tubePitches) + 1;
   tube = std::max(1u, std::min(readOutEle->numTubesInLay(), tube));
  const Amg::Transform3D closureCheck{readOutEle->globalToLocalTransform(gctx, 
                                      readOutEle->measurementHash(layer, tube))*localToGlobal};
    if (!Amg::isIdentity(closureCheck)) {
        ATH_MSG_WARNING("Correction needed "<<layer<<","<<tube<<" "<<Amg::toString(closureCheck));
        if (closureCheck.translation().y() > 0) ++tube;
        else --tube;
    }
   
   const IdentifierHash tubeHash = readOutEle->measurementHash(layer, tube);
   const Identifier tubeId = readOutEle->measurementId(tubeHash);
   {
        const Amg::Transform3D closureCheck{readOutEle->globalToLocalTransform(gctx, tubeHash)*localToGlobal};
        if (!Amg::isIdentity(closureCheck)) {
            THROW_EXCEPTION("Tube hit in Nirvana --  It seems that the tube position "
                             <<Amg::toString(refTubePos, 2)<<", perp: "<<refTubePos.perp()
                             <<" is outside of the volume envelope "
                             <<m_detMgr->idHelperSvc()->toStringDetEl(readOutEle->identify())<<". "
                             <<"Layer: "<<layer<<", tube: "<<tube<<" "
                             <<Amg::toString(closureCheck)
                             <<"tube volume : "<<touchHist->GetVolume(0)->GetName()
                             <<" mdt chamber: "<<touchHist->GetVolume(2)->GetName());    
        }
   }
   ATH_MSG_VERBOSE("Tube & layer number candidate "<<tube<<", "<<layer<<" back and forth transformation "
                     <<Amg::toString(closureCheck));
   return tubeId;  
}

getReadoutElement()

const MuonGMR4::MdtReadoutElement * MuonG4R4::MdtSensitiveDetector::getReadoutElement ( const G4TouchableHistory * touchHist ) const

private

Retrieves the MuonReadoutElement associated to the multilayer in which the energy deposit is taking place.

Parameters

touchHist

Touchable history of the G4 track to find the proper volume name from which the re element can be deduced

The third volume in the history is the volume corresponding to the Muon multilayer

Find the Detector element from the Identifier

Build first the Identifier to find the detector element

Then retrieve the Detector element

Definition at line 22 of file MdtSensitiveDetector.cxx.

                                                                                                                  {
   const std::string stationVolume = touchHist->GetVolume(2)->GetName();
   using namespace MuonGMR4;
   const std::vector<std::string> volumeTokens = tokenize(stationVolume, "_");
   ATH_MSG_VERBOSE("Name of the station volume is "<<stationVolume);
   if (volumeTokens.size() != 5) {
      THROW_EXCEPTION(" Cannot deduce the station name from "<<stationVolume);
   }
   const std::string stName = volumeTokens[0].substr(0,3);
   const int stationEta = atoi(volumeTokens[2]);
   const int stationPhi = atoi(volumeTokens[3]);
   const int multiLayer = atoi(volumeTokens[4]);
   const MdtIdHelper& idHelper{m_detMgr->idHelperSvc()->mdtIdHelper()};
   const Identifier detElId = idHelper.multilayerID(idHelper.elementID(stName,stationEta, stationPhi), multiLayer);
   const MdtReadoutElement* readOutEle = m_detMgr->getMdtReadoutElement(detElId);
   if (!readOutEle) {
      THROW_EXCEPTION(" Failed to retrieve a valid detector element from "
                     <<m_detMgr->idHelperSvc()->toStringDetEl(detElId)<<" "<<stationVolume);
   }
   return readOutEle;
}

Initialize()

void MuonG4R4::MuonSensitiveDetector::Initialize ( G4HCofThisEvent * HCE )

finaloverridevirtualinherited

Create the output container at the beginning of the event.

Definition at line 38 of file MuonSensitiveDetector.cxx.

                                                           {
        m_g4UserEventInfo = AtlasG4EventUserInfo::GetEventUserInfo();
        if (m_g4UserEventInfo) {
            auto* hitVec = m_g4UserEventInfo->GetHitCollectionMap()->Find<MuonSimHitsVec>(m_writeKey);
            if (!hitVec) {
                THROW_EXCEPTION("The event does not contain a MuonSimHit container called '"<<m_writeKey<<"'");
            }
            m_outContainer = hitVec->container.get();
            ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Retrieved '"<<m_writeKey<<"'.");
        } else {
            m_outContainer = nullptr;
        }
    }

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;
  }
}

lastSnapShot() [1/2]

xAOD::MuonSimHit * MuonG4R4::MuonSensitiveDetector::lastSnapShot ( const Identifier & gasGapId, const G4Step * hitStep )

protectedinherited

Returns the last snap shot of the traversing particle.

The G4 track must have stepped through the same volume. Otherwise, a nullptr is returned

Parameters

gasGapId	Identifier of the gasGap to consider
hitStep	Pointer to the current step

Definition at line 167 of file MuonSensitiveDetector.cxx.

                                                                                 {
        const HepMcParticleLink particleLink{genParticleLink(hitStep->GetTrack())};
        return lastSnapShot(hitId, hitStep, particleLink);
    }

lastSnapShot() [2/2]

xAOD::MuonSimHit * MuonG4R4::MuonSensitiveDetector::lastSnapShot ( const Identifier & gasGapId, const G4Step * hitStep, const HepMcParticleLink & particleLink )

privateinherited

Returns the last snap shot matching an already generated HepMcParticleLink.

Parameters

gasGapId	Identifier of the gasGap to consider
hitStep	Pointer to the current step .
particleLink	the existing particle link for the G4Track

There's only a snapshot if the last saved hit has the same Identifier & the same particle Link + G4Track Id

Definition at line 172 of file MuonSensitiveDetector.cxx.

                                                                                                 {
        if (m_outContainer->empty() || 
            m_outContainer->back()->identify() != hitId ||
            particleLink != m_outContainer->back()->genParticleLink() ||
            dec_G4TrkId(*m_outContainer->back()) != hitStep->GetTrack()->GetTrackID()) {
            return nullptr;
        }
        return m_outContainer->back();
    }

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 167 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 182 of file AthMessaging.h.

{ return msg() << lvl; }

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 user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

MuonSensitiveDetector()

MuonG4R4::MuonSensitiveDetector::MuonSensitiveDetector	(	const std::string &	name,
		const std::string &	output_key,
		const std::string &	trf_storeKey,
		const MuonGMR4::MuonDetectorManager *	detMgr )

Recylce the constructor from the MuonSensitiveDetector.

Definition at line 42 of file MuonSensitiveDetector.cxx.

                                                                                           :
        G4VSensitiveDetector{name},
        AthMessaging{name},
        m_writeKey{output_key},
        m_trfCacheKey{trfStore_key},
        m_detMgr{detMgr} {
        m_trfCacheKey.initialize().ignore();
    }

ProcessHits()

G4bool MuonG4R4::MdtSensitiveDetector::ProcessHits ( G4Step * aStep, G4TouchableHistory * ROhist )

finaloverridevirtual

Check whether the detector is sensitive to the traversing particle

Calculate the closest approach of the track w.r.t. the wire. We're starting with the post step position and if, there's a closer approach to the wire from that, the propagation distance will be always less than zero. Otherwise one would need to go forward along the trajectory

Closest approach of the step

Definition at line 48 of file MdtSensitiveDetector.cxx.

                                                                            {

    if (!processStep(aStep)) {
      return true;
    }
    G4Track* currentTrack = aStep->GetTrack();
    const G4StepPoint* preStep = aStep->GetPreStepPoint();
    const G4TouchableHistory* touchHist = static_cast<const G4TouchableHistory*>(preStep->GetTouchable());
    const MdtReadoutElement* reEle{getReadoutElement(touchHist)};
 
    const ActsTrk::GeometryContext gctx{getGeoContext()};
 
    const Identifier HitID = getIdentifier(gctx, reEle, touchHist);
    if (!HitID.is_valid()) {
        ATH_MSG_VERBOSE("No valid hit found");
        return true;
    }
 
    const Amg::Transform3D globalToLocal{reEle->globalToLocalTransform(gctx, reEle->measurementHash(HitID))};
 
    // transform pre and post step positions to local positions
    const Amg::Vector3D prePosition{Amg::Hep3VectorToEigen(preStep->GetPosition())};
    const Amg::Vector3D postPosition{Amg::Hep3VectorToEigen(aStep->GetPostStepPoint()->GetPosition())};
    
    const Amg::Vector3D trackDirection{(postPosition - prePosition).unit()};
 
    const Amg::Vector3D trackLocPos{globalToLocal * prePosition};  
    const Amg::Vector3D trackLocDir{globalToLocal.linear()* trackDirection};
  
    double lambda = Amg::intersect<3>(Amg::Vector3D::Zero(), Amg::Vector3D::UnitZ(),
                                      trackLocPos, trackLocDir).value_or(0);
    if (std::abs(currentTrack->GetDefinition()->GetPDGEncoding()) == 11) {
        lambda = std::clamp(lambda, 0., aStep->GetStepLength());
    }
    const Amg::Vector3D driftHit{trackLocPos + lambda * trackLocDir};
 
 
    const double globalTime{preStep->GetGlobalTime() +  lambda / currentTrack->GetVelocity()};
 
    if (std::abs(currentTrack->GetDefinition()->GetPDGEncoding()) == 11) {
        const xAOD::MuonSimHit* lastRecord = lastSnapShot(HitID, aStep);
        if (lastRecord && lastRecord->localPosition().perp() < driftHit.perp()) {
            return true;
        }
    }
  
    ATH_MSG_VERBOSE(" Dumping of hit "<<m_detMgr->idHelperSvc()->toString(HitID)
                  <<", barcode: "<<genParticleLink(currentTrack).barcode()
                  <<", "<<(*currentTrack) <<", driftCircle: "<<Amg::toString(driftHit, 4)
                  <<", direction "<<Amg::toString(trackLocDir, 4) <<" to SimHit container ahead. ");
    saveHit(HitID, driftHit, trackLocDir, globalTime, aStep);
    return true;
}

processStep()

bool MuonG4R4::MuonSensitiveDetector::processStep ( const G4Step * step ) const

protectedinherited

Checks whether the current step shall be processed at all.

I.e. the particle needs to be charged, there's a minimum velocity needed and the step length must not vanish

Parameters

step	G4 step to consider

Reject secondary particles

Sensitive detector is only sensitive to charged particles or Geantinos

Definition at line 70 of file MuonSensitiveDetector.cxx.

                                                                     {
        const G4Track* currentTrack = aStep->GetTrack();
        ATH_MSG_VERBOSE("Check whether step pdgId: "<<(*currentTrack)<<" will be processed.");
        constexpr double velCutOff = 10.*Gaudi::Units::micrometer / Gaudi::Units::second;
        if (aStep->GetStepLength() < std::numeric_limits<float>::epsilon() || currentTrack->GetVelocity() < velCutOff) {
            ATH_MSG_VERBOSE("Step length is too short ");
            return false;
        }
        if (currentTrack->GetDefinition()->GetPDGCharge() == 0.0) {
            ATH_MSG_VERBOSE("Particle is neutral");
            return currentTrack->GetDefinition() == G4Geantino::GeantinoDefinition() ||
                   currentTrack->GetDefinition() == G4ChargedGeantino::ChargedGeantinoDefinition();
        }
        return true;
    }

propagateAndSaveStrip()

xAOD::MuonSimHit * MuonG4R4::MuonSensitiveDetector::propagateAndSaveStrip ( const Identifier & hitId, const Amg::Transform3D & toGasGap, const G4Step * hitStep )

protectedinherited

Records the G4Step in the sim hit.

Hits are usually expressed at the center point of the step. Except for low-energy electrons where the endpoint of the random walk path is just extended

Parameters

hitId	Identifier of the gas gap or the tube in which the hit is recorded
toGaGap	Transform from the ATLAS global coordinates into the sensitive volume
hitStep	Step from which the particle's information and the pre and post step positions are fetched

Fetch the step end-points

Hit direction as the momentum direction

Electrons randomly work through the gas instead of drifting through the gas -> take the prestep of the first snap shop inside the gas as pre step point

Definition at line 92 of file MuonSensitiveDetector.cxx.

                                                                                        {
        
        const G4Track* currentTrack = aStep->GetTrack();
        const Amg::Vector3D locPostStep{toGasGap*Amg::Hep3VectorToEigen(aStep->GetPostStepPoint()->GetPosition())};
        Amg::Vector3D locPreStep{toGasGap*Amg::Hep3VectorToEigen(aStep->GetPreStepPoint()->GetPosition())};

        Amg::Vector3D locHitDir = toGasGap.linear() * Amg::Hep3VectorToEigen(currentTrack->GetMomentumDirection());

        xAOD::MuonSimHit* prevHit = lastSnapShot(hitID, aStep);
        if (std::abs(currentTrack->GetParticleDefinition()->GetPDGEncoding()) == 11 && prevHit) {
            locPreStep = xAOD::toEigen(prevHit->localPosition()) - 0.5* prevHit->stepLength() * 
                        xAOD::toEigen(prevHit->localDirection());
 
            locHitDir = (locPostStep - locPreStep).unit();
        }
        const Amg::Vector3D locHitPos = 0.5* (locPreStep + locPostStep);
        ATH_MSG_VERBOSE( m_detMgr->idHelperSvc()->toStringGasGap(hitID)<<" - track: "<<(*currentTrack)
                        <<", deposit: "<<aStep->GetTotalEnergyDeposit()<<", -- local coords: "
                        <<"prestep: "<<Amg::toString(locPreStep)<<",  post step: "<<Amg::toString(locPostStep) 
                        <<" mid point: "<< Amg::toString(locHitPos)<<", direction: "<<Amg::toString(locHitDir)
                        <<", deposit: "<<aStep->GetTotalEnergyDeposit());
 
        const double globalTime = currentTrack->GetGlobalTime() + locHitDir.dot(locPostStep - locHitPos) / currentTrack->GetVelocity();
  
        xAOD::MuonSimHit* newHit = saveHit(hitID, locHitPos, locHitDir, globalTime, aStep);
        if (prevHit) {
            newHit->setStepLength((locPostStep - locPreStep).mag());
        }
        return newHit;
    }

saveHit()

xAOD::MuonSimHit * MuonG4R4::MuonSensitiveDetector::saveHit ( const Identifier & hitId, const Amg::Vector3D & hitPos, const Amg::Vector3D & hitDir, const double globTime, const G4Step * hitStep )

protectedinherited

Saves the current Step as a xAOD::MuonSimHit snapshot.

Parameters

hitId	Identifier of the gasGap/ tube where the hit was deposited
hitPos	Local position of the hit expressed w.r.t gas gap coordinate system
hitDir	Local direction of the hit expressed w.r.t gas gap coordinate system
globTime	Global time of the hit
hitStep	Pointer to the step from which the hit information was derived.

Definition at line 128 of file MuonSensitiveDetector.cxx.

                                                                          {
        const G4Track* currentTrack = aStep->GetTrack();
        const HepMcParticleLink particleLink{genParticleLink(currentTrack)};
        // If Geant4 propagates the same track through the same volume just update the last hit and don't write a new one
        xAOD::MuonSimHit* hit = lastSnapShot(hitId, aStep, particleLink);
        bool newHit{false};
        if (!hit) {
            if (!m_outContainer) {
                THROW_EXCEPTION("Cannot find container '"<<m_writeKey<<"'.");
            }
            hit = m_outContainer->push_back(std::make_unique<xAOD::MuonSimHit>());
            newHit = true;
        }
        dec_G4TrkId(*hit) = currentTrack->GetTrackID();
        hit->setIdentifier(hitId); 
        hit->setLocalPosition(xAOD::toStorage(hitPos));  
        hit->setLocalDirection(xAOD::toStorage(hitDir));
        hit->setMass(currentTrack->GetDefinition()->GetPDGMass());
        hit->setGlobalTime(globTime);
        hit->setPdgId(currentTrack->GetDefinition()->GetPDGEncoding());
        hit->setEnergyDeposit(aStep->GetTotalEnergyDeposit() + (newHit ? 0. : hit->energyDeposit()));
        hit->setKineticEnergy(currentTrack->GetKineticEnergy());
        hit->setGenParticleLink(particleLink);
        hit->setStepLength(aStep->GetStepLength());
        
        ATH_MSG_VERBOSE("Save new hit "<<m_detMgr->idHelperSvc()->toString(hitId)
                        <<", pdgId: "<<hit->pdgId()
                        <<", "<<particleLink
                        <<", trackId: "<<currentTrack->GetTrackID()<<", "
                        <<", "<<particleLink.cptr()<<std::endl
                        <<"pos: "<<Amg::toString(hitPos)<<", dir: "<<Amg::toString(hitDir)<<", time: "<<globTime
                        <<", energy: "<<hit->kineticEnergy()<<", stepLength: "<<hit->stepLength()<<", "
                        <<", deposit energy: "<<hit->energyDeposit());
        return hit;
    }

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_detMgr

const MuonGMR4::MuonDetectorManager* MuonG4R4::MuonSensitiveDetector::m_detMgr {nullptr}

protectedinherited

Pointer to the underlying detector manager.

Definition at line 123 of file MuonSensitiveDetector.h.

{nullptr};

m_g4UserEventInfo

AtlasG4EventUserInfo* MuonG4R4::MuonSensitiveDetector::m_g4UserEventInfo {}

privateinherited

G4 event user information holding the current event store/context.

Definition at line 58 of file MuonSensitiveDetector.h.

{};

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

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_outContainer

xAOD::MuonSimHitContainer* MuonG4R4::MuonSensitiveDetector::m_outContainer {}

privateinherited

Pointer to the MuonSimHit output container.

Definition at line 56 of file MuonSensitiveDetector.h.

{};

m_trfCacheKey

SG::ReadHandleKey<ActsTrk::DetectorAlignStore> MuonG4R4::MuonSensitiveDetector::m_trfCacheKey

privateinherited

ReadHandleKey to the DetectorAlignmentStore caching the relevant transformations needed in this event.

Definition at line 61 of file MuonSensitiveDetector.h.

m_writeKey

std::string MuonG4R4::MuonSensitiveDetector::m_writeKey {}

privateinherited

Key under which the output container is stored in the G4 event.

Definition at line 54 of file MuonSensitiveDetector.h.

{};

---

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

• MdtSensitiveDetector.h
• MdtSensitiveDetector.cxx