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->getClusterRef(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->getClusterRef(0) ) ||
             TTClusterAssociationMapHandle->isUnknown( tempStubRef->getClusterRef(1) ) )
        {
          continue;
        }
        else
        {
          if ( TTClusterAssociationMapHandle->isGenuine( tempStubRef->getClusterRef(0) ) &&
               TTClusterAssociationMapHandle->isGenuine( tempStubRef->getClusterRef(1) ) )
          {
            if ( TTClusterAssociationMapHandle->findTrackingParticlePtr( tempStubRef->getClusterRef(0) ).get() ==
                 TTClusterAssociationMapHandle->findTrackingParticlePtr( tempStubRef->getClusterRef(1) ).get() )
            {
              edm::Ptr< TrackingParticle > testTP = TTClusterAssociationMapHandle->findTrackingParticlePtr( tempStubRef->getClusterRef(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->getClusterRef(0) );
            std::vector< edm::Ptr< TrackingParticle > > trackingParticles1 = TTClusterAssociationMapHandle->findTrackingParticlePtrs( tempStubRef->getClusterRef(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;
  } 
}