KLM sensitive-detector class. More...

#include <SensitiveDetector.h>

Inheritance diagram for SensitiveDetector:

Public Member Functions
	SensitiveDetector (const G4String &name, KLMSubdetectorNumber subdetector)
	Constructor.

bool	step (G4Step , G4TouchableHistory ) override
	Process each step and store KLMSimHits.

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.

Private Member Functions
bool	stepBKLM (G4Step , G4TouchableHistory )
	Step in BKLM.

bool	stepEKLM (G4Step , G4TouchableHistory )
	Step in EKLM.

void	convertHitToRPCStrips (const CLHEP::Hep3Vector &, const bklm::Module *, int &, int &, int &, int &)
	Find the ranges of matching RPC strips for BKLM hits.

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
KLMSubdetectorNumber	m_Subdetector
	Subdetector.

bool	m_FirstCall
	Flag to enforce once-only initializations in Initialize().

double	m_HitTimeMax
	Maximum permissible hit time based on overflow of LeCroy 1877 TDC.

BkgSensitiveDetector *	m_BkgSensitiveDetector
	Pointer to a sensitive-detector object used for beam-background steps.

bklm::GeometryPar *	m_GeoPar
	Pointer to GeometryPar singleton.

const EKLMElementNumbers *	m_ElementNumbers
	EKLM element numbers.

DBObjPtr< BKLMSimulationPar >	m_SimPar
	Simulation parameters (from DB).

StoreArray< MCParticle >	m_MCParticles
	MC particles.

StoreArray< KLMSimHit >	m_KLMSimHits
	Simulation hits.

RelationArray	m_MCParticlesToKLMSimHits {m_MCParticles, m_KLMSimHits}
	Relation array between MCPartices and KLMSimHits.

Const::EDetector	m_subdetector
	Subdetector the class belongs to.

Static Private Attributes
static constexpr int	m_DepthSection = 2
	Section depth.

static constexpr int	m_DepthSector = 3
	Sector depth.

static constexpr int	m_DepthLayer = 5
	Layer depth.

static constexpr int	m_DepthPlane = 9
	Plane depth.

static constexpr int	m_DepthScintillator = 10
	Scintillator depth.

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

KLM sensitive-detector class.

Definition at line 38 of file SensitiveDetector.h.

Constructor & Destructor Documentation

◆ SensitiveDetector()

SensitiveDetector	(	const G4String &	name,
		KLMSubdetectorNumber	subdetector
	)

Constructor.

Parameters

[in]	name	Sensitive-detector name.
[in]	subdetector	Subdetector.

Definition at line 33 of file SensitiveDetector.cc.

                                                          :
  SensitiveDetectorBase(name, Const::KLM),
  m_Subdetector(subdetector),
  m_FirstCall(true),
  m_BkgSensitiveDetector(nullptr),
  m_GeoPar(nullptr)
{
  if (!m_SimPar.isValid())
    B2FATAL("BKLM simulation parameters are not available.");
  m_HitTimeMax = m_SimPar->getHitTimeMax();
  m_MCParticles.isOptional();
  m_KLMSimHits.registerInDataStore();
  m_MCParticlesToKLMSimHits.registerInDataStore();
  registerMCParticleRelation(m_MCParticlesToKLMSimHits);
}

Member Function Documentation

◆ convertHitToRPCStrips()

void convertHitToRPCStrips	(	const CLHEP::Hep3Vector &	localPosition,
		const bklm::Module *	m,
		int &	phiStripLower,
		int &	phiStripUpper,
		int &	zStripLower,
		int &	zStripUpper
	)

private

Find the ranges of matching RPC strips for BKLM hits.

Definition at line 239 of file SensitiveDetector.cc.

