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 (const auto& iTag : ttStubsTokens_) {
    auto associationMapForOutput = std::make_unique<TTStubAssociationMap<Ref_Phase2TrackerDigi_>>();
 
    edm::Handle<TTStubDetSetVec> ttStubHandle;
    iEvent.getByToken(iTag, ttStubHandle);
 
    edm::Handle<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>> ttClusterAssociationMapHandle;
    iEvent.getByToken(ttClusterTruthTokens_.at(ncont1), ttClusterAssociationMapHandle);
 
    std::map<TTStubRef, TrackingParticlePtr> stubToTrackingParticleMap;
    std::map<TrackingParticlePtr, std::vector<TTStubRef>> trackingParticleToStubVectorMap;
 
 
    if (not ttStubHandle->empty()) {
      for (const auto& gd : theTrackerGeom->dets()) {
        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) {
          TTStubRef tempStubRef = edmNew::makeRefTo(ttStubHandle, contentIter);
 
          for (unsigned int ic = 0; ic < 2; ic++) {
            const std::vector<TrackingParticlePtr>& tempTPs =
                ttClusterAssociationMapHandle->findTrackingParticlePtrs(tempStubRef->clusterRef(ic));
 
            for (const TrackingParticlePtr& testTP : tempTPs) {
              if (testTP.isNull())
                continue;
 
              if (trackingParticleToStubVectorMap.find(testTP) == trackingParticleToStubVectorMap.end()) {
                std::vector<TTStubRef> stubVector;
                trackingParticleToStubVectorMap.emplace(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()) {
                const TrackingParticlePtr& testTP =
                    ttClusterAssociationMapHandle->findTrackingParticlePtr(tempStubRef->clusterRef(0));
 
                stubToTrackingParticleMap.emplace(tempStubRef, testTP);
 
                continue;
              } else {
                continue;
              }
            }  
            else {
              TrackingParticle* prevTPAddress = nullptr;
              unsigned int whichTP = 0;
 
              const std::vector<TrackingParticlePtr>& trackingParticles0 =
                  ttClusterAssociationMapHandle->findTrackingParticlePtrs(tempStubRef->clusterRef(0));
              const std::vector<TrackingParticlePtr>& 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 {
                TrackingParticlePtr testTP = trackingParticles1.at(whichTP);
 
                stubToTrackingParticleMap.emplace(tempStubRef, testTP);
 
                continue;
              }  
            }    
          }      
        }
      }  
    }
 
    for (auto& p : trackingParticleToStubVectorMap) {
      std::vector<TTStubRef>& tempVector = p.second;
 
      std::sort(tempVector.begin(), tempVector.end());
      tempVector.erase(std::unique(tempVector.begin(), tempVector.end()), tempVector.end());
    }
 
    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;
  }  
}