Plugin to load the Stub finding algorithm and produce the collection of Stubs that goes in the event content. More...

#include <TTStubBuilder.h>

Inheritance diagram for TTStubBuilder< T >:

Public Member Functions
	TTStubBuilder (const edm::ParameterSet &iConfig)
	Constructor. More...

	~TTStubBuilder () override
	Destructor;. More...

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginRun (const edm::Run &run, const edm::EventSetup &iSetup) override
	Mandatory methods. More...

void	endRun (const edm::Run &run, const edm::EventSetup &iSetup) override
	End run. More...

template<>
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup)
	Implementation of methods of TTClusterBuilder.h. More...

void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override

template<>
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup)
	Implement the producer. More...

Static Private Member Functions
static bool	SortStubBendPairs (const std::pair< unsigned int, double > &left, const std::pair< unsigned int, double > &right)
	Sort routine for stub ordering. More...

static bool	SortStubsBend (const TTStub< T > &left, const TTStub< T > &right)
	Analogous sorting routine directly from stubs. More...

Private Attributes
bool	applyFE

edm::EDGetTokenT< edmNew::DetSetVector< TTCluster< T > > >	clustersToken

bool	ForbidMultipleStubs

unsigned int	high_rate_max_ring [5]

int	ievt

unsigned int	maxStubs_2S

unsigned int	maxStubs_2S_CIC_5

unsigned int	maxStubs_PS

unsigned int	maxStubs_PS_CIC_10

unsigned int	maxStubs_PS_CIC_5

std::unordered_map< int, int >	moduleStubs_CBC

std::unordered_map< int, std::vector< TTStub< Ref_Phase2TrackerDigi_ > > >	moduleStubs_CIC
	Temporary storage for stubs before max check. More...

std::unordered_map< int, int >	moduleStubs_MPA

unsigned int	tedd1_maxring

unsigned int	tedd2_maxring

edm::ESHandle< TTStubAlgorithm< T > >	theStubFindingAlgoHandle
	Data members. More...

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

template<typename T>
class TTStubBuilder< T >

Plugin to load the Stub finding algorithm and produce the collection of Stubs that goes in the event content.

After moving from SimDataFormats to DataFormats, the template structure of the class was maintained in order to accomodate any types other than PixelDigis in case there is such a need in the future.

Author: Andrew W. Rose; Nicola Pozzobon; Ivan Reid

Date: 2013, Jul 18

Definition at line 43 of file TTStubBuilder.h.

Constructor & Destructor Documentation

template<typename T >

TTStubBuilder< T >::TTStubBuilder ( const edm::ParameterSet & iConfig )

explicit

Constructor.

Close class.

Implementation of methods

Here, in the header file, the methods which do not depend on the specific type <T> that can fit the template. Other methods, with type-specific features, are implemented in the source file.Constructors

Definition at line 111 of file TTStubBuilder.h.

References TTStubBuilder< T >::applyFE, TTStubBuilder< T >::clustersToken, TTStubBuilder< T >::ForbidMultipleStubs, edm::ParameterSet::getParameter(), TTStubBuilder< T >::high_rate_max_ring, TTStubBuilder< T >::maxStubs_2S, TTStubBuilder< T >::maxStubs_2S_CIC_5, TTStubBuilder< T >::maxStubs_PS, TTStubBuilder< T >::maxStubs_PS_CIC_10, TTStubBuilder< T >::maxStubs_PS_CIC_5, TTStubBuilder< T >::tedd1_maxring, and TTStubBuilder< T >::tedd2_maxring.

 {
   clustersToken = consumes< edmNew::DetSetVector< TTCluster< T > > >(iConfig.getParameter< edm::InputTag >( "TTClusters" ));
   ForbidMultipleStubs = iConfig.getParameter< bool >( "OnlyOnePerInputCluster" );
   applyFE             = iConfig.getParameter< bool >( "FEineffs" );
   maxStubs_2S         = iConfig.getParameter< uint32_t >( "CBClimit" );
   maxStubs_PS         = iConfig.getParameter< uint32_t >( "MPAlimit" );
   maxStubs_2S_CIC_5   = iConfig.getParameter< uint32_t >( "SS5GCIClimit" );
   maxStubs_PS_CIC_5   = iConfig.getParameter< uint32_t >( "PS5GCIClimit" );
   maxStubs_PS_CIC_10  = iConfig.getParameter< uint32_t >( "PS10GCIClimit" );
   tedd1_maxring       = iConfig.getParameter< uint32_t >( "TEDD1Max10GRing" );
   tedd2_maxring       = iConfig.getParameter< uint32_t >( "TEDD2Max10GRing" );
   produces< edmNew::DetSetVector< TTCluster< T > > >( "ClusterAccepted" );
   produces< edmNew::DetSetVector< TTStub< T > > >( "StubAccepted" );
   produces< edmNew::DetSetVector< TTStub< T > > >( "StubRejected" );
 
   high_rate_max_ring[0] = tedd1_maxring;
   high_rate_max_ring[1] = tedd1_maxring;
   high_rate_max_ring[2] = tedd2_maxring;
   high_rate_max_ring[3] = tedd2_maxring;
   high_rate_max_ring[4] = tedd2_maxring;
 }

