TrackingParticleNumberOfLayers Class Reference

#include <TrackingParticleNumberOfLayers.h>

Public Types
enum	{ nTrackerLayers = 0, nPixelLayers = 1, nStripMonoAndStereoLayers = 2 }

Public Member Functions
std::tuple< std::unique_ptr < edm::ValueMap< unsigned int > >, std::unique_ptr < edm::ValueMap< unsigned int > >, std::unique_ptr < edm::ValueMap< unsigned int > > >	calculate (const edm::Handle< TrackingParticleCollection > &tps, const TrackerTopology &tTopo) const
	TrackingParticleNumberOfLayers (const edm::Event &iEvent, const std::vector< edm::EDGetTokenT< std::vector< PSimHit >>> &simHitTokens)

Private Attributes
std::vector< std::pair < unsigned int, const PSimHit * > >	trackIdToHitPtr_

Detailed Description

This class calculates the number of tracker layers, pixel layers, and strip mono+stereo layers "crossed" by TrackingParticle.

The numbers of pixel and strip mono+stereo layers are not available from TrackingParticle itself, so they are calculated here in a standalone way in order to not to modify the TP dataformat (for now). The number of tracker layers is available in TP, but its calculation in TrackingTruthAccumulator gives wrong results (too many layers) for loopers, so also it is calculated here on the same go.

The PSimHits are needed for the calculation, so, in practice, in events with pileup the numbers of layers can be calculated only for TPs from the signal event (i.e. not for pileup TPs). Fortunately this is exactly what is sufficient for MultiTrackValidator.

Eventually we should move to use HitPattern as in reco::TrackBase (more information in a compact format), and consider adding it to the TrackingParticle itself.

In principle we could utilize the TP->SimHit map produced in SimHitTPAssociationProducer instead of doing the association here again, but

