Inheritance diagram for TrackTimeValueMapProducer:

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

	TrackTimeValueMapProducer (const edm::ParameterSet &)

	~TrackTimeValueMapProducer ()

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

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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 &	itemsToGetFromEvent () 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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	calculateTrackTimes (const edm::View< reco::Track > &, const std::vector< reco::RecoToSimCollection > &, std::vector< float > &) const

std::pair< float, float >	extractTrackVertexTime (const std::vector< std::pair< TrackingParticleRef, double > > &) const

Private Attributes
const std::vector< edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator > >	associators_

const edm::EDGetTokenT< edm::View< reco::Track > >	gsfTracks_

const edm::EDGetTokenT< edm::HepMCProduct >	hepMCProduct_

std::vector< std::unique_ptr< const ResolutionModel > >	resolutions_

const edm::EDGetTokenT< TrackingParticleCollection >	trackingParticles_

const edm::EDGetTokenT< TrackingVertexCollection >	trackingVertices_

const edm::EDGetTokenT< edm::View< reco::Track > >	tracks_

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	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::global::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 41 of file TrackTimeValueMapProducer.cc.

Constructor & Destructor Documentation

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

Definition at line 87 of file TrackTimeValueMapProducer.cc.

References Exception, reco::get(), dataset::name, ctppsDiamondLocalTracks_cfi::resolution, resolutions_, AlCaHLTBitMon_QueryRunRegistry::string, and GlobalPosition_Frontier_DevDB_cff::tag.

                                                                                 :
   tracks_(consumes<edm::View<reco::Track> >( conf.getParameter<edm::InputTag>("trackSrc") ) ),
   gsfTracks_(consumes<edm::View<reco::Track> >( conf.getParameter<edm::InputTag>("gsfTrackSrc") ) ),
   trackingParticles_(consumes<TrackingParticleCollection>( conf.getParameter<edm::InputTag>("trackingParticleSrc") ) ),
   trackingVertices_(consumes<TrackingVertexCollection>( conf.getParameter<edm::InputTag>("trackingVertexSrc") ) ),
   associators_( edm::vector_transform( conf.getParameter<std::vector<edm::InputTag> >("associators"), [this](const edm::InputTag& tag){ return this->consumes<reco::TrackToTrackingParticleAssociator>(tag); } ) )
 {
   // setup resolution models
   const std::vector<edm::ParameterSet>& resos = conf.getParameterSetVector("resolutionModels");
   for( const auto& reso : resos ) {
     const std::string& name = reso.getParameter<std::string>("modelName");
     ResolutionModel* resomod = ResolutionModelFactory::get()->create(name,reso);
     resolutions_.emplace_back( resomod );  
 
     // times and time resolutions for general tracks
     produces<edm::ValueMap<float> >(generalTracksName+name);
     produces<edm::ValueMap<float> >(generalTracksName+name+resolution);
     
     //for gsf tracks
     produces<edm::ValueMap<float> >(gsfTracksName+name);
     produces<edm::ValueMap<float> >(gsfTracksName+name+resolution);
   }
   // get RNG engine
   edm::Service<edm::RandomNumberGenerator> rng;
   if (!rng.isAvailable()){
     throw cms::Exception("Configuration")
       << "TrackTimeValueMapProducer::TrackTimeValueMapProducer() - RandomNumberGeneratorService is not present in configuration file.\n"
       << "Add the service in the configuration file or remove the modules that require it.";
   }
 
 }

TrackTimeValueMapProducer::~TrackTimeValueMapProducer ( )

inline

Definition at line 44 of file TrackTimeValueMapProducer.cc.

References produce().

44 { }

Member Function Documentation

void TrackTimeValueMapProducer::calculateTrackTimes	(	const edm::View< reco::Track > &	tkcoll,
		const std::vector< reco::RecoToSimCollection > &	assocs,
		std::vector< float > &	tvals
	)		const

private

Definition at line 200 of file TrackTimeValueMapProducer.cc.

References TrackValidation_cff::association, edm::AssociationMap< edm::OneToManyWithQualityGeneric< edm::View< reco::Track >, TrackingParticleCollection, double > >::const_iterator, constexpr, extractTrackVertexTime(), edm::View< T >::refAt(), and edm::View< T >::size().

