Produces SimHits in the tracker layers. More...

Inheritance diagram for fastsim::TrackerSimHitProducer:

Public Member Functions
std::pair< double, std::unique_ptr< PSimHit > >	createHitOnDetector (const TrajectoryStateOnSurface &particle, int pdgId, double layerThickness, double eLoss, int simTrackId, const GeomDet &detector, GlobalPoint &refPos)
	Helper funtion to create the actual SimHit on a detector (sub-) module. More...

void	interact (Particle &particle, const SimplifiedGeometry &layer, std::vector< std::unique_ptr< Particle >> &secondaries, const RandomEngineAndDistribution &random) override
	Perform the interaction. More...

void	registerProducts (edm::ProducesCollector) const override
	Register the SimHit collection. More...

void	storeProducts (edm::Event &iEvent) override
	Store the SimHit collection. More...

	TrackerSimHitProducer (const std::string &name, const edm::ParameterSet &cfg)
	Constructor. More...

	~TrackerSimHitProducer () override
	Default destructor. More...

Public Member Functions inherited from fastsim::InteractionModel
const std::string	getName ()
	Return (unique) name of this interaction. More...

virtual void	interact (Particle &particle, const SimplifiedGeometry &layer, std::vector< std::unique_ptr< Particle > > &secondaries, const RandomEngineAndDistribution &random)=0
	Perform the interaction. More...

	InteractionModel (std::string name)
	Constructor. More...

virtual	~InteractionModel ()
	Default destructor. More...

Private Attributes
bool	doHitsFromInboundParticles_
	If not set, incoming particles (negative speed relative to center of detector) don't create a SimHits since reconstruction anyways not possible. More...

double	minMomentum_
	Set the minimal momentum of incoming particle. More...

const double	onSurfaceTolerance_
	Max distance between particle and active (sub-) module. Otherwise particle has to be propagated. More...

std::unique_ptr< edm::PSimHitContainer >	simHitContainer_
	The SimHit. More...

Detailed Description

Produces SimHits in the tracker layers.

Also assigns the energy loss of the particle (ionization) with the SimHit. Furthermore, SimHits from different SubModules have to be sorted by their occurance!

See also: EnergyLoss

Definition at line 52 of file TrackerSimHitProducer.cc.

Constructor & Destructor Documentation

fastsim::TrackerSimHitProducer::TrackerSimHitProducer	(	const std::string &	name,
		const edm::ParameterSet &	cfg
	)

Constructor.

Definition at line 106 of file TrackerSimHitProducer.cc.

References doHitsFromInboundParticles_, edm::ParameterSet::getParameter(), and minMomentum_.

     : fastsim::InteractionModel(name), onSurfaceTolerance_(0.01), simHitContainer_(new edm::PSimHitContainer) {
   // Set the minimal momentum
   minMomentum_ = cfg.getParameter<double>("minMomentumCut");
   // - if not set, particles from outside the beampipe with a negative speed in R direction are propagated but no SimHits
   // - particle with positive (negative) z and negative (positive) speed in z direction: no SimHits
   // -> this is not neccesary since a track reconstruction is not possible in this case anyways
   doHitsFromInboundParticles_ = cfg.getParameter<bool>("doHitsFromInboundParticles");
 }

fastsim::TrackerSimHitProducer::~TrackerSimHitProducer ( )

inlineoverride

Default destructor.

Definition at line 58 of file TrackerSimHitProducer.cc.

References createHitOnDetector(), hgcalTestNeighbor_cfi::detector, simKBmtfDigis_cfi::eLoss, iEvent, interact(), EgammaValidation_cff::pdgId, registerProducts(), and storeProducts().

58 { ; }

Member Function Documentation

std::pair< double, std::unique_ptr< PSimHit > > fastsim::TrackerSimHitProducer::createHitOnDetector	(	const TrajectoryStateOnSurface &	particle,
		int	pdgId,
		double	layerThickness,
		double	eLoss,
		int	simTrackId,
		const GeomDet &	detector,
		GlobalPoint &	refPos
	)

Helper funtion to create the actual SimHit on a detector (sub-) module.

Parameters

particle	Representation of the particle's trajectory
pdgId	The pdgId of the particle
layerThickness	The thickness of the layer (in radLengths)
eLoss	The energy that particle deposited in the detector (lost via ionisation)
simTrackId	The SimTrack this hit should be assigned to
detector	The detector element that is hit
refPos	Reference position that is used to sort the hits if layer consists of sub-detectors \ return Returns the SimHit and the distance relative to refPos since hits have to be ordered (in time) afterwards.

Definition at line 254 of file TrackerSimHitProducer.cc.