template<typename T >

TTStubBuilder< T >::~TTStubBuilder ( )

override

Destructor;.

Destructor.

Definition at line 136 of file TTStubBuilder.h.

136 {}

Member Function Documentation

template<typename T >

void TTStubBuilder< T >::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Mandatory methods.

Begin run.

Get the stub finding algorithm

Definition at line 140 of file TTStubBuilder.h.

References edm::EventSetup::get(), TTStubBuilder< T >::ievt, TTStubBuilder< T >::moduleStubs_CBC, TTStubBuilder< T >::moduleStubs_CIC, TTStubBuilder< T >::moduleStubs_MPA, and TTStubBuilder< T >::theStubFindingAlgoHandle.

 {
   iSetup.get< TTStubAlgorithmRecord >().get( theStubFindingAlgoHandle );
   ievt=0;
   moduleStubs_CIC.clear();
   moduleStubs_MPA.clear();
   moduleStubs_CBC.clear();
 }

template<typename T >

void TTStubBuilder< T >::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overrideprivate

End run.

Definition at line 152 of file TTStubBuilder.h.

152 {}

template<>

void TTStubBuilder< Ref_Phase2TrackerDigi_ >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Implementation of methods of TTClusterBuilder.h.

Here, in the source file, the methods which do depend on the specific type <T> that can fit the template.

Author: Andrew W. Rose; Nicola Pozzobon; Ivan Reid

Date: 2013, Jul 18Implement the producer

Prepare output

Get the Clusters already stored away

Go on only if both detectors have Clusters

Get the DetSets of the Clusters

If there are Clusters in both sensors you can try and make a Stub This is ~redundant

Create the vectors of objects to be passed to the FastFillers

Get chip size information

SV 21/11/17: tracker topology method should be updated, currently provide wrong nums

Loop over pairs of Clusters

Temporary storage to allow only one stub per inner cluster if requested in cfi

Build a temporary Stub

Check for compatibility

If the Stub is above threshold

Stub accepted

End of loop over outer clusters

Here tempOutput stores all the stubs from this inner cluster Check if there is need to store only one (if only one already, skip this step)

If so, sort the stubs by bend and keep only the first one (smallest bend)

Get to the second element (the switch above ensures there are min 2)

tempIter points now to the second element

Delete all-but-the first one from tempOutput

Here, tempOutput is either of size 1 (if entering the switch) either of size N with all the valid combinations ...

Now loop over the accepted stubs (1 or N) for this inner cluster

Get the stub

Put in the output

This means that ALL stubs go into the output

This means that only some of them do

Put in the temporary output

Find out which MPA/CBC ASIC

Find out which CIC ASIC

Already a stub for this ASIC?

No, so new entry

Already a stub for this ASIC?

No, so new entry

Already a stub for this ASIC?

No, so new entry

Sort them by |bend| and pick up only the first N.

End of check on max number of stubs per module

End of nested loop

End of loop over pairs of Clusters

Create the FastFillers

End of loop over detector elements

Put output in the event (1) Get also the OrphanHandle of the accepted clusters

Now, correctly reset the output

Get the DetId and prepare the FastFiller

detid of the two components. This should be done via a TrackerTopology method that is not yet available.

Get the DetSets of the clusters

Get the DetSet of the stubs

Prepare the new DetSet to replace the current one Loop over the stubs

Create a temporary stub

Compare the clusters stored in the stub with the ones of this module

If no compatible clusters were found, skip to the next one

getter is in FULL-strip units, setter is in HALF-strip units

End of loop over stubs of this module

End of loop over stub DetSetVector

Put output in the event (2)

Definition at line 16 of file TTStubBuilder.cc.

