TTStubAssociator.cc

Go to the documentation of this file.

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

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

  if (TTClusterTruthInputTags.size() != TTStubsInputTags.size()) {
    edm::LogError("TTStubAsso ") << "E R R O R! the InputTag vectors have different size!";
    return;
  }

  int ncont1 = 0;

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


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

    edm::Handle<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>> TTStubHandle;
    iEvent.getByToken(*iTag, TTStubHandle);

    edm::Handle<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>> TTClusterAssociationMapHandle;
    iEvent.getByToken(TTClusterTruthTokens.at(ncont1), TTClusterAssociationMapHandle);

    std::map<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>,
             edm::Ptr<TrackingParticle>>
        stubToTrackingParticleMap;
    std::map<edm::Ptr<TrackingParticle>,
             std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>>
        trackingParticleToStubVectorMap;
    stubToTrackingParticleMap.clear();
    trackingParticleToStubVectorMap.clear();


    if (!TTStubHandle->empty()) {
      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 (!tTopo->isLower(detid))
          continue;  // loop on the stacks: choose the lower arbitrarily

        DetId stackDetid = tTopo->stack(detid);  // Stub module detid

        if (TTStubHandle->find(stackDetid) == TTStubHandle->end())
          continue;

        edmNew::DetSet<TTStub<Ref_Phase2TrackerDigi_>> stubs = (*TTStubHandle)[stackDetid];

        for (auto contentIter = stubs.begin(); contentIter != stubs.end(); ++contentIter) {
          edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>> tempStubRef =
              edmNew::makeRefTo(TTStubHandle, contentIter);

          //        std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >, TTCluster< Ref_Phase2TrackerDigi_ > > > theseClusters = tempStubRef->getClusterRefs();

          for (unsigned int ic = 0; ic < 2; ic++) {
            std::vector<edm::Ptr<TrackingParticle>> tempTPs =
                TTClusterAssociationMapHandle->findTrackingParticlePtrs(tempStubRef->clusterRef(ic));

            for (unsigned int itp = 0; itp < tempTPs.size(); itp++) {
              edm::Ptr<TrackingParticle> testTP = tempTPs.at(itp);

              if (testTP.isNull())
                continue;

              if (trackingParticleToStubVectorMap.find(testTP) == trackingParticleToStubVectorMap.end()) {
                std::vector<
                    edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
                    stubVector;
                stubVector.clear();
                trackingParticleToStubVectorMap.insert(std::make_pair(testTP, stubVector));
              }
              trackingParticleToStubVectorMap.find(testTP)->second.push_back(tempStubRef);  
            }
          }

          if (TTClusterAssociationMapHandle->isUnknown(tempStubRef->clusterRef(0)) ||
              TTClusterAssociationMapHandle->isUnknown(tempStubRef->clusterRef(1))) {
            continue;
          } else {
            if (TTClusterAssociationMapHandle->isGenuine(tempStubRef->clusterRef(0)) &&
                TTClusterAssociationMapHandle->isGenuine(tempStubRef->clusterRef(1))) {
              if (TTClusterAssociationMapHandle->findTrackingParticlePtr(tempStubRef->clusterRef(0)).get() ==
                  TTClusterAssociationMapHandle->findTrackingParticlePtr(tempStubRef->clusterRef(1)).get()) {
                edm::Ptr<TrackingParticle> testTP =
                    TTClusterAssociationMapHandle->findTrackingParticlePtr(tempStubRef->clusterRef(0));

                stubToTrackingParticleMap.insert(std::make_pair(tempStubRef, testTP));

                continue;
              } else {
                continue;
              }
            }  
            else {
              TrackingParticle* prevTPAddress = nullptr;
              unsigned int whichTP = 0;

              std::vector<edm::Ptr<TrackingParticle>> trackingParticles0 =
                  TTClusterAssociationMapHandle->findTrackingParticlePtrs(tempStubRef->clusterRef(0));
              std::vector<edm::Ptr<TrackingParticle>> trackingParticles1 =
                  TTClusterAssociationMapHandle->findTrackingParticlePtrs(tempStubRef->clusterRef(1));

              bool escape = false;

              for (unsigned int i = 0; i < trackingParticles0.size() && !escape; i++) {
                if (trackingParticles0.at(i).isNull())
                  continue;

                for (unsigned int k = 0; k < trackingParticles1.size() && !escape; k++) {
                  if (trackingParticles1.at(k).isNull())
                    continue;

                  if (trackingParticles0.at(i).get() == trackingParticles1.at(k).get()) {
                    if (prevTPAddress == nullptr) {
                      prevTPAddress = const_cast<TrackingParticle*>(trackingParticles1.at(k).get());
                      whichTP = k;
                    }

                    if (prevTPAddress != const_cast<TrackingParticle*>(trackingParticles1.at(k).get())) {
                      escape = true;
                      continue;
                    }
                  }
                }
              }  

              if (escape)
                continue;

              if (prevTPAddress == nullptr) {
                continue;
              } else {
                edm::Ptr<TrackingParticle> testTP = trackingParticles1.at(whichTP);

                stubToTrackingParticleMap.insert(std::make_pair(tempStubRef, testTP));

                continue;
              }  
            }    
          }      
        }
      }  
    }

    typename std::map<edm::Ptr<TrackingParticle>,
                      std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>,
                                           TTStub<Ref_Phase2TrackerDigi_>>>>::iterator iterMapToClean;
    for (iterMapToClean = trackingParticleToStubVectorMap.begin();
         iterMapToClean != trackingParticleToStubVectorMap.end();
         ++iterMapToClean) {
      std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<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<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>> theCluAssoMap(TTClusterAssociationMapHandle);

    associationMapForOutput->setTTStubToTrackingParticleMap(stubToTrackingParticleMap);
    associationMapForOutput->setTrackingParticleToTTStubsMap(trackingParticleToStubVectorMap);
    associationMapForOutput->setTTClusterAssociationMap(theCluAssoMap);

    iEvent.put(std::move(associationMapForOutput), TTStubsInputTags.at(ncont1).instance());

    ++ncont1;
  }  
}