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;
  }  
}