SensitiveDetectorBase Class Reference

Base class for Sensitive Detector implementation of PXD and SVD. More...

#include <SensitiveDetectorBase.h>

Inheritance diagram for SensitiveDetectorBase:

Public Member Functions
	SensitiveDetectorBase (SensorInfoBase *info)
	Constructor.
void	setOptions (bool seeNeutrons, bool onlyPrimaryTrueHits, float distanceTolerance, float electronTolerance, float minimumElectrons)
	Set all common options.
virtual	~SensitiveDetectorBase () override
	Destructor freeing the sensor Info.
SensorInfoBase *	getSensorInfo ()
	Return a pointer to the SensorInfo associated with this instance.
VxdID	getSensorID () const
	Return the VxdID belonging to this sensitive detector.

Static Public Member Functions
static const std::map< std::string, RelationArray::EConsolidationAction > &	getMCParticleRelations ()
	Return a list of all registered Relations with MCParticles.
static void	setActive (bool activeStatus)
	Enable/Disable all Sensitive Detectors.
static void	registerMCParticleRelation (const std::string &name, RelationArray::EConsolidationAction ignoreAction=RelationArray::c_negativeWeight)
	Register an relation involving MCParticles.
static void	registerMCParticleRelation (const RelationArray &relation, RelationArray::EConsolidationAction ignoreAction=RelationArray::c_negativeWeight)
	Overload to make it easer to register MCParticle relations.

Protected Member Functions
virtual int	saveTrueHit (const SensorTraversal &traversal)=0
	Save the actual TrueHit for this sensor traversal.
virtual int	saveSimHit (const SensorTraversal &traversal, const SensorTraversal::range &points)=0
	Save a SimHit for this track including the given points.
virtual void	saveRelations (const SensorTraversal &traversal, int trueHitIndex, std::vector< std::pair< unsigned int, float > > simHitIndices)=0
	Save the relations between MCParticle, TrueHit and SimHits.
std::vector< unsigned int >	simplifyEnergyDeposit (const SensorTraversal::range &points)
	Simplify the energy deposition profile using Douglas-Peuker-Algorithm We normally force a Geant4 step after 5µm but energy deposition does not necessarily vary much between these short steps.
StepInformation	findMidPoint (const SensorTraversal &traversal)
	Find the mid-point of the track traversal.

Private Member Functions
bool	step (G4Step *step, G4TouchableHistory *) override
	Process a single Geant4 Step.
bool	finishTrack ()
	Process a track once all steps are known.
std::vector< std::pair< unsigned int, float > >	createSimHits ()
	Determine which SimHits to create.
virtual bool	ProcessHits (G4Step *aStep, G4TouchableHistory *aROhist)
	Check if recording hits is enabled and if so call step() and set the correct MCParticle flag.

Private Attributes
SensorInfoBase *	m_info {0}
	Pointer to the SensorInfo associated with this instance.
std::stack< SensorTraversal >	m_tracks
	stack of SensorTraversal information for all tracks not finished so far
float	m_distanceTolerance {0}
	maximum distance between step point and linear interpolation of sensor traversal before a new simhit object is created
float	m_electronTolerance {0}
	maximum relative difference between electron density of two steps where they can be considered similar enough to be merged
float	m_minimumElectrons {0}
	minimum number of electrons a track must deposit for SimHit/TrueHits to be created