{
  double phiStripD = m->getPhiStrip(localPosition);
  int phiStrip = int(phiStripD);
  int pMin = m->getPhiStripMin();
  if (phiStrip < pMin)
    return;
  int pMax = m->getPhiStripMax();
  if (phiStrip > pMax)
    return;
 
  double zStripD = m->getZStrip(localPosition);
  int zStrip = int(zStripD);
  int zMin = m->getZStripMin();
  if (zStrip < zMin)
    return;
  int zMax = m->getZStripMax();
  if (zStrip > zMax)
    return;
 
  phiStripLower = phiStrip;
  phiStripUpper = phiStrip;
  zStripLower = zStrip;
  zStripUpper = zStrip;
  double phiStripDiv = fmod(phiStripD, 1.0) - 0.5; // between -0.5 and +0.5 within central phiStrip
  double zStripDiv = fmod(zStripD, 1.0) - 0.5;   // between -0.5 and +0.5 within central zStrip
  int n = 0;
  double rand = gRandom->Uniform();
  for (n = 1; n < m_SimPar->getMaxMultiplicity(); ++n) {
    if (m_SimPar->getPhiMultiplicityCDF(phiStripDiv, n) > rand)
      break;
  }
  int nextStrip = (phiStripDiv > 0.0 ? 1 : -1);
  while (--n > 0) {
    phiStrip += nextStrip;
    if ((phiStrip >= pMin) && (phiStrip <= pMax)) {
      phiStripLower = std::min(phiStrip, phiStripLower);
      phiStripUpper = std::max(phiStrip, phiStripUpper);
    }
    nextStrip = (nextStrip > 0 ? -(1 + nextStrip) : 1 - nextStrip);
  }
  rand = gRandom->Uniform();
  for (n = 1; n < m_SimPar->getMaxMultiplicity(); ++n) {
    if (m_SimPar->getZMultiplicityCDF(zStripDiv, n) > rand)
      break;
  }
  nextStrip = (zStripDiv > 0.0 ? 1 : -1);
  while (--n > 0) {
    zStrip += nextStrip;
    if ((zStrip >= zMin) && (zStrip <= zMax)) {
      zStripLower = std::min(zStrip, zStripLower);
      zStripUpper = std::max(zStrip, zStripUpper);
    }
    nextStrip = (nextStrip > 0 ? -(1 + nextStrip) : 1 - nextStrip);
  }
  return;
}

◆ 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.

42{ return s_mcRelations; }

Belle2::Simulation::SensitiveDetectorBase::s_mcRelations

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.

Definition: SensitiveDetectorBase.h:87

◆ 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.

67 { 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.");
      }
    }

◆ 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.

50{ s_active = activeStatus; }

◆ step()

bool step	(	G4Step *	step,
		G4TouchableHistory *	history
	)

overridevirtual

Process each step and store KLMSimHits.

Implements SensitiveDetectorBase.

Definition at line 299 of file SensitiveDetector.cc.

{
  if (m_Subdetector == KLMElementNumbers::c_BKLM)
    return stepBKLM(step, history);
  else
    return stepEKLM(step, history);
}

◆ stepBKLM()

G4bool stepBKLM	(	G4Step *	step,
		G4TouchableHistory *	history
	)

private

Step in BKLM.

Definition at line 117 of file SensitiveDetector.cc.

