Inheritance diagram for pat::PATLostTracks:

Public Member Functions
	PATLostTracks (const edm::ParameterSet &)

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

	~PATLostTracks ()

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

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 Types
enum	TrkStatus { TrkStatus::NOTUSED =0, TrkStatus::PFCAND, TrkStatus::PFCANDNOTRKPROPS, TrkStatus::PFELECTRON, TrkStatus::PFPOSITRON, TrkStatus::VTX }

Private Member Functions
void	addPackedCandidate (std::vector< pat::PackedCandidate > &cands, const reco::TrackRef &trk, const reco::VertexRef &pvSlimmed, const reco::VertexRefProd &pvSlimmedColl, const reco::Vertex &pvOrig, const TrkStatus trkStatus) const

bool	passTrkCuts (const reco::Track &tr) const

Private Attributes
const edm::EDGetTokenT< reco::PFCandidateCollection >	cands_

const int	covarianceSchema_

const int	covarianceVersion_

const edm::EDGetTokenT< reco::VertexCompositeCandidateCollection >	kshorts_

const edm::EDGetTokenT< reco::VertexCompositeCandidateCollection >	lambdas_

const edm::EDGetTokenT< edm::Association< pat::PackedCandidateCollection > >	map_

const double	minHits_

const double	minPixelHits_

const double	minPt_

const double	minPtToStoreProps_

const edm::EDGetTokenT< reco::VertexCollection >	pv_

const edm::EDGetTokenT< reco::VertexCollection >	pvOrigs_

std::vector< reco::TrackBase::TrackQuality >	qualsToAutoAccept_

const edm::EDGetTokenT< reco::TrackCollection >	tracks_

const edm::EDGetTokenT< reco::VertexCollection >	vertices_

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 38 of file PATLostTracks.cc.

Member Enumeration Documentation

enum pat::PATLostTracks::TrkStatus

strongprivate

Enumerator
NOTUSED
PFCAND
PFCANDNOTRKPROPS
PFELECTRON
PFPOSITRON
VTX

Definition at line 46 of file PATLostTracks.cc.

                          {
       NOTUSED=0,
       PFCAND,
       PFCANDNOTRKPROPS,
       PFELECTRON,
       PFPOSITRON,
       VTX
     };

Constructor & Destructor Documentation

pat::PATLostTracks::PATLostTracks ( const edm::ParameterSet & iConfig )

explicit

Definition at line 81 of file PATLostTracks.cc.

References Exception, spr::find(), edm::ParameterSet::getParameter(), mps_alisetup::msg, reco::TrackBase::qualityByName(), qualsToAutoAccept_, create_public_lumi_plots::transform, and reco::TrackBase::undefQuality.

                                                               :
   cands_(consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("inputCandidates"))),
   map_(consumes<edm::Association<pat::PackedCandidateCollection> >(iConfig.getParameter<edm::InputTag>("packedPFCandidates"))),
   tracks_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("inputTracks"))),
   vertices_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("secondaryVertices"))),
   kshorts_(consumes<reco::VertexCompositeCandidateCollection>(iConfig.getParameter<edm::InputTag>("kshorts"))),
   lambdas_(consumes<reco::VertexCompositeCandidateCollection>(iConfig.getParameter<edm::InputTag>("lambdas"))),
   pv_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("primaryVertices"))),
   pvOrigs_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("originalVertices"))),
   minPt_(iConfig.getParameter<double>("minPt")),
   minHits_(iConfig.getParameter<uint32_t>("minHits")),
   minPixelHits_(iConfig.getParameter<uint32_t>("minPixelHits")) ,
   minPtToStoreProps_(iConfig.getParameter<double>("minPtToStoreProps")),
   covarianceVersion_(iConfig.getParameter<int >("covarianceVersion")),
   covarianceSchema_(iConfig.getParameter<int >("covarianceSchema"))
 
 { 
   std::vector<std::string> trkQuals(iConfig.getParameter<std::vector<std::string> >("qualsToAutoAccept"));
   std::transform(trkQuals.begin(),trkQuals.end(),std::back_inserter(qualsToAutoAccept_),reco::TrackBase::qualityByName);
   
   if(std::find(qualsToAutoAccept_.begin(),qualsToAutoAccept_.end(),reco::TrackBase::undefQuality)!=qualsToAutoAccept_.end()){
     std::ostringstream msg;
     msg<<" PATLostTracks has a quality requirement which resolves to undefQuality. This usually means a typo and is therefore treated a config error\nquality requirements:\n   ";
     for(const auto& trkQual : trkQuals) msg <<trkQual<<" ";
     throw cms::Exception("Configuration") << msg.str();
   } 
     
   produces< std::vector<reco::Track> > ();
   produces< std::vector<pat::PackedCandidate> > (); produces< std::vector<pat::PackedCandidate> > ("eleTracks");
   produces< edm::Association<pat::PackedCandidateCollection> > ();
 }

