MDTSensitiveDetector Class Reference

#include <MDTSensitiveDetector.h>

Inheritance diagram for MDTSensitiveDetector:

Collaboration diagram for MDTSensitiveDetector:

Public Member Functions
	MDTSensitiveDetector (const std::string &name, const std::string &hitCollectionName, const unsigned int nTubesMax)
	construction/destruction
void	Initialize (G4HCofThisEvent *HCE) override final
	member functions
G4bool	ProcessHits (G4Step *aStep, G4TouchableHistory *ROhist) override final

Private Member Functions
	FRIEND_TEST (MDTSensitiveDetectortest, Initialize)
	FRIEND_TEST (MDTSensitiveDetectortest, ProcessHits)
	FRIEND_TEST (MDTSensitiveDetectortest, GetIdentifier)
int	GetIdentifier (const G4TouchableHistory *touchHist)

Private Attributes
std::string	m_hitCollectionName
	member data
MDTSimHitCollection *	m_MDTHitColl {nullptr}
AtlasG4EventUserInfo *	m_g4UserEventInfo {nullptr}
const MdtHitIdHelper *	m_muonHelper
double	m_driftRadius
double	m_globalTime
Amg::Vector3D	m_localPosition
double	m_DEFAULT_TUBE_RADIUS
	radius assigned to radius if radius is invalid

Detailed Description

Author

danie.nosp@m.la.r.nosp@m.ebuzz.nosp@m.i@pv.nosp@m..infn.nosp@m..it

nveld.nosp@m.ik@n.nosp@m.ikhef.nosp@m..nl

Class methods and properties

The method MDTSensitiveDetector::ProcessHits is executed by the G4 kernel each time a charged particle (or a geantino) crosses one of the MDT Sensitive Gas volumes.

Once a G4Step is perfomed by the particle in the sensitive volume (both when the particle leaves the tube or stops in it), Pre and PostStepPositions are tranformed into local coordinates (chamber reference system, with Z along the tube direction and XY tranversal plane) and used to calculate the local direction of the track.

Two cases are given: 1) the particle over-passed the wire: here the drift radius (the impact parameter) is computed as the local direction distance from the wire;
2) the step doesn't allow the particle to over-pass the wire: here the shortest distance to the wire, which is one of the two end-points, is calculated for each step which occurs inside the sensitive volumes and only the closer one is kept; this case includes also the hard scattering case inside the sensitive volume.

Navigating with the touchableHistory method GetHistoryDepth() through the hierarchy of the volumes crossed by the particles, the MDTSensitiveDetector determinates the correct set of geometry parameters to be folded in the Simulation Identifier associated to each hit. The MDT SimIDs are 32-bit unsigned integers, built using the MuonSimEvent/MdtHitIdHelper class which inherits from the MuonHitIdHelper base class.

We describe in the following, how each field of the identifier is retrieved.

1) stationName, stationEta, stationPhi: when a volume is found in the hierarchy, whose name contains the substring "station", the stationName is extracted from the volume's name; stationPhi and stationEta are calculated starting from the volume copy number, assigned by MuonGeoModel.

2) multilayer: when a volume is found in the hierarchy, whose name contains the substring "component", the multilayer is set to 1 or to 2, according to the component number (multilayer=1 if the component is 1, 5 or 8; multilayer=2 if the component is 3, 7, 8, 10, 11 or 14).

3) tubeLayer and tube: when a volume is found in the hierarchy, whose name contains the substring "Drift", tubeLayer and tube are calculated starting from the Drift volume copy number.

notes:

1) this implementation of the MDT Sensitive Detectors can handle different situations: hard scattering of the muon on the sensitive volume (its direction changes), soft secondary particles completely included in the sensitive volume, muon hits masked by secondaries, like delta rays.

2) for each hit, the time of flight (the G4 globalTime), is recorded and associated to the hit.

3) more than none MDT hit can occur in the same tube. The hit selection is done at the level of the digitization procedure.

4) the MDTHit object contains: the SimID, the drift radius and the globalTime.

Definition at line 85 of file MDTSensitiveDetector.h.

Constructor & Destructor Documentation

MDTSensitiveDetector()