{
  /* Once-only initializations (constructor is called too early for these). */
  if (m_FirstCall) {
    m_FirstCall = false;
    m_GeoPar = bklm::GeometryPar::instance();
    if (m_GeoPar->doBeamBackgroundStudy())
      m_BkgSensitiveDetector = new BkgSensitiveDetector("BKLM");
    if (!gRandom)
      B2FATAL("gRandom is not initialized; please set up gRandom first");
  }
 
  // Record a BeamBackHit for any particle
  if (m_BkgSensitiveDetector != nullptr) {
    m_BkgSensitiveDetector->step(step, history);
  }
 
  // It is not necessary to detect motion from one volume to another (or track death
  // in the RPC gas volume).  Experimentation shows that most tracks pass through the
  // RPC gas volume in one step (although, on occasion, a delta ray will take a couple
  // of short steps entirely within gas).  Therefore, save every step in the gas
  // instead of trying to find entry and exit points and then saving only the midpoint.
  // Do same for scintillators.
 
  double       eDep     = step->GetTotalEnergyDeposit() / CLHEP::MeV;  // GEANT4: in MeV
  G4StepPoint* preStep  = step->GetPreStepPoint();
  G4StepPoint* postStep = step->GetPostStepPoint();
  G4Track*     track    = step->GetTrack();
 
  // Record a KLMSimHit for a charged track that deposits some energy.
  if ((eDep > 0.0) && (postStep->GetCharge() != 0.0)) {
    const G4VTouchable* hist = preStep->GetTouchable();
    int depth = hist->GetHistoryDepth();
    if (depth < m_DepthPlane) {
      B2WARNING("BKLM SensitiveDetector::step(): "
                << LogVar("Touchable HistoryDepth", depth)
                << LogVar("Should be at least", m_DepthPlane));
      return false;
    }
    int plane = hist->GetCopyNumber(depth - m_DepthPlane);
    int layer = hist->GetCopyNumber(depth - m_DepthLayer);
    int sector = hist->GetCopyNumber(depth - m_DepthSector);
    int section = hist->GetCopyNumber(depth - m_DepthSection);
    double time = 0.5 * (preStep->GetGlobalTime() + postStep->GetGlobalTime());  // GEANT4: in ns
    if (time > m_HitTimeMax)
      return false;
    const CLHEP::Hep3Vector globalPosition = 0.5 * (preStep->GetPosition() + postStep->GetPosition()) / CLHEP::cm; // in cm
    const bklm::Module* m = m_GeoPar->findModule(section, sector, layer);
    const CLHEP::Hep3Vector localPosition = m->globalToLocal(globalPosition);
    int trackID = track->GetTrackID();
    if (m->hasRPCs()) {
      const CLHEP::Hep3Vector propagationTimes =
        m->getPropagationTimes(localPosition);
      int phiStripLower = -1;
      int phiStripUpper = -1;
      int zStripLower = -1;
      int zStripUpper = -1;
      convertHitToRPCStrips(localPosition, m, phiStripLower, phiStripUpper, zStripLower, zStripUpper);
      if (zStripLower > 0) {
        KLMSimHit* simHit = m_KLMSimHits.appendNew();
        simHit->setSubdetector(KLMElementNumbers::c_BKLM);
        simHit->setSection(section);
        simHit->setSector(sector);
        simHit->setLayer(layer);
        simHit->setPlane(BKLMElementNumbers::c_ZPlane);
        simHit->setStrip(zStripLower);
        simHit->setLastStrip(zStripUpper);
        simHit->setPropagationTime(propagationTimes.z());
        simHit->setTime(time);
        simHit->setEnergyDeposit(eDep);
        simHit->setPosition(globalPosition.x(), globalPosition.y(),
                            globalPosition.z());
        simHit->setPDG(track->GetDefinition()->GetPDGEncoding());
        m_MCParticlesToKLMSimHits.add(trackID, simHit->getArrayIndex());
      }
      if (phiStripLower > 0) {
        KLMSimHit* simHit = m_KLMSimHits.appendNew();
        simHit->setSubdetector(KLMElementNumbers::c_BKLM);
        simHit->setSection(section);
        simHit->setSector(sector);
        simHit->setLayer(layer);
        simHit->setPlane(BKLMElementNumbers::c_PhiPlane);
        simHit->setStrip(phiStripLower);
        simHit->setLastStrip(phiStripUpper);
        simHit->setPropagationTime(propagationTimes.y());
        simHit->setTime(time);
        simHit->setEnergyDeposit(eDep);
        simHit->setPosition(globalPosition.x(), globalPosition.y(),
                            globalPosition.z());
        simHit->setPDG(track->GetDefinition()->GetPDGEncoding());
        m_MCParticlesToKLMSimHits.add(trackID, simHit->getArrayIndex());
      }
    } else {
      int scint = hist->GetCopyNumber(depth - m_DepthScintillator);
      bool phiPlane = (plane == BKLM_INNER);
      double propagationTime =
        m->getPropagationTime(localPosition, scint, phiPlane);
      KLMSimHit* simHit = m_KLMSimHits.appendNew();
      simHit->setSubdetector(KLMElementNumbers::c_BKLM);
      simHit->setSection(section);
      simHit->setSector(sector);
      simHit->setLayer(layer);
      if (phiPlane) {
        simHit->setPlane(BKLMElementNumbers::c_PhiPlane);
      } else {
        simHit->setPlane(BKLMElementNumbers::c_ZPlane);
      }
      simHit->setStrip(scint);
      simHit->setLastStrip(scint);
      simHit->setPropagationTime(propagationTime);
      simHit->setTime(time);
      simHit->setEnergyDeposit(eDep);
      simHit->setPosition(globalPosition.x(), globalPosition.y(),
                          globalPosition.z());
      simHit->setPDG(track->GetDefinition()->GetPDGEncoding());
      m_MCParticlesToKLMSimHits.add(trackID, simHit->getArrayIndex());
    }
    return true;
  }
  return false;
}

