TTTrackAssociator.cc

Go to the documentation of this file.

 
#include "SimTracker/TrackTriggerAssociation/plugins/TTTrackAssociator.h"
 
template <>
void TTTrackAssociator<Ref_Phase2TrackerDigi_>::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  if (iEvent.isRealData())
    return;
 
  edm::Handle<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>> ttClusterAssociationMapHandle;
  iEvent.getByToken(ttClusterTruthToken_, ttClusterAssociationMapHandle);
  edm::Handle<TTStubAssociationMap<Ref_Phase2TrackerDigi_>> ttStubAssociationMapHandle;
  iEvent.getByToken(ttStubTruthToken_, ttStubAssociationMapHandle);
 
  int ncont1 = 0;
 
  for (const auto& iTag : ttTracksTokens_) {
    auto associationMapForOutput = std::make_unique<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>>();
 
    edm::Handle<std::vector<TTTrack<Ref_Phase2TrackerDigi_>>> TTTrackHandle;
    iEvent.getByToken(iTag, TTTrackHandle);
 
    std::map<TTTrackPtr, TrackingParticlePtr> trackToTrackingParticleMap;
    std::map<TrackingParticlePtr, std::vector<TTTrackPtr>> trackingParticleToTrackVectorMap;
 
    // Start the loop on tracks
 
    for (unsigned int jTrk = 0; jTrk < TTTrackHandle->size(); jTrk++) {
      TTTrackPtr tempTrackPtr(TTTrackHandle, jTrk);
 
      const std::vector<TTStubRef>& theseStubs = tempTrackPtr->getStubRefs();
 
      std::map<const TrackingParticle*, TrackingParticlePtr> auxMap;
      int mayCombinUnknown = 0;
 
      for (const TTStubRef& stub : theseStubs) {
        for (unsigned int ic = 0; ic < 2; ic++) {
          const std::vector<TrackingParticlePtr>& tempTPs =
              ttClusterAssociationMapHandle->findTrackingParticlePtrs(stub->clusterRef(ic));
          for (const TrackingParticlePtr& testTP : tempTPs)  // List of TPs linked to stub clusters
          {
            if (testTP.isNull())  // No TP linked to this cluster
              continue;
 
            if (trackingParticleToTrackVectorMap.find(testTP) == trackingParticleToTrackVectorMap.end()) {
              std::vector<TTTrackPtr> trackVector;
              trackingParticleToTrackVectorMap.emplace(testTP, trackVector);
            }
            trackingParticleToTrackVectorMap.find(testTP)->second.push_back(tempTrackPtr);  
 
            if (auxMap.find(testTP.get()) == auxMap.end()) {
              auxMap.emplace(testTP.get(), testTP);
            }
          }
        }  
 
        if (ttStubAssociationMapHandle->isUnknown(stub))
          ++mayCombinUnknown;
 
      }  
 
      if (mayCombinUnknown >= 2)
        continue;
 
 
      std::vector<const TrackingParticle*> tpInAllStubs;
 
      for (const auto& auxPair : auxMap) {
        const std::vector<TTStubRef>& tempStubs = ttStubAssociationMapHandle->findTTStubRefs(auxPair.second);
 
        // Count stubs on track that are not related to this TP
        int nnotfound = 0;
        for (const TTStubRef& stub : theseStubs) {
          if (std::find(tempStubs.begin(), tempStubs.end(), stub) == tempStubs.end()) {
            ++nnotfound;
          }
        }
 
        if (nnotfound > 1)
          continue;
 
        tpInAllStubs.push_back(auxPair.first);
      }
 
      std::sort(tpInAllStubs.begin(), tpInAllStubs.end());
      tpInAllStubs.erase(std::unique(tpInAllStubs.begin(), tpInAllStubs.end()), tpInAllStubs.end());
      unsigned int nTPs = tpInAllStubs.size();
 
      if (nTPs != 1)
        continue;
 
      trackToTrackingParticleMap.emplace(tempTrackPtr, auxMap.find(tpInAllStubs.at(0))->second);
 
    }  
 
    for (auto& p : trackingParticleToTrackVectorMap) {
      std::vector<TTTrackPtr>& tempVector = p.second;
 
      std::sort(tempVector.begin(), tempVector.end());
      tempVector.erase(std::unique(tempVector.begin(), tempVector.end()), tempVector.end());
    }
 
    edm::RefProd<TTStubAssociationMap<Ref_Phase2TrackerDigi_>> theStubAssoMap(ttStubAssociationMapHandle);
 
    associationMapForOutput->setTTTrackToTrackingParticleMap(trackToTrackingParticleMap);
    associationMapForOutput->setTrackingParticleToTTTracksMap(trackingParticleToTrackVectorMap);
    associationMapForOutput->setTTStubAssociationMap(theStubAssoMap);
    associationMapForOutput->setAllowOneFalse2SStub(TTTrackAllowOneFalse2SStub);
 
    iEvent.put(std::move(associationMapForOutput), ttTracksInputTags_.at(ncont1).instance());
 
    ++ncont1;
  }  
}