MuonSensitiveDetector Class Reference

#include <MuonSensitiveDetector.h>

Inheritance diagram for MuonSensitiveDetector:

Public Member Functions
void	clearHits () override
void	EndOfEvent (G4HCofThisEvent *) override
void	fillHits (edm::PSimHitContainer &, const std::string &) override
const MuonSlaveSD *	GetSlaveMuon () const
	MuonSensitiveDetector (const std::string &, const MuonOffsetMap *, const MuonGeometryConstants &, const SensitiveDetectorCatalog &, edm::ParameterSet const &p, const SimTrackManager *)
G4bool	ProcessHits (G4Step *, G4TouchableHistory *) override
uint32_t	setDetUnitId (const G4Step *) override
	~MuonSensitiveDetector () override
Public Member Functions inherited from SensitiveTkDetector
	SensitiveTkDetector (const std::string &iname, const SensitiveDetectorCatalog &clg)
Public Member Functions inherited from SensitiveDetector
void	EndOfEvent (G4HCofThisEvent *eventHC) override
const std::vector< std::string > &	getNames () const
void	Initialize (G4HCofThisEvent *eventHC) override
bool	isCaloSD () const
	SensitiveDetector (const std::string &iname, const SensitiveDetectorCatalog &, bool calo)
	~SensitiveDetector () override
Public Member Functions inherited from Observer< const BeginOfEvent *>
	Observer ()
void	slotForUpdate (const BeginOfEvent * iT)
virtual	~Observer ()

Protected Member Functions
void	update (const BeginOfEvent *) override
	This routine will be called when the appropriate signal arrives. More...
Protected Member Functions inherited from SensitiveDetector
TrackInformation *	cmsTrackInformation (const G4Track *aTrack)
Local3DPoint	ConvertToLocal3DPoint (const G4ThreeVector &point) const
Local3DPoint	FinalStepPosition (const G4Step *step, coordinates) const
Local3DPoint	InitialStepPosition (const G4Step *step, coordinates) const
Local3DPoint	LocalPostStepPosition (const G4Step *step) const
Local3DPoint	LocalPreStepPosition (const G4Step *step) const
void	NaNTrap (const G4Step *step) const
void	setNames (const std::vector< std::string > &)

Private Member Functions
bool	acceptHit (uint32_t id)
Local3DPoint	cmsUnits (const Local3DPoint &v)
void	createHit (const G4Step *)
Local3DPoint	FinalStepPositionVsParent (const G4Step *currentStep, G4int levelsUp)
Local3DPoint	InitialStepPositionVsParent (const G4Step *currentStep, G4int levelsUp)
bool	newHit (const G4Step *)
void	saveHit ()
void	updateHit (const G4Step *)

Private Attributes
bool	allMuonsPersistent_
bool	demoGEM_
bool	demoRPC_
MuonSubDetector *	detector
float	ePersistentCutGeV_
MuonG4Numbering *	g4numbering
bool	haveDemo_
uint32_t	newDetUnitId
MuonSimHitNumberingScheme *	numbering
bool	printHits_
MuonSlaveSD *	slaveMuon
uint32_t	theDetUnitId
G4ProcessTypeEnumerator *	theG4ProcessTypeEnumerator
UpdatablePSimHit *	theHit
const SimTrackManager *	theManager
SimHitPrinter *	thePrinter
const G4VPhysicalVolume *	thePV
const MuonFrameRotation *	theRotation
int	theTrackID

Additional Inherited Members
Protected Types inherited from SensitiveDetector
enum	coordinates { WorldCoordinates, LocalCoordinates }

Detailed Description

implementation of SensitiveDetector for the muon detector; a MuonSlaveSD handles the interfacing to the database; numbering scheme are booked according to the detector name

Author

Arno Straessner, CERN arno..nosp@m.stra.nosp@m.essne.nosp@m.r@ce.nosp@m.rn.ch

Modification: 19/05/03. P.Arce Add SimTracks selection

Definition at line 39 of file MuonSensitiveDetector.h.

Constructor & Destructor Documentation

MuonSensitiveDetector()

