Inheritance diagram for TrackTimingImporter:

Public Member Functions
void	importToBlock (const edm::Event &, ElementList &) const override

	TrackTimingImporter (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)

Public Member Functions inherited from BlockElementImporterBase
	BlockElementImporterBase (const BlockElementImporterBase &)=delete

	BlockElementImporterBase (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)

const std::string &	name () const

BlockElementImporterBase &	operator= (const BlockElementImporterBase &)=delete

virtual void	updateEventSetup (const edm::EventSetup &)

virtual	~BlockElementImporterBase ()=default

Private Attributes
const bool	debug_

edm::EDGetTokenT< edm::ValueMap< float > >	srcTime_

edm::EDGetTokenT< edm::ValueMap< float > >	srcTimeError_

edm::EDGetTokenT< edm::ValueMap< float > >	srcTimeErrorGsf_

edm::EDGetTokenT< edm::ValueMap< float > >	srcTimeGsf_

edm::EDGetTokenT< edm::ValueMap< float > >	srcTimeQuality_

edm::EDGetTokenT< edm::ValueMap< float > >	srcTimeQualityGsf_

const double	timeQualityThreshold_

const bool	useTimeQuality_

Additional Inherited Members
Public Types inherited from BlockElementImporterBase
typedef std::vector< std::unique_ptr< reco::PFBlockElement > >	ElementList

Detailed Description

Definition at line 14 of file TrackTimingImporter.cc.

Constructor & Destructor Documentation

◆ TrackTimingImporter()

TrackTimingImporter::TrackTimingImporter	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	sumes
	)

inline

Definition at line 16 of file TrackTimingImporter.cc.

       : BlockElementImporterBase(conf, sumes),
         useTimeQuality_(conf.existsAs<edm::InputTag>("timeQualityMap")),
         timeQualityThreshold_(useTimeQuality_ ? conf.getParameter<double>("timeQualityThreshold") : -99.),
         srcTime_(sumes.consumes<edm::ValueMap<float>>(conf.getParameter<edm::InputTag>("timeValueMap"))),
         srcTimeError_(sumes.consumes<edm::ValueMap<float>>(conf.getParameter<edm::InputTag>("timeErrorMap"))),
         srcTimeQuality_(useTimeQuality_
                             ? sumes.consumes<edm::ValueMap<float>>(conf.getParameter<edm::InputTag>("timeQualityMap"))
                             : edm::EDGetTokenT<edm::ValueMap<float>>()),
         srcTimeGsf_(sumes.consumes<edm::ValueMap<float>>(conf.getParameter<edm::InputTag>("timeValueMapGsf"))),
         srcTimeErrorGsf_(sumes.consumes<edm::ValueMap<float>>(conf.getParameter<edm::InputTag>("timeErrorMapGsf"))),
         srcTimeQualityGsf_(useTimeQuality_ ? sumes.consumes<edm::ValueMap<float>>(
                                                  conf.getParameter<edm::InputTag>("timeQualityMapGsf"))
                                            : edm::EDGetTokenT<edm::ValueMap<float>>()),
         debug_(conf.getUntrackedParameter<bool>("debug", false)) {}

Member Function Documentation

◆ importToBlock()

void TrackTimingImporter::importToBlock	(	const edm::Event &	e,
		BlockElementImporterBase::ElementList &	elems
	)		const

overridevirtual

Implements BlockElementImporterBase.

Definition at line 44 of file TrackTimingImporter.cc.

                                                                                                            {
   typedef BlockElementImporterBase::ElementList::value_type ElementType;
  
   auto const& time = e.get(srcTime_);
   auto const& timeErr = e.get(srcTimeError_);
   auto const& timeGsf = e.get(srcTimeGsf_);
   auto const& timeErrGsf = e.get(srcTimeErrorGsf_);
  
   edm::Handle<edm::ValueMap<float>> timeQualH, timeQualGsfH;
   if (useTimeQuality_) {
     e.getByToken(srcTimeQuality_, timeQualH);
     e.getByToken(srcTimeQualityGsf_, timeQualGsfH);
   }
  
   for (auto& elem : elems) {
     if (reco::PFBlockElement::TRACK == elem->type()) {
       const auto& ref = elem->trackRef();
       if (time.contains(ref.id())) {
         const bool assocQuality = useTimeQuality_ ? (*timeQualH)[ref] > timeQualityThreshold_ : true;
         if (assocQuality) {
           elem->setTime(time[ref], timeErr[ref]);
         } else {
           elem->setTime(0., -1.);
         }
       }
       if (debug_) {
         edm::LogInfo("TrackTimingImporter")
             << "Track with pT / eta " << ref->pt() << " / " << ref->eta() << " has time: " << elem->time() << " +/- "
             << elem->timeError() << std::endl;
       }
     } else if (reco::PFBlockElement::GSF == elem->type()) {
       const auto& ref = static_cast<const reco::PFBlockElementGsfTrack*>(elem.get())->GsftrackRef();
       if (timeGsf.contains(ref.id())) {
         const bool assocQuality = useTimeQuality_ ? (*timeQualGsfH)[ref] > timeQualityThreshold_ : true;
         if (assocQuality) {
           elem->setTime(timeGsf[ref], timeErrGsf[ref]);
         } else {
           elem->setTime(0., -1.);
         }
       }
       if (debug_) {
         edm::LogInfo("TrackTimingImporter")
             << "Track with pT / eta " << ref->pt() << " / " << ref->eta() << " has time: " << elem->time() << " +/- "
             << elem->timeError() << std::endl;
       }
     }
   }
 }