#include <TrackCandidateProducer.h>

Inheritance diagram for TrackCandidateProducer:

Public Member Functions
virtual void	produce (edm::Event &e, const edm::EventSetup &es) override

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

	TrackCandidateProducer (const edm::ParameterSet &conf)

	TrackCandidateProducer (const edm::ParameterSet &conf)

virtual	~TrackCandidateProducer ()

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

Private Attributes
bool	hitMasks_exists

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

FastTrackerRecHitSplitter	hitSplitter

unsigned int	maxNumberOfCrossedLayers

double	maxSeedMatchEstimator

unsigned int	minNumberOfCrossedLayers

std::string	propagatorLabel

edm::EDGetTokenT < FastTrackerRecHitCombinationCollection >	recHitCombinationsToken

bool	rejectOverlaps

edm::EDGetTokenT< edm::View < TrajectorySeed > >	seedToken

edm::EDGetTokenT < edm::SimTrackContainer >	simTrackToken

edm::EDGetTokenT < edm::SimVertexContainer >	simVertexToken

bool	splitHits

Additional Inherited Members
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

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 42 of file TrackCandidateProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 66 of file TrackCandidateProducer.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hitMasksToken, maxSeedMatchEstimator, propagatorLabel, recHitCombinationsToken, rejectOverlaps, seedToken, simTrackToken, splitHits, and AlCaHLTBitMon_QueryRunRegistry::string.

     : hitSplitter()
 {  
     // produces
     produces<TrackCandidateCollection>();
     
     // consumes
     if (conf.exists("hitMasks")){
     hitMasksToken = consumes<std::vector<bool> >(conf.getParameter<edm::InputTag>("hitMasks"));
     }
     seedToken = consumes<edm::View<TrajectorySeed> >(conf.getParameter<edm::InputTag>("src"));
     recHitCombinationsToken = consumes<FastTrackerRecHitCombinationCollection>(conf.getParameter<edm::InputTag>("recHitCombinations"));
     simTrackToken = consumes<edm::SimTrackContainer>(conf.getParameter<edm::InputTag>("simTracks"));
     
     // other parameters
     maxSeedMatchEstimator = conf.getUntrackedParameter<double>("maxSeedMatchEstimator",0);
     rejectOverlaps = conf.getParameter<bool>("OverlapCleaning");
     splitHits = conf.getParameter<bool>("SplitHits");
     propagatorLabel = conf.getParameter<std::string>("propagator");
 }

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

explicit

virtual TrackCandidateProducer::~TrackCandidateProducer ( )

inlinevirtual

Definition at line 24 of file TrackCandidateProducer.h.

24 {;}

Member Function Documentation

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

overridevirtual

Implements edm::stream::EDProducerBase.

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

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 88 of file TrackCandidateProducer.cc.