Referenced by produce().

                                                                                      { 
   constexpr float flt_max = std::numeric_limits<float>::quiet_NaN();
   
   for( unsigned itk = 0; itk < tkcoll.size(); ++itk ) {
     const auto tkref = tkcoll.refAt(itk);
     reco::RecoToSimCollection::const_iterator track_tps = assocs.back().end();
     for( const auto& association : assocs ) {
       track_tps = association.find(tkref);
       if( track_tps != association.end() ) break;
     }
     if( track_tps != assocs.back().end() ) {
       if( !track_tps->val.size() ) {
         tvals.push_back(flt_max);
       } else {        
         const std::pair<float,float> time_info = extractTrackVertexTime(track_tps->val);
         tvals.push_back(time_info.first);
       }
     } else {
       tvals.push_back(flt_max);
     }
   } 
 }

std::pair< float, float > TrackTimeValueMapProducer::extractTrackVertexTime ( const std::vector< std::pair< TrackingParticleRef, double > > & tp_list ) const

private

Definition at line 226 of file TrackTimeValueMapProducer.cc.

References LogDebug, mps_fire::result, and edm::second().

Referenced by calculateTrackTimes().

                                                                                                 {
   float result = 0.f;
   float result_z = 0.f;
   for( const auto& tpref : tp_list ) {
     const auto& tvertex = tpref.first->parentVertex();
     result = tvertex->position().T()*CLHEP::second; // convert into nano-seconds
     result_z = tvertex->position().Z();
     // account for secondary vertices...
     
     if( tvertex->nSourceTracks() ) {
       auto pvertex = tvertex->sourceTracks()[0]->parentVertex();
       result = pvertex->position().T()*CLHEP::second;
       result_z = pvertex->position().Z();
       while( pvertex->nSourceTracks() ) {
         pvertex = pvertex->sourceTracks()[0]->parentVertex();
         result = pvertex->position().T()*CLHEP::second;
         result_z = pvertex->position().Z();
       }
     }    
   }
   if( tp_list.size() > 1 ) LogDebug("TooManyTracks") << "track matched to " << tp_list.size() << " tracking particles!" << std::endl;
   return std::make_pair(result,result_z);
 }

void TrackTimeValueMapProducer::produce	(	edm::StreamID	sid,
		edm::Event &	evt,
		const edm::EventSetup &	es
	)		const

overridevirtual

Definition at line 119 of file TrackTimeValueMapProducer.cc.

References ctfWithMaterialTrackMCMatch_cfi::associator, simPFProducer_cfi::associators, associators_, calculateTrackTimes(), edm::Event::getByToken(), edm::RandomNumberGenerator::getEngine(), gsfTracks_, mps_fire::i, edm::isFinite(), dataset::name, ctppsDiamondLocalTracks_cfi::resolution, resolutions_, edm::View< T >::size(), AlCaHLTBitMon_QueryRunRegistry::string, create_public_lumi_plots::times, trackingParticles_, and tracks_.

