TTClusterBuilder.cc

Go to the documentation of this file.

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

template< >
void TTClusterBuilder< Ref_Phase2TrackerDigi_ >::produce( edm::Event& iEvent, const edm::EventSetup& iSetup )
{
  auto ttClusterDSVForOutput      = std::make_unique<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>>();
  std::map< DetId, std::vector< Ref_Phase2TrackerDigi_ > > rawHits;
  this->RetrieveRawHits( rawHits, iEvent );

  // 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();
  
  // Loop on the OT stacks
  for (auto gd=theTrackerGeom->dets().begin(); gd != theTrackerGeom->dets().end(); gd++) {     
      DetId detid = (*gd)->geographicalId();
      if(detid.subdetId()==1 || detid.subdetId()==2 ) 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);

      std::vector< std::vector< Ref_Phase2TrackerDigi_ > > lowerHits, upperHits;
      
      typename std::map< DetId, std::vector< Ref_Phase2TrackerDigi_ > >::const_iterator lowerHitFind = rawHits.find(lowerDetid);
      typename std::map< DetId, std::vector< Ref_Phase2TrackerDigi_ > >::const_iterator upperHitFind = rawHits.find(upperDetid);
      
      bool isPSP = (theTrackerGeom->getDetectorType(lowerDetid)==TrackerGeometry::ModuleType::Ph2PSP);
      if ( lowerHitFind != rawHits.end() ) theClusterFindingAlgoHandle->Cluster( lowerHits, lowerHitFind->second, isPSP );  
      if ( upperHitFind != rawHits.end() ) theClusterFindingAlgoHandle->Cluster( upperHits, upperHitFind->second, false ); 
      
      { 
    edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >::FastFiller lowerOutputFiller( *ttClusterDSVForOutput, lowerDetid ); 
      for ( unsigned int i = 0; i < lowerHits.size(); i++ )
    {
      TTCluster< Ref_Phase2TrackerDigi_ > temp( lowerHits.at(i), lowerDetid, 0, storeLocalCoord );
      lowerOutputFiller.push_back( temp );
    }
      if ( lowerOutputFiller.empty() )
        lowerOutputFiller.abort();
     }
     {  
       edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >::FastFiller upperOutputFiller( *ttClusterDSVForOutput, upperDetid );
     for ( unsigned int i = 0; i < upperHits.size(); i++ )
       {
     TTCluster< Ref_Phase2TrackerDigi_ > temp( upperHits.at(i), upperDetid, 1, storeLocalCoord );
     upperOutputFiller.push_back( temp );
       }
     if ( upperOutputFiller.empty() )
       upperOutputFiller.abort();
       }
    } 
  
  iEvent.put( std::move(ttClusterDSVForOutput), "ClusterInclusive" );
}

template< >
void TTClusterBuilder< Ref_Phase2TrackerDigi_ >::RetrieveRawHits( std::map< DetId, std::vector< Ref_Phase2TrackerDigi_ > > &mRawHits,
                                                          const edm::Event& iEvent )
{ 
  mRawHits.clear();
  std::vector< edm::EDGetTokenT< edm::DetSetVector< Phase2TrackerDigi > > >::iterator it;
  for ( it = rawHitTokens.begin(); it != rawHitTokens.end(); ++it ) { 

    edm::Handle< edm::DetSetVector< Phase2TrackerDigi > > HitHandle;
    iEvent.getByToken( *it, HitHandle );
    edm::DetSetVector<Phase2TrackerDigi>::const_iterator detsIter;
    edm::DetSet<Phase2TrackerDigi>::const_iterator       hitsIter;

    for ( detsIter = HitHandle->begin(); detsIter != HitHandle->end(); detsIter++ ) { 
      DetId id = detsIter->id;
      for ( hitsIter = detsIter->data.begin(); hitsIter != detsIter->data.end(); hitsIter++ ) {
         mRawHits[id].push_back( edm::makeRefTo( HitHandle, id , hitsIter ) );
      } 
    }

  }
}