pat::PATLostTracks::~PATLostTracks ( )

Definition at line 113 of file PATLostTracks.cc.

113 {}

Member Function Documentation

void pat::PATLostTracks::addPackedCandidate	(	std::vector< pat::PackedCandidate > &	cands,
		const reco::TrackRef &	trk,
		const reco::VertexRef &	pvSlimmed,
		const reco::VertexRefProd &	pvSlimmedColl,
		const reco::Vertex &	pvOrig,
		const TrkStatus	trkStatus
	)		const

private

Definition at line 227 of file PATLostTracks.cc.

References covarianceSchema_, covarianceVersion_, DEFINE_FWK_MODULE, hcalTTPDigis_cfi::id, edm::Ref< C, T, F >::key(), ResonanceBuilder::mass, minPtToStoreProps_, p4, PFELECTRON, PFPOSITRON, reco::Vertex::trackWeight(), pat::PackedCandidate::UsedInFitTight, and VTX.

Referenced by produce().

 {
     const float mass = 0.13957018;
     
     int id=211*trk->charge();
     if(trkStatus==TrkStatus::PFELECTRON) id=11;
     else if(trkStatus==TrkStatus::PFPOSITRON) id=-11; 
     
     reco::Candidate::PolarLorentzVector p4(trk->pt(),trk->eta(),trk->phi(),mass);
     cands.emplace_back(pat::PackedCandidate(p4,trk->vertex(),
                         trk->pt(),trk->eta(),trk->phi(),
                         id,pvSlimmedColl,pvSlimmed.key()));
 
     if(trk->pt()>minPtToStoreProps_ || trkStatus==TrkStatus::VTX) cands.back().setTrackProperties(*trk,covarianceSchema_,covarianceVersion_);
     if(pvOrig.trackWeight(trk) > 0.5) {
          cands.back().setAssociationQuality(pat::PackedCandidate::UsedInFitTight);
     }
 }

bool pat::PATLostTracks::passTrkCuts ( const reco::Track & tr ) const

private

Definition at line 217 of file PATLostTracks.cc.

References reco::TrackBase::hitPattern(), minHits_, minPixelHits_, minPt_, reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), reco::TrackBase::pt(), and qualsToAutoAccept_.

Referenced by produce().

 {
     const bool passTrkHits = tr.pt() > minPt_ && 
                              tr.numberOfValidHits() >= minHits_ && 
                              tr.hitPattern().numberOfValidPixelHits() >= minPixelHits_;
     const bool passTrkQual = passesQuality(tr,qualsToAutoAccept_);
 
     return passTrkHits || passTrkQual;
 }

