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

  int nmod=-1;

  // Loop over all the tracker elements

  //  for (auto gd=theTrackerGeom->dets().begin(); gd != theTrackerGeom->dets().end(); gd++)
  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 lowerDetid = detid;
    DetId upperDetid = tTopo->partnerDetId(detid);
    DetId stackDetid = tTopo->stack(detid);
    bool isPS        = (theTrackerGeom->getDetectorType(stackDetid)==TrackerGeometry::ModuleType::Ph2PSP);

    bool is10G_PS = false;
    
    // Determine if this module is a 10G transmission scheme module
    //
    // sviret comment (221217): this info should be made available in conddb at some point
    // not in TrackerTopology as some modules may switch between 10G and 5G transmission  
    // schemes during running period

    if (detid.subdetId()==StripSubdetector::TOB)
    {
      if (tTopo->layer(detid)==1) is10G_PS = true;
    }
    else if (detid.subdetId()==StripSubdetector::TID)
    {
      if (tTopo->tidRing(detid)<=high_rate_max_ring[tTopo->tidWheel(detid)-1]) is10G_PS = true;
    }


    ++nmod;

    unsigned int maxStubs;
    std::vector< std::pair< unsigned int, double > > bendMap;

    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();

    int chipSize = 127; 
    if (isPS) chipSize = 120;

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

      std::vector< TTStub< Ref_Phase2TrackerDigi_ > > tempOutput;

      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;
    float thisROffset = 0;
    float thisHardBend = 0;

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

        if ( thisConfirmation )
        {
          tempTTStub.setTriggerDisplacement( thisDisplacement );
          tempTTStub.setTriggerOffset( thisOffset );
      tempTTStub.setRealTriggerOffset( thisROffset );
      tempTTStub.setHardwareBend( thisHardBend );
      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];

    // A temporary stub, for FE problems
    TTStub< Ref_Phase2TrackerDigi_ > tempTTStub2( tempTTStub.getDetId() );
    
    tempTTStub2.addClusterRef( (tempTTStub.getClusterRef(0)) );
    tempTTStub2.addClusterRef( (tempTTStub.getClusterRef(1)) );
    tempTTStub2.setTriggerDisplacement( 2.*tempTTStub.getTriggerDisplacement() ); 
    tempTTStub2.setTriggerOffset( 2.*tempTTStub.getTriggerOffset() ); 
    tempTTStub2.setRealTriggerOffset( 2.*tempTTStub.getRealTriggerOffset() );
    tempTTStub2.setHardwareBend( tempTTStub.getHardwareBend() );


        if ( !applyFE ) // No dynamic inefficiencies (DEFAULT)
        {
          tempInner.push_back( *(tempTTStub.getClusterRef(0)) );
          tempOuter.push_back( *(tempTTStub.getClusterRef(1)) );
          tempAccepted.push_back( tempTTStub );
        }
        else
        {
      bool FEreject = false;
      MeasurementPoint mp0 = tempTTStub.getClusterRef(0)->findAverageLocalCoordinates();
      int seg       = static_cast<int>(mp0.y());
      if (isPS) seg = seg/16;
      int chip      = 1000*nmod+10*int(tempTTStub.getTriggerPosition()/chipSize)+seg; 
          int CIC_chip  = 10*nmod+seg; 

      // First look is the stub is passing trough the very front end (CBC/MPA)
      (isPS)
        ? maxStubs = maxStubs_PS
        : maxStubs = maxStubs_2S;

      if (isPS) // MPA
      {
        if ( moduleStubs_MPA.find( chip ) == moduleStubs_MPA.end() ) 
        {
          moduleStubs_MPA.emplace(chip,1);
        }
        else
        {
          if ( moduleStubs_MPA[chip] < int(maxStubs) )
          {
        ++moduleStubs_MPA[chip];
          }
          else
          {
        FEreject = true;
          }
        }
      }
      else // CBC
      {
        if ( moduleStubs_CBC.find( chip ) == moduleStubs_CBC.end() ) 
        {
          moduleStubs_CBC.emplace(chip,1);
        }
        else
        {
          if ( moduleStubs_CBC[chip] < int(maxStubs) )
          {
        ++moduleStubs_CBC[chip];
          }
          else
          {
        FEreject = true;
          }
        }
      }
       
      // End of the MPA/CBC loop

      // If the stub has been already thrown out, there is no reason to include it into the CIC stream
      // We keep is in the stub final container tough, but flagged as reject by FE

      if (FEreject) 
      {
        tempTTStub2.setTriggerDisplacement( 500+2.*tempTTStub.getTriggerDisplacement() ); 
        tempTTStub2.setTriggerOffset( 500+2.*tempTTStub.getTriggerOffset() ); 
        tempTTStub2.setRealTriggerOffset( 500+2.*tempTTStub.getRealTriggerOffset() );
        
        tempInner.push_back( *(tempTTStub2.getClusterRef(0)) );
        tempOuter.push_back( *(tempTTStub2.getClusterRef(1)) );
        tempAccepted.push_back( tempTTStub2 );
        continue;     
      }

      (isPS)
        ? maxStubs = maxStubs_PS_CIC_5
        : maxStubs = maxStubs_2S_CIC_5;

      if (is10G_PS) maxStubs = maxStubs_PS_CIC_10;

      if ( moduleStubs_CIC.find( CIC_chip ) == moduleStubs_CIC.end() ) 
          {
        std::vector< TTStub< Ref_Phase2TrackerDigi_ > > tempStubs(1,tempTTStub);
        moduleStubs_CIC.emplace(CIC_chip,tempStubs);
        tempInner.push_back( *(tempTTStub.getClusterRef(0)) );
        tempOuter.push_back( *(tempTTStub.getClusterRef(1)) );
        tempAccepted.push_back( tempTTStub ); // The stub is added
          }
          else
          {
        bool CIC_reject=true;

        if ( moduleStubs_CIC[CIC_chip].size() < maxStubs )
        {
          moduleStubs_CIC[CIC_chip].push_back( tempTTStub ); //We add the new stub
          tempInner.push_back( *(tempTTStub.getClusterRef(0)) );
          tempOuter.push_back( *(tempTTStub.getClusterRef(1)) );
          tempAccepted.push_back( tempTTStub ); // The stub is added
        }
        else
        {
          moduleStubs_CIC[CIC_chip].push_back( tempTTStub ); //We add the new stub

          bendMap.clear();
          bendMap.reserve(moduleStubs_CIC[CIC_chip].size());
        
          for ( unsigned int i = 0; i < moduleStubs_CIC[CIC_chip].size(); ++i )
          {
        bendMap.emplace_back(i,moduleStubs_CIC[CIC_chip].at(i).getTriggerBend());
          }

          std::sort( bendMap.begin(), bendMap.end(), TTStubBuilder< Ref_Phase2TrackerDigi_ >::SortStubBendPairs );
          
          // bendMap contains link over all the stubs included in moduleStubs_CIC[CIC_chip]
          
          for ( unsigned int i = 0; i < maxStubs; ++i ) 
          {
        // The stub we have added is among the first ones, add it
        if (bendMap[i].first==moduleStubs_CIC[CIC_chip].size()-1)
        {
          CIC_reject=false;
        }
          }

          if (CIC_reject) // The stub added does not pass the cut
          {       
        tempTTStub2.setTriggerDisplacement( 1000+2.*tempTTStub.getTriggerDisplacement() ); 
        tempTTStub2.setTriggerOffset( 1000+2.*tempTTStub.getTriggerOffset() ); 
            tempTTStub2.setRealTriggerOffset( 1000+2.*tempTTStub.getRealTriggerOffset() );
    
        tempInner.push_back( *(tempTTStub2.getClusterRef(0)) );
        tempOuter.push_back( *(tempTTStub2.getClusterRef(1)) );
        tempAccepted.push_back( tempTTStub2 );
          }
          else
          {
        tempInner.push_back( *(tempTTStub.getClusterRef(0)) );
        tempOuter.push_back( *(tempTTStub.getClusterRef(1)) );
        tempAccepted.push_back( tempTTStub ); // The stub is added
          }
        }
          }
    } 
      } 
    } 

    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() );             
      tempTTStub.setRealTriggerOffset( 2.*stubIter->getRealTriggerOffset() );
      tempTTStub.setHardwareBend( stubIter->getHardwareBend() );

      acceptedOutputFiller.push_back( tempTTStub );

    } 

    if ( acceptedOutputFiller.empty() )
      acceptedOutputFiller.abort();

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

  ++ievt;
  if (ievt%8==0)    moduleStubs_CIC.clear(); // Everything is cleared up after 8BX
  if (ievt%2==0)    moduleStubs_MPA.clear(); // Everything is cleared up after 2BX
  moduleStubs_CBC.clear(); // Everything is cleared up after everyBX

}