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

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)

	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

Private Attributes
SeedingTree< TrackingLayer >	_seedingTree

const reco::BeamSpot *	beamSpot

bool	hitMasks_exists

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

const MagneticField *	magneticField

const MagneticFieldMap *	magneticFieldMap

std::string	measurementTrackerLabel

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	skipSeedFinderSelector

bool	testBeamspotCompatibility

bool	testPrimaryVertexCompatibility

std::shared_ptr < PropagatorWithMaterial >	thePropagator

std::unique_ptr < TrackingRegionProducer >	theRegionProducer

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

NOTE: what is called here 'FastTrackPreCandidate' is currently still known as 'FastTrackerRecHitCombination'

TrajectorySeedProducer emulates the reconstruction of TrajectorySeeds in FastSim.

The input data is a list of FastTrackPreCandidates. (input data are configured through the parameter 'src') In each given FastTrackPreCandidate, TrajectorySeedProducer searches for one combination of hits that matches all given seed requirements, (see parameters 'layerList','regionFactoryPSet') In that process it respects the order of the hits in the FastTrackPreCandidate. When such combination is found, a TrajectorySeed is reconstructed. Optionally, one can specify a list of hits to be ignored by TrajectorySeedProducer. (see parameter 'hitMasks')

The output data is the list of reconstructed TrajectorySeeds.

Definition at line 62 of file TrajectorySeedProducer.cc.

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 )

region producer

Definition at line 94 of file TrajectorySeedProducer.cc.

References _seedingTree, edm::EDConsumerBase::consumesCollector(), SurfaceDeformationFactory::create(), TrackingLayer::createFromString(), edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hitMasksToken, SeedingTree< DATA >::insert(), geometryCSVtoXML::line, measurementTrackerLabel, recHitCombinationsToken, seedCreator, skipSeedFinderSelector, AlCaHLTBitMon_QueryRunRegistry::string, and theRegionProducer.

 {
 
     // produces
     produces<TrajectorySeedCollection>();
 
     // consumes
     recHitCombinationsToken = consumes<FastTrackerRecHitCombinationCollection>(conf.getParameter<edm::InputTag>("recHitCombinations"));
     if (conf.exists("hitMasks")){
     hitMasksToken = consumes<std::vector<bool> >(conf.getParameter<edm::InputTag>("hitMasks"));
     }
 
     // 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);
     }
 
     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));
 
     // other parameters
     measurementTrackerLabel = conf.getParameter<std::string>("measurementTracker");
     skipSeedFinderSelector = conf.getUntrackedParameter<bool>("skipSeedFinderSelector",false);
 
 }

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

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

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

inline

Definition at line 152 of file TrajectorySeedProducer.h.

References TrajectorySeedHitCandidate::getTrackingLayer().

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

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

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

Referenced by passHitTuplesCuts().

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

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

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

virtual

Implements edm::stream::EDProducerBase.

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

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

virtual

Implements edm::stream::EDProducerBase.

Definition at line 142 of file TrajectorySeedProducer.cc.