Referenced by ~TrackTimeValueMapProducer().

                                                                                                      {
   // get RNG engine
   edm::Service<edm::RandomNumberGenerator> rng;  
   auto rng_engine = &(rng->getEngine(sid));
 
   // get sim track associators
   std::vector<edm::Handle<reco::TrackToTrackingParticleAssociator> > associators;
   for( const auto& token : associators_ ) {
     associators.emplace_back();
     auto& back = associators.back();
     evt.getByToken(token,back);
   }
 
   std::vector<float> generalTrackTimes, gsfTrackTimes;
  
   //get track collections
   edm::Handle<edm::View<reco::Track> > TrackCollectionH;
   evt.getByToken(tracks_, TrackCollectionH);
   const edm::View<reco::Track>& TrackCollection = *TrackCollectionH;
 
   edm::Handle<edm::View<reco::Track> > GsfTrackCollectionH;
   evt.getByToken(gsfTracks_, GsfTrackCollectionH);
   const edm::View<reco::Track>& GsfTrackCollection = *GsfTrackCollectionH;
 
   //get tracking particle collections
   edm::Handle<TrackingParticleCollection>  TPCollectionH;
   evt.getByToken(trackingParticles_, TPCollectionH);
   //const TrackingParticleCollection&  TPCollection = *TPCollectionH;
   
   // associate the reco tracks / gsf Tracks
   std::vector<reco::RecoToSimCollection> associatedTracks, associatedTracksGsf;  
   for( auto associator : associators ) {
     associatedTracks.emplace_back(associator->associateRecoToSim(TrackCollectionH, TPCollectionH));
     associatedTracksGsf.emplace_back(associator->associateRecoToSim(GsfTrackCollectionH, TPCollectionH));
   }
   
 
   calculateTrackTimes(TrackCollection, associatedTracks, generalTrackTimes);
   calculateTrackTimes(GsfTrackCollection, associatedTracksGsf, gsfTrackTimes);
 
   for( const auto& reso : resolutions_ ) {
     const std::string& name = reso->name();
     std::vector<float> times, resos;
     std::vector<float> gsf_times, gsf_resos;
     
     times.reserve(TrackCollection.size());
     resos.reserve(TrackCollection.size());
     gsf_times.reserve(GsfTrackCollection.size());
     gsf_resos.reserve(GsfTrackCollection.size());
 
     for( unsigned i = 0; i < TrackCollection.size(); ++i ) {
       const reco::Track& tk = TrackCollection[i];
       if( edm::isFinite( generalTrackTimes[i] ) && generalTrackTimes[i] != 0.f) {
         const float resolution = reso->getTimeResolution(tk);
         times.push_back( CLHEP::RandGauss::shoot(rng_engine, generalTrackTimes[i], resolution) );
         resos.push_back( resolution );
       } else {
         times.push_back( generalTrackTimes[i] );
         resos.push_back( fakeBeamSpotTimeWidth );
       }
     }
 
     for( unsigned i = 0; i < GsfTrackCollection.size(); ++i ) {
       const reco::Track& tk = GsfTrackCollection[i];
       if( edm::isFinite( gsfTrackTimes[i] )  && gsfTrackTimes[i] != 0.f ) {
         const float resolution = reso->getTimeResolution(tk);
         gsf_times.push_back( CLHEP::RandGauss::shoot(rng_engine, gsfTrackTimes[i], resolution) );
         gsf_resos.push_back( resolution ); 
       } else {
         gsf_times.push_back( gsfTrackTimes[i] );
         gsf_resos.push_back( fakeBeamSpotTimeWidth );
       }
     }
 
     writeValueMap( evt, TrackCollectionH, times, generalTracksName+name );
     writeValueMap( evt, TrackCollectionH, resos, generalTracksName+name+resolution );
     writeValueMap( evt, GsfTrackCollectionH, gsf_times, gsfTracksName+name );
     writeValueMap( evt, GsfTrackCollectionH, gsf_resos, gsfTracksName+name+resolution );
   }
 }

Member Data Documentation

const std::vector<edm::EDGetTokenT<reco::TrackToTrackingParticleAssociator> > TrackTimeValueMapProducer::associators_

private

Definition at line 56 of file TrackTimeValueMapProducer.cc.

Referenced by produce().

const edm::EDGetTokenT<edm::View<reco::Track> > TrackTimeValueMapProducer::gsfTracks_

private

Definition at line 51 of file TrackTimeValueMapProducer.cc.

Referenced by produce().

const edm::EDGetTokenT<edm::HepMCProduct> TrackTimeValueMapProducer::hepMCProduct_

private

Definition at line 54 of file TrackTimeValueMapProducer.cc.

std::vector<std::unique_ptr<const ResolutionModel> > TrackTimeValueMapProducer::resolutions_

private

Definition at line 58 of file TrackTimeValueMapProducer.cc.

Referenced by produce(), and TrackTimeValueMapProducer().

const edm::EDGetTokenT<TrackingParticleCollection> TrackTimeValueMapProducer::trackingParticles_

private

Definition at line 52 of file TrackTimeValueMapProducer.cc.

Referenced by produce().

const edm::EDGetTokenT<TrackingVertexCollection> TrackTimeValueMapProducer::trackingVertices_

private

Definition at line 53 of file TrackTimeValueMapProducer.cc.

const edm::EDGetTokenT<edm::View<reco::Track> > TrackTimeValueMapProducer::tracks_

private

Definition at line 50 of file TrackTimeValueMapProducer.cc.

Referenced by produce().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation