#include <TrajectorySeedProducer.h>

Inheritance diagram for TrajectorySeedProducer:

Public Types
typedef std::vector < std::unique_ptr < TrackingRegion > >	Regions

Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
bool	compatibleWithBeamSpot (const GlobalPoint &gpos1, const GlobalPoint &gpos2, double error, bool forward) const

bool	compatibleWithPrimaryVertex (const GlobalPoint &gpos1, const GlobalPoint &gpos2, double error, bool forward) const

const SeedingNode < TrackingLayer > *	insertHit (const std::vector< TrajectorySeedHitCandidate > &trackerRecHits, std::vector< int > &hitIndicesInTree, const SeedingNode< TrackingLayer > *node, unsigned int trackerHit) const

bool	isHitOnLayer (const TrajectorySeedHitCandidate &trackerRecHit, const TrackingLayer &layer) const

virtual std::vector< unsigned int >	iterateHits (unsigned int start, const std::vector< TrajectorySeedHitCandidate > &trackerRecHits, std::vector< int > hitIndicesInTree, bool processSkippedHits) const
	method tries to insert all hits into the tree structure. More...

bool	pass2HitsCuts (const TrajectorySeedHitCandidate &hit1, const TrajectorySeedHitCandidate &hit2) const

bool	passHitTuplesCuts (const SeedingNode< TrackingLayer > &seedingNode, const std::vector< TrajectorySeedHitCandidate > &trackerRecHits, const std::vector< int > &hitIndicesInTree, const TrajectorySeedHitCandidate &currentTrackerHit) const
	method checks if a SimTrack fulfills the quality requirements. More...

virtual void	produce (edm::Event &e, const edm::EventSetup &es)

bool	testWithRegions (const TrajectorySeedHitCandidate &innerHit, const TrajectorySeedHitCandidate &outerHit) const
	method inserts hit into the tree structure at an empty position. More...

	TrajectorySeedProducer (const edm::ParameterSet &conf)

virtual	~TrajectorySeedProducer ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Public Attributes
const edm::EventSetup *	es_

const MeasurementTrackerEvent *	measurementTrackerEvent

edm::EDGetTokenT < MeasurementTrackerEvent >	measurementTrackerEventToken

Regions	regions

std::unique_ptr < TrackingRegionProducer >	theRegionProducer

Private Attributes
SeedingTree< TrackingLayer >	_seedingTree

const reco::BeamSpot *	beamSpot

bool	hitMasks_exists

edm::EDGetTokenT< std::vector < bool > >	hitMasksToken

const MagneticField *	magneticField

const MagneticFieldMap *	magneticFieldMap

unsigned int	minLayersCrossed

double	nSigmaZ

double	originHalfLength

double	originRadius

const reco::VertexCollection *	primaryVertices

double	ptMin

edm::EDGetTokenT < FastTrackerRecHitCombinationCollection >	recHitCombinationsToken

std::unique_ptr< SeedCreator >	seedCreator

std::vector< std::vector < TrackingLayer > >	seedingLayers

double	simTrack_maxD0

double	simTrack_maxZ0

double	simTrack_pTMin

bool	testBeamspotCompatibility

bool	testPrimaryVertexCompatibility

std::shared_ptr < PropagatorWithMaterial >	thePropagator

const TrackerGeometry *	trackerGeometry

const TrackerTopology *	trackerTopology

Additional Inherited Members
Static Public Member Functions inherited from edm::stream::EDProducerBase
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

Definition at line 35 of file TrajectorySeedProducer.h.

Member Typedef Documentation

typedef std::vector<std::unique_ptr<TrackingRegion> > TrajectorySeedProducer::Regions

Definition at line 192 of file TrajectorySeedProducer.h.

Constructor & Destructor Documentation

TrajectorySeedProducer::TrajectorySeedProducer ( const edm::ParameterSet & conf )

Definition at line 49 of file TrajectorySeedProducer.cc.

