TTTrackAssociator.cc

Go to the documentation of this file.

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

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

  edm::Handle< TTClusterAssociationMap< Ref_Phase2TrackerDigi_ > > TTClusterAssociationMapHandle;
  iEvent.getByToken( TTClusterTruthToken, TTClusterAssociationMapHandle );
  edm::Handle< TTStubAssociationMap< Ref_Phase2TrackerDigi_ > > TTStubAssociationMapHandle;
  iEvent.getByToken( TTStubTruthToken, TTStubAssociationMapHandle );


  int ncont1=0;

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

    edm::Handle< std::vector< TTTrack< Ref_Phase2TrackerDigi_ > > > TTTrackHandle;
    iEvent.getByToken( *iTag, TTTrackHandle );

    std::map< edm::Ptr< TTTrack< Ref_Phase2TrackerDigi_ > >, edm::Ptr< TrackingParticle > >                trackToTrackingParticleMap;
    std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTTrack< Ref_Phase2TrackerDigi_ > > > > trackingParticleToTrackVectorMap;
    trackToTrackingParticleMap.clear();
    trackingParticleToTrackVectorMap.clear();


    // Start the loop on tracks

    unsigned int j = 0; 
    typename std::vector< TTTrack< Ref_Phase2TrackerDigi_ > >::const_iterator inputIter;
    for ( inputIter = TTTrackHandle->begin();
          inputIter != TTTrackHandle->end();
          ++inputIter )
    {
      edm::Ptr< TTTrack< Ref_Phase2TrackerDigi_ > > tempTrackPtr( TTTrackHandle, j++ );

      std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_Phase2TrackerDigi_ > >, TTStub< Ref_Phase2TrackerDigi_ > > > theseStubs = tempTrackPtr->getStubRefs();

      std::map< const TrackingParticle*, edm::Ptr< TrackingParticle > > auxMap;
      auxMap.clear();
      int mayCombinUnknown = 0;

      for ( unsigned int is = 0; is < theseStubs.size(); is++ )
      {
    //        std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >, TTCluster< Ref_Phase2TrackerDigi_ > > > theseClusters = theseStubs.at(is)->getClusterRefs();
        for ( unsigned int ic = 0; ic < 2; ic++ )
        {
          std::vector< edm::Ptr< TrackingParticle > > tempTPs = TTClusterAssociationMapHandle->findTrackingParticlePtrs( theseStubs.at(is)->getClusterRef(ic) );
          for ( unsigned int itp = 0; itp < tempTPs.size(); itp++ ) // List of TPs linked to stub clusters
          {
            edm::Ptr< TrackingParticle > testTP = tempTPs.at(itp);

            if ( testTP.isNull() ) // No TP linked to this cluster
              continue;

            if ( trackingParticleToTrackVectorMap.find( testTP ) == trackingParticleToTrackVectorMap.end() )
            {
              std::vector< edm::Ptr< TTTrack< Ref_Phase2TrackerDigi_ > > > trackVector;
              trackVector.clear();
              trackingParticleToTrackVectorMap.insert( std::make_pair( testTP, trackVector ) );
            }
            trackingParticleToTrackVectorMap.find( testTP )->second.push_back( tempTrackPtr ); 

            if ( auxMap.find( testTP.get() ) == auxMap.end() )
            {
              auxMap.insert( std::make_pair( testTP.get(), testTP ) );
            }

          }
        } 

    if ( TTStubAssociationMapHandle->isUnknown( theseStubs.at(is) ) )
      ++mayCombinUnknown;

      } 

      if ( mayCombinUnknown >= 2 )
        continue;


      std::vector< const TrackingParticle* > tpInAllStubs;

      std::map< const TrackingParticle*, edm::Ptr< TrackingParticle > >::const_iterator iterAuxMap;
      for ( iterAuxMap = auxMap.begin();
            iterAuxMap != auxMap.end();
            ++iterAuxMap )
      {
        std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_Phase2TrackerDigi_ > >, TTStub< Ref_Phase2TrackerDigi_ > > > tempStubs = TTStubAssociationMapHandle->findTTStubRefs( iterAuxMap->second );

    int nnotfound=0;
        //bool allFound = true;
    //        for ( unsigned int js = 0; js < theseStubs.size() && allFound; js++ )
        for ( unsigned int js = 0; js < theseStubs.size(); js++ )
        {
          if ( std::find( tempStubs.begin(), tempStubs.end(), theseStubs.at(js) ) == tempStubs.end() )
          {
        //  allFound = false;
        ++nnotfound;
          }
        }

        if (nnotfound>1)
      //if (!allFound)
      continue;

        tpInAllStubs.push_back( iterAuxMap->first );
      }

      std::sort( tpInAllStubs.begin(), tpInAllStubs.end() );
      tpInAllStubs.erase( std::unique( tpInAllStubs.begin(), tpInAllStubs.end() ), tpInAllStubs.end() );
      unsigned int nTPs = tpInAllStubs.size();

      if ( nTPs != 1 ) continue;

      trackToTrackingParticleMap.insert( std::make_pair( tempTrackPtr, auxMap.find( tpInAllStubs.at(0) )->second ) ); 

    } 

    typename std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTTrack< Ref_Phase2TrackerDigi_ > > > >::iterator iterMapToClean;
    for ( iterMapToClean = trackingParticleToTrackVectorMap.begin();
          iterMapToClean != trackingParticleToTrackVectorMap.end();
          ++iterMapToClean )
    {
      std::vector< edm::Ptr< TTTrack< 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< TTStubAssociationMap< Ref_Phase2TrackerDigi_ > > theStubAssoMap( TTStubAssociationMapHandle );

    associationMapForOutput->setTTTrackToTrackingParticleMap( trackToTrackingParticleMap ); 
    associationMapForOutput->setTrackingParticleToTTTracksMap( trackingParticleToTrackVectorMap );
    associationMapForOutput->setTTStubAssociationMap( theStubAssoMap );

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

    ++ncont1;
  } 
}