MuonSensitiveDetector::MuonSensitiveDetector ( const std::string &  name, const MuonOffsetMap *  offmap, const MuonGeometryConstants &  constants, const SensitiveDetectorCatalog &  clg, edm::ParameterSet const &  p, const SimTrackManager *  manager  )

explicit

Definition at line 39 of file MuonSensitiveDetector.cc.

References allMuonsPersistent_, demoGEM_, demoRPC_, detector, ePersistentCutGeV_, g4numbering, haveDemo_, MuonSubDetector::isBarrel(), MuonSubDetector::isEndcap(), MuonSubDetector::isGEM(), MuonSubDetector::isME0(), MuonSubDetector::isRPC(), Skims_PA_cff::name, numbering, AlCaHLTBitMon_ParallelJobs::p, printHits_, slaveMuon, theG4ProcessTypeEnumerator, theManager, thePrinter, and theRotation.

    : SensitiveTkDetector(name, clg),
      thePV(nullptr),
      theHit(nullptr),
      theDetUnitId(0),
      newDetUnitId(0),
      theTrackID(0),
      thePrinter(nullptr),
      theManager(manager) {
  // Here simply create 1 MuonSlaveSD for the moment
  //
  bool dd4hep = p.getParameter<bool>("g4GeometryDD4hepSource");
  edm::ParameterSet muonSD = p.getParameter<edm::ParameterSet>("MuonSD");
  printHits_ = muonSD.getParameter<bool>("PrintHits");
  ePersistentCutGeV_ = muonSD.getParameter<double>("EnergyThresholdForPersistency") / CLHEP::GeV;  //Default 1. GeV
  allMuonsPersistent_ = muonSD.getParameter<bool>("AllMuonsPersistent");
  haveDemo_ = muonSD.getParameter<bool>("HaveDemoChambers");
  demoGEM_ = muonSD.getParameter<bool>("UseDemoHitGEM");
  demoRPC_ = muonSD.getParameter<bool>("UseDemoHitRPC");

#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("MuonSim") << "create MuonSubDetector " << name << " with dd4hep flag " << dd4hep
                              << " Flags for Demonstration chambers " << haveDemo_ << " for GEM " << demoGEM_
                              << " for RPC " << demoRPC_;
#endif
  detector = new MuonSubDetector(name);

  G4String sdet = "unknown";
  if (detector->isEndcap()) {
    theRotation = new MuonEndcapFrameRotation();
    sdet = "Endcap";
  } else if (detector->isRPC()) {
    theRotation = new MuonRPCFrameRotation(constants, offmap, dd4hep);
    sdet = "RPC";
  } else if (detector->isGEM()) {
    theRotation = new MuonGEMFrameRotation(constants);
    sdet = "GEM";
  } else if (detector->isME0()) {
    theRotation = new MuonME0FrameRotation(constants);
    sdet = "ME0";
  } else {
    theRotation = new MuonFrameRotation();
    if (detector->isBarrel())
      sdet = "Barrel";
  }
  slaveMuon = new MuonSlaveSD(detector, theManager);
  numbering = new MuonSimHitNumberingScheme(detector, constants);
  g4numbering = new MuonG4Numbering(constants, offmap, dd4hep);

  if (printHits_) {
    thePrinter = new SimHitPrinter("HitPositionOSCAR.dat");
  }

  edm::LogVerbatim("MuonSim") << " of type " << sdet << " <" << GetName() << "> EnergyThresholdForPersistency(GeV) "
                              << ePersistentCutGeV_ / CLHEP::GeV << " allMuonsPersistent: " << allMuonsPersistent_;

  theG4ProcessTypeEnumerator = new G4ProcessTypeEnumerator;
}

~MuonSensitiveDetector()

MuonSensitiveDetector::~MuonSensitiveDetector ( )

override

Definition at line 103 of file MuonSensitiveDetector.cc.

References detector, g4numbering, numbering, slaveMuon, theG4ProcessTypeEnumerator, and theRotation.

                                              {
  delete g4numbering;
  delete numbering;
  delete slaveMuon;
  delete theRotation;
  delete detector;
  delete theG4ProcessTypeEnumerator;
}

Member Function Documentation

acceptHit()

bool MuonSensitiveDetector::acceptHit ( uint32_t  id )

private

Definition at line 357 of file MuonSensitiveDetector.cc.