References _seedingTree, edm::EDConsumerBase::consumesCollector(), SurfaceDeformationFactory::create(), TrackingLayer::createFromString(), edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), hitMasks_exists, hitMasksToken, SeedingTree< DATA >::insert(), geometryCSVtoXML::line, measurementTrackerEventToken, minLayersCrossed, eostools::move(), recHitCombinationsToken, seedCreator, seedingLayers, AlCaHLTBitMon_QueryRunRegistry::string, and theRegionProducer.

                                                                          :
     magneticField(nullptr),
     magneticFieldMap(nullptr),
     trackerGeometry(nullptr),
     trackerTopology(nullptr),
     theRegionProducer(nullptr)
 {
 
     produces<TrajectorySeedCollection>();
 
     // tokens
     recHitCombinationsToken = consumes<FastTrackerRecHitCombinationCollection>(conf.getParameter<edm::InputTag>("recHitCombinations"));
     measurementTrackerEventToken = consumes<MeasurementTrackerEvent>(conf.getParameter<edm::InputTag>("MeasurementTrackerEvent"));
     hitMasks_exists = conf.exists("hitMasks");
     if (hitMasks_exists){
       edm::InputTag hitMasksTag = conf.getParameter<edm::InputTag>("hitMasks");   
       hitMasksToken = consumes<std::vector<bool> >(hitMasksTag);
     }
     
     // The smallest number of hits for a track candidate
     minLayersCrossed = conf.getParameter<unsigned int>("minLayersCrossed");
 
     // read Layers
     std::vector<std::string> layerStringList = conf.getParameter<std::vector<std::string>>("layerList");
     for(auto it=layerStringList.cbegin(); it < layerStringList.cend(); ++it) 
     {
         std::vector<TrackingLayer> trackingLayerList;
         std::string line = *it;
         std::string::size_type pos=0;
         while (pos != std::string::npos) 
         {
             pos=line.find("+");
             std::string layer = line.substr(0, pos);
             TrackingLayer layerSpec = TrackingLayer::createFromString(layer);
 
             trackingLayerList.push_back(layerSpec);
             line=line.substr(pos+1,std::string::npos); 
         }
         _seedingTree.insert(trackingLayerList);
         seedingLayers.push_back(std::move(trackingLayerList));
     }
 
        // region producer                                                                                                                                                  
     if(conf.exists("RegionFactoryPSet")){
         edm::ParameterSet regfactoryPSet = conf.getParameter<edm::ParameterSet>("RegionFactoryPSet");
         std::string regfactoryName = regfactoryPSet.getParameter<std::string>("ComponentName");
         theRegionProducer.reset(TrackingRegionProducerFactory::get()->create(regfactoryName,regfactoryPSet, consumesCollector()));
 
         // seed creator                                                                                                                                                 
         const edm::ParameterSet & seedCreatorPSet = conf.getParameter<edm::ParameterSet>("SeedCreatorPSet");
         std::string seedCreatorName = seedCreatorPSet.getParameter<std::string>("ComponentName");
         seedCreator.reset(SeedCreatorFactory::get()->create( seedCreatorName, seedCreatorPSet));
     }
 }

virtual TrajectorySeedProducer::~TrajectorySeedProducer ( )

inlinevirtual

Definition at line 70 of file TrajectorySeedProducer.h.

71 {

72 }

Member Function Documentation

bool TrajectorySeedProducer::compatibleWithBeamSpot	(	const GlobalPoint &	gpos1,
		const GlobalPoint &	gpos2,
		double	error,
		bool	forward
	)		const

Check that the seed is compatible with a track coming from within a cylinder of radius originRadius, with a decent pT.

bool TrajectorySeedProducer::compatibleWithPrimaryVertex	(	const GlobalPoint &	gpos1,
		const GlobalPoint &	gpos2,
		double	error,
		bool	forward
	)		const

Check that the seed is compatible with a track coming from within a cylinder of radius originRadius, with a decent pT.

const SeedingNode< TrackingLayer > * TrajectorySeedProducer::insertHit	(	const std::vector< TrajectorySeedHitCandidate > &	trackerRecHits,
		std::vector< int > &	hitIndicesInTree,
		const SeedingNode< TrackingLayer > *	node,
		unsigned int	trackerHit
	)		const

Definition at line 133 of file TrajectorySeedProducer.cc.

References SeedingNode< DATA >::getChild(), SeedingNode< DATA >::getChildrenSize(), SeedingNode< DATA >::getData(), SeedingNode< DATA >::getIndex(), SeedingNode< DATA >::getParent(), isHitOnLayer(), passHitTuplesCuts(), and fileCollector::seed.