References TTStub< T >::addClusterRef(), edmNew::DetSet< T >::begin(), edmNew::DetSetVector< T >::begin(), TrackerGeometry::dets(), edmNew::DetSet< T >::empty(), edmNew::DetSetVector< T >::empty(), edmNew::DetSet< T >::end(), edmNew::DetSetVector< T >::end(), plotBeamSpotDB::first, edm::EventSetup::get(), edm::Event::getByToken(), TTStub< T >::getClusterRef(), TrackerGeometry::getDetectorType(), TTStub< T >::getDetId(), TTStub< T >::getHardwareBend(), TTStub< T >::getRealTriggerOffset(), TTStub< T >::getTriggerDisplacement(), TTStub< T >::getTriggerOffset(), TTStub< T >::getTriggerPosition(), mps_fire::i, edmNew::DetSetVector< T >::id(), createfilelist::int, TrackerTopology::isLower(), TrackerTopology::layer(), funct::m, edmNew::makeRefTo(), eostools::move(), TrackerTopology::partnerDetId(), TrackerGeometry::Ph2PSP, edm::ESHandle< T >::product(), edmNew::DetSetVector< T >::push_back(), edm::Event::put(), TTStub< T >::setHardwareBend(), TTStub< T >::setRealTriggerOffset(), TTStub< T >::setTriggerDisplacement(), TTStub< T >::setTriggerOffset(), findQualityFiles::size, TrackerTopology::stack(), DetId::subdetId(), StripSubdetector::TID, TrackerTopology::tidRing(), TrackerTopology::tidWheel(), StripSubdetector::TOB, and PV2DBase< T, PVType, FrameType >::y().

 {
   //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
 
 }

template<typename T >

void TTStubBuilder< T >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Referenced by TTStubBuilder< T >::SortStubsBend().

template<>

void TTStubBuilder< Ref_Phase2TrackerDigi_ >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Implement the producer.

template<typename T >

bool TTStubBuilder< T >::SortStubBendPairs	(	const std::pair< unsigned int, double > &	left,
		const std::pair< unsigned int, double > &	right
	)

staticprivate

Sort routine for stub ordering.

Sorting method for stubs NOTE: this must be static!

Definition at line 156 of file TTStubBuilder.h.

 {
   return fabs(left.second) < fabs(right.second);
 }

template<typename T >

bool TTStubBuilder< T >::SortStubsBend	(	const TTStub< T > &	left,
		const TTStub< T > &	right
	)

staticprivate

Analogous sorting routine directly from stubs.

Definition at line 163 of file TTStubBuilder.h.

References TTStub< T >::getTriggerBend(), iEvent, and TTStubBuilder< T >::produce().

 {
   return fabs(left.getTriggerBend()) < fabs(right.getTriggerBend());
 }

Member Data Documentation

template<typename T >

bool TTStubBuilder< T >::applyFE

private

Definition at line 70 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

edm::EDGetTokenT< edmNew::DetSetVector< TTCluster< T > > > TTStubBuilder< T >::clustersToken

private

Definition at line 55 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

bool TTStubBuilder< T >::ForbidMultipleStubs

private

Definition at line 56 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

unsigned int TTStubBuilder< T >::high_rate_max_ring[5]

private

Definition at line 96 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

int TTStubBuilder< T >::ievt

private

Definition at line 82 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::beginRun().

template<typename T >

unsigned int TTStubBuilder< T >::maxStubs_2S

private

Definition at line 73 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

unsigned int TTStubBuilder< T >::maxStubs_2S_CIC_5

private

Definition at line 75 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

unsigned int TTStubBuilder< T >::maxStubs_PS

private

Definition at line 74 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

unsigned int TTStubBuilder< T >::maxStubs_PS_CIC_10

private

Definition at line 77 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

unsigned int TTStubBuilder< T >::maxStubs_PS_CIC_5

private

Definition at line 76 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

std::unordered_map< int, int > TTStubBuilder< T >::moduleStubs_CBC

private

Definition at line 88 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::beginRun().

template<typename T >

std::unordered_map< int, std::vector< TTStub< Ref_Phase2TrackerDigi_ > > > TTStubBuilder< T >::moduleStubs_CIC

private

Temporary storage for stubs before max check.

Definition at line 86 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::beginRun().

template<typename T >

std::unordered_map< int, int > TTStubBuilder< T >::moduleStubs_MPA

private

Definition at line 87 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::beginRun().

template<typename T >

unsigned int TTStubBuilder< T >::tedd1_maxring

private

Definition at line 79 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

unsigned int TTStubBuilder< T >::tedd2_maxring

private

Definition at line 80 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::TTStubBuilder().

template<typename T >

edm::ESHandle< TTStubAlgorithm< T > > TTStubBuilder< T >::theStubFindingAlgoHandle

private

Data members.

Definition at line 54 of file TTStubBuilder.h.

Referenced by TTStubBuilder< T >::beginRun().

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename T> class TTStubBuilder< T >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T>
class TTStubBuilder< T >