SensitiveDetector< SimHitClass, TrueHitClass > Class Template Reference

Sensitive Detector implementation of PXD and SVD. More...

#include <SensitiveDetector.h>

Inheritance diagram for SensitiveDetector< SimHitClass, TrueHitClass >:

Public Member Functions
	SensitiveDetector (VXD::SensorInfoBase *sensorInfo)
	Construct instance and take over ownership of the sensorInfo pointer.
void	setOptions (bool seeNeutrons, bool onlyPrimaryTrueHits, float distanceTolerance, float electronTolerance, float minimumElectrons)
	Set all common options.
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
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
int	saveTrueHit (const SensorTraversal &traversal) override
	Save the actual TrueHit for a given sensor traversal information.
int	saveSimHit (const SensorTraversal &traversal, const SensorTraversal::range &points) override
	Save a SimHit for a track along the given points.
void	saveRelations (const SensorTraversal &traversal, int trueHitIndex, std::vector< std::pair< unsigned int, float > > simHitIndices) override
	Save the relations between MCParticle, TrueHit and SimHits.
std::array< float, 3 >	vecToFloat (const G4ThreeVector &vec)
	Convert G4ThreeVector (aka Hep3Vector) to float array to store in TrueHit/SimHit classes.
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
StoreArray< SimHitClass >	m_simhits
	StoreArray for the SimHits.
StoreArray< TrueHitClass >	m_truehits
	StoreArray for the TrueHits.
StoreArray< MCParticle >	m_mcparticles
	StoreArray for the MCParticles, needed by relations.
RelationArray	m_relMCSimHits {m_mcparticles, m_simhits}
	Relation between MCParticle and SimHits.
RelationArray	m_relMCTrueHits {m_mcparticles, m_truehits}
	Relation between MCParticle and TrueHits.
RelationArray	m_relTrueSimHits {m_truehits, m_simhits}
	Relation between TrueHits and SimHits.
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

template<class SimHitClass, class TrueHitClass>
class Belle2::VXD::SensitiveDetector< SimHitClass, TrueHitClass >

Sensitive Detector implementation of PXD and SVD.

This class provides the actual implementation of the hit generation for PXD and SVD. It is templated to be able to create the corresponding output collection.

It generates two different kinds of Hits:

• SimHits which correspond to Geant4 steps inside the sensitive volume. There will be several SimHits per traversal, since the step length of Geant4 is limited to provide detailed information about energy deposition.
• TrueHits are aggregated objects which store the position where a particle crossed the detector plane (local z=0). There can be only one TrueHit per traversal of one sensor, but there may be more than one TrueHit for curling Tracks. TrueHits also carry information about the particle momenta before and after entering the silicon (or at start/end point if the track started/ended inside the silicon. MODIFIED July 2013 (based largely on suggestions by Martin Ritter):
  1. Every particle that either enters or leaves the sensitive volume and deposits some energy there, will create a TrueHit.
  2. The (u,v,w) position of the TrueHit are the coordinates of the midpoint of the track inside the sensitive volume (rather of the x-ing point with z=0): the w (z) coordinate is added to TrueHits.
  3. Each MC particle entering the sensitive volume will be un-ignored, so that the TrueHits created by secondaries entering the sensitive volume will be attributed to the correct MCParticle (that is, not to its primary ancestor).
  4. SimHit relations to MCParticles that don't produce a TrueHit and get re-attributed (to their primary ancestor) will have negative sign. This concerns the secondaries created inside the sensitive volume that don't reach another sensitive volume.

Template Parameters

SimHitClass	Class to use when generating SimHits
TrueHitClass	Class to use when generating TrueHits

Definition at line 64 of file SensitiveDetector.h.

Constructor & Destructor Documentation

SensitiveDetector()

SensitiveDetector ( VXD::SensorInfoBase *  sensorInfo )

explicit

Construct instance and take over ownership of the sensorInfo pointer.

Definition at line 122 of file SensitiveDetector.h.

                                                                                                :
      VXD::SensitiveDetectorBase(sensorInfo)
    {
      //Register output collections.
      //m_mcparticles.isRequired();
      m_simhits.registerInDataStore();
      m_truehits.registerInDataStore();
      m_relMCSimHits.registerInDataStore();
      m_relMCTrueHits.registerInDataStore();
      m_relTrueSimHits.registerInDataStore();
      registerMCParticleRelation(m_relMCSimHits, RelationArray::c_negativeWeight);
      registerMCParticleRelation(m_relMCTrueHits, RelationArray::c_deleteElement);
    }

Member Function Documentation

createSimHits()

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

privateinherited

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 )

protectedinherited

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 ( )

privateinherited

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

inlineinherited

Return the VxdID belonging to this sensitive detector.

Definition at line 80 of file SensitiveDetectorBase.h.

{ return m_info->getID(); }

getSensorInfo()

SensorInfoBase * getSensorInfo ( )

inlineinherited

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()

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

overrideprivatevirtual

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

Implements SensitiveDetectorBase.

Definition at line 185 of file SensitiveDetector.h.

    {
      m_relMCSimHits.add(traversal.getTrackID(), simHitIndices.begin(), simHitIndices.end());
      //If there is no truehit there are obviously no relations ;)
      if (trueHitIndex >= 0) {
        m_relMCTrueHits.add(traversal.getTrackID(), trueHitIndex, traversal.getElectrons());
        m_relTrueSimHits.add(trueHitIndex, simHitIndices.begin(), simHitIndices.end());
      }
    }