Referenced by iterateHits().

 {
   if (!node->getParent() || hitIndicesInTree[node->getParent()->getIndex()]>=0)
     {
       if (hitIndicesInTree[node->getIndex()]<0)
         {
       const TrajectorySeedHitCandidate& currentTrackerHit = trackerRecHits[trackerHit];
       if (!isHitOnLayer(currentTrackerHit,node->getData()))
             {
           return nullptr;
             }
       if (!passHitTuplesCuts(*node,trackerRecHits,hitIndicesInTree,currentTrackerHit))
             {
           return nullptr;
             }
       hitIndicesInTree[node->getIndex()]=trackerHit;
       if (node->getChildrenSize()==0)
             {
           return node;
             }
       return nullptr;
         }
       else
         {
       for (unsigned int ichild = 0; ichild<node->getChildrenSize(); ++ichild)
             {
           const SeedingNode<TrackingLayer>* seed = insertHit(trackerRecHits,hitIndicesInTree,node->getChild(ichild),trackerHit);
           if (seed)
                 {
           return seed;
                 }
             }
         }
     }
     return nullptr;
 }

bool TrajectorySeedProducer::isHitOnLayer	(	const TrajectorySeedHitCandidate &	trackerRecHit,
		const TrackingLayer &	layer
	)		const

inline

Definition at line 152 of file TrajectorySeedProducer.h.

References TrajectorySeedHitCandidate::getTrackingLayer().

Referenced by insertHit().

     {
         return layer==trackerRecHit.getTrackingLayer();
     }

std::vector< unsigned int > TrajectorySeedProducer::iterateHits	(	unsigned int	start,
		const std::vector< TrajectorySeedHitCandidate > &	trackerRecHits,
		std::vector< int >	hitIndicesInTree,
		bool	processSkippedHits
	)		const

virtual

method tries to insert all hits into the tree structure.

Parameters

start	index where to begin insertion. Important for recursion.
trackerRecHits	list of all TrackerRecHits.
hitIndicesInTree	hit indices which translates the tree node to the hits in trackerRecHits.
currentTrackerHit	hit which is tested.

Returns: list of hit indices which form a found seed. Returns empty list if no seed was found.

Definition at line 175 of file TrajectorySeedProducer.cc.

References _seedingTree, SeedingNode< DATA >::getDepth(), SeedingNode< DATA >::getIndex(), SeedingNode< DATA >::getParent(), SeedingTree< DATA >::getRoot(), insertHit(), and SeedingTree< DATA >::numberOfRoots().

Referenced by produce().

 {
   for (unsigned int irecHit = start; irecHit<trackerRecHits.size(); ++irecHit)
     {
       unsigned int currentHitIndex=irecHit;
       
       for (unsigned int inext=currentHitIndex+1; inext< trackerRecHits.size(); ++inext)
         {
       //if multiple hits are on the same layer -> follow all possibilities by recusion
       if (trackerRecHits[currentHitIndex].getTrackingLayer()==trackerRecHits[inext].getTrackingLayer())
         {
           if (processSkippedHits)
         {
           //recusively call the method again with hit 'inext' but skip all following on the same layer though 'processSkippedHits=false'
           std::vector<unsigned int> seedHits = iterateHits(
                                    inext,
                                    trackerRecHits,
                                    hitIndicesInTree,
                                    false
                                    );
           if (seedHits.size()>0)
             {
               return seedHits;
                     }
                 }
           irecHit+=1; 
             }
       else
         {
           break;
         }
         }
       
       processSkippedHits=true;
       
       const SeedingNode<TrackingLayer>* seedNode = nullptr;
       for (unsigned int iroot=0; seedNode==nullptr && iroot<_seedingTree.numberOfRoots(); ++iroot)
     {
       seedNode=insertHit(trackerRecHits,hitIndicesInTree,_seedingTree.getRoot(iroot), currentHitIndex);
     }
       if (seedNode)
     {
       std::vector<unsigned int> seedIndices(seedNode->getDepth()+1);
       while (seedNode)
         {
           seedIndices[seedNode->getDepth()]=hitIndicesInTree[seedNode->getIndex()];
           seedNode=seedNode->getParent();
         }
       return seedIndices;
     }
     
     }
   
   return std::vector<unsigned int>();
   
 }