void pat::PATLostTracks::produce	(	edm::StreamID	,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		const

overridevirtual

Definition at line 115 of file PATLostTracks.cc.

References addPackedCandidate(), cands_, reco::LeafCandidate::charge(), edm::Event::getByToken(), edm::HandleBase::id(), edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::isNonnull(), crabWrapper::key, edm::Ref< C, T, F >::key(), lostTracks_cfi::kshorts, kshorts_, lostTracks_cfi::lambdas, lambdas_, map_, HPSPFTaus_cff::mapping, eostools::move(), NOTUSED, passTrkCuts(), reco::LeafCandidate::pdgId(), PFCAND, PFCANDNOTRKPROPS, PFELECTRON, PFPOSITRON, edm::Event::put(), MetAnalyzer::pv(), pv_, pvOrigs_, alignCSCRings::r, reco::PFCandidate::trackRef(), l1t::tracks, tracks_, ecalDrivenElectronSeedsParameters_cff::vertices, vertices_, and VTX.

                                                                                                {
 
     edm::Handle<reco::PFCandidateCollection> cands;
     iEvent.getByToken( cands_, cands );
     std::vector<reco::Candidate>::const_iterator cand;
 
     edm::Handle<edm::Association<pat::PackedCandidateCollection> > pf2pc;
     iEvent.getByToken(map_,pf2pc);
 
     edm::Handle<reco::TrackCollection> tracks;
     iEvent.getByToken( tracks_, tracks );
     
     edm::Handle<reco::VertexCollection> vertices;
     iEvent.getByToken( vertices_, vertices );
 
     edm::Handle<reco::VertexCompositeCandidateCollection> kshorts;
     iEvent.getByToken( kshorts_, kshorts );
     edm::Handle<reco::VertexCompositeCandidateCollection> lambdas;
     iEvent.getByToken( lambdas_, lambdas );
 
     edm::Handle<reco::VertexCollection> pvs;
     iEvent.getByToken( pv_, pvs );
     reco::VertexRef pv(pvs.id());
     reco::VertexRefProd pvRefProd(pvs);
     if (!pvs->empty()) {
         pv = reco::VertexRef(pvs, 0);
     }
     edm::Handle<reco::VertexCollection> pvOrigs;
     iEvent.getByToken( pvOrigs_, pvOrigs );
     const reco::Vertex & pvOrig = (*pvOrigs)[0];
 
     auto outPtrTrks = std::make_unique<std::vector<reco::Track>>();
     auto outPtrTrksAsCands = std::make_unique<std::vector<pat::PackedCandidate>>();
     auto outPtrEleTrksAsCands = std::make_unique<std::vector<pat::PackedCandidate>>();
   
     std::vector<TrkStatus> trkStatus(tracks->size(),TrkStatus::NOTUSED);
     //Mark all tracks used in candidates    
     //check if packed candidates are storing the tracks by seeing if number of hits >0    
     //currently we dont use that information though
     //electrons will never store their track (they store the GSF track)
     for(unsigned int ic=0, nc = cands->size(); ic < nc; ++ic) {
         edm::Ref<reco::PFCandidateCollection> r(cands,ic);
         const reco::PFCandidate &cand=(*cands)[ic]; 
     if(cand.charge() && cand.trackRef().isNonnull() && cand.trackRef().id() == tracks.id() ) { 
       
       if(cand.pdgId()==11) trkStatus[cand.trackRef().key()]=TrkStatus::PFELECTRON;    
       else if(cand.pdgId()==-11) trkStatus[cand.trackRef().key()]=TrkStatus::PFPOSITRON;
       else if((*pf2pc)[r]->numberOfHits() > 0) trkStatus[cand.trackRef().key()]=TrkStatus::PFCAND; 
       else trkStatus[cand.trackRef().key()]=TrkStatus::PFCANDNOTRKPROPS; 
     }
     }
         
     //Mark all tracks used in secondary vertices
     for(const auto& secVert : *vertices){
         for(auto trkIt = secVert.tracks_begin();trkIt!=secVert.tracks_end();trkIt++){
         if(trkStatus[trkIt->key()]==TrkStatus::NOTUSED)  trkStatus[trkIt->key()]=TrkStatus::VTX;
     }
     }
     for(const auto& v0 : *kshorts){
         for(size_t dIdx=0;dIdx<v0.numberOfDaughters(); dIdx++){
         size_t key= (dynamic_cast<const reco::RecoChargedCandidate*>(v0.daughter(dIdx)))->track().key();
         if(trkStatus[key]==TrkStatus::NOTUSED)  trkStatus[key]=TrkStatus::VTX;
     }
     }
     for(const auto& v0 : *lambdas){
         for(size_t dIdx=0;dIdx<v0.numberOfDaughters(); dIdx++){
         size_t key= (dynamic_cast<const reco::RecoChargedCandidate*>(v0.daughter(dIdx)))->track().key();
         if(trkStatus[key]==TrkStatus::NOTUSED)  trkStatus[key]=TrkStatus::VTX;
     }
     }
     std::vector<int> mapping(tracks->size(),-1);  
     int lostTrkIndx=0;
     for(unsigned int trkIndx=0; trkIndx < tracks->size(); trkIndx++){
         reco::TrackRef trk(tracks,trkIndx);
     if( trkStatus[trkIndx] == TrkStatus::VTX || 
        (trkStatus[trkIndx]==TrkStatus::NOTUSED && passTrkCuts(*trk)) ) { 
     
         outPtrTrks->emplace_back(*trk);
         addPackedCandidate(*outPtrTrksAsCands,trk,pv,pvRefProd,pvOrig,trkStatus[trkIndx]);
     
         //for creating the reco::Track -> pat::PackedCandidate map
         //not done for the lostTrack:eleTracks collection
         mapping[trkIndx]=lostTrkIndx;
         lostTrkIndx++;
     }else if( (trkStatus[trkIndx]==TrkStatus::PFELECTRON || trkStatus[trkIndx]==TrkStatus::PFPOSITRON ) 
           && passTrkCuts(*trk) ) {
         addPackedCandidate(*outPtrEleTrksAsCands,trk,pv,pvRefProd,pvOrig,trkStatus[trkIndx]);
 
     
       }       
     } 
     
     iEvent.put(std::move(outPtrTrks));
     iEvent.put(std::move(outPtrEleTrksAsCands),"eleTracks");
     edm::OrphanHandle<pat::PackedCandidateCollection> oh = iEvent.put(std::move(outPtrTrksAsCands));
     auto tk2pc = std::make_unique<edm::Association<pat::PackedCandidateCollection>>(oh);
     edm::Association<pat::PackedCandidateCollection>::Filler tk2pcFiller(*tk2pc);
     tk2pcFiller.insert(tracks, mapping.begin(), mapping.end());
     tk2pcFiller.fill() ; 
     iEvent.put(std::move(tk2pc));   
 }