#include <TrackCandidateProducer.h>

Inheritance diagram for TrackCandidateProducer:

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

	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 18 of file TrackCandidateProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 44 of file TrackCandidateProducer.cc.

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

     : hitSplitter()
 {  
   // products
   produces<TrackCandidateCollection>();
   
   // general parameters
   minNumberOfCrossedLayers = conf.getParameter<unsigned int>("MinNumberOfCrossedLayers");
   rejectOverlaps = conf.getParameter<bool>("OverlapCleaning");
   splitHits = conf.getParameter<bool>("SplitHits");
 
   // input tags, labels, tokens
   hitMasks_exists = conf.exists("hitMasks");
   if (hitMasks_exists){
       hitMasksToken = consumes<std::vector<bool> >(conf.getParameter<edm::InputTag>("hitMasks"));
   }
 
   edm::InputTag simTrackLabel = conf.getParameter<edm::InputTag>("simTracks");
   simVertexToken = consumes<edm::SimVertexContainer>(simTrackLabel);
   simTrackToken = consumes<edm::SimTrackContainer>(simTrackLabel);
 
   edm::InputTag seedLabel = conf.getParameter<edm::InputTag>("src");
   seedToken = consumes<edm::View<TrajectorySeed> >(seedLabel);
 
   edm::InputTag recHitCombinationsLabel = conf.getParameter<edm::InputTag>("recHitCombinations");
   recHitCombinationsToken = consumes<FastTrackerRecHitCombinationCollection>(recHitCombinationsLabel);
   
   propagatorLabel = conf.getParameter<std::string>("propagator");
 
   maxSeedMatchEstimator = conf.getUntrackedParameter<double>("maxSeedMatchEstimator",0);
 }

virtual TrackCandidateProducer::~TrackCandidateProducer ( )

inlinevirtual

Definition at line 24 of file TrackCandidateProducer.h.

24 {;}

Member Function Documentation

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 77 of file TrackCandidateProducer.cc.