Referenced by interact(), and ~TrackerSimHitProducer().

                          {
   // determine position and momentum of particle in the coordinate system of the detector
   LocalPoint localPosition;
   LocalVector localMomentum;
 
   // if the particle is close enough, no further propagation is needed
   if (fabs(detector.toLocal(particle.globalPosition()).z()) < onSurfaceTolerance_) {
     localPosition = particle.localPosition();
     localMomentum = particle.localMomentum();
   }
   // else, propagate
   else {
     // find crossing of particle with detector layer
     HelixArbitraryPlaneCrossing crossing(particle.globalPosition().basicVector(),
                                          particle.globalMomentum().basicVector(),
                                          particle.transverseCurvature(),
                                          anyDirection);
     std::pair<bool, double> path = crossing.pathLength(detector.surface());
     // case propagation succeeds
     if (path.first) {
       localPosition = detector.toLocal(GlobalPoint(crossing.position(path.second)));
       localMomentum = detector.toLocal(GlobalVector(crossing.direction(path.second)));
       localMomentum = localMomentum.unit() * particle.localMomentum().mag();
     }
     // case propagation fails
     else {
       return std::pair<double, std::unique_ptr<PSimHit>>(0, std::unique_ptr<PSimHit>(nullptr));
     }
   }
 
   // find entry and exit point of particle in detector
   const Plane& detectorPlane = detector.surface();
   double halfThick = 0.5 * detectorPlane.bounds().thickness();
   double pZ = localMomentum.z();
   LocalPoint entry = localPosition + (-halfThick / pZ) * localMomentum;
   LocalPoint exit = localPosition + (halfThick / pZ) * localMomentum;
   double tof = particle.globalPosition().mag() / fastsim::Constants::speedOfLight;  // in nanoseconds
 
   // make sure the simhit is physically on the module
   double boundX = detectorPlane.bounds().width() / 2.;
   double boundY = detectorPlane.bounds().length() / 2.;
   // Special treatment for TID and TEC trapeziodal modules
   unsigned subdet = DetId(detector.geographicalId()).subdetId();
   if (subdet == 4 || subdet == 6)
     boundX *= 1. - localPosition.y() / detectorPlane.position().perp();
   if (fabs(localPosition.x()) > boundX || fabs(localPosition.y()) > boundY) {
     return std::pair<double, std::unique_ptr<PSimHit>>(0, std::unique_ptr<PSimHit>(nullptr));
   }
 
   // Create the hit: the energy loss rescaled to the module thickness
   // Total thickness is in radiation lengths, 1 radlen = 9.36 cm
   // Sensitive module thickness is about 30 microns larger than
   // the module thickness itself
   eLoss *= (2. * halfThick - 0.003) / (9.36 * layerThickness);
 
   // Position of the hit in global coordinates
   GlobalPoint hitPos(detector.surface().toGlobal(localPosition));
 
   return std::pair<double, std::unique_ptr<PSimHit>>(
       (hitPos - refPos).mag(),
       std::unique_ptr<PSimHit>(new PSimHit(entry,
                                            exit,
                                            localMomentum.mag(),
                                            tof,
                                            eLoss,
                                            pdgId,
                                            detector.geographicalId().rawId(),
                                            simTrackId,
                                            localMomentum.theta(),
                                            localMomentum.phi())));
 }

void fastsim::TrackerSimHitProducer::interact	(	Particle &	particle,
		const SimplifiedGeometry &	layer,
		std::vector< std::unique_ptr< Particle >> &	secondaries,
		const RandomEngineAndDistribution &	random
	)

override

Perform the interaction.

Parameters

particle	The particle that interacts with the matter.
layer	The detector layer that interacts with the particle.
secondaries	Particles that are produced in the interaction (if any).
random	The Random Engine.

Definition at line 125 of file TrackerSimHitProducer.cc.

References anyDirection, fastsim::Particle::charge(), GeometricSearchDet::compatibleDets(), GeomDet::components(), createHitOnDetector(), hgcalTestNeighbor_cfi::detector, doHitsFromInboundParticles_, fastsim::SimplifiedGeometry::getDetLayer(), fastsim::Particle::getEnergyDeposit(), fastsim::SimplifiedGeometry::getMagneticFieldZ(), fastsim::Particle::getMotherSimTrackIndex(), fastsim::SimplifiedGeometry::getThickness(), fastsim::SimplifiedGeometry::isForward(), GeomDet::isLeaf(), fastsim::Particle::isLooper(), HLT_2018_cff::magneticField, genParticles_cff::map, minMomentum_, fastsim::Particle::momentum(), eostools::move(), EgammaValidation_cff::pdgId, fastsim::Particle::pdgId(), fastsim::Particle::position(), position, TrackCandidateProducer_cfi::propagator, fastsim::Particle::setEnergyDeposit(), fastsim::Particle::setLooper(), simHitContainer_, fastsim::Particle::simTrackIndex(), GeometricSearchDet::surface(), and Surface::tangentPlane().