bool	m_seeNeutrons {false}
	also create SimHit/TrueHit objects for neutrons (or charged particles which deposit less than m_minimumElectrons electrons
bool	m_onlyPrimaryTrueHits {false}
	only create TrueHits for primary particles
Const::EDetector	m_subdetector
	Subdetector the class belongs to.

Static Private Attributes
static std::map< std::string, RelationArray::EConsolidationAction >	s_mcRelations
	Static set holding all relations which have to be updated at the end of the Event.
static bool	s_active
	Static bool which indicates wether recording of hits is enabled.

Detailed Description

Base class for Sensitive Detector implementation of PXD and SVD.

This base class provides common access to sensor information (like transformation) and performs the the collection of energy depositing when particles cross the sensor. Most of the calculations are contained here while the detector dependent hit and relation creation is delegated to the derived VXD::SensitiveDetector<SimHitClass, TrueHitClass>.

Definition at line 37 of file SensitiveDetectorBase.h.

Constructor & Destructor Documentation

SensitiveDetectorBase()

SensitiveDetectorBase ( SensorInfoBase *  info )

inlineexplicit

Constructor.

Parameters

info	pointer to a valid SensorInfo instance providing information about the sensor this sensitive detector instance will handle. Ownership of the SensorInfo goes to the sensitive detector instance

Definition at line 45 of file SensitiveDetectorBase.h.

                                                          :
        Simulation::SensitiveDetectorBase((info->getType() == SensorInfoBase::PXD ? "PXD " : "SVD ") + (std::string)info->getID(),
                                          info->getType() == SensorInfoBase::PXD ? Const::PXD : Const::SVD), m_info(info) {};

~SensitiveDetectorBase()

virtual ~SensitiveDetectorBase ( )

inlineoverridevirtual

Destructor freeing the sensor Info.

Reimplemented from SensitiveDetectorBase.

Definition at line 71 of file SensitiveDetectorBase.h.

      {
        if (m_info) delete m_info;
      }

Member Function Documentation

createSimHits()

std::vector< std::pair< unsigned int, float > > createSimHits ( )

private

Determine which SimHits to create.

A SimHit is a linear approximation of the particle trajectory. As such we try to combine as many Geant4 steps as possible by defining a distance tolerance and using the Douglas-Peucker algortihm to determine the required number of SimHits to keep the maximum distance of all Geant4 steps below that tolerance.

Returns

indices and electrons of all created simhits

Definition at line 126 of file SensitiveDetectorBase.cc.

    {
      SensorTraversal& traversal = m_tracks.top();
      //List of created simhit indices to be able to create relations
      std::vector<std::pair<unsigned int, float>> simhits;
 
      //We need to check how close the steps would be to a linear approximation
      //of the traversal and split the track if they are too far away. To do
      //this we check the whole track and split it at the point with the
      //largest distance recursively until the largest distance is inside the
      //tolerance. For that we need a stack of segments and check each segment
      //in turn until they fulfill the criteria.
      static std::stack<SensorTraversal::range> stack;
      //Lets push the full segment, first step point to last step point, on the
      //stack. We use inclusive range, so the second iterator is still included
      stack.push(make_pair(traversal.begin(), traversal.end() - 1));
      //Iterators needed for checking
      SensorTraversal::iterator firstPoint, finalPoint, splitPoint;
 
      //Check all segments ...
      while (!stack.empty()) {
        //Get first and last point
        std::tie(firstPoint, finalPoint) = stack.top();
        //Remove segment from stack
        stack.pop();
        //Direction of the segment
        const G4ThreeVector n = (finalPoint->position - firstPoint->position).unit();
        //find largest distance to segment by looping over all intermediate points
        double maxDistance(0);
        for (auto nextPoint = firstPoint + 1; nextPoint != finalPoint; ++nextPoint) {
          //Calculate distances between point p and line segment,
          //x = a + t*n, where a is a point on the line and n is the unit vector
          //pointing in line direction. distance = ||(p-a) - ((p-a)*n)*n||
          const G4ThreeVector pa = nextPoint->position - firstPoint->position;
          const double dist = (pa - (pa * n) * n).mag();
          //Update splitpoint if distance is larger then previously known
          if (dist > maxDistance) {
            splitPoint = nextPoint;
            maxDistance = dist;
          }
        }
        //If we are above the tolerance we split the track
        if (maxDistance > m_distanceTolerance) {
          //If we split in this order, all created simhits will be in correct
          //order. That is not a requirement but a nice side effect.
          stack.push(make_pair(splitPoint, finalPoint));
          stack.push(make_pair(firstPoint, splitPoint));
          continue;
        }
        //Otherwise we create a SimHit
        //FIXME: check for m_minimumElectrons?
        int simHitIndex = saveSimHit(traversal, std::make_pair(firstPoint, finalPoint));
        simhits.push_back(std::make_pair(simHitIndex, finalPoint->electrons - firstPoint->electrons));
      }
      return simhits;
    }

findMidPoint()

StepInformation findMidPoint ( const SensorTraversal &  traversal )

protected

Find the mid-point of the track traversal.

This function will return the position and momentum at the center of the track traversal, using cubic spline interpolation between the actual geant4 steps. Center is defined as "half the flight length" in this case.

Parameters

traversal

information on the particle traversal to be used when finding the midpoint

Returns

position and momentum at the mid point

Definition at line 274 of file SensitiveDetectorBase.cc.

    {
      //We want the middle of the track so we need to find the two steps
      //which enclose this
      const double midLength = traversal.getLength() * 0.5;
      auto after = traversal.begin();
      while (after->length < midLength) ++after;
      //Now we have an iterator after the half length. We know that the first
      //step contains length 0 so we can savely subtract one to get the one
      //before
      auto before = after - 1;
      //the midpoint is in between so calculate the fractions from both sides
      const double fl = (after->length - midLength) / (after->length - before->length);
      const double fr = (1 - fl);
      //we calculate the time and electrons using weighted average
      const double midTime = fl * before->time + fr * after->time;
      const double midElectrons = fl * before->electrons + fr * after->electrons;
      //now we use 3rd order bezier curve to approximate mid position and momentum.
      //The two base points are easy ...
      const G4ThreeVector& p0 = before->position;
      const G4ThreeVector& p3 = after->position;
      //And the two control points are the base points +- the appropriately
      //scaled momenta
      const double momentumScale = (p3 - p0).mag() / before->momentum.mag() / 3;
      const G4ThreeVector p1 = p0 + momentumScale * before->momentum;
      const G4ThreeVector p2 = p3 - momentumScale * after->momentum;
      // The curve is B(t) = (1-t)^3*P0 + 3*(1-t)^2*t*P1 + 3*(1-t)*t^2*P2 + t^3*P3
      const G4ThreeVector midPos = (
                                     fl * fl * fl * p0
                                     + 3 * fl * fl * fr * p1
                                     + 3 * fl * fr * fr * p2
                                     + fr * fr * fr * p3
                                   );
      // The derivative is dB(t)/dt = 3*[(1-t)^2*(P1-P0)+2*(1-t)*t*(P2-P1)+t^2*(P3-P2)]
      const G4ThreeVector midMom = 1.0 / momentumScale * (
                                     fl * fl * (p1 - p0)
                                     + 2 * fl * fr * (p2 - p1)
                                     + fr * fr * (p3 - p2)
                                   );
      //Okay, we now have everything
      return StepInformation(midPos, midMom, midElectrons, midTime, midLength);
    }

finishTrack()

bool finishTrack ( )

private

Process a track once all steps are known.

This function decides whether TrueHit/SimHits will be saved

Definition at line 94 of file SensitiveDetectorBase.cc.

    {
      SensorTraversal& traversal = m_tracks.top();
#ifdef VXD_SENSITIVEDETECTOR_DEBUG
      SensitiveDetectorDebugHelper& debug = SensitiveDetectorDebugHelper::getInstance();
      debug.startTraversal(getSensorID(), traversal);
#endif
      bool save = traversal.getElectrons() >= m_minimumElectrons || (m_seeNeutrons
                  && (abs(traversal.getPDGCode()) == Const::neutron.getPDGCode()));
      if (save) {
        int trueHitIndex = -1;
        if (!m_onlyPrimaryTrueHits || traversal.isPrimary()) {
          trueHitIndex = saveTrueHit(traversal);
        }
        std::vector<std::pair<unsigned int, float>> simhits = createSimHits();
        saveRelations(traversal, trueHitIndex, simhits);
      }
#ifdef VXD_SENSITIVEDETECTOR_DEBUG
      debug.finishTraversal();
#endif
      //No we just need to take care of the stack of traversals
      if (m_tracks.size() == 1) {
        //reuse traversal to keep memory if this is the first one
        traversal.reset();
      } else {
        //this should only happen if the parent track got suspended. As this
        //rarely happens in PXD we do not care for re-usability here
        m_tracks.pop();
      }
      return save;
    }

getMCParticleRelations()

static const std::map< std::string, RelationArray::EConsolidationAction > & getMCParticleRelations ( )

inlinestaticinherited

Return a list of all registered Relations with MCParticles.

Definition at line 42 of file SensitiveDetectorBase.h.

{ return s_mcRelations; }

getSensorID()

VxdID getSensorID ( ) const

inline

Return the VxdID belonging to this sensitive detector.

Definition at line 80 of file SensitiveDetectorBase.h.

{ return m_info->getID(); }

getSensorInfo()

SensorInfoBase * getSensorInfo ( )

inline

Return a pointer to the SensorInfo associated with this instance.

Definition at line 77 of file SensitiveDetectorBase.h.

{ return m_info; }

ProcessHits()

bool ProcessHits ( G4Step *  aStep, G4TouchableHistory *  aROhist  )

inlineprivatevirtualinherited

Check if recording hits is enabled and if so call step() and set the correct MCParticle flag.

Called by Geant4 for each step inside the sensitive volumes attached

Definition at line 94 of file SensitiveDetectorBase.h.

    {
      if (!s_active) return false;
      bool result = step(aStep, aROhist);
      // Do not include hits from invalid detector (beast,teastbeam, etc.)
      if (result && (m_subdetector != Const::invalidDetector)) TrackInfo::getInfo(*aStep->GetTrack()).addSeenInDetector(m_subdetector);
      return result;
    }

registerMCParticleRelation() [1/2]

static void registerMCParticleRelation ( const RelationArray &  relation, RelationArray::EConsolidationAction  ignoreAction = RelationArray::c_negativeWeight  )

inlinestaticinherited

Overload to make it easer to register MCParticle relations.

Parameters

relation	RelationArray to register
ignoreAction

Definition at line 66 of file SensitiveDetectorBase.h.

                                                                                                                             { registerMCParticleRelation(relation.getName(), ignoreAction); }

registerMCParticleRelation() [2/2]

void registerMCParticleRelation ( const std::string &  name, RelationArray::EConsolidationAction  ignoreAction = RelationArray::c_negativeWeight  )

staticinherited

Register an relation involving MCParticles.

All Relations which point from an MCParticle to something have to be registered with addMCParticleRelation() because the index of the MCParticles might change at the end of the event. During simulation, the TrackID should be used as index of the MCParticle

Parameters

name	Name of the relation to register
ignoreAction

Definition at line 22 of file SensitiveDetectorBase.cc.

    {
      std::pair<std::map<std::string, RelationArray::EConsolidationAction>::iterator, bool> insert = s_mcRelations.insert(std::make_pair(
            name, ignoreAction));
      //If the relation already exists and the ignoreAction is different we do have a problem
      if (!insert.second && insert.first->second != ignoreAction) {
        B2FATAL("MCParticle Relation " << name << " already registered with different ignore action.");
      }
    }

saveRelations()

virtual void saveRelations ( const SensorTraversal &  traversal, int  trueHitIndex, std::vector< std::pair< unsigned int, float > >  simHitIndices  )

protectedpure virtual

Save the relations between MCParticle, TrueHit and SimHits.

Parameters

traversal	information on the particle traversal to be used when creating the Relations
trueHitIndex	index of the TrueHit, <0 if no TrueHit was created
simHitIndices	indices of the SimHits along with the number of electrons deposited in each SimHit

Implemented in SensitiveDetector< SimHitClass, TrueHitClass >.

saveSimHit()

virtual int saveSimHit ( const SensorTraversal &  traversal, const SensorTraversal::range &  points  )

protectedpure virtual

Save a SimHit for this track including the given points.

This function depends on the actual SimHit implementation and is implemented in VXD::SensitiveDetector.

Parameters

traversal	information on the particle traversal to be used when creating the SimHit
points	pair of iterators to the first and last step position to be used for the SimHit

Returns

the index of the created SimHit in its StoreArray

Implemented in SensitiveDetector< SimHitClass, TrueHitClass >.

saveTrueHit()

virtual int saveTrueHit ( const SensorTraversal &  traversal )

protectedpure virtual

Save the actual TrueHit for this sensor traversal.

This function depends on the actual TrueHit implementation and is implemented in VXD::SensitiveDetector.

Parameters

traversal

information on the particle traversal to be used when creating the TrueHit

Returns

the index of the created TrueHit in its StoreArray

Implemented in SensitiveDetector< SimHitClass, TrueHitClass >.

setActive()

static void setActive ( bool  activeStatus )

inlinestaticinherited

Enable/Disable all Sensitive Detectors.

By default, all sensitive detectors won't create hits to make it possible to use the Geant4 Navigator for non-simulation purposes. Only during simulation the sensitive detectors will be enabled to record hits

Parameters

activeStatus

bool to indicate wether hits should be recorded

Definition at line 50 of file SensitiveDetectorBase.h.

{ s_active = activeStatus; }

setOptions()

void setOptions ( bool  seeNeutrons, bool  onlyPrimaryTrueHits, float  distanceTolerance, float  electronTolerance, float  minimumElectrons  )

inline

Set all common options.

Parameters

seeNeutrons	if true, simhits are also stored for neutrons
onlyPrimaryTrueHits	if true, truehits will only be created for primary particles
distanceTolerance	maximal distance of step position from linear approximation.
electronTolerance	maximum deviation of energy deposition from linear approximation in electrons
minimumElectrons	minimum number of electrons to be deposited before SimHits are created.

Definition at line 60 of file SensitiveDetectorBase.h.

      {
        m_seeNeutrons = seeNeutrons;
        m_onlyPrimaryTrueHits = onlyPrimaryTrueHits;
        m_distanceTolerance = distanceTolerance;
        m_electronTolerance = electronTolerance;
        m_minimumElectrons = minimumElectrons;
      }

simplifyEnergyDeposit()

std::vector< unsigned int > simplifyEnergyDeposit ( const SensorTraversal::range &  points )

protected

Simplify the energy deposition profile using Douglas-Peuker-Algorithm We normally force a Geant4 step after 5µm but energy deposition does not necessarily vary much between these short steps.

Saving all steps would be a waste of space so we define a tolerance (in electrons) and keep only the points needed so that no point is further away from the profile than this tolerance.

Parameters

points

pair of iterators to the first and last point of the energy deposition profile

Returns

list of encoded EnergyDeposit values representing the simplified energy deposition profile.

Definition at line 183 of file SensitiveDetectorBase.cc.

    {
      //At the end we want a list of points indication how many electrons where
      //deposited so far along the track, e.g. [(0.5,100), (1.0, 2000)] would
      //indicate that after half the step length 100 electrons were deposited
      //and at the end of the step we have 2000 electrons. To save some memory
      //we encode this information as unsigned int using ElectronDeposit later
      //on.
      std::vector<unsigned int> electronProfile;
 
      //We need an iterator to the first and last point in a segment
      SensorTraversal::iterator firstPoint, finalPoint;
      //for now let's extract the full segment
      std::tie(firstPoint, finalPoint) = points;
      //If this is not the first SimHit for a sensor traversal we need to
      //subtract the electrons already taken care of
      const double electronsOffset = (firstPoint->electrons);
      //We also need the length of the step
      const double length = finalPoint->length - firstPoint->length;
      //And the start length
      const double lengthOffset = firstPoint->length;
 
      //We need to keep track of sub segments and where they should insert a
      //midpoint if required. So we need a tuple of three iterators: insert
      //position, first point and last point of the segment. We store those
      //in a stack which we declare static to avoid some relocations if
      //possible.
      static std::stack <SensorTraversal::range> stack;
      //And we push the full segment on the stack
      stack.push(points);
 
      //Now we check all segments we encounter until none exceed the maximum
      //tolerance anymore
      while (!stack.empty()) {
        //Get next segment to be checked
        std::tie(firstPoint, finalPoint) = stack.top();
        //And remove it from the stack
        stack.pop();
 
        //Some variables we need
        const double startElectrons = firstPoint->electrons;
        const double startLength = firstPoint->length;
        const double segmentLength = finalPoint->length - startLength;
        const double segmentElectrons = finalPoint->electrons - startElectrons;
        //We want to give the tolerance in electrons so we need to convert the
        //step length into electrons. We do this by using the average number of
        //electrons created per micrometer for a minimum ionizing particle.
        const double lengthScale = 1. / Unit::um * 80;
        //we need the slope for the linear approximation:
        //electrons= slope*(length-startLength)*lengthScale+startElectrons;
        const double slope = segmentElectrons / segmentLength / lengthScale;
        //Distance between point x0,y0 and line a*x+b*y+c=0 is given as
        //abs(a*x0+b*y0+c)/sqrt(a^2+b^2). In our case:
        //x0=(length-startLength)*lengthScale, y0=electrons
        //a=slope, b=-1, c=startElectrons.
        //Nominator is independent of the actual point so we calculate it now
        const double distanceConstant = std::sqrt(slope * slope + 1);
 
        //Variable to remember maximum distance from linear approximation
        double maxDistance(0);
        //and also the point with the largest distance
        SensorTraversal::iterator splitPoint;
 
        //No go through all intermediate points
        for (auto nextPoint = firstPoint + 1; nextPoint != finalPoint; ++nextPoint) {
          //and check their distance from the linear approximation
          const double x = (nextPoint->length - startLength) * lengthScale;
          const double dist = fabs(x * slope - nextPoint->electrons + startElectrons) / distanceConstant;
          //and remember if it is the largest distance
          if (dist > maxDistance) {
            splitPoint = nextPoint;
            maxDistance = dist;
          }
        }
        //if the largest distance is above the tolerance we split the segment
        if (maxDistance > m_electronTolerance) {
          //And add the two sub segments to the stack in the correcto order to
          //ensure sorted processing: We always add the segments at the front
          //last so they will be processed first
          stack.push(make_pair(splitPoint, finalPoint));
          stack.push(make_pair(firstPoint, splitPoint));
          continue;
        }
        //otherwise we add the endpoint of the current segment to the list of points.
        const double fraction = (finalPoint->length - lengthOffset) / length;
        const double electrons = (finalPoint->electrons - electronsOffset);
        electronProfile.push_back(VXDElectronDeposit(fraction, electrons));
      }
      return electronProfile;
    }

step()

bool step ( G4Step *  step, G4TouchableHistory *    )

overrideprivatevirtual

Process a single Geant4 Step.

This function stores the necessary information to create the TrueHits and SimHits and will call finishTrack() if a track leaves the volume or is stopped inside the volume.

Implements SensitiveDetectorBase.

Definition at line 28 of file SensitiveDetectorBase.cc.

    {
      // Get track
      const G4Track& track = *step->GetTrack();
      // Get particle PDG code
      const int pdgCode = track.GetDefinition()->GetPDGEncoding();
      // Get particle charge (only keep charged tracks, photons and magnetic monopoles)
      const bool isNeutral = track.GetDefinition()->GetPDGCharge() == 0;
      const bool isAllowedNeutral = (pdgCode == Const::photon.getPDGCode()) || (m_seeNeutrons
                                    && (abs(pdgCode) == Const::neutron.getPDGCode())) || (abs(pdgCode) == 99666);
      //Not interested in neutral particles except photons, magnetic monopoles and maybe neutrons
      if (isNeutral && !isAllowedNeutral) return false;
 
      // Get track ID
      const int trackID = track.GetTrackID();
      //Get deposited energy
      const double electrons = step->GetTotalEnergyDeposit() * Unit::MeV / Const::ehEnergy;
      // Get step information
      const G4StepPoint& postStep = *step->GetPostStepPoint();
      const G4StepPoint& preStep = *step->GetPreStepPoint();
      const G4AffineTransform& topTransform = preStep.GetTouchableHandle()->GetHistory()->GetTopTransform();
      const G4ThreeVector postStepPos = topTransform.TransformPoint(postStep.GetPosition()) * Unit::mm;
      const G4ThreeVector postStepMom = topTransform.TransformAxis(postStep.GetMomentum()) * Unit::MeV;
 
      //Get the current track info
      //if none present or not matching current trackID create one first
      //if trackID is 0 we can reuse the existing top
      if (m_tracks.empty() || (m_tracks.top().getTrackID() > 0 && m_tracks.top().getTrackID() != trackID)) {
        m_tracks.push(SensorTraversal());
      }
      SensorTraversal& traversal = m_tracks.top();
      if (traversal.getTrackID() == 0) {
        bool isPrimary = Simulation::TrackInfo::getInfo(track).hasStatus(MCParticle::c_PrimaryParticle);
        //If new track, remember values
        traversal.setInitial(trackID, pdgCode, isPrimary);
        //Remember if the track came from the outside
        if (preStep.GetStepStatus() == fGeomBoundary) traversal.hasEntered();
        //Add start position
        const G4ThreeVector preStepPos = topTransform.TransformPoint(preStep.GetPosition()) * Unit::mm;
        const G4ThreeVector preStepMom = topTransform.TransformAxis(preStep.GetMomentum()) * Unit::MeV;
        traversal.add(preStepPos, preStepMom, 0, preStep.GetGlobalTime() * Unit::ns, 0);
      }
      //Add new track
      traversal.add(postStepPos, postStepMom, electrons,
                    postStep.GetGlobalTime() * Unit::ns,
                    step->GetStepLength() * Unit::mm);
      //check if we are leaving the volume
      bool isLeaving = (postStep.GetStepStatus() == fGeomBoundary);
      //remember that in the track info
      if (isLeaving) traversal.hasLeft();
      //If this step is to the boundary or track gets killed, save hits and
      //return whether or not we saved something
      if (isLeaving || track.GetTrackStatus() >= fStopAndKill) {
        bool saved = finishTrack();
        //If we saved at least one simhit and the track is not contained inside
        //the sensor volume: keep MCParticle
        if (saved && !traversal.isContained()) {
          Simulation::TrackInfo::getInfo(track).setIgnore(false);
        }
        return saved;
      }
      //Track not finished so we do not save anything, let's return false for
      //now
      return false;
    }

Member Data Documentation

m_distanceTolerance

float m_distanceTolerance {0}

private

maximum distance between step point and linear interpolation of sensor traversal before a new simhit object is created

Definition at line 168 of file SensitiveDetectorBase.h.

m_electronTolerance

float m_electronTolerance {0}

private

maximum relative difference between electron density of two steps where they can be considered similar enough to be merged

Definition at line 171 of file SensitiveDetectorBase.h.

m_info

SensorInfoBase* m_info {0}

private

Pointer to the SensorInfo associated with this instance.

Definition at line 163 of file SensitiveDetectorBase.h.

m_minimumElectrons

float m_minimumElectrons {0}

private

minimum number of electrons a track must deposit for SimHit/TrueHits to be created

Definition at line 174 of file SensitiveDetectorBase.h.

m_onlyPrimaryTrueHits

bool m_onlyPrimaryTrueHits {false}

private

only create TrueHits for primary particles

Definition at line 179 of file SensitiveDetectorBase.h.

m_seeNeutrons

bool m_seeNeutrons {false}

private

also create SimHit/TrueHit objects for neutrons (or charged particles which deposit less than m_minimumElectrons electrons

Definition at line 177 of file SensitiveDetectorBase.h.

m_subdetector

Const::EDetector m_subdetector

privateinherited

Subdetector the class belongs to.

Definition at line 91 of file SensitiveDetectorBase.h.

m_tracks

std::stack<SensorTraversal> m_tracks

private

stack of SensorTraversal information for all tracks not finished so far

Definition at line 165 of file SensitiveDetectorBase.h.

s_active

bool s_active

staticprivateinherited

Static bool which indicates wether recording of hits is enabled.

Definition at line 89 of file SensitiveDetectorBase.h.

s_mcRelations

map< string, RelationArray::EConsolidationAction > s_mcRelations

staticprivateinherited

Static set holding all relations which have to be updated at the end of the Event.

Definition at line 87 of file SensitiveDetectorBase.h.

---

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

• vxd/simulation/include/SensitiveDetectorBase.h
• vxd/simulation/src/SensitiveDetectorBase.cc