References clone(), PTrajectoryStateOnDet::detId(), TrajectorySeed::direction(), Exception, edm::OwnVector< T, P >::front(), TrackingRecHit::geographicalId(), edm::EventSetup::get(), edm::Event::getByToken(), fastTrackingHelper::getRecHitCombinationIndex(), BaseTrackerRecHit::hit(), TrajectorySeedHitCandidate::hit(), hitMasks_exists, hitMasksToken, hitSplitter, cmsHarvester::index, TrajectoryStateOnSurface::isValid(), TrajectorySeedHitCandidate::layerNumber(), TrajectorySeedHitCandidate::localError(), HLT_FULL_cff::magneticField, SeedMatcher::matchRecHitCombinations(), maxSeedMatchEstimator, TrajectorySeed::nHits(), oppositeToMomentum, convertSQLitetoXML_cfg::output, trajectoryStateTransform::persistentState(), edm::Handle< T >::product(), edm::ESHandle< class >::product(), HLT_FULL_cff::propagator, propagatorLabel, edm::OwnVector< T, P >::push_back(), edm::Event::put(), DetId::rawId(), recHitCombinationsToken, TrajectorySeed::recHits(), rejectOverlaps, FastTrackerRecHit::sameId(), fileCollector::seed, seedToken, fastTrackingHelper::setRecHitCombinationIndex(), simTrackToken, simVertexToken, FastTrackerRecHitSplitter::split(), splitHits, TrajectorySeed::startingState(), TrajectorySeedHitCandidate::subDetId(), TrajectoryStateOnSurface::surface(), and trajectoryStateTransform::transientState().

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

                                                                     {        
 
   // get services
   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);
   //  Propagator* thePropagator = propagator.product()->clone();
 
   // get products
   edm::Handle<edm::View<TrajectorySeed> > seeds;
   e.getByToken(seedToken,seeds);
 
   edm::Handle<FastTrackerRecHitCombinationCollection> recHitCombinations;
   e.getByToken(recHitCombinationsToken, recHitCombinations);
 
   edm::Handle<edm::SimVertexContainer> simVertices;
   e.getByToken(simVertexToken,simVertices);
 
   edm::Handle<edm::SimTrackContainer> simTracks;
   e.getByToken(simTrackToken,simTracks);
 
   // the hits to be skipped
   std::unique_ptr<HitMaskHelper> hitMaskHelper;
   if (hitMasks_exists == true){
       edm::Handle<std::vector<bool> > hitMasks;
       e.getByToken(hitMasksToken,hitMasks);
       hitMaskHelper.reset(new HitMaskHelper(hitMasks.product()));
   }
   
   // output collection
   std::auto_ptr<TrackCandidateCollection> output(new TrackCandidateCollection);    
 
   // loop over the seeds
   for (unsigned seednr = 0; seednr < seeds->size(); ++seednr){
 
     
       const TrajectorySeed seed = (*seeds)[seednr];
       std::vector<int32_t> recHitCombinationIndices;
     if(seed.nHits()==0){
     recHitCombinationIndices = SeedMatcher::matchRecHitCombinations(
         seed,
         *recHitCombinations,
         *simTracks,
         maxSeedMatchEstimator,
         *propagator,
         *magneticField,
         *trackerGeometry);
     }
     else
     {
 
     // Get the combination of hits that produced the seed
     int32_t icomb = fastTrackingHelper::getRecHitCombinationIndex(seed);
     recHitCombinationIndices.push_back(icomb);
     }
     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];
 
     // select hits, temporarily store as TrajectorySeedHitCandidates
     std::vector<TrajectorySeedHitCandidate> recHitCandidates;
     TrajectorySeedHitCandidate recHitCandidate;
     TrajectorySeed::range seedHitRange = seed.recHits();//Hits in a seed
     for (TrajectorySeed::const_iterator ihit = seedHitRange.first; ihit != seedHitRange.second; ++ihit) {
       TrajectorySeedHitCandidate seedHit=TrajectorySeedHitCandidate((const FastTrackerRecHit*)(&*ihit),
                                     trackerGeometry.product(),trackerTopology.product());
       recHitCandidates.push_back(seedHit);
     }
     bool passedLastSeedHit = false;
 
     for (const auto & _hit : recHitCombination) {
       TrajectorySeedHitCandidate currentTrackerHit=TrajectorySeedHitCandidate(_hit.get(),trackerGeometry.product(),trackerTopology.product());
       if(seed.nHits()==0)passedLastSeedHit=true;
 
       if(!passedLastSeedHit)
     {
       const FastTrackerRecHit * lastSeedHit = recHitCandidates.back().hit();
       if(seed.nHits()==0||lastSeedHit->sameId(currentTrackerHit.hit()))     
         {
           passedLastSeedHit=true;
         }
       continue;
     }
     
     // apply hit masking
     if(hitMaskHelper 
        && hitMaskHelper->mask(_hit.get())){
         continue;
     }
 
       recHitCandidate = TrajectorySeedHitCandidate(_hit.get(),trackerGeometry.product(),trackerTopology.product());
       // hit selection
       //         - always select first hit
       if(        recHitCandidates.size() == 0 ) {
       recHitCandidates.push_back(recHitCandidate);
       }
       //         - in case of *no* verlap rejection: select all hits
       else if(   !rejectOverlaps) {
       recHitCandidates.push_back(recHitCandidate);
       }
       //         - in case of overlap rejection: 
       //              - select hit if it is not on same layer as previous hit
       else if(   recHitCandidate.subDetId()    != recHitCandidates.back().subDetId() ||
          recHitCandidate.layerNumber() != recHitCandidates.back().layerNumber() ) {
       recHitCandidates.push_back(recHitCandidate);
       }
       //         - in case of overlap rejection and hit is on same layer as previous hit 
       //              - replace previous hit with current hit if it has better precision
       else if (  recHitCandidate.localError() < recHitCandidates.back().localError() ){
       recHitCandidates.back() = recHitCandidate;
 
       }
     }
 
     // order hits along the seed direction
     bool oiSeed = seed.direction()==oppositeToMomentum;
     if (oiSeed)
     {
     std::reverse(recHitCandidates.begin(),recHitCandidates.end());
     }
 
     // Convert TrajectorySeedHitCandidate to TrackingRecHit and split hits
     edm::OwnVector<TrackingRecHit> trackRecHits;
     for ( unsigned index = 0; index<recHitCandidates.size(); ++index ) {
     if(splitHits){
         hitSplitter.split(*recHitCandidates[index].hit(),trackRecHits,oiSeed);
     }
     else {
         trackRecHits.push_back(recHitCandidates[index].hit()->clone());
     }
     }
 
 
     // set the recHitCombinationIndex
     fastTrackingHelper::setRecHitCombinationIndex(trackRecHits,icomb);
 
     // create track candidate state
     //   - get seed state
     DetId seedDetId(seed.startingState().detId());
     const GeomDet* gdet = trackerGeometry->idToDet(seedDetId);
     TrajectoryStateOnSurface seedTSOS = trajectoryStateTransform::transientState(seed.startingState(), &(gdet->surface()),magneticField.product());
     //   - backPropagate seedState to first recHit
     const GeomDet* initialLayer = trackerGeometry->idToDet(trackRecHits.front().geographicalId());
     const TrajectoryStateOnSurface initialTSOS = propagator->propagate(seedTSOS,initialLayer->surface()) ;
     //   - check validity and transform
     if (!initialTSOS.isValid()) continue; 
     PTrajectoryStateOnDet PTSOD = trajectoryStateTransform::persistentState(initialTSOS,trackRecHits.front().geographicalId().rawId()); 
     // add track candidate to output collection
     output->push_back(TrackCandidate(trackRecHits,seed,PTSOD,edm::RefToBase<TrajectorySeed>(seeds,seednr)));
 
     }
   }
   
   // Save the track candidates
   e.put(output);
 
 }