◆ stepEKLM()

bool stepEKLM	(	G4Step *	aStep,
		G4TouchableHistory *	history
	)

private

Step in EKLM.

Definition at line 50 of file SensitiveDetector.cc.

{
  /* Once-only initializations (constructor is called too early for these). */
  if (m_FirstCall) {
    m_FirstCall = false;
    const EKLM::GeometryData* geometryData = &EKLM::GeometryData::Instance();
    if (geometryData->beamBackgroundStudy())
      m_BkgSensitiveDetector = new BkgSensitiveDetector("EKLM");
  }
 
  // Record a BeamBackHit for any particle
  if (m_BkgSensitiveDetector != nullptr) {
    m_BkgSensitiveDetector->step(aStep, history);
  }
 
  const int stripLevel = 1;
  int section, layer, sector, plane, strip, stripGlobal;
  HepGeom::Point3D<double> gpos, lpos;
  G4TouchableHandle hist = aStep->GetPreStepPoint()->GetTouchableHandle();
  section = hist->GetVolume(stripLevel + 6)->GetCopyNo();
  layer = hist->GetVolume(stripLevel + 5)->GetCopyNo();
  sector = hist->GetVolume(stripLevel + 4)->GetCopyNo();
  plane = hist->GetVolume(stripLevel + 3)->GetCopyNo();
  strip = hist->GetVolume(stripLevel)->GetCopyNo();
  stripGlobal = m_ElementNumbers->stripNumber(
                  section, layer, sector, plane, strip);
  const G4double eDep = aStep->GetTotalEnergyDeposit();
  /* Do not record hits without deposited energy. */
  if (eDep <= 0)
    return false;
  const G4Track& track = * aStep->GetTrack();
  const G4double hitTime = track.GetGlobalTime();
  if (hitTime > m_HitTimeMax)
    return false;
  /* Hit position. */
  gpos = 0.5 * (aStep->GetPostStepPoint()->GetPosition() +
                aStep->GetPreStepPoint()->GetPosition());
  lpos = hist->GetHistory()->GetTopTransform().TransformPoint(gpos);
  /* Create step hit and store in to DataStore */
  KLMSimHit* hit = m_KLMSimHits.appendNew();
  hit->setSubdetector(KLMElementNumbers::c_EKLM);
  hit->setSection(section);
  hit->setSector(sector);
  hit->setLayer(layer);
  hit->setPlane(plane);
  hit->setStrip(strip);
  hit->setLastStrip(strip);
  // hit->setPropagationTime();
  hit->setTime(hitTime);
  hit->setEnergyDeposit(eDep);
  CLHEP::Hep3Vector trackMomentum = track.GetMomentum();
  hit->setMomentum(ROOT::Math::PxPyPzEVector(trackMomentum.x(), trackMomentum.y(),
                                             trackMomentum.z(), track.GetTotalEnergy()));
  hit->setTrackID(track.GetTrackID());
  hit->setParentTrackID(track.GetParentID());
  hit->setLocalPosition(lpos.x() / CLHEP::mm * Unit::mm,
                        lpos.y() / CLHEP::mm * Unit::mm,
                        lpos.z() / CLHEP::mm * Unit::mm);
  hit->setPosition(gpos.x() / CLHEP::mm * Unit::mm,
                   gpos.y() / CLHEP::mm * Unit::mm,
                   gpos.z() / CLHEP::mm * Unit::mm);
  hit->setPDG(track.GetDefinition()->GetPDGEncoding());
  hit->setVolumeID(stripGlobal);
  m_MCParticlesToKLMSimHits.add(track.GetTrackID(), hit->getArrayIndex());
  return true;
}

