TTClusterAssociator.cc

Go to the documentation of this file.

#include "SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.h"

template <>
void TTClusterAssociator<Ref_Phase2TrackerDigi_>::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
  if (iEvent.isRealData())
    return;

  iEvent.getByToken(digisimLinkToken, thePixelDigiSimLinkHandle);


  iEvent.getByToken(tpToken, TrackingParticleHandle);

  //  const TrackerTopology* const tTopo = theTrackerTopology.product();
  const TrackerGeometry* const theTrackerGeom = theTrackerGeometry.product();

  std::map<std::pair<unsigned int, EncodedEventId>, edm::Ptr<TrackingParticle>> simTrackUniqueToTPMap;
  simTrackUniqueToTPMap.clear();

  if (!TrackingParticleHandle->empty()) {
    unsigned int tpCnt = 0;
    std::vector<TrackingParticle>::const_iterator iterTPart;
    for (iterTPart = TrackingParticleHandle->begin(); iterTPart != TrackingParticleHandle->end(); ++iterTPart) {
      edm::Ptr<TrackingParticle> tempTPPtr(TrackingParticleHandle, tpCnt++);

      EncodedEventId eventId = EncodedEventId(tempTPPtr->eventId());

      std::vector<SimTrack>::const_iterator iterSimTrack;
      for (iterSimTrack = tempTPPtr->g4Tracks().begin(); iterSimTrack != tempTPPtr->g4Tracks().end(); ++iterSimTrack) {
        std::pair<unsigned int, EncodedEventId> simTrackUniqueId(iterSimTrack->trackId(), eventId);
        simTrackUniqueToTPMap.insert(std::make_pair(simTrackUniqueId, tempTPPtr));
      }
    }  
  }


  int ncont1 = 0;

  for (auto iTag = TTClustersTokens.begin(); iTag != TTClustersTokens.end(); iTag++) {
    auto associationMapForOutput = std::make_unique<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>>();

    edm::Handle<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>> TTClusterHandle;

    iEvent.getByToken(*iTag, TTClusterHandle);

    std::map<edm::Ref<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>, TTCluster<Ref_Phase2TrackerDigi_>>,
             std::vector<edm::Ptr<TrackingParticle>>>
        clusterToTrackingParticleVectorMap;
    std::map<edm::Ptr<TrackingParticle>,
             std::vector<
                 edm::Ref<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>, TTCluster<Ref_Phase2TrackerDigi_>>>>
        trackingParticleToClusterVectorMap;
    clusterToTrackingParticleVectorMap.clear();
    trackingParticleToClusterVectorMap.clear();

    for (auto gd = theTrackerGeom->dets().begin(); gd != theTrackerGeom->dets().end(); gd++) {
      DetId detid = (*gd)->geographicalId();
      if (detid.subdetId() != StripSubdetector::TOB && detid.subdetId() != StripSubdetector::TID)
        continue;  // only run on OT

      if (TTClusterHandle->find(detid) == TTClusterHandle->end())
        continue;

      edmNew::DetSet<TTCluster<Ref_Phase2TrackerDigi_>> clusters = (*TTClusterHandle)[detid];

      for (auto contentIter = clusters.begin(); contentIter != clusters.end(); ++contentIter) {
        edm::Ref<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>, TTCluster<Ref_Phase2TrackerDigi_>> tempCluRef =
            edmNew::makeRefTo(TTClusterHandle, contentIter);

        if (clusterToTrackingParticleVectorMap.find(tempCluRef) == clusterToTrackingParticleVectorMap.end()) {
          std::vector<edm::Ptr<TrackingParticle>> tpVector;
          tpVector.clear();
          clusterToTrackingParticleVectorMap.insert(std::make_pair(tempCluRef, tpVector));
        }

        if (thePixelDigiSimLinkHandle->find(detid) == thePixelDigiSimLinkHandle->end()) {

          std::vector<Ref_Phase2TrackerDigi_> theseHits = tempCluRef->getHits();
          for (unsigned int i = 0; i < theseHits.size(); i++) {
            edm::Ptr<TrackingParticle> tempTPPtr;  // = new edm::Ptr< TrackingParticle >();
            clusterToTrackingParticleVectorMap.find(tempCluRef)->second.push_back(tempTPPtr);
          }

          continue;
        }

        edm::DetSet<PixelDigiSimLink> thisDigiSimLink = (*(thePixelDigiSimLinkHandle))[detid];
        edm::DetSet<PixelDigiSimLink>::const_iterator iterSimLink;

        std::vector<Ref_Phase2TrackerDigi_> theseHits = tempCluRef->getHits();
        for (unsigned int i = 0; i < theseHits.size(); i++) {
          for (iterSimLink = thisDigiSimLink.data.begin(); iterSimLink != thisDigiSimLink.data.end(); iterSimLink++) {
            if (static_cast<int>(iterSimLink->channel()) != static_cast<int>(theseHits.at(i)->channel()))
              continue;

            unsigned int curSimTrkId = iterSimLink->SimTrackId();
            EncodedEventId curSimEvId = iterSimLink->eventId();

            std::pair<unsigned int, EncodedEventId> thisUniqueId = std::make_pair(curSimTrkId, curSimEvId);

            if (simTrackUniqueToTPMap.find(thisUniqueId) != simTrackUniqueToTPMap.end()) {
              edm::Ptr<TrackingParticle> thisTrackingParticle = simTrackUniqueToTPMap.find(thisUniqueId)->second;

              clusterToTrackingParticleVectorMap.find(tempCluRef)->second.push_back(thisTrackingParticle);

              if (trackingParticleToClusterVectorMap.find(thisTrackingParticle) ==
                  trackingParticleToClusterVectorMap.end()) {
                std::vector<
                    edm::Ref<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>, TTCluster<Ref_Phase2TrackerDigi_>>>
                    clusterVector;
                clusterVector.clear();
                trackingParticleToClusterVectorMap.insert(std::make_pair(thisTrackingParticle, clusterVector));
              }
              trackingParticleToClusterVectorMap.find(thisTrackingParticle)
                  ->second.push_back(tempCluRef);  
            } else {

              edm::Ptr<TrackingParticle> tempTPPtr;  // = new edm::Ptr< TrackingParticle >();
              clusterToTrackingParticleVectorMap.find(tempCluRef)->second.push_back(tempTPPtr);
            }
          }  
        }    

        std::vector<edm::Ptr<TrackingParticle>> theseClusterTrackingParticlePtrs =
            clusterToTrackingParticleVectorMap.find(tempCluRef)->second;
        bool allOfThemAreNull = true;
        for (unsigned int tpi = 0; tpi < theseClusterTrackingParticlePtrs.size() && allOfThemAreNull; tpi++) {
          if (theseClusterTrackingParticlePtrs.at(tpi).isNull() == false)
            allOfThemAreNull = false;
        }

        if (allOfThemAreNull) {
          clusterToTrackingParticleVectorMap.erase(tempCluRef);  
        }
      }
    }  

    std::map<edm::Ptr<TrackingParticle>,
             std::vector<edm::Ref<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>,
                                  TTCluster<Ref_Phase2TrackerDigi_>>>>::iterator iterMapToClean;
    for (iterMapToClean = trackingParticleToClusterVectorMap.begin();
         iterMapToClean != trackingParticleToClusterVectorMap.end();
         ++iterMapToClean) {
      std::vector<edm::Ref<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>, TTCluster<Ref_Phase2TrackerDigi_>>>
          tempVector = iterMapToClean->second;

      std::sort(tempVector.begin(), tempVector.end());
      tempVector.erase(std::unique(tempVector.begin(), tempVector.end()), tempVector.end());
      iterMapToClean->second = tempVector;
    }

    associationMapForOutput->setTTClusterToTrackingParticlesMap(clusterToTrackingParticleVectorMap);
    associationMapForOutput->setTrackingParticleToTTClustersMap(trackingParticleToClusterVectorMap);

    //   iEvent.put( associationMapForOutput, (*iTag).instance() );
    iEvent.put(std::move(associationMapForOutput), TTClustersInputTags.at(ncont1).instance());

    ++ncont1;

  }  
}