Inheritance diagram for TrackTimeValueMapProducer:

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

	TrackTimeValueMapProducer (const edm::ParameterSet &)

	~TrackTimeValueMapProducer () override

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

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

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

virtual	~ProducerBase () noexcept(false)

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	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 &	itemsToGetFrom (BranchType iType) 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
float	extractTrackVertexTime (const TrackingParticle &, const reco::TransientTrack &) const

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

const float	etaMax_

const float	etaMaxForPtThreshold_

const float	etaMin_

const edm::EDGetTokenT< std::vector< PileupSummaryInfo > >	pileupSummaryInfo_

const float	pMin_

const float	ptMin_

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_

const std::string	tracksName_

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

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 46 of file TrackTimeValueMapProducer.cc.

Constructor & Destructor Documentation

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

Definition at line 89 of file TrackTimeValueMapProducer.cc.

References etaMax_, etaMaxForPtThreshold_, etaMin_, Exception, reco::get(), dataset::name, pMin_, ptMin_, fftjetproducer_cfi::resolution, resolutions_, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, and tracksName_.

                                                                                 :
   tracks_(consumes<edm::View<reco::Track> >( conf.getParameter<edm::InputTag>("trackSrc") ) ),
   tracksName_(conf.getParameter<edm::InputTag>("trackSrc").label()),
   trackingParticles_(consumes<TrackingParticleCollection>( conf.getParameter<edm::InputTag>("trackingParticleSrc") ) ),
   trackingVertices_(consumes<TrackingVertexCollection>( conf.getParameter<edm::InputTag>("trackingVertexSrc") ) ),
   pileupSummaryInfo_(consumes<std::vector<PileupSummaryInfo> >( conf.getParameter<edm::InputTag>("pileupSummaryInfo") ) ),
   associators_( edm::vector_transform( conf.getParameter<std::vector<edm::InputTag> >("associators"), [this](const edm::InputTag& tag){ return this->consumes<reco::TrackToTrackingParticleAssociator>(tag); } ) ),
   etaMin_( conf.getParameter<double>("etaMin") ),
   etaMax_( conf.getParameter<double>("etaMax") ),
   ptMin_( conf.getParameter<double>("ptMin") ),
   pMin_( conf.getParameter<double>("pMin") ),
   etaMaxForPtThreshold_( conf.getParameter<double>("etaMaxForPtThreshold") )
 {
   // 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> >(tracksName_+name);
     produces<edm::ValueMap<float> >(tracksName_+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 ( )

inlineoverride

Definition at line 49 of file TrackTimeValueMapProducer.cc.

References produce().

49 { }

Member Function Documentation

float TrackTimeValueMapProducer::extractTrackVertexTime	(	const TrackingParticle &	tp,
		const reco::TransientTrack &	tt
	)		const

private

Definition at line 231 of file TrackTimeValueMapProducer.cc.

References reco::TrackBase::charge(), reco::deltaPhi(), dt, PVValHelper::dz, reco::TransientTrack::field(), MagneticField::inTesla(), TrajectoryStateClosestToPoint::momentum(), AlCaHLTBitMon_ParallelJobs::p, reco::TrackBase::p(), TrackingParticle::parentVertex(), BPhysicsValidation_cfi::pdgid, TrackingParticle::pdgId(), PV3DBase< T, PVType, FrameType >::phi(), reco::TrackBase::phi(), reco::TrackBase::pt(), TCMET_cfi::radius, mps_fire::result, edm::second(), PixelCPETemplateReco_cfi::speed, mathSSE::sqrt(), ntuplemaker::time, reco::TransientTrack::track(), reco::TransientTrack::trajectoryStateClosestToPoint(), reco::TrackBase::vz(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by produce().

                                                                                          {
   int pdgid = tp.pdgId();
   const auto& tvertex = tp.parentVertex();
   math::XYZTLorentzVectorD result = tvertex->position();
   
   // account for secondary vertices...
   if( tvertex->nSourceTracks() && tvertex->sourceTracks()[0]->pdgId()==pdgid ) {
     auto pvertex = tvertex->sourceTracks()[0]->parentVertex();
     result = pvertex->position();
     while( pvertex->nSourceTracks() && pvertex->sourceTracks()[0]->pdgId()==pdgid ) {
       pvertex = pvertex->sourceTracks()[0]->parentVertex();
       result = pvertex->position();
     }
   }
   
   float time = result.T()*CLHEP::second;
   //correct for time of flight from track reference position
   GlobalPoint result_pos(result.x(),result.y(),result.z());
   const auto &tkstate = tt.trajectoryStateClosestToPoint(result_pos);
   float tkphi = tkstate.momentum().phi();
   float tkz = tkstate.position().z();
   float dphi = reco::deltaPhi(tkphi,tt.track().phi());
   float dz = tkz - tt.track().vz();
   
   float radius = 100.*tt.track().pt()/(0.3*tt.field()->inTesla(GlobalPoint(0,0,0)).z());
   float pathlengthrphi = tt.track().charge()*dphi*radius;
   
   float pathlength = std::sqrt(pathlengthrphi*pathlengthrphi + dz*dz);
   float p = tt.track().p();
   
   float speed = std::sqrt(1./(1.+m_pion/p))*CLHEP::c_light/CLHEP::cm;  //speed in cm/ns
   float dt = pathlength/speed;
 
   return time-dt;
 }

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

override

Definition at line 123 of file TrackTimeValueMapProducer.cc.

References funct::abs(), TrackValidation_cff::association, ctfWithMaterialTrackMCMatch_cfi::associator, simPFProducer_cfi::associators, associators_, TransientTrackBuilder::build(), edm::AssociationMap< Tag >::const_iterator, reco::TrackBase::eta(), etaMaxForPtThreshold_, etaMin_, extractTrackVertexTime(), f, edm::EventSetup::get(), edm::Event::getByToken(), edm::RandomNumberGenerator::getEngine(), mps_fire::i, LogDebug, SiStripPI::max, dataset::name, reco::TrackBase::p(), pileupSummaryInfo_, pMin_, reco::TrackBase::pt(), ptMin_, edm::View< T >::refAt(), fftjetproducer_cfi::resolution, resolutions_, edm::View< T >::size(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, ntuplemaker::time, create_public_lumi_plots::times, trackingParticles_, tracks_, tracksName_, and groupFilesInBlocks::tt.

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;
  
   //get track collections
   edm::Handle<edm::View<reco::Track> > TrackCollectionH;
   evt.getByToken(tracks_, TrackCollectionH);
   const edm::View<reco::Track>& TrackCollection = *TrackCollectionH;
 
   //get tracking particle collections
   edm::Handle<TrackingParticleCollection>  TPCollectionH;
   evt.getByToken(trackingParticles_, TPCollectionH);
   
   edm::Handle<std::vector<PileupSummaryInfo> > pileupSummaryH;
   evt.getByToken(pileupSummaryInfo_, pileupSummaryH);
   
   //transient track builder
   edm::ESHandle<TransientTrackBuilder> theB;
   es.get<TransientTrackRecord>().get("TransientTrackBuilder",theB);
   
   // associate the reco tracks / gsf Tracks
   std::vector<reco::RecoToSimCollection> associatedTracks;  
   for( auto associator : associators ) {
     associatedTracks.emplace_back(associator->associateRecoToSim(TrackCollectionH, TPCollectionH));
   }
   
 
   double sumSimTime = 0.;
   double sumSimTimeSq = 0.;
   int nsim = 0;
   for (const PileupSummaryInfo &puinfo : *pileupSummaryH) {
     if (puinfo.getBunchCrossing() == 0) {
       for (const float &time : puinfo.getPU_times()) {
         double simtime = time;
         sumSimTime += simtime;
         sumSimTimeSq += simtime*simtime;
         ++nsim;
       }
       break;
     }
   }
   
   double meanSimTime = sumSimTime/double(nsim);
   double varSimTime = sumSimTimeSq/double(nsim) - meanSimTime*meanSimTime;
   double rmsSimTime = std::sqrt(std::max(0.1*0.1,varSimTime));
 
   for( unsigned itk = 0; itk < TrackCollection.size(); ++itk ) {
     const auto tkref = TrackCollection.refAt(itk);
     reco::RecoToSimCollection::const_iterator track_tps = associatedTracks.back().end();
 
     for( const auto& association : associatedTracks ) {
       track_tps = association.find(tkref);
       if( track_tps != association.end() ) break;
     }
 
     if (track_tps != associatedTracks.back().end() && track_tps->val.size() == 1) {
       reco::TransientTrack tt = theB->build(*tkref);
       float time = extractTrackVertexTime(*track_tps->val[0].first,tt);
       generalTrackTimes.push_back(time);
     }
     else {
       float rndtime = CLHEP::RandGauss::shoot(rng_engine, meanSimTime, rmsSimTime);
       generalTrackTimes.push_back(rndtime);
       if (track_tps != associatedTracks.back().end() && track_tps->val.size() > 1) {
         LogDebug("TooManyTracks") << "track matched to " << track_tps->val.size() << " tracking particles!" << std::endl;
       }
     }
   }
   
   for( const auto& reso : resolutions_ ) {
     const std::string& name = reso->name();
     std::vector<float> times, resos;
     
     times.reserve(TrackCollection.size());
     resos.reserve(TrackCollection.size());
 
     for( unsigned i = 0; i < TrackCollection.size(); ++i ) {
       const reco::Track& tk = TrackCollection[i];
       const float absEta = std::abs(tk.eta());
       bool inAcceptance = absEta < etaMax_ && absEta >= etaMin_ && tk.p()>pMin_ && (absEta>etaMaxForPtThreshold_ || tk.pt()>ptMin_);
       if (inAcceptance) {
         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(0.0f);
         resos.push_back(-1.);
       }
     }
 
     writeValueMap( evt, TrackCollectionH, times, tracksName_+name );
     writeValueMap( evt, TrackCollectionH, resos, tracksName_+name+resolution );
   }
 }