Member Data Documentation

◆ m_BkgSensitiveDetector

BkgSensitiveDetector* m_BkgSensitiveDetector

private

Pointer to a sensitive-detector object used for beam-background steps.

Definition at line 99 of file SensitiveDetector.h.

◆ m_DepthLayer

constexpr int m_DepthLayer = 5

staticconstexprprivate

Layer depth.

Definition at line 87 of file SensitiveDetector.h.

◆ m_DepthPlane

constexpr int m_DepthPlane = 9

staticconstexprprivate

Plane depth.

Definition at line 90 of file SensitiveDetector.h.

◆ m_DepthScintillator

constexpr int m_DepthScintillator = 10

staticconstexprprivate

Scintillator depth.

Definition at line 93 of file SensitiveDetector.h.

◆ m_DepthSection

constexpr int m_DepthSection = 2

staticconstexprprivate

Section depth.

Definition at line 81 of file SensitiveDetector.h.

◆ m_DepthSector

constexpr int m_DepthSector = 3

staticconstexprprivate

Sector depth.

Definition at line 84 of file SensitiveDetector.h.

◆ m_ElementNumbers

const EKLMElementNumbers* m_ElementNumbers

private

EKLM element numbers.

Definition at line 105 of file SensitiveDetector.h.

◆ m_FirstCall

bool m_FirstCall

private

Flag to enforce once-only initializations in Initialize().

Definition at line 75 of file SensitiveDetector.h.

◆ m_GeoPar

bklm::GeometryPar* m_GeoPar

private

Pointer to GeometryPar singleton.

Definition at line 102 of file SensitiveDetector.h.

◆ m_HitTimeMax

double m_HitTimeMax

private

Maximum permissible hit time based on overflow of LeCroy 1877 TDC.

Definition at line 78 of file SensitiveDetector.h.

◆ m_KLMSimHits

StoreArray<KLMSimHit> m_KLMSimHits

private

Simulation hits.

Definition at line 114 of file SensitiveDetector.h.

◆ m_MCParticles

StoreArray<MCParticle> m_MCParticles

private

MC particles.

Definition at line 111 of file SensitiveDetector.h.

◆ m_MCParticlesToKLMSimHits

RelationArray m_MCParticlesToKLMSimHits {m_MCParticles, m_KLMSimHits}

private

Relation array between MCPartices and KLMSimHits.

Definition at line 117 of file SensitiveDetector.h.

◆ m_SimPar

DBObjPtr<BKLMSimulationPar> m_SimPar

private

Simulation parameters (from DB).

Definition at line 108 of file SensitiveDetector.h.

◆ m_Subdetector

KLMSubdetectorNumber m_Subdetector

private

Subdetector.

Definition at line 72 of file SensitiveDetector.h.

◆ m_subdetector

Const::EDetector m_subdetector

privateinherited

Subdetector the class belongs to.

Definition at line 91 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:

klm/simulation/include/SensitiveDetector.h
klm/simulation/src/SensitiveDetector.cc

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SensitiveDetector()

Member Function Documentation

◆ convertHitToRPCStrips()

◆ getMCParticleRelations()

◆ ProcessHits()

◆ registerMCParticleRelation() [1/2]

◆ registerMCParticleRelation() [2/2]

◆ setActive()

◆ step()

◆ stepBKLM()

◆ stepEKLM()

Member Data Documentation

◆ m_BkgSensitiveDetector

◆ m_DepthLayer

◆ m_DepthPlane

◆ m_DepthScintillator

◆ m_DepthSection

◆ m_DepthSector

◆ m_ElementNumbers

◆ m_FirstCall

◆ m_GeoPar

◆ m_HitTimeMax

◆ m_KLMSimHits

◆ m_MCParticles

◆ m_MCParticlesToKLMSimHits

◆ m_SimPar

◆ m_Subdetector

◆ m_subdetector

◆ s_active

◆ s_mcRelations