bool TrajectorySeedProducer::pass2HitsCuts	(	const TrajectorySeedHitCandidate &	hit1,
		const TrajectorySeedHitCandidate &	hit2
	)		const

Definition at line 105 of file TrajectorySeedProducer.cc.

References TrackingRecHit::det(), GeometricSearchTracker::detLayer(), HitPairGeneratorFromLayerPair::doublets(), es_, GeomDet::geographicalId(), MeasurementTracker::geometricSearchTracker(), TrajectorySeedHitCandidate::hit(), MeasurementTrackerEvent::measurementTracker(), measurementTrackerEvent, regions, query::result, and seedCreator.

Referenced by passHitTuplesCuts().

 {
   const DetLayer * innerLayer =
     measurementTrackerEvent->measurementTracker().geometricSearchTracker()->detLayer(innerHit.hit()->det()->geographicalId());
   const DetLayer * outerLayer =
     measurementTrackerEvent->measurementTracker().geometricSearchTracker()->detLayer(outerHit.hit()->det()->geographicalId());
   std::vector<BaseTrackerRecHit const *> innerHits(1,(const BaseTrackerRecHit*) innerHit.hit());
   std::vector<BaseTrackerRecHit const *> outerHits(1,(const BaseTrackerRecHit*) outerHit.hit());
   for(Regions::const_iterator ir=regions.begin(); ir < regions.end(); ++ir){
     
     const RecHitsSortedInPhi* ihm=new RecHitsSortedInPhi (innerHits, (**ir).origin(), innerLayer);
     
     const RecHitsSortedInPhi* ohm=new RecHitsSortedInPhi (outerHits, (**ir).origin(), outerLayer);
     
     HitDoublets result(*ihm,*ohm); 
     
     HitPairGeneratorFromLayerPair::doublets(**ir,*innerLayer,*outerLayer,*ihm,*ohm,*es_,0,result);
     
     if(result.size()!=0){
       seedCreator->init(**ir,*es_,0);
       return true; }
     
   }
   
   return false;
 }

bool TrajectorySeedProducer::passHitTuplesCuts	(	const SeedingNode< TrackingLayer > &	seedingNode,
		const std::vector< TrajectorySeedHitCandidate > &	trackerRecHits,
		const std::vector< int > &	hitIndicesInTree,
		const TrajectorySeedHitCandidate &	currentTrackerHit
	)		const

inline

method checks if a SimTrack fulfills the quality requirements.

Parameters

theSimTrack	the SimTrack to be tested.
theSimVertex	the associated SimVertex of the SimTrack.

Returns: true if a track fulfills the requirements.method checks if a TrajectorySeedHitCandidate fulfills the quality requirements.

Parameters

seedingNode	tree node at which the hit will be inserted.
trackerRecHits	list of all TrackerRecHits.
hitIndicesInTree	hit indices which translates the tree node to the hits in trackerRecHits.
currentTrackerHit	hit which is tested.

Returns: true if a hit fulfills the requirements.

Definition at line 91 of file TrajectorySeedProducer.h.

References SeedingNode< DATA >::getDepth(), SeedingNode< DATA >::getIndex(), SeedingNode< DATA >::getParent(), and pass2HitsCuts().

Referenced by insertHit().

     {
         switch (seedingNode.getDepth())
         {
             case 0:
             {
                 return true;
                 /* example for 1 hits
                 const TrajectorySeedHitCandidate& hit1 = currentTrackerHit;
                 return pass1HitsCuts(hit1,trackingAlgorithmId);
                 */
             }
 
             case 1:
             {
                 const SeedingNode<TrackingLayer>* parentNode = &seedingNode;
                 parentNode = parentNode->getParent();
                 const TrajectorySeedHitCandidate& hit1 = trackerRecHits[hitIndicesInTree[parentNode->getIndex()]];
                 const TrajectorySeedHitCandidate& hit2 = currentTrackerHit;
 
                 return pass2HitsCuts(hit1,hit2);
             }
             case 2:
             {
                 return true;
                 /* example for 3 hits
                 const SeedingNode<LayerSpec>* parentNode = &seedingNode;
                 parentNode = parentNode->getParent();
                 const TrajectorySeedHitCandidate& hit2 = trackerRecHits[hitIndicesInTree[parentNode->getIndex()]];
                 parentNode = parentNode->getParent();
                 const TrajectorySeedHitCandidate& hit1 = trackerRecHits[hitIndicesInTree[parentNode->getIndex()]];
                 const TrajectorySeedHitCandidate& hit3 = currentTrackerHit;
                 return pass3HitsCuts(hit1,hit2,hit3,trackingAlgorithmId);
                 */
             }
         }
         return true;
     }

void TrajectorySeedProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	es
	)

virtual

Implements edm::stream::EDProducerBase.

Definition at line 238 of file TrajectorySeedProducer.cc.

References _seedingTree, clone(), es_, edm::EventSetup::get(), edm::Event::getByToken(), SeedingTree< DATA >::getSingleSet(), TrajectorySeedHitCandidate::getTrackingLayer(), hitMasks_exists, hitMasksToken, TrajectorySeedHitCandidate::isOnTheSameLayer(), iterateHits(), magneticField, magneticFieldMap, measurementTrackerEvent, measurementTrackerEventToken, minLayersCrossed, eostools::move(), SeedingTree< DATA >::numberOfNodes(), convertSQLitetoXML_cfg::output, edm::Handle< T >::product(), edm::OwnVector< T, P >::push_back(), edm::Event::put(), recHitCombinationsToken, regions, seedCreator, fastTrackingHelper::setRecHitCombinationIndex(), edm::OwnVector< T, P >::size(), theRegionProducer, trackerGeometry, and trackerTopology.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

 {        
 
     // services
     edm::ESHandle<MagneticField> magneticFieldHandle;
     edm::ESHandle<TrackerGeometry> trackerGeometryHandle;
     edm::ESHandle<MagneticFieldMap> magneticFieldMapHandle;
     edm::ESHandle<TrackerTopology> trackerTopologyHandle;
 
     es.get<IdealMagneticFieldRecord>().get(magneticFieldHandle);
     es.get<TrackerDigiGeometryRecord>().get(trackerGeometryHandle);
     es.get<MagneticFieldMapRecord>().get(magneticFieldMapHandle);
     es.get<TrackerTopologyRcd>().get(trackerTopologyHandle);
     
     magneticField = &(*magneticFieldHandle);
     trackerGeometry = &(*trackerGeometryHandle);
     magneticFieldMap = &(*magneticFieldMapHandle);
     trackerTopology = &(*trackerTopologyHandle);
 
     es_ = &es;
 
     // hit masks
     std::unique_ptr<HitMaskHelper> hitMaskHelper;
     if (hitMasks_exists){  
     edm::Handle<std::vector<bool> > hitMasks;
     e.getByToken(hitMasksToken,hitMasks);
     hitMaskHelper.reset(new HitMaskHelper(hitMasks.product()));
     }
     
     // hit combinations
     edm::Handle<FastTrackerRecHitCombinationCollection> recHitCombinations;
     e.getByToken(recHitCombinationsToken, recHitCombinations);
 
     // measurement tracker event (only used to access services)
     edm::Handle<MeasurementTrackerEvent> measurementTrackerEventHandle;
     e.getByToken(measurementTrackerEventToken,measurementTrackerEventHandle);
     measurementTrackerEvent = measurementTrackerEventHandle.product();
 
     // output
     std::unique_ptr<TrajectorySeedCollection> output(new TrajectorySeedCollection());
 
     // produce the regions;
     if(!theRegionProducer){
     edm::LogWarning("TrajectorySeedProducer") << " RegionFactory is not initialised properly, please check your configuration. Producing empty seed collection" << std::endl;
     e.put(std::move(output));
     return;
     }
     
     regions = theRegionProducer->regions(e,es);
     
     
     for ( unsigned icomb=0; icomb<recHitCombinations->size(); ++icomb)
     {
       
 
         FastTrackerRecHitCombination recHitCombination = (*recHitCombinations)[icomb];
 
         TrajectorySeedHitCandidate previousTrackerHit;
         TrajectorySeedHitCandidate currentTrackerHit;
         unsigned int layersCrossed=0;
     
 
         std::vector<TrajectorySeedHitCandidate> trackerRecHits;
         for (const auto & _hit : recHitCombination )
         {
             // skip masked hits
             if(hitMaskHelper && hitMaskHelper->mask(_hit.get()))
             continue;
         
             previousTrackerHit=currentTrackerHit;
       
             currentTrackerHit = TrajectorySeedHitCandidate(_hit.get(),trackerGeometry,trackerTopology);
       
             if (!currentTrackerHit.isOnTheSameLayer(previousTrackerHit))
             {
                 ++layersCrossed;
             }
             if (_seedingTree.getSingleSet().find(currentTrackerHit.getTrackingLayer())!=_seedingTree.getSingleSet().end())
             {
                 //add only the hits which are actually on the requested layers
                 trackerRecHits.push_back(std::move(currentTrackerHit));
             }
         }
       
         if ( layersCrossed < minLayersCrossed)
         {
             continue;
         }
 
         // set the combination index
       
         //A SeedingNode is associated by its index to this list. The list stores the indices of the hits in 'trackerRecHits'
         /* example
            SeedingNode                     | hit index                 | hit
            -------------------------------------------------------------------------------
            index=  0:  [BPix1]             | hitIndicesInTree[0] (=1)  | trackerRecHits[1]
            index=  1:   -- [BPix2]         | hitIndicesInTree[1] (=3)  | trackerRecHits[3]
            index=  2:   --  -- [BPix3]     | hitIndicesInTree[2] (=4)  | trackerRecHits[4]
            index=  3:   --  -- [FPix1_pos] | hitIndicesInTree[3] (=6)  | trackerRecHits[6]
            index=  4:   --  -- [FPix1_neg] | hitIndicesInTree[4] (=7)  | trackerRecHits[7]
      
            The implementation has been chosen such that the tree only needs to be build once upon construction.
         */
 
         // find the first combination of hits,
         // compatible with the seedinglayer,
         // and with one of the tracking regions
         std::vector<int> hitIndicesInTree(_seedingTree.numberOfNodes(),-1);
         std::vector<unsigned int> seedHitNumbers = iterateHits(0,trackerRecHits,hitIndicesInTree,true);
 
         // create a seed from those hits
         if (seedHitNumbers.size()>1){
         // temporary hit copies to allow setting the recHitCombinationIndex
         edm::OwnVector<FastTrackerRecHit> seedHits;
         for(unsigned iIndex = 0;iIndex < seedHitNumbers.size();++iIndex){
             seedHits.push_back(trackerRecHits[seedHitNumbers[iIndex]].hit()->clone());
         }
         fastTrackingHelper::setRecHitCombinationIndex(seedHits,icomb);
 
         // the actual seed creation
         seedCreator->makeSeed(*output,SeedingHitSet(&seedHits[0],&seedHits[1],
                                 seedHits.size() >=3 ? &seedHits[2] : nullptr,
                                 seedHits.size() >=4 ? &seedHits[3] : nullptr));
         }
     }
     e.put(std::move(output));
 
 }