saveSimHit()

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

overrideprivatevirtual

Save a SimHit for a track along the given points.

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

Implements SensitiveDetectorBase.

Definition at line 163 of file SensitiveDetector.h.

    {
      //Convert position to floats here
      auto posIn = vecToFloat(points.first->position);
      auto posOut = vecToFloat(points.second->position);
      auto electronProfile = simplifyEnergyDeposit(points);
 
      //Create the simhit
      int simHitIndex = m_simhits.getEntries();
      SimHitClass* simhit = m_simhits.appendNew(getSensorID(), traversal.getPDGCode(), points.first->time,
                                                posIn.data(), posOut.data());
      simhit->setEnergyDeposit(electronProfile);
#ifdef VXD_SENSITIVEDETECTOR_DEBUG
      int startPoint = std::distance(traversal.begin(), (SensorTraversal::const_iterator)points.first);
      int endPoint = std::distance(traversal.begin(), (SensorTraversal::const_iterator)points.second);
      SensitiveDetectorDebugHelper::getInstance().addSimHit(simhit, startPoint, endPoint);
#endif
      return simHitIndex;
    }

saveTrueHit()

int saveTrueHit ( const SensorTraversal &  traversal )

overrideprivatevirtual

Save the actual TrueHit for a given sensor traversal information.

Parameters

traversal

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

Returns

the index of the created TrueHit in its StoreArray

Implements SensitiveDetectorBase.

Definition at line 137 of file SensitiveDetector.h.

    {
      //We have the full sensor traversal information, we only lack the midpoint so lets get it
      StepInformation midPoint = findMidPoint(traversal);
 
      //By now everything is done: just convert the position and momenta in float[3] and create a truehit
      auto posEntry = vecToFloat(traversal.front().position);
      auto posMidPoint = vecToFloat(midPoint.position);
      auto posExit = vecToFloat(traversal.back().position);
      auto momEntry = vecToFloat(traversal.front().momentum);
      auto momMidPoint = vecToFloat(midPoint.momentum);
      auto momExit = vecToFloat(traversal.back().momentum);
      //And we should convert the electrons back in energy ...
      const double energyDep = traversal.getElectrons() * Const::ehEnergy;
 
      //create the truehit
      int trueHitIndex = m_truehits.getEntries();
      m_truehits.appendNew(getSensorID(), posEntry.data(), posMidPoint.data(), posExit.data(),
                           momEntry.data(), momMidPoint.data(), momExit.data(), energyDep, midPoint.time);
#ifdef VXD_SENSITIVEDETECTOR_DEBUG
      SensitiveDetectorDebugHelper::getInstance().addTrueHit(m_truehits[trueHitIndex]);
#endif
      return trueHitIndex;
    }

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  )

inlineinherited

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 )

protectedinherited

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 *    )

overrideprivatevirtualinherited

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

vecToFloat()

std::array< float, 3 > vecToFloat ( const G4ThreeVector &  vec )

inlineprivate

Convert G4ThreeVector (aka Hep3Vector) to float array to store in TrueHit/SimHit classes.

Parameters

vec	vector to convert

Returns

array containing x,y,z as floats

Definition at line 102 of file SensitiveDetector.h.

      {
        return std::array<float, 3> {{(float)vec.x(), (float)vec.y(), (float)vec.z()}};
      }

Member Data Documentation

m_distanceTolerance

float m_distanceTolerance {0}

privateinherited

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}

privateinherited

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}

privateinherited

Pointer to the SensorInfo associated with this instance.

Definition at line 163 of file SensitiveDetectorBase.h.

m_mcparticles

StoreArray<MCParticle> m_mcparticles

private

StoreArray for the MCParticles, needed by relations.

Definition at line 112 of file SensitiveDetector.h.

m_minimumElectrons

float m_minimumElectrons {0}

privateinherited

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}

privateinherited

only create TrueHits for primary particles

Definition at line 179 of file SensitiveDetectorBase.h.

m_relMCSimHits

RelationArray m_relMCSimHits {m_mcparticles, m_simhits}

private

Relation between MCParticle and SimHits.

Definition at line 114 of file SensitiveDetector.h.

m_relMCTrueHits

RelationArray m_relMCTrueHits {m_mcparticles, m_truehits}

private

Relation between MCParticle and TrueHits.

Definition at line 116 of file SensitiveDetector.h.

m_relTrueSimHits

RelationArray m_relTrueSimHits {m_truehits, m_simhits}

private

Relation between TrueHits and SimHits.

Definition at line 118 of file SensitiveDetector.h.

m_seeNeutrons

bool m_seeNeutrons {false}

privateinherited

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_simhits

StoreArray<SimHitClass> m_simhits

private

StoreArray for the SimHits.

Definition at line 108 of file SensitiveDetector.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

privateinherited

stack of SensorTraversal information for all tracks not finished so far

Definition at line 165 of file SensitiveDetectorBase.h.

m_truehits

StoreArray<TrueHitClass> m_truehits

private

StoreArray for the TrueHits.

Definition at line 110 of file SensitiveDetector.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 file:

• vxd/simulation/include/SensitiveDetector.h