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;

  } 
}