bool TrajectorySeedProducer::testWithRegions	(	const TrajectorySeedHitCandidate &	innerHit,
		const TrajectorySeedHitCandidate &	outerHit
	)		const

method inserts hit into the tree structure at an empty position.

Parameters

trackerRecHits	list of all TrackerRecHits.
hitIndicesInTree	hit indices which translates the tree node to the hits in trackerRecHits. Empty positions are identified with '-1'.
node	where to look for an empty position. Important for recursive tree traversing (Breadth-first). Starts with the root.
trackerHit	hit which is tested.

Returns: pointer if this hit is inserted at a leaf which means that a seed has been found. Returns 'nullptr' otherwise.

Member Data Documentation

SeedingTree<TrackingLayer> TrajectorySeedProducer::_seedingTree

private

Definition at line 39 of file TrajectorySeedProducer.h.

Referenced by iterateHits(), produce(), and TrajectorySeedProducer().

const reco::BeamSpot* TrajectorySeedProducer::beamSpot

private

Definition at line 61 of file TrajectorySeedProducer.h.

const edm::EventSetup* TrajectorySeedProducer::es_

Definition at line 199 of file TrajectorySeedProducer.h.

Referenced by pass2HitsCuts(), and produce().

bool TrajectorySeedProducer::hitMasks_exists