References MuonSubdetId::CSC, TauDecayModes::dec, demoGEM_, demoRPC_, MuonSubdetId::DT, RemoveAddSevLevel::flag, MuonSubdetId::GEM, haveDemo_, MuonSubdetId::ME0, HLT_2022v11_cff::region, relativeConstraints::ring, MuonSubdetId::RPC, relativeConstraints::station, and DetId::subdetId().

Referenced by saveHit().

                                                 {
  if (id == 0) {
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("MuonSim") << "DetId " << id << " Flag " << false;
#endif
    return false;
  }
  bool flag(true);
  if (haveDemo_) {
    int subdet = DetId(id).subdetId();
    if (subdet == MuonSubdetId::GEM) {
      if (GEMDetId(id).station() == 2)
        flag = demoGEM_;
    } else if (subdet == MuonSubdetId::RPC) {
      if ((RPCDetId(id).region() != 0) && (RPCDetId(id).ring() == 1) && (RPCDetId(id).station() > 2))
        flag = demoRPC_;
    }
  }
#ifdef EDM_ML_DEBUG
  int subdet = DetId(id).subdetId();
  if (subdet == MuonSubdetId::RPC)
    edm::LogVerbatim("MuonSim") << "DetId " << std::hex << id << std::dec << " RPC " << RPCDetId(id) << " Flag "
                                << flag;
  else if (subdet == MuonSubdetId::GEM)
    edm::LogVerbatim("MuonSim") << "DetId " << std::hex << id << std::dec << " GEM " << GEMDetId(id) << " Flag "
                                << flag;
  else if (subdet == MuonSubdetId::ME0)
    edm::LogVerbatim("MuonSim") << "DetId " << std::hex << id << std::dec << " " << ME0DetId(id) << " Flag " << flag;
  else if (subdet == MuonSubdetId::CSC)
    edm::LogVerbatim("MuonSim") << "DetId " << std::hex << id << std::dec << " CSC Flag " << flag;
  else if (subdet == MuonSubdetId::DT)
    edm::LogVerbatim("MuonSim") << "DetId " << std::hex << id << std::dec << " DT Flag " << flag;
  else
    edm::LogVerbatim("MuonSim") << "DetId " << std::hex << id << std::dec << " Unknown Flag " << flag;
#endif
  return flag;
}

clearHits()

void MuonSensitiveDetector::clearHits ( )

overridevirtual

Implements SensitiveDetector.

Definition at line 120 of file MuonSensitiveDetector.cc.

References TrackingSlaveSD::Initialize(), and slaveMuon.

Referenced by update().

                                      {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("MuonSim") << "MuonSensitiveDetector::clearHits";
#endif
  slaveMuon->Initialize();
}

cmsUnits()

Local3DPoint MuonSensitiveDetector::cmsUnits ( const Local3DPoint &  v )

inlineprivate

Definition at line 61 of file MuonSensitiveDetector.h.

References findQualityFiles::v.

Referenced by createHit(), and updateHit().

{ return Local3DPoint(v.x() * 0.1, v.y() * 0.1, v.z() * 0.1); }

createHit()

void MuonSensitiveDetector::createHit ( const G4Step *  aStep )

private

Definition at line 178 of file MuonSensitiveDetector.cc.

