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 (auto iTag = TTTracksTokens.begin(); iTag != TTTracksTokens.end(); iTag++) {
    auto associationMapForOutput = std::make_unique<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>>();
 
    edm::Handle<std::vector<TTTrack<Ref_Phase2TrackerDigi_>>> TTTrackHandle;
    iEvent.getByToken(*iTag, TTTrackHandle);
 
    std::map<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>, edm::Ptr<TrackingParticle>> trackToTrackingParticleMap;
    std::map<edm::Ptr<TrackingParticle>, std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>>>
        trackingParticleToTrackVectorMap;
    trackToTrackingParticleMap.clear();
    trackingParticleToTrackVectorMap.clear();
 
    // Start the loop on tracks
 
    unsigned int j = 0;  
    typename std::vector<TTTrack<Ref_Phase2TrackerDigi_>>::const_iterator inputIter;
    for (inputIter = TTTrackHandle->begin(); inputIter != TTTrackHandle->end(); ++inputIter) {
      edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>> tempTrackPtr(TTTrackHandle, j++);
 
      std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
          theseStubs = tempTrackPtr->getStubRefs();
 
      std::map<const TrackingParticle*, edm::Ptr<TrackingParticle>> auxMap;
      auxMap.clear();
      int mayCombinUnknown = 0;
 
      for (unsigned int is = 0; is < theseStubs.size(); is++) {
        //        std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >, TTCluster< Ref_Phase2TrackerDigi_ > > > theseClusters = theseStubs.at(is)->getClusterRefs();
        for (unsigned int ic = 0; ic < 2; ic++) {
          std::vector<edm::Ptr<TrackingParticle>> tempTPs =
              TTClusterAssociationMapHandle->findTrackingParticlePtrs(theseStubs.at(is)->clusterRef(ic));
          for (unsigned int itp = 0; itp < tempTPs.size(); itp++)  // List of TPs linked to stub clusters
          {
            edm::Ptr<TrackingParticle> testTP = tempTPs.at(itp);
 
            if (testTP.isNull())  // No TP linked to this cluster
              continue;
 
            if (trackingParticleToTrackVectorMap.find(testTP) == trackingParticleToTrackVectorMap.end()) {
              std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>> trackVector;
              trackVector.clear();
              trackingParticleToTrackVectorMap.insert(std::make_pair(testTP, trackVector));
            }
            trackingParticleToTrackVectorMap.find(testTP)->second.push_back(tempTrackPtr);  
 
            if (auxMap.find(testTP.get()) == auxMap.end()) {
              auxMap.insert(std::make_pair(testTP.get(), testTP));
            }
          }
        }  
 
        if (TTStubAssociationMapHandle->isUnknown(theseStubs.at(is)))
          ++mayCombinUnknown;
 
      }  
 
      if (mayCombinUnknown >= 2)
        continue;
 
 
      std::vector<const TrackingParticle*> tpInAllStubs;
 
      std::map<const TrackingParticle*, edm::Ptr<TrackingParticle>>::const_iterator iterAuxMap;
      for (iterAuxMap = auxMap.begin(); iterAuxMap != auxMap.end(); ++iterAuxMap) {
        std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
            tempStubs = TTStubAssociationMapHandle->findTTStubRefs(iterAuxMap->second);
 
        int nnotfound = 0;
        //bool allFound = true;
        //        for ( unsigned int js = 0; js < theseStubs.size() && allFound; js++ )
        for (unsigned int js = 0; js < theseStubs.size(); js++) {
          if (std::find(tempStubs.begin(), tempStubs.end(), theseStubs.at(js)) == tempStubs.end()) {
            //  allFound = false;
            ++nnotfound;
          }
        }
 
        if (nnotfound > 1)
          //if (!allFound)
          continue;
 
        tpInAllStubs.push_back(iterAuxMap->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.insert(std::make_pair(tempTrackPtr, auxMap.find(tpInAllStubs.at(0))->second));
 
    }  
 
    typename std::map<edm::Ptr<TrackingParticle>, std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>>>::iterator
        iterMapToClean;
    for (iterMapToClean = trackingParticleToTrackVectorMap.begin();
         iterMapToClean != trackingParticleToTrackVectorMap.end();
         ++iterMapToClean) {
      std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>> tempVector = iterMapToClean->second;
 
      std::sort(tempVector.begin(), tempVector.end());
      tempVector.erase(std::unique(tempVector.begin(), tempVector.end()), tempVector.end());
 
      iterMapToClean->second = tempVector;
    }
 
    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;
  }  
}