private

Definition at line 59 of file TrajectorySeedProducer.h.

Referenced by produce(), and TrajectorySeedProducer().

edm::EDGetTokenT<std::vector<bool> > TrajectorySeedProducer::hitMasksToken

private

Definition at line 66 of file TrajectorySeedProducer.h.

Referenced by produce(), and TrajectorySeedProducer().

const MagneticField* TrajectorySeedProducer::magneticField

private

Definition at line 41 of file TrajectorySeedProducer.h.

Referenced by produce().

const MagneticFieldMap* TrajectorySeedProducer::magneticFieldMap

private

Definition at line 42 of file TrajectorySeedProducer.h.

Referenced by produce().

const MeasurementTrackerEvent* TrajectorySeedProducer::measurementTrackerEvent

Definition at line 198 of file TrajectorySeedProducer.h.

Referenced by pass2HitsCuts(), and produce().

edm::EDGetTokenT<MeasurementTrackerEvent> TrajectorySeedProducer::measurementTrackerEventToken

Definition at line 197 of file TrajectorySeedProducer.h.

Referenced by produce(), and TrajectorySeedProducer().

unsigned int TrajectorySeedProducer::minLayersCrossed

private

Definition at line 51 of file TrajectorySeedProducer.h.

Referenced by produce(), and TrajectorySeedProducer().

double TrajectorySeedProducer::nSigmaZ

private

Definition at line 57 of file TrajectorySeedProducer.h.

double TrajectorySeedProducer::originHalfLength

private

Definition at line 56 of file TrajectorySeedProducer.h.

double TrajectorySeedProducer::originRadius

private

Definition at line 54 of file TrajectorySeedProducer.h.

const reco::VertexCollection* TrajectorySeedProducer::primaryVertices

private

Definition at line 63 of file TrajectorySeedProducer.h.

double TrajectorySeedProducer::ptMin

private

Definition at line 55 of file TrajectorySeedProducer.h.

edm::EDGetTokenT<FastTrackerRecHitCombinationCollection> TrajectorySeedProducer::recHitCombinationsToken

private

Definition at line 65 of file TrajectorySeedProducer.h.

Referenced by produce(), and TrajectorySeedProducer().

Regions TrajectorySeedProducer::regions

Definition at line 193 of file TrajectorySeedProducer.h.

Referenced by pass2HitsCuts(), and produce().

std::unique_ptr<SeedCreator> TrajectorySeedProducer::seedCreator

private

Definition at line 50 of file TrajectorySeedProducer.h.

Referenced by pass2HitsCuts(), produce(), and TrajectorySeedProducer().

std::vector<std::vector<TrackingLayer> > TrajectorySeedProducer::seedingLayers

private

Definition at line 53 of file TrajectorySeedProducer.h.

Referenced by TrajectorySeedProducer().

double TrajectorySeedProducer::simTrack_maxD0

private

Definition at line 48 of file TrajectorySeedProducer.h.

double TrajectorySeedProducer::simTrack_maxZ0

private

Definition at line 49 of file TrajectorySeedProducer.h.

double TrajectorySeedProducer::simTrack_pTMin

private

Definition at line 47 of file TrajectorySeedProducer.h.

bool TrajectorySeedProducer::testBeamspotCompatibility

private

Definition at line 60 of file TrajectorySeedProducer.h.

bool TrajectorySeedProducer::testPrimaryVertexCompatibility

private

Definition at line 62 of file TrajectorySeedProducer.h.

std::shared_ptr<PropagatorWithMaterial> TrajectorySeedProducer::thePropagator

private

Definition at line 45 of file TrajectorySeedProducer.h.

std::unique_ptr<TrackingRegionProducer> TrajectorySeedProducer::theRegionProducer

Definition at line 196 of file TrajectorySeedProducer.h.

Referenced by produce(), and TrajectorySeedProducer().

const TrackerGeometry* TrajectorySeedProducer::trackerGeometry

private

Definition at line 43 of file TrajectorySeedProducer.h.

Referenced by produce().

const TrackerTopology* TrajectorySeedProducer::trackerTopology

private

Definition at line 44 of file TrajectorySeedProducer.h.

Referenced by produce().

Public Types

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation