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 = &iSetup.getData(theTrackerGeometryToken_);
  const TrackerTopology* const tTopo = &iSetup.getData(theTrackerTopologyToken_);


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