TTStubBuilder.cc

Go to the documentation of this file.

#include "L1Trigger/TrackTrigger/plugins/TTStubBuilder.h"

template< >
void TTStubBuilder< Ref_Phase2TrackerDigi_ >::produce( edm::Event& iEvent, const edm::EventSetup& iSetup )
{
  //Retrieve tracker topology from geometry                                                                                                              
  edm::ESHandle<TrackerTopology> tTopoHandle;
  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
  const TrackerTopology* const tTopo = tTopoHandle.product();
  edm::ESHandle< TrackerGeometry > tGeomHandle;
  iSetup.get< TrackerDigiGeometryRecord >().get( tGeomHandle );
  const TrackerGeometry* const theTrackerGeom = tGeomHandle.product();
    
  auto ttClusterDSVForOutput      = std::make_unique<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>>();
  auto ttStubDSVForOutputTemp     = std::make_unique<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>>();
  auto ttStubDSVForOutputAccepted = std::make_unique<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>>();
  auto ttStubDSVForOutputRejected = std::make_unique<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>>();

  edm::Handle< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > > > clusterHandle;
  iEvent.getByToken( clustersToken, clusterHandle );

  //  unsigned maxStubs = theStackedTracker->getCBC3MaxStubs();  
  unsigned maxStubs = 0; // 0 is default, cut is disabled

  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 lowerDetid = detid;
      DetId upperDetid = tTopo->partnerDetId(detid);
      DetId stackDetid = tTopo->stack(detid);

    if ( clusterHandle->find( lowerDetid ) == clusterHandle->end() ||
         clusterHandle->find( upperDetid ) == clusterHandle->end() )
      continue;

    edmNew::DetSet< TTCluster< Ref_Phase2TrackerDigi_ > > lowerClusters = (*clusterHandle)[ lowerDetid ];
    edmNew::DetSet< TTCluster< Ref_Phase2TrackerDigi_ > > upperClusters = (*clusterHandle)[ upperDetid ];

    if ( lowerClusters.empty() || upperClusters.empty() )
      continue;

    std::vector< TTCluster< Ref_Phase2TrackerDigi_ > > tempInner; 
    std::vector< TTCluster< Ref_Phase2TrackerDigi_ > > tempOuter; 
    std::vector< TTStub< Ref_Phase2TrackerDigi_ > >   tempAccepted; 
    tempInner.clear();
    tempOuter.clear();
    tempAccepted.clear();

    const GeomDetUnit* det0 = theTrackerGeom->idToDetUnit( lowerDetid );
    const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( det0 );
    const PixelTopology* top0 = dynamic_cast< const PixelTopology* >( &(pix0->specificTopology()) );
    const int chipSize = 2 * top0->rowsperroc(); 

    std::unordered_map< int, std::vector< TTStub< Ref_Phase2TrackerDigi_ > > > moduleStubs; 

    for ( auto lowerClusterIter = lowerClusters.begin();
               lowerClusterIter != lowerClusters.end();
               ++lowerClusterIter ) {

      std::vector< TTStub< Ref_Phase2TrackerDigi_ > > tempOutput;
      // tempOutput.clear();

      for ( auto upperClusterIter = upperClusters.begin();
                 upperClusterIter != upperClusters.end();
                 ++upperClusterIter ) {

        TTStub< Ref_Phase2TrackerDigi_ > tempTTStub( stackDetid );
        tempTTStub.addClusterRef( edmNew::makeRefTo( clusterHandle, lowerClusterIter ) );
        tempTTStub.addClusterRef( edmNew::makeRefTo( clusterHandle, upperClusterIter ) );

        bool thisConfirmation = false;
        int thisDisplacement = 999999;
        int thisOffset = 0;

        theStubFindingAlgoHandle->PatternHitCorrelation( thisConfirmation, thisDisplacement, thisOffset, tempTTStub );

        if ( thisConfirmation )
        {
          tempTTStub.setTriggerDisplacement( thisDisplacement );
          tempTTStub.setTriggerOffset( thisOffset );
      tempOutput.push_back( tempTTStub );
        } 
      } 

      if ( ForbidMultipleStubs && tempOutput.size() > 1 )
      {
        std::sort( tempOutput.begin(), tempOutput.end(), TTStubBuilder< Ref_Phase2TrackerDigi_ >::SortStubsBend );

        typename std::vector< TTStub< Ref_Phase2TrackerDigi_ > >::iterator tempIter = tempOutput.begin();
        ++tempIter;


        tempOutput.erase( tempIter, tempOutput.end() );
      }


      for ( unsigned int iTempStub = 0; iTempStub < tempOutput.size(); ++iTempStub )
      {
        const TTStub< Ref_Phase2TrackerDigi_ >& tempTTStub = tempOutput[iTempStub];

        if ( maxStubs == 0 )
        {
          tempInner.push_back( *(tempTTStub.getClusterRef(0)) );
          tempOuter.push_back( *(tempTTStub.getClusterRef(1)) );
          tempAccepted.push_back( tempTTStub );
        }
        else
        {
          int chip = tempTTStub.getTriggerPosition() / chipSize; 
          if ( moduleStubs.find( chip ) == moduleStubs.end() ) 
          {
            std::vector< TTStub< Ref_Phase2TrackerDigi_ > > tempStubs(1,tempTTStub);
            //tempStubs.clear();
            //tempStubs.push_back( tempTTStub );
            moduleStubs.insert( std::pair< int, std::vector< TTStub< Ref_Phase2TrackerDigi_ > > >( chip, tempStubs ) );
          }
          else
          {
            moduleStubs[chip].push_back( tempTTStub );
          }
        } 
      } 
    } 

    if ( moduleStubs.empty() == false )
    {
      for ( auto const & is : moduleStubs )
      {
        if ( is.second.size() <= maxStubs )
        {
          for ( auto const & ts: is.second )
          {
            tempInner.push_back( *(ts.getClusterRef(0)) );
            tempOuter.push_back( *(ts.getClusterRef(1)) );
            tempAccepted.push_back( ts );
          }
        }
        else
        {
          std::vector< std::pair< unsigned int, double > > bendMap;
          bendMap.reserve(is.second.size());
          for ( unsigned int i = 0; i < is.second.size(); ++i )
          {
            bendMap.push_back( std::pair< unsigned int, double >( i, is.second[i].getTriggerBend() ) );
          }
          std::sort( bendMap.begin(), bendMap.end(), TTStubBuilder< Ref_Phase2TrackerDigi_ >::SortStubBendPairs );

          for ( unsigned int i = 0; i < maxStubs; ++i )
          {
            tempInner.push_back( *(is.second[bendMap[i].first].getClusterRef(0)) );
            tempOuter.push_back( *(is.second[bendMap[i].first].getClusterRef(1)) );
            tempAccepted.push_back( is.second[bendMap[i].first] );
          }
        }
      } 
    } 
    if ( !tempInner.empty() )
    {
      typename edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >::FastFiller lowerOutputFiller( *ttClusterDSVForOutput, lowerDetid );
      for ( unsigned int m = 0; m < tempInner.size(); m++ )
      {
        lowerOutputFiller.push_back( tempInner.at(m) );
      }
      if ( lowerOutputFiller.empty() )
        lowerOutputFiller.abort();
    }

    if ( !tempOuter.empty() )
    {
      typename edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >::FastFiller upperOutputFiller( *ttClusterDSVForOutput, upperDetid );
      for ( unsigned int m = 0; m < tempOuter.size(); m++ )
      {
        upperOutputFiller.push_back( tempOuter.at(m) );
      }
      if ( upperOutputFiller.empty() )
        upperOutputFiller.abort();
    }

    if ( !tempAccepted.empty() )
    {
      typename edmNew::DetSetVector< TTStub< Ref_Phase2TrackerDigi_ > >::FastFiller tempAcceptedFiller( *ttStubDSVForOutputTemp, stackDetid);
      for ( unsigned int m = 0; m < tempAccepted.size(); m++ )
      {
        tempAcceptedFiller.push_back( tempAccepted.at(m) );
      }
      if ( tempAcceptedFiller.empty() )
        tempAcceptedFiller.abort();
    }

  } 

  edm::OrphanHandle< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > > > ttClusterAcceptedHandle = iEvent.put( std::move(ttClusterDSVForOutput), "ClusterAccepted" );

  typename edmNew::DetSetVector< TTStub< Ref_Phase2TrackerDigi_ > >::const_iterator stubDetIter;

  for ( stubDetIter = ttStubDSVForOutputTemp->begin();
        stubDetIter != ttStubDSVForOutputTemp->end();
        ++stubDetIter ) {
    DetId thisStackedDetId = stubDetIter->id();
    typename edmNew::DetSetVector< TTStub< Ref_Phase2TrackerDigi_ > >::FastFiller acceptedOutputFiller( *ttStubDSVForOutputAccepted, thisStackedDetId );

    DetId lowerDetid = thisStackedDetId+1;
    DetId upperDetid = thisStackedDetId+2;

    edmNew::DetSet< TTCluster< Ref_Phase2TrackerDigi_ > > lowerClusters = (*ttClusterAcceptedHandle)[ lowerDetid ];
    edmNew::DetSet< TTCluster< Ref_Phase2TrackerDigi_ > > upperClusters = (*ttClusterAcceptedHandle)[ upperDetid ];

    edmNew::DetSet< TTStub< Ref_Phase2TrackerDigi_ > > theseStubs = (*ttStubDSVForOutputTemp)[ thisStackedDetId ];

    typename edmNew::DetSet< TTCluster< Ref_Phase2TrackerDigi_ > >::iterator clusterIter;
    typename edmNew::DetSet< TTStub< Ref_Phase2TrackerDigi_ > >::iterator stubIter;
    for ( stubIter = theseStubs.begin();
          stubIter != theseStubs.end();
          ++stubIter ) {
      TTStub< Ref_Phase2TrackerDigi_ > tempTTStub( stubIter->getDetId() );

      const edm::Ref< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >, TTCluster< Ref_Phase2TrackerDigi_ > >& lowerClusterToBeReplaced = stubIter->getClusterRef(0);
      const edm::Ref< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >, TTCluster< Ref_Phase2TrackerDigi_ > >& upperClusterToBeReplaced = stubIter->getClusterRef(1);

      bool lowerOK = false;
      bool upperOK = false;

      for ( clusterIter = lowerClusters.begin();
            clusterIter != lowerClusters.end() && !lowerOK;
            ++clusterIter ) {
        if ( clusterIter->getHits() == lowerClusterToBeReplaced->getHits() ) {
          tempTTStub.addClusterRef( edmNew::makeRefTo( ttClusterAcceptedHandle, clusterIter ) );
          lowerOK = true;
        }
      }

      for ( clusterIter = upperClusters.begin();
            clusterIter != upperClusters.end() && !upperOK;
            ++clusterIter ) {
        if ( clusterIter->getHits() == upperClusterToBeReplaced->getHits() ) {
          tempTTStub.addClusterRef( edmNew::makeRefTo( ttClusterAcceptedHandle, clusterIter ) );
          upperOK = true;
        }
      }

      if ( !lowerOK || !upperOK ) continue;

      tempTTStub.setTriggerDisplacement( 2.*stubIter->getTriggerDisplacement() ); 
      tempTTStub.setTriggerOffset( 2.*stubIter->getTriggerOffset() );             

      acceptedOutputFiller.push_back( tempTTStub );

    } 

    if ( acceptedOutputFiller.empty() )
      acceptedOutputFiller.abort();
   
  } 
    
  iEvent.put( std::move(ttStubDSVForOutputAccepted), "StubAccepted" );
  iEvent.put( std::move(ttStubDSVForOutputRejected), "StubRejected" );
}