References _seedingTree, clone(), TrackingRecHit::det(), HitPairGeneratorFromLayerPair::doublets(), GeomDet::geographicalId(), edm::EventSetup::get(), edm::Event::getByToken(), BaseTrackerRecHit::hit(), fastTrackingUtilities::hitIsMasked(), hitMasksToken, edm::EDGetTokenT< T >::isUninitialized(), HLT_25ns10e33_v2_cff::measurementTracker, measurementTrackerLabel, eostools::move(), nullptr, TrackingRegion::origin(), convertSQLitetoXML_cfg::output, edm::ESHandle< class >::product(), edm::OwnVector< T, P >::push_back(), edm::Event::put(), recHitCombinationsToken, HLT_25ns10e33_v2_cff::region, regions, mps_fire::result, seedCreator, HLT_25ns10e33_v2_cff::seedFinder, fastTrackingUtilities::setRecHitCombinationIndex(), edm::OwnVector< T, P >::size(), skipSeedFinderSelector, theRegionProducer, and trackerTopology.

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

 {        
 
     // services
     edm::ESHandle<TrackerTopology> trackerTopology;
     edm::ESHandle<MeasurementTracker> measurementTrackerHandle;
     
     es.get<TrackerTopologyRcd>().get(trackerTopology);
     es.get<CkfComponentsRecord>().get(measurementTrackerLabel, measurementTrackerHandle);
     const MeasurementTracker * measurementTracker = &(*measurementTrackerHandle);
     
     // input data
     edm::Handle<FastTrackerRecHitCombinationCollection> recHitCombinations;
     e.getByToken(recHitCombinationsToken, recHitCombinations);
     const std::vector<bool> * hitMasks = 0;
     if (!hitMasksToken.isUninitialized())
     {
     edm::Handle<std::vector<bool> > hitMasksHandle;
     e.getByToken(hitMasksToken,hitMasksHandle);
     hitMasks = &(*hitMasksHandle);
     }
     
     // output data
     std::unique_ptr<TrajectorySeedCollection> output(new TrajectorySeedCollection());
 
     // produce the regions;
     const auto regions = theRegionProducer->regions(e,es);
     // and make sure there is at least one region
     if(regions.size() == 0)
     {
     e.put(std::move(output));
     return;
     }
     
     // pointer to selected region
     TrackingRegion * selectedTrackingRegion = 0;
        
     // define a lambda function
     // to select hit pairs, triplets, ... compatible with the region
     SeedFinder::Selector selectorFunction = [&es,&measurementTracker,&selectedTrackingRegion](const std::vector<const FastTrackerRecHit*>& hits) -> bool
     {
     // criteria for hit pairs
     // based on HitPairGeneratorFromLayerPair::doublets( const TrackingRegion& region, const edm::Event & iEvent, const edm::EventSetup& iSetup, Layers layers)
     if (hits.size()==2)
     {
         const FastTrackerRecHit * innerHit = hits[0];
         const FastTrackerRecHit * outerHit = hits[1];
         
         const DetLayer * innerLayer = measurementTracker->geometricSearchTracker()->detLayer(innerHit->det()->geographicalId());
         const DetLayer * outerLayer = measurementTracker->geometricSearchTracker()->detLayer(outerHit->det()->geographicalId());
         
         std::vector<BaseTrackerRecHit const *> innerHits(1,(const BaseTrackerRecHit*) innerHit->hit());
         std::vector<BaseTrackerRecHit const *> outerHits(1,(const BaseTrackerRecHit*) outerHit->hit());
         
         //const RecHitsSortedInPhi* ihm=new RecHitsSortedInPhi (innerHits, selectedTrackingRegion->origin(), innerLayer);
         //const RecHitsSortedInPhi* ohm=new RecHitsSortedInPhi (outerHits, selectedTrackingRegion->origin(), outerLayer);
         const RecHitsSortedInPhi ihm(innerHits, selectedTrackingRegion->origin(), innerLayer);
         const RecHitsSortedInPhi ohm(outerHits, selectedTrackingRegion->origin(), outerLayer);
         
         HitDoublets result(ihm,ohm); 
         HitPairGeneratorFromLayerPair::doublets(*selectedTrackingRegion,*innerLayer,*outerLayer,ihm,ohm,es,0,result);
         
         if(result.size()!=0)
         {
         return true; 
         }
         else
         {
         return false;
         }
     }
     else
     {
     
         // no criteria for hit combinations that are not pairs
         return true;
     }
     };
 
     if(skipSeedFinderSelector)
     {
     selectedTrackingRegion = regions[0].get();
     selectorFunction = [](const std::vector<const FastTrackerRecHit*>& hits) -> bool
     {
         return true;
     };
     }
 
 
     // instantiate the seed finder
     SeedFinder seedFinder(_seedingTree,*trackerTopology.product());
     seedFinder.setHitSelector(selectorFunction);
     
     // loop over the combinations
     for ( unsigned icomb=0; icomb<recHitCombinations->size(); ++icomb)
     {
     FastTrackerRecHitCombination recHitCombination = (*recHitCombinations)[icomb];
         
     // create a list of hits cleaned from masked hits
     std::vector<const FastTrackerRecHit * > seedHitCandidates;
     for (const auto & _hit : recHitCombination )
     {
         if(hitMasks && fastTrackingUtilities::hitIsMasked(_hit.get(),hitMasks))
         {
         continue;
         }
         seedHitCandidates.push_back(_hit.get());
     }
 
     // loop over the regions
     for(auto region = regions.begin();region != regions.end(); ++region)
     {
         
         // set the region
         selectedTrackingRegion = region->get();
 
         // find the hits on the seeds
         std::vector<unsigned int> seedHitNumbers = seedFinder.getSeed(seedHitCandidates);
 
         // create a seed from those hits
         if (seedHitNumbers.size()>1)
         {
 
         // copy the hits and make them aware of the combination they originate from
         edm::OwnVector<FastTrackerRecHit> seedHits;
         for(unsigned iIndex = 0;iIndex < seedHitNumbers.size();++iIndex)
         {
             seedHits.push_back(seedHitCandidates[seedHitNumbers[iIndex]]->clone());
         }
         fastTrackingUtilities::setRecHitCombinationIndex(seedHits,icomb);
         
         seedCreator->init(*selectedTrackingRegion,es,0);
         seedCreator->makeSeed(
             *output,
             SeedingHitSet(
             &seedHits[0],
             &seedHits[1],
             seedHits.size() >=3 ? &seedHits[2] : nullptr,
             seedHits.size() >=4 ? &seedHits[3] : nullptr
             )
             );
         break; // break the loop over the regions
         }
     }
     }
     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 75 of file TrajectorySeedProducer.cc.

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

bool TrajectorySeedProducer::hitMasks_exists

private

Definition at line 59 of file TrajectorySeedProducer.h.

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

private

Definition at line 70 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

const MagneticField* TrajectorySeedProducer::magneticField

private

Definition at line 41 of file TrajectorySeedProducer.h.

const MagneticFieldMap* TrajectorySeedProducer::magneticFieldMap

private

Definition at line 42 of file TrajectorySeedProducer.h.

const MeasurementTrackerEvent* TrajectorySeedProducer::measurementTrackerEvent

Definition at line 198 of file TrajectorySeedProducer.h.

edm::EDGetTokenT<MeasurementTrackerEvent> TrajectorySeedProducer::measurementTrackerEventToken

Definition at line 197 of file TrajectorySeedProducer.h.

std::string TrajectorySeedProducer::measurementTrackerLabel

private

Definition at line 79 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

unsigned int TrajectorySeedProducer::minLayersCrossed

private

Definition at line 51 of file TrajectorySeedProducer.h.

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 69 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

Regions TrajectorySeedProducer::regions

Definition at line 193 of file TrajectorySeedProducer.h.

Referenced by produce().

std::unique_ptr< SeedCreator > TrajectorySeedProducer::seedCreator

private

Definition at line 77 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

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

private

Definition at line 74 of file TrajectorySeedProducer.cc.

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::skipSeedFinderSelector

private

Definition at line 81 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

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

private

Definition at line 78 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

const TrackerGeometry* TrajectorySeedProducer::trackerGeometry

private

Definition at line 43 of file TrajectorySeedProducer.h.

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