MDTSensitiveDetector::MDTSensitiveDetector	(	const std::string &	name,
		const std::string &	hitCollectionName,
		const unsigned int	nTubesMax )

construction/destruction

Definition at line 24 of file MDTSensitiveDetector.cxx.

  : G4VSensitiveDetector( name )
  , m_hitCollectionName( hitCollectionName )
  , m_driftRadius(0.)
  , m_globalTime(0.)
  , m_DEFAULT_TUBE_RADIUS( std::numeric_limits<double>::max() )
{
  m_muonHelper = MdtHitIdHelper::GetHelper(nTubesMax);
}

Member Function Documentation

FRIEND_TEST() [1/3]

MDTSensitiveDetector::FRIEND_TEST ( MDTSensitiveDetectortest , GetIdentifier  )

private

FRIEND_TEST() [2/3]

MDTSensitiveDetector::FRIEND_TEST ( MDTSensitiveDetectortest , Initialize  )

private

FRIEND_TEST() [3/3]

MDTSensitiveDetector::FRIEND_TEST ( MDTSensitiveDetectortest , ProcessHits  )

private

GetIdentifier()

int MDTSensitiveDetector::GetIdentifier ( const G4TouchableHistory * touchHist )

private

Definition at line 145 of file MDTSensitiveDetector.cxx.

{
  // attributes of the MDT identifier construction
  std::string stationName;
  int         stationEta=1;
  int         stationPhi=1;
  int         multilayer=1;
  int         tubeLayer=1;
  int         tube=1;
 
  bool isAssembly = false;
  // scan geometry tree to identify the tube
  for (int i = touchHist->GetHistoryDepth(); i>=0; i--) {
 
    std::string::size_type npos;
    std::string::size_type loc1;
    std::string::size_type loc2;
    std::string volName = touchHist->GetVolume(i)->GetName();
 
    // check if this station is an assembly
    if ((npos = volName.find("av_")) != std::string::npos &&
        (npos = volName.find("impr_")) != std::string::npos)  isAssembly = true;
 
    // station: name, eta and phi (-> chamber!)
    if ((npos = volName.find("station")) != std::string::npos && (!isAssembly)) {
 
      volName.resize(npos-2);
      int volCopyNo = touchHist->GetVolume(i)->GetCopyNo();
      volCopyNo=volCopyNo%1000;
      stationName   = volName;
      stationEta    = volCopyNo/100;
      stationPhi    = abs(volCopyNo%100);
 
    }
    else if ((npos = volName.find("component")) != std::string::npos  && (!isAssembly)) {     // multilayer
 
      int gmID = 0;
      if ((loc1 = volName.find('[')) != std::string::npos) {
        if ((loc2 = volName.find(']', loc1+1)) != std::string::npos) {
          std::istringstream istrvar(volName.substr(loc1+1,loc2-loc1-1));
          istrvar>>gmID;
        }
      }
      multilayer = gmID;
 
    } else if ((npos = volName.find("MDT")) != std::string::npos && isAssembly) {
 
      // vol name for Assembly components are
      // av_WWW_impr_XXX_Muon::BMSxMDTxx_pv_ZZZ_NAME
      //                                               where WWW is ass. istance nr.
      //                                                     XXX is comp. imprint nr.
      //                                                     BMSxMDTxx is the name of the comp. log.Vol.
      //                                                        x station sub-type; xx technology subtype
      //                                                     ZZZ is the comp. number of order
      //                                                     NAME is the comp. tag (geoIdentifierTag)
      //                                                          for MDTs NAME is ml[1] or ml[2]
      // copy numbers for Ass.components are =
      //                CopyNoBase(= geoIdentifierTag of the assembly) + geoIdentifierTag of the component
      //                geoIdentifierTag of the component = Job
      //                geoIdentifierTag of the assembly = (sideC*10000 +
      //                             mirsign*1000 + abs(zi)*100 + fi+1)*100000;
      //                             mirsign*1000 + abs(zi)*100 + fi+1)*100000;
      //
      if ((loc1 = volName.find("Muon::")) != std::string::npos) {
        stationName = volName.substr(loc1+6,3);
      }
 
      int copyNr = touchHist->GetVolume(i)->GetCopyNo();
      int copyNrBase = int(copyNr/100000);
      int sideC  = int(copyNrBase/10000);
      int zi     = int((copyNrBase%1000)/100);
      int fi     = int(copyNrBase%100);
      if (sideC == 1) zi = -zi;
      stationEta = zi;
      stationPhi = fi;
 
      int gmID = 0;
      if ((loc1 = volName.find('[')) != std::string::npos) {
        if ((loc2 = volName.find(']', loc1+1)) != std::string::npos) {
          std::istringstream istrvar(volName.substr(loc1+1,loc2-loc1-1));
          istrvar>>gmID;
        }
      }
      multilayer = gmID;
    } else if ((npos = volName.find("Drift")) != std::string::npos) {         // layer and tube
      tubeLayer = touchHist->GetVolume(i)->GetCopyNo()/maxNTubesPerLayer;
      tube      = touchHist->GetVolume(i)->GetCopyNo()%maxNTubesPerLayer;
    }
  }
  //construct the hit identifier
  return m_muonHelper->BuildMdtHitId(stationName, stationPhi, stationEta, multilayer,tubeLayer, tube);
}

Initialize()

void MDTSensitiveDetector::Initialize ( G4HCofThisEvent * HCE )

finaloverride

member functions

Definition at line 35 of file MDTSensitiveDetector.cxx.

{
  m_MDTHitColl = nullptr;
  if (auto* eventInfo = AtlasG4EventUserInfo::GetEventUserInfo()) {
    m_MDTHitColl = eventInfo->GetHitCollectionMap()->Find<MDTSimHitCollection>(m_hitCollectionName);
    m_g4UserEventInfo = eventInfo;
  }
  m_driftRadius = m_DEFAULT_TUBE_RADIUS;
}

ProcessHits()

G4bool MDTSensitiveDetector::ProcessHits ( G4Step * aStep, G4TouchableHistory * ROhist )

finaloverride

Definition at line 45 of file MDTSensitiveDetector.cxx.

                                                                            {
 
  if (!m_MDTHitColl) {
    G4Exception("MDTSensitiveDetector::ProcessHits", "MDTHitCollectionMissing", FatalException,
                "Hit collection not initialized; did SetupEvent run?");
    return false;
  }
  G4Track* currentTrack = aStep->GetTrack();
 
  // MDTs sensitive to charged particle only
  if (currentTrack->GetDefinition()->GetPDGCharge() == 0.0) {
    if (currentTrack->GetDefinition()!=G4Geantino::GeantinoDefinition()) return true;
    else if (currentTrack->GetDefinition()==G4ChargedGeantino::ChargedGeantinoDefinition()) return true;
  }
 
  G4VPhysicalVolume*  physVolPostStep = aStep->GetPostStepPoint()->GetPhysicalVolume();
  if (nullptr == physVolPostStep)  return true;
 
  // hit information to be recorded
  double     globalTime;
  double     driftRadius;
  Amg::Vector3D localPosition;
  localPosition.setZero();
 
  // get top transformation
  const G4AffineTransform trans = currentTrack->GetTouchable()->GetHistory()->GetTopTransform();
 
  // transform pre and post step positions to local positions
 
  Amg::Vector3D localVertex1( Amg::Hep3VectorToEigen( trans.TransformPoint(aStep->GetPreStepPoint()->GetPosition()) ) );
  Amg::Vector3D localVertex2( Amg::Hep3VectorToEigen( trans.TransformPoint(aStep->GetPostStepPoint()->GetPosition()) ) );
 
  // calculate local direction from begin- and end-point of the step
  Amg::Vector3D localDirection( (localVertex2 - localVertex1) );  // normalized
  localDirection.z() = 0.;       // look in xy-plane
 
  // See if particle passed wire by projecting begin- and end-point on the step direction
  if( (localVertex2.dot(localDirection)) * (localVertex1.dot(localDirection)) < 0 ) { // particle passed wire
 
    // compute drift radius ( = impact parameter)
    double Xpos = localVertex1[0];
    double Ypos = localVertex1[1];
    double Xdir = localDirection[0];
    double Ydir = localDirection[1];
 
    double Alpha = -1*(Xpos*Xdir + Ypos*Ydir)/(Xdir*Xdir + Ydir*Ydir);   // localPosition*localDirection
 
    localPosition = localVertex1 + Alpha*(localVertex2-localVertex1);
    driftRadius = localPosition.perp();
    globalTime = aStep->GetPreStepPoint()->GetGlobalTime();  // take pre step time
 
  }else{   // particle didn't pass wire, one of the end-points is the shortest distance to the wire
 
    // calculate which of the two end-points is closer to the wire
    double dist1 = localVertex1.perp();
    double dist2 = localVertex2.perp();
    if( dist1 < dist2 ){  // first is closer
      driftRadius = dist1;
      localPosition = localVertex1;
      globalTime = aStep->GetPreStepPoint()->GetGlobalTime();
    }else{                // second is closer
      driftRadius = dist2;
      localPosition = localVertex2;
      globalTime = aStep->GetPostStepPoint()->GetGlobalTime();
    }
  }
 
  if( driftRadius < m_driftRadius ){  // check if current step came closer to the wire than the previous ones
    m_driftRadius = driftRadius;
    m_globalTime  = globalTime;
    m_localPosition = localPosition;
  }
 
  // check if particle left tube or stopped in tube
  G4String  namePreStepMat  = aStep->GetPreStepPoint()->GetMaterial()->GetName();
  G4String  namePostStepMat = aStep->GetPostStepPoint()->GetMaterial()->GetName();
  G4String  nameSD          = aStep->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetSensitiveDetector()->GetName();
  // G4int     trackid         = aStep->GetTrack()->GetTrackID();
  // see if we were in the sensitive volume and left it, or the particle was killed
  if( ((nameSD) && (namePreStepMat != namePostStepMat)) || (currentTrack->GetTrackStatus() ==  fStopAndKill)){
 
    // get identifier
    const G4TouchableHistory* touchHist = static_cast<const G4TouchableHistory*>(aStep->GetPreStepPoint()->GetTouchable());
    int MDTid = GetIdentifier(touchHist);
 
    TrackHelper trHelp(aStep->GetTrack());
 
    // construct new mdt hit
    m_MDTHitColl->Emplace(MDTid, m_globalTime, m_driftRadius, m_localPosition,
                          trHelp.GenerateParticleLink(m_g4UserEventInfo ? m_g4UserEventInfo->GetEventStore() : nullptr),
                          aStep->GetStepLength(),
                          aStep->GetTotalEnergyDeposit(),
                          currentTrack->GetDefinition()->GetPDGEncoding(),
                          aStep->GetPreStepPoint()->GetKineticEnergy());
 
    m_driftRadius = m_DEFAULT_TUBE_RADIUS; // reset start value of driftRadius
  }
  return true;
}

Member Data Documentation

m_DEFAULT_TUBE_RADIUS

double MDTSensitiveDetector::m_DEFAULT_TUBE_RADIUS

private

radius assigned to radius if radius is invalid

Definition at line 112 of file MDTSensitiveDetector.h.

m_driftRadius

double MDTSensitiveDetector::m_driftRadius

private

Definition at line 107 of file MDTSensitiveDetector.h.

m_g4UserEventInfo

AtlasG4EventUserInfo* MDTSensitiveDetector::m_g4UserEventInfo {nullptr}

private

Definition at line 104 of file MDTSensitiveDetector.h.

{nullptr};

m_globalTime

double MDTSensitiveDetector::m_globalTime

private

Definition at line 108 of file MDTSensitiveDetector.h.

m_hitCollectionName

std::string MDTSensitiveDetector::m_hitCollectionName

private

member data

Definition at line 102 of file MDTSensitiveDetector.h.

m_localPosition

Amg::Vector3D MDTSensitiveDetector::m_localPosition

private

Definition at line 109 of file MDTSensitiveDetector.h.

m_MDTHitColl

MDTSimHitCollection* MDTSensitiveDetector::m_MDTHitColl {nullptr}

private

Definition at line 103 of file MDTSensitiveDetector.h.

{nullptr};

m_muonHelper

const MdtHitIdHelper* MDTSensitiveDetector::m_muonHelper

private

Definition at line 105 of file MDTSensitiveDetector.h.

---

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

• MDTSensitiveDetector.h
• MDTSensitiveDetector.cxx