References funct::abs(), allMuonsPersistent_, SensitiveDetector::cmsTrackInformation(), cmsUnits(), SensitiveDetector::ConvertToLocal3DPoint(), detector, ePersistentCutGeV_, SensitiveDetector::FinalStepPosition(), FinalStepPositionVsParent(), info(), SensitiveDetector::InitialStepPosition(), InitialStepPositionVsParent(), MuonSubDetector::isBarrel(), MuonSubDetector::isEndcap(), SensitiveDetector::LocalCoordinates, PV3DBase< T, PVType, FrameType >::mag(), newDetUnitId, AlCaHLTBitMon_ParallelJobs::p, SiStripOfflineCRack_cfg::p2, G4TrackToParticleID::particleID(), PV3DBase< T, PVType, FrameType >::phi(), G4ProcessTypeEnumerator::processId(), theDetUnitId, theG4ProcessTypeEnumerator, theHit, thePV, theRotation, PV3DBase< T, PVType, FrameType >::theta(), theTrackID, MuonFrameRotation::transformPoint(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by ProcessHits().

                                                         {
  Local3DPoint theEntryPoint;
  Local3DPoint theExitPoint;

  if (detector->isBarrel()) {
    // 1 levels up
    theEntryPoint = cmsUnits(theRotation->transformPoint(InitialStepPositionVsParent(aStep, 1), aStep));
    theExitPoint = cmsUnits(theRotation->transformPoint(FinalStepPositionVsParent(aStep, 1), aStep));
  } else if (detector->isEndcap()) {
    // save local z at current level
    theEntryPoint = theRotation->transformPoint(InitialStepPosition(aStep, LocalCoordinates), aStep);
    theExitPoint = theRotation->transformPoint(FinalStepPosition(aStep, LocalCoordinates), aStep);
    float zentry = theEntryPoint.z();
    float zexit = theExitPoint.z();
    // 4 levels up
    Local3DPoint tempEntry = theRotation->transformPoint(InitialStepPositionVsParent(aStep, 4), aStep);
    Local3DPoint tempExit = theRotation->transformPoint(FinalStepPositionVsParent(aStep, 4), aStep);
    // reset local z from z wrt deep-parent volume to z wrt low-level volume
    theEntryPoint = cmsUnits(Local3DPoint(tempEntry.x(), tempEntry.y(), zentry));
    theExitPoint = cmsUnits(Local3DPoint(tempExit.x(), tempExit.y(), zexit));
  } else {
    theEntryPoint = cmsUnits(theRotation->transformPoint(InitialStepPosition(aStep, LocalCoordinates), aStep));
    theExitPoint = cmsUnits(theRotation->transformPoint(FinalStepPosition(aStep, LocalCoordinates), aStep));
  }

  const G4Track* theTrack = aStep->GetTrack();
  const G4StepPoint* preStepPoint = aStep->GetPreStepPoint();

  float thePabs = preStepPoint->GetMomentum().mag() / CLHEP::GeV;
  float theTof = preStepPoint->GetGlobalTime() / CLHEP::nanosecond;
  float theEnergyLoss = aStep->GetTotalEnergyDeposit() / CLHEP::GeV;
  int theParticleType = G4TrackToParticleID::particleID(theTrack);

  theDetUnitId = newDetUnitId;
  thePV = preStepPoint->GetPhysicalVolume();
  theTrackID = theTrack->GetTrackID();

  // convert momentum direction it to local frame
  const G4ThreeVector& gmd = preStepPoint->GetMomentumDirection();
  G4ThreeVector lmd = static_cast<const G4TouchableHistory*>(preStepPoint->GetTouchable())
                          ->GetHistory()
                          ->GetTopTransform()
                          .TransformAxis(gmd);
  Local3DPoint lnmd = ConvertToLocal3DPoint(lmd);
  lnmd = theRotation->transformPoint(lnmd, aStep);
  float theThetaAtEntry = lnmd.theta();
  float thePhiAtEntry = lnmd.phi();

  theHit = new UpdatablePSimHit(theEntryPoint,
                                theExitPoint,
                                thePabs,
                                theTof,
                                theEnergyLoss,
                                theParticleType,
                                theDetUnitId,
                                theTrackID,
                                theThetaAtEntry,
                                thePhiAtEntry,
                                theG4ProcessTypeEnumerator->processId(theTrack->GetCreatorProcess()));

  // Make track persistent
  int thePID = std::abs(theTrack->GetDefinition()->GetPDGEncoding());
  //---VI - in parameters cut in energy is declared but applied to momentum
  if (thePabs > ePersistentCutGeV_ || (thePID == 13 && allMuonsPersistent_)) {
    TrackInformation* info = cmsTrackInformation(theTrack);
    info->storeTrack(true);
  }

#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("MuonSim") << "=== NEW Muon hit for " << GetName() << " Edep(GeV)= " << theEnergyLoss << " "
                              << thePV->GetLogicalVolume()->GetName();
  const G4VProcess* p = aStep->GetPostStepPoint()->GetProcessDefinedStep();
  const G4VProcess* p2 = aStep->GetPreStepPoint()->GetProcessDefinedStep();
  G4String sss = "";
  if (p)
    sss += " POST PROCESS: " + p->GetProcessName();
  if (p2)
    sss += ";  PRE  PROCESS: " + p2->GetProcessName();
  if (!sss.empty())
    edm::LogVerbatim("MuonSim") << sss;
  edm::LogVerbatim("MuonSim") << " theta= " << theThetaAtEntry << " phi= " << thePhiAtEntry << " Pabs(GeV/c)  "
                              << thePabs << " Eloss(GeV)= " << theEnergyLoss << " Tof(ns)=  " << theTof
                              << " trackID= " << theTrackID << " detID= " << theDetUnitId << "\n Local:  entry "
                              << theEntryPoint << " exit " << theExitPoint << " delta "
                              << (theExitPoint - theEntryPoint) << "\n Global: entry "
                              << aStep->GetPreStepPoint()->GetPosition() << " exit "
                              << aStep->GetPostStepPoint()->GetPosition();
#endif
}

EndOfEvent()

void MuonSensitiveDetector::EndOfEvent ( G4HCofThisEvent *  )

override

Definition at line 322 of file MuonSensitiveDetector.cc.

References saveHit().

{ saveHit(); }

fillHits()

void MuonSensitiveDetector::fillHits ( edm::PSimHitContainer &  cc, const std::string &  hname  )

overridevirtual

Implements SensitiveTkDetector.

Definition at line 324 of file MuonSensitiveDetector.cc.

References TrackingSlaveSD::hits(), TrackingSlaveSD::name(), and slaveMuon.

                                                                                    {
  if (slaveMuon->name() == hname) {
    cc = slaveMuon->hits();
  }
}

FinalStepPositionVsParent()

Local3DPoint MuonSensitiveDetector::FinalStepPositionVsParent ( const G4Step *  currentStep, G4int  levelsUp  )

private

Definition at line 343 of file MuonSensitiveDetector.cc.

References SensitiveDetector::ConvertToLocal3DPoint(), and LEDCalibrationChannels::depth.

Referenced by createHit(), and updateHit().

                                                                                                       {
  const G4StepPoint* postStepPoint = currentStep->GetPostStepPoint();
  const G4StepPoint* preStepPoint = currentStep->GetPreStepPoint();
  const G4ThreeVector& globalCoordinates = postStepPoint->GetPosition();

  const G4TouchableHistory* theTouchable = (const G4TouchableHistory*)(preStepPoint->GetTouchable());

  G4int depth = theTouchable->GetHistory()->GetDepth();
  G4ThreeVector localCoordinates =
      theTouchable->GetHistory()->GetTransform(depth - levelsUp).TransformPoint(globalCoordinates);

  return ConvertToLocal3DPoint(localCoordinates);
}

GetSlaveMuon()

const MuonSlaveSD* MuonSensitiveDetector::GetSlaveMuon ( ) const

inline

Definition at line 55 of file MuonSensitiveDetector.h.

References slaveMuon.

{ return slaveMuon; }

InitialStepPositionVsParent()

Local3DPoint MuonSensitiveDetector::InitialStepPositionVsParent ( const G4Step *  currentStep, G4int  levelsUp  )

private

Transform from local coordinates of a volume to local coordinates of a parent volume one or more levels up the volume hierarchy: e.g. levelsUp = 1 for immediate parent. This is done by moving from local_1 -> global -> local_2.

Definition at line 330 of file MuonSensitiveDetector.cc.

References SensitiveDetector::ConvertToLocal3DPoint(), and LEDCalibrationChannels::depth.

Referenced by createHit().

                                                                                                         {
  const G4StepPoint* preStepPoint = currentStep->GetPreStepPoint();
  const G4ThreeVector& globalCoordinates = preStepPoint->GetPosition();

  const G4TouchableHistory* theTouchable = (const G4TouchableHistory*)(preStepPoint->GetTouchable());

  G4int depth = theTouchable->GetHistory()->GetDepth();
  G4ThreeVector localCoordinates =
      theTouchable->GetHistory()->GetTransform(depth - levelsUp).TransformPoint(globalCoordinates);

  return ConvertToLocal3DPoint(localCoordinates);
}

newHit()

bool MuonSensitiveDetector::newHit ( const G4Step *  aStep )

private

Definition at line 173 of file MuonSensitiveDetector.cc.

References newDetUnitId, theDetUnitId, theHit, thePV, and theTrackID.

Referenced by ProcessHits().

                                                      {
  return (!theHit || (aStep->GetTrack()->GetTrackID() != theTrackID) ||
          (aStep->GetPreStepPoint()->GetPhysicalVolume() != thePV) || newDetUnitId != theDetUnitId);
}

ProcessHits()

bool MuonSensitiveDetector::ProcessHits ( G4Step *  aStep, G4TouchableHistory *  ROhist  )

overridevirtual

Implements SensitiveDetector.

Definition at line 127 of file MuonSensitiveDetector.cc.

References createHit(), SensitiveDetector::InitialStepPosition(), Skims_PA_cff::name, newDetUnitId, newHit(), saveHit(), setDetUnitId(), AlCaHLTBitMon_QueryRunRegistry::string, theDetUnitId, thePV, theTrackID, updateHit(), and SensitiveDetector::WorldCoordinates.

                                                                                 {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("MuonSim") << " MuonSensitiveDetector::ProcessHits " << InitialStepPosition(aStep, WorldCoordinates);
#endif

  if (aStep->GetTotalEnergyDeposit() > 0.) {
    newDetUnitId = setDetUnitId(aStep);
#ifdef EDM_ML_DEBUG
    G4VPhysicalVolume* vol = aStep->GetPreStepPoint()->GetTouchable()->GetVolume(0);
    std::string namx = static_cast<std::string>(vol->GetName());
    std::string name = namx.substr(0, 2);
    if (name == "RE")
      edm::LogVerbatim("MuonSim") << "DETID " << namx << " " << RPCDetId(newDetUnitId);
#endif
    if (newHit(aStep)) {
      saveHit();
      createHit(aStep);
    } else {
      updateHit(aStep);
    }
    thePV = aStep->GetPreStepPoint()->GetPhysicalVolume();
    theTrackID = aStep->GetTrack()->GetTrackID();
    theDetUnitId = newDetUnitId;
  }
  return true;
}

saveHit()

void MuonSensitiveDetector::saveHit ( )

private

Definition at line 306 of file MuonSensitiveDetector.cc.

References acceptHit(), detector, PSimHit::detUnitId(), PSimHit::entryPoint(), PSimHit::exitPoint(), MuonSubDetector::name(), printHits_, SimHitPrinter::printId(), SimHitPrinter::printLocal(), TrackingSlaveSD::processHits(), slaveMuon, SimHitPrinter::startNewSimHit(), theHit, and thePrinter.

Referenced by EndOfEvent(), and ProcessHits().

                                    {
  if (theHit) {
    if (acceptHit(theHit->detUnitId())) {
      if (printHits_) {
        thePrinter->startNewSimHit(detector->name());
        thePrinter->printId(theHit->detUnitId());
        thePrinter->printLocal(theHit->entryPoint(), theHit->exitPoint());
      }
      // hit is included into hit collection
      slaveMuon->processHits(*theHit);
    }
    delete theHit;
    theHit = nullptr;
  }
}

setDetUnitId()

uint32_t MuonSensitiveDetector::setDetUnitId ( const G4Step *  aStep )

overridevirtual

Implements SensitiveDetector.

Definition at line 154 of file MuonSensitiveDetector.cc.

References MuonSimHitNumberingScheme::baseNumberToUnitNumber(), g4numbering, personalPlayback::level, EgammaValidation_cff::num, numbering, MuonG4Numbering::PhysicalVolumeToBaseNumber(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ProcessHits().

                                                                {
  MuonBaseNumber num = g4numbering->PhysicalVolumeToBaseNumber(aStep);

#ifdef EDM_ML_DEBUG
  std::stringstream MuonBaseNumber;
  MuonBaseNumber << "MuonNumbering :: number of levels = " << num.getLevels() << std::endl;
  MuonBaseNumber << "Level \t SuperNo \t BaseNo" << std::endl;
  for (int level = 1; level <= num.getLevels(); level++) {
    MuonBaseNumber << level << " \t " << num.getSuperNo(level) << " \t " << num.getBaseNo(level) << std::endl;
  }
  std::string MuonBaseNumbr = MuonBaseNumber.str();

  edm::LogVerbatim("MuonSim") << "MuonSensitiveDetector::setDetUnitId :: " << MuonBaseNumbr;
  edm::LogVerbatim("MuonSim") << "MuonSensitiveDetector::setDetUnitId :: MuonDetUnitId = "
                              << (numbering->baseNumberToUnitNumber(num));
#endif
  return numbering->baseNumberToUnitNumber(num);
}

update()

void MuonSensitiveDetector::update ( const BeginOfEvent *  )

overrideprotectedvirtual

This routine will be called when the appropriate signal arrives.

Implements Observer< const BeginOfEvent *>.

Definition at line 112 of file MuonSensitiveDetector.cc.

References clearHits(), theDetUnitId, thePV, and theTrackID.

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), progressbar.ProgressBar::finish(), and MatrixUtil.Steps::overwrite().

                                                        {
  clearHits();
  //----- Initialize variables to check if two steps belong to same hit
  thePV = nullptr;
  theDetUnitId = 0;
  theTrackID = 0;
}

updateHit()

void MuonSensitiveDetector::updateHit ( const G4Step *  aStep )

private

Definition at line 268 of file MuonSensitiveDetector.cc.

References UpdatablePSimHit::addEnergyLoss(), cmsUnits(), detector, SensitiveDetector::FinalStepPosition(), FinalStepPositionVsParent(), MuonSubDetector::isBarrel(), MuonSubDetector::isEndcap(), SensitiveDetector::LocalCoordinates, AlCaHLTBitMon_ParallelJobs::p, SiStripOfflineCRack_cfg::p2, theDetUnitId, theHit, thePV, theRotation, theTrackID, MuonFrameRotation::transformPoint(), UpdatablePSimHit::updateExitPoint(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by ProcessHits().

                                                         {
  Local3DPoint theExitPoint;

  if (detector->isBarrel()) {
    theExitPoint = cmsUnits(theRotation->transformPoint(FinalStepPositionVsParent(aStep, 1), aStep));
  } else if (detector->isEndcap()) {
    // save local z at current level
    theExitPoint = theRotation->transformPoint(FinalStepPosition(aStep, LocalCoordinates), aStep);
    float zexit = theExitPoint.z();
    Local3DPoint tempExitPoint = theRotation->transformPoint(FinalStepPositionVsParent(aStep, 4), aStep);
    theExitPoint = cmsUnits(Local3DPoint(tempExitPoint.x(), tempExitPoint.y(), zexit));
  } else {
    theExitPoint = cmsUnits(theRotation->transformPoint(FinalStepPosition(aStep, LocalCoordinates), aStep));
  }

  float theEnergyLoss = aStep->GetTotalEnergyDeposit() / CLHEP::GeV;

  theHit->updateExitPoint(theExitPoint);
  theHit->addEnergyLoss(theEnergyLoss);

#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("MuonSim") << "=== NEW Update muon hit for " << GetName() << " Edep(GeV)= " << theEnergyLoss << " "
                              << thePV->GetLogicalVolume()->GetName();
  const G4VProcess* p = aStep->GetPostStepPoint()->GetProcessDefinedStep();
  const G4VProcess* p2 = aStep->GetPreStepPoint()->GetProcessDefinedStep();
  G4String sss = "";
  if (p)
    sss += " POST PROCESS: " + p->GetProcessName();
  if (p2)
    sss += ";  PRE  PROCESS: " + p2->GetProcessName();
  if (!sss.empty())
    edm::LogVerbatim("MuonSim") << sss;
  edm::LogVerbatim("MuonSim") << " delEloss(GeV)= " << theEnergyLoss
                              << " Tof(ns)=  " << aStep->GetPreStepPoint()->GetGlobalTime() / CLHEP::nanosecond
                              << " trackID= " << theTrackID << " detID= " << theDetUnitId << " exit " << theExitPoint;
#endif
}

Member Data Documentation

allMuonsPersistent_

bool MuonSensitiveDetector::allMuonsPersistent_

private

Definition at line 94 of file MuonSensitiveDetector.h.

Referenced by createHit(), and MuonSensitiveDetector().

demoGEM_

bool MuonSensitiveDetector::demoGEM_

private

Definition at line 98 of file MuonSensitiveDetector.h.

Referenced by acceptHit(), and MuonSensitiveDetector().

demoRPC_

bool MuonSensitiveDetector::demoRPC_

private

Definition at line 99 of file MuonSensitiveDetector.h.

Referenced by acceptHit(), and MuonSensitiveDetector().

detector

MuonSubDetector* MuonSensitiveDetector::detector

private

Definition at line 66 of file MuonSensitiveDetector.h.

Referenced by createHit(), MuonSensitiveDetector(), saveHit(), updateHit(), and ~MuonSensitiveDetector().

ePersistentCutGeV_

float MuonSensitiveDetector::ePersistentCutGeV_

private

Definition at line 93 of file MuonSensitiveDetector.h.

Referenced by createHit(), and MuonSensitiveDetector().

g4numbering

MuonG4Numbering* MuonSensitiveDetector::g4numbering

private

Definition at line 68 of file MuonSensitiveDetector.h.

Referenced by MuonSensitiveDetector(), setDetUnitId(), and ~MuonSensitiveDetector().

haveDemo_

bool MuonSensitiveDetector::haveDemo_

private

Definition at line 97 of file MuonSensitiveDetector.h.

Referenced by acceptHit(), and MuonSensitiveDetector().

newDetUnitId

uint32_t MuonSensitiveDetector::newDetUnitId

private

Definition at line 86 of file MuonSensitiveDetector.h.

Referenced by createHit(), newHit(), and ProcessHits().

numbering

MuonSimHitNumberingScheme* MuonSensitiveDetector::numbering

private

Definition at line 65 of file MuonSensitiveDetector.h.

Referenced by MuonSensitiveDetector(), setDetUnitId(), and ~MuonSensitiveDetector().

printHits_

bool MuonSensitiveDetector::printHits_

private

Definition at line 89 of file MuonSensitiveDetector.h.

Referenced by MuonSensitiveDetector(), and saveHit().

slaveMuon

MuonSlaveSD* MuonSensitiveDetector::slaveMuon

private

Definition at line 64 of file MuonSensitiveDetector.h.

Referenced by clearHits(), fillHits(), GetSlaveMuon(), MuonSensitiveDetector(), saveHit(), and ~MuonSensitiveDetector().

theDetUnitId

uint32_t MuonSensitiveDetector::theDetUnitId

private

Definition at line 85 of file MuonSensitiveDetector.h.

Referenced by createHit(), newHit(), ProcessHits(), update(), and updateHit().

theG4ProcessTypeEnumerator

G4ProcessTypeEnumerator* MuonSensitiveDetector::theG4ProcessTypeEnumerator

private

Definition at line 101 of file MuonSensitiveDetector.h.

Referenced by createHit(), MuonSensitiveDetector(), and ~MuonSensitiveDetector().

theHit

UpdatablePSimHit* MuonSensitiveDetector::theHit

private

Definition at line 84 of file MuonSensitiveDetector.h.

Referenced by createHit(), newHit(), saveHit(), and updateHit().

theManager

const SimTrackManager* MuonSensitiveDetector::theManager

private

Definition at line 103 of file MuonSensitiveDetector.h.

Referenced by MuonSensitiveDetector().

thePrinter

SimHitPrinter* MuonSensitiveDetector::thePrinter

private

Definition at line 90 of file MuonSensitiveDetector.h.

Referenced by MuonSensitiveDetector(), and saveHit().

thePV

const G4VPhysicalVolume* MuonSensitiveDetector::thePV

private

Definition at line 83 of file MuonSensitiveDetector.h.

Referenced by createHit(), newHit(), ProcessHits(), update(), and updateHit().

theRotation

const MuonFrameRotation* MuonSensitiveDetector::theRotation

private

Definition at line 67 of file MuonSensitiveDetector.h.

Referenced by createHit(), MuonSensitiveDetector(), updateHit(), and ~MuonSensitiveDetector().

theTrackID

int MuonSensitiveDetector::theTrackID

private

Definition at line 87 of file MuonSensitiveDetector.h.

Referenced by createHit(), newHit(), ProcessHits(), update(), and updateHit().