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 ()
	Destructor;. More...

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

	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 &	itemsToGetFromEvent () 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

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

virtual	~EDConsumerBase () noexcept(false)

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

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

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

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

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

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
edm::EDGetTokenT < edmNew::DetSetVector < TTCluster< T > > >	clustersToken

bool	ForbidMultipleStubs

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

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 78 of file TTStubBuilder.h.

References edm::ParameterSet::getParameter().

 {
   clustersToken = consumes< edmNew::DetSetVector< TTCluster< T > > >(iConfig.getParameter< edm::InputTag >( "TTClusters" ));
   ForbidMultipleStubs = iConfig.getParameter< bool >( "OnlyOnePerInputCluster" );
   produces< edmNew::DetSetVector< TTCluster< T > > >( "ClusterAccepted" );
   produces< edmNew::DetSetVector< TTStub< T > > >( "StubAccepted" );
   produces< edmNew::DetSetVector< TTStub< T > > >( "StubRejected" );
 }

template<typename T >

TTStubBuilder< T >::~TTStubBuilder ( )

Destructor;.

Destructor.

Definition at line 89 of file TTStubBuilder.h.

89 {}

Member Function Documentation

template<typename T >

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

privatevirtual

Mandatory methods.

Begin run.

Get the stub finding algorithm

Reimplemented from edm::EDProducer.

Definition at line 93 of file TTStubBuilder.h.

References edm::EventSetup::get().

 {
   iSetup.get< TTStubAlgorithmRecord >().get( theStubFindingAlgoHandle );
 }

template<typename T >

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

privatevirtual

End run.

Reimplemented from edm::EDProducer.

Definition at line 101 of file TTStubBuilder.h.

101 {}

template<>

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

privatevirtual

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

Get the maximum number of stubs per ROC (CBC3-style)

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

Need to find ASIC size in half-strip units

Temporary storage for stubs before max check

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 ASIC

Already a stub for this ASIC?

No, so new entry

Already existing entry

End of check on max number of stubs per module

End of nested loop

End of loop over pairs of Clusters

If we are working with max no. stub/ROC, then clean the temporary output and store only the selected stubs

Loop over ROC's the ROC ID is not important

Put the stubs into the output

Sort them and pick up only the first N.

Put the highest momenta (lowest bend) stubs into the event

End of loop over temp output

End store only the selected stubs if max no. stub/ROC is set

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)

Implements edm::EDProducer.

Definition at line 16 of file TTStubBuilder.cc.

References TTStub< T >::addClusterRef(), edmNew::DetSet< T >::begin(), edmNew::DetSetVector< T >::begin(), TrackerGeometry::dets(), edmNew::DetSetVector< T >::empty(), edmNew::DetSet< T >::end(), edmNew::DetSetVector< T >::end(), edm::false, edm::EventSetup::get(), edm::Event::getByToken(), TTStub< T >::getClusterRef(), TTStub< T >::getTriggerPosition(), i, edmNew::DetSetVector< T >::id(), TrackerGeometry::idToDetUnit(), TrackerTopology::isLower(), visualization-live-secondInstance_cfg::m, edmNew::makeRefTo(), eostools::move(), TrackerTopology::partnerDetId(), edm::ESHandle< class >::product(), edmNew::DetSetVector< T >::push_back(), edm::Event::put(), PixelTopology::rowsperroc(), TTStub< T >::setTriggerDisplacement(), TTStub< T >::setTriggerOffset(), edmNew::DetSet< T >::size(), PixelGeomDetUnit::specificTopology(), TrackerTopology::stack(), DetId::subdetId(), StripSubdetector::TID, and StripSubdetector::TOB.

 {
   //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 = 3;
 
   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.size() == 0 || upperClusters.size() == 0 )
       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.size() > 0 )
     {
       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.size() > 0 )
     {
       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.size() > 0 )
     {
       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() );
 
       edm::Ref< edmNew::DetSetVector< TTCluster< Ref_Phase2TrackerDigi_ > >, TTCluster< Ref_Phase2TrackerDigi_ > > lowerClusterToBeReplaced = stubIter->getClusterRef(0);
       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" );
 }

template<typename T >

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

privatevirtual

Implements edm::EDProducer.

template<>

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

privatevirtual

Implements edm::EDProducer.

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 105 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 112 of file TTStubBuilder.h.

References TTStub< T >::getTriggerBend().

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

Member Data Documentation

template<typename T >

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

private

Definition at line 55 of file TTStubBuilder.h.

template<typename T >

bool TTStubBuilder< T >::ForbidMultipleStubs

private

Definition at line 56 of file TTStubBuilder.h.

template<typename T >

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

private

Data members.

Definition at line 54 of file TTStubBuilder.h.

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 >