Referenced by ~TrackerSimHitProducer().

                                                                                          {
   // the energy deposit in the layer
   double energyDeposit = particle.getEnergyDeposit();
   particle.setEnergyDeposit(0);
 
   //
   // don't save hits from particle that did a loop or are inbound (coming from the outer part of the tracker, going towards the center)
   //
   if (!doHitsFromInboundParticles_) {
     if (particle.isLooper()) {
       return;
     }
     if (particle.momentum().X() * particle.position().X() + particle.momentum().Y() * particle.position().Y() < 0) {
       particle.setLooper();
       return;
     }
     if (layer.isForward() && ((particle.position().Z() > 0 && particle.momentum().Z() < 0) ||
                               (particle.position().Z() < 0 && particle.momentum().Z() > 0))) {
       particle.setLooper();
       return;
     }
   }
 
   //
   // check that layer has tracker modules
   //
   if (!layer.getDetLayer()) {
     return;
   }
 
   //
   // no material
   //
   if (layer.getThickness(particle.position(), particle.momentum()) < 1E-10) {
     return;
   }
 
   //
   // only charged particles
   //
   if (particle.charge() == 0) {
     return;
   }
 
   //
   // save hit only if momentum higher than threshold
   //
   if (particle.momentum().Perp2() < minMomentum_ * minMomentum_) {
     return;
   }
 
   // create the trajectory of the particle
   UniformMagneticField magneticField(layer.getMagneticFieldZ(particle.position()));
   GlobalPoint position(particle.position().X(), particle.position().Y(), particle.position().Z());
   GlobalVector momentum(particle.momentum().Px(), particle.momentum().Py(), particle.momentum().Pz());
   auto plane = layer.getDetLayer()->surface().tangentPlane(position);
   TrajectoryStateOnSurface trajectory(
       GlobalTrajectoryParameters(position, momentum, TrackCharge(particle.charge()), &magneticField), *plane);
 
   // find detectors compatible with the particle's trajectory
   AnalyticalPropagator propagator(&magneticField, anyDirection);
   InsideBoundsMeasurementEstimator est;
   std::vector<DetWithState> compatibleDetectors = layer.getDetLayer()->compatibleDets(trajectory, propagator, est);
 
   // You have to sort the simHits in the order they occur!
 
   // The old algorithm (sorting by distance to IP) doesn't seem to make sense to me (what if particle moves inwards?)
 
   // Detector layers have to be sorted by proximity to particle.position
   // Propagate particle backwards a bit to make sure it's outside any components
   std::map<double, std::unique_ptr<PSimHit>> distAndHits;
   // Position relative to which the hits should be sorted
   GlobalPoint positionOutside(particle.position().x() - particle.momentum().x() / particle.momentum().P() * 10.,
                               particle.position().y() - particle.momentum().y() / particle.momentum().P() * 10.,
                               particle.position().z() - particle.momentum().z() / particle.momentum().P() * 10.);
 
   // FastSim: cheat tracking -> assign hits to closest charged daughter if particle decays
   int pdgId = particle.pdgId();
   int simTrackId =
       particle.getMotherSimTrackIndex() >= 0 ? particle.getMotherSimTrackIndex() : particle.simTrackIndex();
 
   // loop over the compatible detectors
   for (const auto& detectorWithState : compatibleDetectors) {
     const GeomDet& detector = *detectorWithState.first;
     const TrajectoryStateOnSurface& particleState = detectorWithState.second;
 
     // if the detector has no components
     if (detector.isLeaf()) {
       std::pair<double, std::unique_ptr<PSimHit>> hitPair = createHitOnDetector(particleState,
                                                                                 pdgId,
                                                                                 layer.getThickness(particle.position()),
                                                                                 energyDeposit,
                                                                                 simTrackId,
                                                                                 detector,
                                                                                 positionOutside);
       if (hitPair.second) {
         distAndHits.insert(distAndHits.end(), std::move(hitPair));
       }
     } else {
       // if the detector has components
       for (const auto component : detector.components()) {
         std::pair<double, std::unique_ptr<PSimHit>> hitPair =
             createHitOnDetector(particleState,
                                 pdgId,
                                 layer.getThickness(particle.position()),
                                 energyDeposit,
                                 simTrackId,
                                 *component,
                                 positionOutside);
         if (hitPair.second) {
           distAndHits.insert(distAndHits.end(), std::move(hitPair));
         }
       }
     }
   }
 
   // Fill simHitContainer
   for (std::map<double, std::unique_ptr<PSimHit>>::const_iterator it = distAndHits.begin(); it != distAndHits.end();
        it++) {
     simHitContainer_->push_back(*(it->second));
   }
 }

void fastsim::TrackerSimHitProducer::registerProducts ( edm::ProducesCollector producesCollector ) const

overridevirtual

Register the SimHit collection.

Reimplemented from fastsim::InteractionModel.

Definition at line 116 of file TrackerSimHitProducer.cc.

References edm::ProducesCollector::produces().

Referenced by ~TrackerSimHitProducer().

                                                                                                 {
   producesCollector.produces<edm::PSimHitContainer>("TrackerHits");
 }

void fastsim::TrackerSimHitProducer::storeProducts ( edm::Event & iEvent )

overridevirtual

Store the SimHit collection.

Reimplemented from fastsim::InteractionModel.

Definition at line 120 of file TrackerSimHitProducer.cc.

References eostools::move(), edm::Event::put(), and simHitContainer_.

Referenced by ~TrackerSimHitProducer().

                                                                  {
   iEvent.put(std::move(simHitContainer_), "TrackerHits");
   simHitContainer_.reset(new edm::PSimHitContainer);
 }