References alongMomentum, clone(), TrackingLayer::createFromDetId(), PTrajectoryStateOnDet::detId(), TrajectorySeed::direction(), Exception, edm::OwnVector< T, P >::front(), TrackingRecHit::geographicalId(), edm::EventSetup::get(), edm::Event::getByToken(), fastTrackingUtilities::getRecHitCombinationIndex(), fastTrackingUtilities::hitIsMasked(), fastTrackingUtilities::hitLocalError(), hitMasksToken, hitSplitter, cmsHarvester::index, edm::EDGetTokenT< T >::isUninitialized(), TrajectoryStateOnSurface::isValid(), HLT_25ns10e33_v2_cff::magneticField, SeedMatcher::matchRecHitCombinations(), maxSeedMatchEstimator, eostools::move(), TrajectorySeed::nHits(), convertSQLitetoXML_cfg::output, trajectoryStateTransform::persistentState(), edm::ESHandle< class >::product(), HLT_25ns10e33_v2_cff::propagator, propagatorLabel, edm::OwnVector< T, P >::push_back(), edm::Event::put(), DetId::rawId(), recHitCombinationsToken, TrajectorySeed::recHits(), rejectOverlaps, FastTrackerRecHit::sameId(), fileCollector::seed, seedToken, fastTrackingUtilities::setRecHitCombinationIndex(), simTrackToken, FastTrackerRecHitSplitter::split(), splitHits, TrajectorySeed::startingState(), TrajectoryStateOnSurface::surface(), and trajectoryStateTransform::transientState().

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

                                                                     {        
 
     // get records
     edm::ESHandle<MagneticField>          magneticField;
     es.get<IdealMagneticFieldRecord>().get(magneticField);
 
     edm::ESHandle<TrackerGeometry>        trackerGeometry;
     es.get<TrackerDigiGeometryRecord>().get(trackerGeometry);
 
     edm::ESHandle<TrackerTopology>        trackerTopology;
     es.get<TrackerTopologyRcd>().get(trackerTopology);
 
     edm::ESHandle<Propagator>             propagator;
     es.get<TrackingComponentsRecord>().get(propagatorLabel,propagator);
 
     // get products
     edm::Handle<edm::View<TrajectorySeed> > seeds;
     e.getByToken(seedToken,seeds);
 
     edm::Handle<FastTrackerRecHitCombinationCollection> recHitCombinations;
     e.getByToken(recHitCombinationsToken, recHitCombinations);
 
     edm::Handle<edm::SimTrackContainer> simTracks;
     e.getByToken(simTrackToken,simTracks);
 
     const std::vector<bool> * hitMasks = 0;
     if (!hitMasksToken.isUninitialized()){
     edm::Handle<std::vector<bool> > hitMasksHandle;
     e.getByToken(hitMasksToken,hitMasksHandle);
     hitMasks = &(*hitMasksHandle);
     }
     
     // output collection
     std::unique_ptr<TrackCandidateCollection> output(new TrackCandidateCollection);    
     
     // loop over the seeds
     for (unsigned seedIndex = 0; seedIndex < seeds->size(); ++seedIndex){
 
     const TrajectorySeed seed = (*seeds)[seedIndex];
     std::vector<int32_t> recHitCombinationIndices;
 
     // match hitless seeds to simTracks and find corresponding recHitCombination
     if(seed.nHits()==0){
         recHitCombinationIndices = SeedMatcher::matchRecHitCombinations(
         seed,
         *recHitCombinations,
         *simTracks,
         maxSeedMatchEstimator,
         *propagator,
         *magneticField,
         *trackerGeometry);
     }
     // for normal seeds, retrieve the corresponding recHitCombination from the seed hits
     else
     {
         int32_t icomb = fastTrackingUtilities::getRecHitCombinationIndex(seed);
         recHitCombinationIndices.push_back(icomb);
     }
 
     // loop over the matched recHitCombinations
     for(auto icomb : recHitCombinationIndices)
     {
         if(icomb < 0 || unsigned(icomb) >= recHitCombinations->size())
         {
         throw cms::Exception("TrackCandidateProducer") << " found seed with recHitCombination out or range: " << icomb << std::endl;
         }
         const FastTrackerRecHitCombination & recHitCombination = (*recHitCombinations)[icomb];
         
         // container for select hits
         std::vector<const FastTrackerRecHit *> selectedRecHits;
 
         // add the seed hits
         TrajectorySeed::range seedHitRange = seed.recHits();//Hits in a seed
         for (TrajectorySeed::const_iterator ihit = seedHitRange.first; ihit != seedHitRange.second; ++ihit) 
         {
         selectedRecHits.push_back(static_cast<const FastTrackerRecHit*>(&*ihit));
         }
 
         // prepare to skip seed hits
         const FastTrackerRecHit * lastHitToSkip = 0;
         if(selectedRecHits.size() > 0)
         {
         lastHitToSkip = selectedRecHits.back();
         }
 
         // inOut or outIn tracking ?
         bool hitsAlongMomentum = (seed.direction()== alongMomentum);
 
         // add hits from combination to hit selection
         for (unsigned hitIndex = hitsAlongMomentum ? 0 : recHitCombination.size() - 1;
          hitIndex < recHitCombination.size();
          hitsAlongMomentum ? ++hitIndex : --hitIndex) 
         {
         
         const FastTrackerRecHit * selectedRecHit = recHitCombination[hitIndex].get();
         
         // skip seed hits
         if(lastHitToSkip)
         {
             if(lastHitToSkip->sameId(selectedRecHit))     
             {
             lastHitToSkip=0;
             }
             continue;
         }
 
         // apply hit masking
         if(hitMasks && fastTrackingUtilities::hitIsMasked(selectedRecHit,hitMasks))
         {
             continue;
         }
 
 
         //  if overlap rejection is not switched on, accept all hits
         //  always accept the first hit
         //  also accept a hit if it is not on the layer of the previous hit
         if( !  rejectOverlaps
             || selectedRecHits.size() == 0 
             || ( TrackingLayer::createFromDetId(selectedRecHits.back()->geographicalId(),*trackerTopology.product())
              != TrackingLayer::createFromDetId(selectedRecHit->geographicalId(),*trackerTopology.product())))
         {
             selectedRecHits.push_back(selectedRecHit);
         }
         //  else:
         //    overlap rejection is switched on
         //    the hit is on the same layer as the previous hit
         //  accept the one with smallest error
         else if ( fastTrackingUtilities::hitLocalError(selectedRecHit) 
               < fastTrackingUtilities::hitLocalError(selectedRecHits.back()) )
         {
             selectedRecHits.back() = selectedRecHit;
         }
         }
         
         // split hits / store copies for the track candidate
         edm::OwnVector<TrackingRecHit> hitsForTrackCandidate;
         for ( unsigned index = 0; index<selectedRecHits.size(); ++index ) 
         {
         if(splitHits)
         {
             // add split hits to splitSelectedRecHits
             hitSplitter.split(*selectedRecHits[index],hitsForTrackCandidate,hitsAlongMomentum);
         }
         else 
         {
             hitsForTrackCandidate.push_back(selectedRecHits[index]->clone());
         }
         }
     
         // set the recHitCombinationIndex
         fastTrackingUtilities::setRecHitCombinationIndex(hitsForTrackCandidate,icomb);
         
         // create track candidate state
         //   1. get seed state (defined on the surface of the most outer hit)
         DetId seedDetId(seed.startingState().detId());
         const GeomDet* gdet = trackerGeometry->idToDet(seedDetId);
         TrajectoryStateOnSurface seedTSOS = trajectoryStateTransform::transientState(seed.startingState(), &(gdet->surface()),magneticField.product());
         //   2. backPropagate the seedState to the surfuce of the most inner hit
         const GeomDet* initialLayer = trackerGeometry->idToDet(hitsForTrackCandidate.front().geographicalId());
         const TrajectoryStateOnSurface initialTSOS = propagator->propagate(seedTSOS,initialLayer->surface()) ;
         //   3. check validity and transform
         if (!initialTSOS.isValid()) continue; 
         PTrajectoryStateOnDet PTSOD = trajectoryStateTransform::persistentState(initialTSOS,hitsForTrackCandidate.front().geographicalId().rawId()); 
         
         // add track candidate to output collection
         output->push_back(TrackCandidate(hitsForTrackCandidate,seed,PTSOD,edm::RefToBase<TrajectorySeed>(seeds,seedIndex)));
     }
     }
   
     // Save the track candidates
     e.put(std::move(output));
     
 }