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

std::vector< bool > const &	recordProvenanceList () 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)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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 &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

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

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

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

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::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (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

◆ TTStubBuilder()

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

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

References edm::ParameterSet::getParameter().

◆ ~TTStubBuilder()

template<typename T >

TTStubBuilder< T >::~TTStubBuilder ( )

override

Destructor;.

Destructor.

Definition at line 133 of file TTStubBuilder.h.

133 {}

Member Function Documentation

◆ beginRun()

template<typename T >

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

overrideprivatevirtual

Mandatory methods.

Begin run.

Get the stub finding algorithm

Reimplemented from edm::EDProducer.

Definition at line 137 of file TTStubBuilder.h.

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

References edm::EventSetup::get(), and get.

◆ endRun()

template<typename T >

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

overrideprivatevirtual

End run.

Reimplemented from edm::EDProducer.

Definition at line 148 of file TTStubBuilder.h.

148 {}

◆ produce() [1/3]

template<>

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

privatevirtual

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 18 Implement 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

Already a stub for this ASIC?

No, so new entry

Already a stub for this ASIC?

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)

Implements edm::EDProducer.

Definition at line 16 of file TTStubBuilder.cc.

                                                                                                  {
   //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_>>>();
  
   static constexpr int CBCFailOffset = 500;
   static constexpr int CICFailOffset = 1000;
  
   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));
         tempTTStub.setModuleTypePS(isPS);
  
         bool thisConfirmation = false;
         int thisDisplacement = 999999;
         int thisOffset = 0;
         float thisHardBend = 0;
  
         theStubFindingAlgoHandle->PatternHitCorrelation(
             thisConfirmation, thisDisplacement, thisOffset, thisHardBend, tempTTStub);
         // Removed real offset.  Ivan Reid 10/2019
  
         if (thisConfirmation) {
           tempTTStub.setRawBend(thisDisplacement);
           tempTTStub.setBendOffset(thisOffset);
           tempTTStub.setBendBE(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.clusterRef(0)));
         tempTTStub2.addClusterRef((tempTTStub.clusterRef(1)));
         tempTTStub2.setRawBend(2. * tempTTStub.rawBend());
         tempTTStub2.setBendOffset(2. * tempTTStub.bendOffset());
         tempTTStub2.setBendBE(tempTTStub.bendBE());
         tempTTStub2.setModuleTypePS(tempTTStub.moduleTypePS());
  
         if (!applyFE)  // No dynamic inefficiencies (DEFAULT)
         {
           tempInner.push_back(*(tempTTStub.clusterRef(0)));
           tempOuter.push_back(*(tempTTStub.clusterRef(1)));
           tempAccepted.push_back(tempTTStub);
         } else {
           bool FEreject = false;
           MeasurementPoint mp0 = tempTTStub.clusterRef(0)->findAverageLocalCoordinates();
           int seg = static_cast<int>(mp0.y());
           if (isPS)
             seg = seg / 16;
           int chip = 1000 * nmod + 10 * int(tempTTStub.innerClusterPosition() / 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.setRawBend(CBCFailOffset + 2. * tempTTStub.rawBend());
             tempTTStub2.setBendOffset(CBCFailOffset + 2. * tempTTStub.bendOffset());
  
             tempInner.push_back(*(tempTTStub2.clusterRef(0)));
             tempOuter.push_back(*(tempTTStub2.clusterRef(1)));
             tempAccepted.push_back(tempTTStub2);
             continue;
           }
  
           maxStubs = isPS ? maxStubs_PS_CIC_5 : maxStubs_2S_CIC_5;
  
           if (is10G_PS)
             maxStubs = maxStubs_PS_CIC_10;
  
           if (moduleStubs_CIC.find(CIC_chip) == moduleStubs_CIC.end())  
           {
             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.setRawBend(CBCFailOffset + 2. * tempTTStub.rawBend());
             tempTTStub2.setBendOffset(CBCFailOffset + 2. * tempTTStub.bendOffset());
  
             tempInner.push_back(*(tempTTStub2.clusterRef(0)));
             tempOuter.push_back(*(tempTTStub2.clusterRef(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())  
           {
             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.clusterRef(0)));
               tempOuter.push_back(*(tempTTStub.clusterRef(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).bendFE());
               }
  
               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.setRawBend(CICFailOffset + 2. * tempTTStub.rawBend());
                 tempTTStub2.setBendOffset(CICFailOffset + 2. * tempTTStub.bendOffset());
  
                 tempInner.push_back(*(tempTTStub2.clusterRef(0)));
                 tempOuter.push_back(*(tempTTStub2.clusterRef(1)));
                 tempAccepted.push_back(tempTTStub2);
               } else {
                 tempInner.push_back(*(tempTTStub.clusterRef(0)));
                 tempOuter.push_back(*(tempTTStub.clusterRef(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->clusterRef(0);
       const edm::Ref<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>, TTCluster<Ref_Phase2TrackerDigi_>>&
           upperClusterToBeReplaced = stubIter->clusterRef(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.setRawBend(2. * stubIter->rawBend());  
       tempTTStub.setBendOffset(
           2. * stubIter->bendOffset());  
       tempTTStub.setBendBE(stubIter->bendBE());
       tempTTStub.setModuleTypePS(stubIter->moduleTypePS());
  
       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
 }

References TTStub< T >::addClusterRef(), edmNew::DetSet< T >::begin(), edmNew::DetSetVector< T >::begin(), TTStub< T >::bendBE(), TTStub< T >::bendOffset(), TTStub< T >::clusterRef(), TrackerGeometry::dets(), edmNew::DetSet< T >::empty(), edmNew::DetSetVector< T >::empty(), edmNew::DetSet< T >::end(), edmNew::DetSetVector< T >::end(), dqmdumpme::first, edm::EventSetup::get(), get, TrackerGeometry::getDetectorType(), TTStub< T >::getDetId(), mps_fire::i, edmNew::DetSetVector< T >::id(), iEvent, TTStub< T >::innerClusterPosition(), createfilelist::int, TrackerTopology::isLower(), TrackerTopology::layer(), visualization-live-secondInstance_cfg::m, edmNew::makeRefTo(), TTStub< T >::moduleTypePS(), eostools::move(), TrackerTopology::partnerDetId(), TrackerGeometry::Ph2PSP, edm::ESHandle< T >::product(), edmNew::DetSetVector< T >::push_back(), TTStub< T >::rawBend(), TTStub< T >::setBendBE(), TTStub< T >::setBendOffset(), TTStub< T >::setModuleTypePS(), TTStub< T >::setRawBend(), findQualityFiles::size, TrackerTopology::stack(), DetId::subdetId(), StripSubdetector::TID, TrackerTopology::tidRing(), TrackerTopology::tidWheel(), StripSubdetector::TOB, and PV2DBase< T, PVType, FrameType >::y().

◆ produce() [2/3]

template<>

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

privatevirtual

Implement the producer.

Implements edm::EDProducer.

◆ produce() [3/3]

template<typename T >

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

overrideprivatevirtual

Implements edm::EDProducer.

◆ SortStubBendPairs()

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

                                                                                      {
   return std::abs(left.second) < std::abs(right.second);
 }

References funct::abs().

◆ SortStubsBend()

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

                                                                                   {
   return std::abs(left.bendFE()) < std::abs(right.bendFE());
 }

private

Temporary storage for stubs before max check.

Definition at line 86 of file TTStubBuilder.h.

◆ moduleStubs_MPA

template<typename T >

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

private

Definition at line 87 of file TTStubBuilder.h.

◆ tedd1_maxring

template<typename T >

unsigned int TTStubBuilder< T >::tedd1_maxring

private

Definition at line 79 of file TTStubBuilder.h.

◆ tedd2_maxring

template<typename T >

unsigned int TTStubBuilder< T >::tedd2_maxring

private

Definition at line 80 of file TTStubBuilder.h.

◆ theStubFindingAlgoHandle

template<typename T >

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

private

Data members.

Definition at line 53 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

◆ TTStubBuilder()

◆ ~TTStubBuilder()

Member Function Documentation

◆ beginRun()

◆ endRun()

◆ produce() [1/3]

◆ produce() [2/3]

◆ produce() [3/3]

◆ SortStubBendPairs()

◆ SortStubsBend()

Member Data Documentation

◆ applyFE

◆ clustersToken

◆ ForbidMultipleStubs

◆ high_rate_max_ring

◆ ievt

◆ maxStubs_2S

◆ maxStubs_2S_CIC_5

◆ maxStubs_PS

◆ maxStubs_PS_CIC_10

◆ maxStubs_PS_CIC_5

◆ moduleStubs_CBC

◆ moduleStubs_CIC

◆ moduleStubs_MPA

◆ tedd1_maxring

◆ tedd2_maxring

◆ theStubFindingAlgoHandle

template<typename T>
class TTStubBuilder< T >