• SimTrack SimHits need to looped over in the order defined by SimTrack (to do the same as in TrackingTruthAccumulator). While possible, it would be cumbersome to do (more than just doing the association via SimTrack id)
• The main customer of this class, MultiTrackValidator, can in principle take a TrackingParticle collection different from the one of SimHitTPAssociationProducer (e.g. after a selection, since MTV does not support TP Refs because of how reco::RecoToSimCollection and reco::SimToRecoCollection are defined

Definition at line 46 of file TrackingParticleNumberOfLayers.h.

Member Enumeration Documentation

anonymous enum

Enumerator
nTrackerLayers
nPixelLayers
nStripMonoAndStereoLayers

Definition at line 51 of file TrackingParticleNumberOfLayers.h.

{ nTrackerLayers = 0, nPixelLayers = 1, nStripMonoAndStereoLayers = 2 };

Constructor & Destructor Documentation

TrackingParticleNumberOfLayers::TrackingParticleNumberOfLayers	(	const edm::Event &	iEvent,
		const std::vector< edm::EDGetTokenT< std::vector< PSimHit >>> &	simHitTokens
	)

Definition at line 28 of file TrackingParticleNumberOfLayers.cc.

References edm::Event::getByToken(), and trackIdToHitPtr_.

                                                                                               {
  // A multimap linking SimTrack::trackId() to a pointer to PSimHit
  // Similar to TrackingTruthAccumulator
  for (const auto &simHitToken : simHitTokens) {
    edm::Handle<std::vector<PSimHit>> hsimhits;
    iEvent.getByToken(simHitToken, hsimhits);
    trackIdToHitPtr_.reserve(trackIdToHitPtr_.size() + hsimhits->size());
    for (const auto &simHit : *hsimhits) {
      trackIdToHitPtr_.emplace_back(simHit.trackId(), &simHit);
    }
  }
  std::stable_sort(trackIdToHitPtr_.begin(), trackIdToHitPtr_.end(), trackIdHitPairLessSort);
}

Member Function Documentation

std::tuple< std::unique_ptr< edm::ValueMap< unsigned int > >, std::unique_ptr< edm::ValueMap< unsigned int > >, std::unique_ptr< edm::ValueMap< unsigned int > > > TrackingParticleNumberOfLayers::calculate	(	const edm::Handle< TrackingParticleCollection > &	tps,
		const TrackerTopology &	tTopo
	)		const

Definition at line 46 of file TrackingParticleNumberOfLayers.cc.

References PSimHit::detUnitId(), TrackingParticle::eventId(), PSimHit::eventId(), edm::helper::Filler< Map >::fill(), TrackingParticle::g4Tracks(), mps_fire::i, edm::helper::Filler< Map >::insert(), fastTrackerRecHitType::isPixel(), dqmiolumiharvest::j, phase1PixelTopology::layer, TrackerTopology::layer(), eostools::move(), nPixelLayers, nStripMonoAndStereoLayers, PSimHit::particleType(), HLT_FULL_cff::particleType, TrackingParticle::pdgId(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, PSimHit::processType(), sistrip::SpyUtilities::range(), cscDigiValidation_cfi::simTrack, DetId::subdetId(), StripSubdetector::TEC, TrackerTopology::tecIsRPhi(), TrackerTopology::tecIsStereo(), StripSubdetector::TIB, TrackerTopology::tibIsRPhi(), TrackerTopology::tibIsStereo(), StripSubdetector::TID, TrackerTopology::tidIsRPhi(), TrackerTopology::tidIsStereo(), StripSubdetector::TOB, TrackerTopology::tobIsRPhi(), TrackerTopology::tobIsStereo(), cmsswSequenceInfo::tp, and trackIdToHitPtr_.

Referenced by TrackingParticleNumberOfLayersProducer::produce().

                                                                              {
  const TrackingParticleCollection &tps = *htps;
  std::vector<unsigned int> valuesLayers(tps.size(), 0);
  std::vector<unsigned int> valuesPixelLayers(tps.size(), 0);
  std::vector<unsigned int> valuesStripMonoAndStereoLayers(tps.size(), 0);
  for (size_t iTP = 0; iTP < tps.size(); ++iTP) {
    const TrackingParticle &tp = tps[iTP];
    const auto pdgId = tp.pdgId();

    // I would prefer a better way...
    constexpr unsigned int maxSubdet = static_cast<unsigned>(StripSubdetector::TEC) + 1;
    constexpr unsigned int maxLayer = 0xF + 1;  // as in HitPattern.h
    bool hasHit[maxSubdet][maxLayer];
    bool hasPixel[maxSubdet][maxLayer];
    bool hasMono[maxSubdet][maxLayer];
    bool hasStereo[maxSubdet][maxLayer];
    memset(hasHit, 0, sizeof(hasHit));
    memset(hasPixel, 0, sizeof(hasPixel));
    memset(hasMono, 0, sizeof(hasMono));
    memset(hasStereo, 0, sizeof(hasStereo));

    for (const SimTrack &simTrack : tp.g4Tracks()) {
      // Logic is from TrackingTruthAccumulator
      auto range = std::equal_range(trackIdToHitPtr_.begin(),
                                    trackIdToHitPtr_.end(),
                                    std::pair<unsigned int, const PSimHit *>(simTrack.trackId(), nullptr),
                                    trackIdHitPairLess);
      if (range.first == range.second)
        continue;

      auto iHitPtr = range.first;
      for (; iHitPtr != range.second; ++iHitPtr) {
        // prevent simhits with particleType != pdgId from being the "first hit"
        if (iHitPtr->second->particleType() == pdgId)
          break;
      }
      if (iHitPtr == range.second)  // no simhits with particleType == pdgId
        continue;
      int processType = iHitPtr->second->processType();
      int particleType = iHitPtr->second->particleType();

      for (; iHitPtr != range.second; ++iHitPtr) {
        const PSimHit &simHit = *(iHitPtr->second);
        if (simHit.eventId() != tp.eventId())
          continue;
        DetId newDetector = DetId(simHit.detUnitId());

        // Check for delta and interaction products discards
        if (processType == simHit.processType() && particleType == simHit.particleType() &&
            pdgId == simHit.particleType()) {
          // The logic of this piece follows HitPattern
          bool isPixel = false;
          bool isStripStereo = false;
          bool isStripMono = false;

          switch (newDetector.subdetId()) {
            case PixelSubdetector::PixelBarrel:
            case PixelSubdetector::PixelEndcap:
              isPixel = true;
              break;
            case StripSubdetector::TIB:
              isStripMono = tTopo.tibIsRPhi(newDetector);
              isStripStereo = tTopo.tibIsStereo(newDetector);
              break;
            case StripSubdetector::TID:
              isStripMono = tTopo.tidIsRPhi(newDetector);
              isStripStereo = tTopo.tidIsStereo(newDetector);
              break;
            case StripSubdetector::TOB:
              isStripMono = tTopo.tobIsRPhi(newDetector);
              isStripStereo = tTopo.tobIsStereo(newDetector);
              break;
            case StripSubdetector::TEC:
              isStripMono = tTopo.tecIsRPhi(newDetector);
              isStripStereo = tTopo.tecIsStereo(newDetector);
              break;
          }

          const auto subdet = newDetector.subdetId();
          const auto layer = tTopo.layer(newDetector);

          hasHit[subdet][layer] = true;
          if (isPixel)
            hasPixel[subdet][layer] = isPixel;
          else if (isStripMono)
            hasMono[subdet][layer] = isStripMono;
          else if (isStripStereo)
            hasStereo[subdet][layer] = isStripStereo;
        }
      }
    }

    unsigned int nLayers = 0;
    unsigned int nPixelLayers = 0;
    unsigned int nStripMonoAndStereoLayers = 0;
    for (unsigned int i = 0; i < maxSubdet; ++i) {
      for (unsigned int j = 0; j < maxLayer; ++j) {
        nLayers += hasHit[i][j];
        nPixelLayers += hasPixel[i][j];
        nStripMonoAndStereoLayers += (hasMono[i][j] && hasStereo[i][j]);
      }
    }

    valuesLayers[iTP] = nLayers;
    valuesPixelLayers[iTP] = nPixelLayers;
    valuesStripMonoAndStereoLayers[iTP] = nStripMonoAndStereoLayers;
  }

  auto ret0 = std::make_unique<edm::ValueMap<unsigned int>>();
  {
    edm::ValueMap<unsigned int>::Filler filler(*ret0);
    filler.insert(htps, valuesLayers.begin(), valuesLayers.end());
    filler.fill();
  }
  auto ret1 = std::make_unique<edm::ValueMap<unsigned int>>();
  {
    edm::ValueMap<unsigned int>::Filler filler(*ret1);
    filler.insert(htps, valuesPixelLayers.begin(), valuesPixelLayers.end());
    filler.fill();
  }
  auto ret2 = std::make_unique<edm::ValueMap<unsigned int>>();
  {
    edm::ValueMap<unsigned int>::Filler filler(*ret2);
    filler.insert(htps, valuesStripMonoAndStereoLayers.begin(), valuesStripMonoAndStereoLayers.end());
    filler.fill();
  }

  return std::make_tuple(std::move(ret0), std::move(ret1), std::move(ret2));
}

Member Data Documentation

std::vector<std::pair<unsigned int, const PSimHit *> > TrackingParticleNumberOfLayers::trackIdToHitPtr_

private

Definition at line 59 of file TrackingParticleNumberOfLayers.h.

Referenced by calculate(), and TrackingParticleNumberOfLayers().