fastsim::TrackerSimHitProducer Class Reference

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

TrackerSimHitProducer()

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

Constructor.

Definition at line 106 of file TrackerSimHitProducer.cc.

    : 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");
}

References looper::cfg, doHitsFromInboundParticles_, and minMomentum_.

~TrackerSimHitProducer()

fastsim::TrackerSimHitProducer::~TrackerSimHitProducer ( )

inlineoverride

Default destructor.

Definition at line 58 of file TrackerSimHitProducer.cc.

{ ; }

Member Function Documentation

createHitOnDetector()

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.

                         {
  // 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())));
}

References anyDirection, PV3DBase< T, PVType, FrameType >::basicVector(), Surface::bounds(), hgcalTestNeighbor_cfi::detector, simKBmtfDigis_cfi::eLoss, mps_splice::entry, beamvalidation::exit(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), Bounds::length(), TrajectoryStateOnSurface::localMomentum(), TrajectoryStateOnSurface::localPosition(), PV3DBase< T, PVType, FrameType >::mag(), mag(), castor_dqm_sourceclient_file_cfg::path, EgammaValidation_cff::pdgId, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), GloballyPositioned< T >::position(), fastsim::Constants::speedOfLight, PV3DBase< T, PVType, FrameType >::theta(), Bounds::thickness(), TrajectoryStateOnSurface::transverseCurvature(), Vector3DBase< T, FrameTag >::unit(), Bounds::width(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

interact()

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.

                                                                                         {
  // 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));
  }
}

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

registerProducts()

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.

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

References edm::ProducesCollector::produces().

storeProducts()

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

overridevirtual

Store the SimHit collection.

Reimplemented from fastsim::InteractionModel.

Definition at line 120 of file TrackerSimHitProducer.cc.

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

References iEvent, and eostools::move().

Member Data Documentation

doHitsFromInboundParticles_

bool fastsim::TrackerSimHitProducer::doHitsFromInboundParticles_

private

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

Definition at line 102 of file TrackerSimHitProducer.cc.

Referenced by TrackerSimHitProducer().

minMomentum_

double fastsim::TrackerSimHitProducer::minMomentum_

private

Set the minimal momentum of incoming particle.

Definition at line 101 of file TrackerSimHitProducer.cc.

Referenced by TrackerSimHitProducer().

onSurfaceTolerance_

const double fastsim::TrackerSimHitProducer::onSurfaceTolerance_

private

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

Definition at line 99 of file TrackerSimHitProducer.cc.

simHitContainer_

std::unique_ptr<edm::PSimHitContainer> fastsim::TrackerSimHitProducer::simHitContainer_

private

The SimHit.

Definition at line 100 of file TrackerSimHitProducer.cc.