Inheritance diagram for pat::PATLostTracks:

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

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

	~PATLostTracks ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	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 (const std::string &iProcessName, std::vector< const char * > &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
edm::EDGetTokenT < reco::PFCandidateCollection >	Cands_

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

double	minHits_

double	minPixelHits_

double	minPt_

edm::EDGetTokenT < reco::VertexCollection >	PV_

edm::EDGetTokenT < reco::VertexCollection >	PVOrigs_

edm::EDGetTokenT < reco::TrackCollection >	Tracks_

edm::EDGetTokenT < reco::VertexCollection >	Vertices_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

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

Constructor & Destructor Documentation

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

explicit

Definition at line 49 of file PATLostTracks.cc.

                                                               :
   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"))),
   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"))
 {
   produces< std::vector<reco::Track> > ();
   produces< std::vector<pat::PackedCandidate> > ();
   produces< edm::Association<pat::PackedCandidateCollection> > ();
 
 }

pat::PATLostTracks::~PATLostTracks ( )

Definition at line 66 of file PATLostTracks.cc.

66 {}

Member Function Documentation

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

virtual

Implements edm::EDProducer.

Definition at line 68 of file PATLostTracks.cc.

References reco::LeafCandidate::charge(), reco::TrackBase::charge(), alignCSCRings::e, reco::TrackBase::eta(), edm::helper::Filler< Map >::fill(), edm::Event::getByToken(), reco::TrackBase::hitPattern(), i, edm::HandleBase::id(), edm::Ref< C, T, F >::id(), edm::helper::Filler< Map >::insert(), edm::Ref< C, T, F >::isNonnull(), j, edm::Ref< C, T, F >::key(), reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), p4, reco::TrackBase::phi(), reco::TrackBase::pt(), edm::Event::put(), alignCSCRings::r, reco::PFCandidate::trackRef(), testEve_cfg::tracks, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::trackWeight(), pat::PackedCandidate::UsedInFitTight, reco::TrackBase::vertex(), and HLT_25ns14e33_v1_cff::vertices.

                                                                             {
 
     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::VertexCollection> pvs;
     iEvent.getByToken( PV_, pvs );
     reco::VertexRef PV(pvs.id());
     if (!pvs->empty()) {
         PV = reco::VertexRef(pvs, 0);
     }
     edm::Handle<reco::VertexCollection> PVOrigs;
     iEvent.getByToken( PVOrigs_, PVOrigs );
     const reco::Vertex & PVOrig = (*PVOrigs)[0];
 
     std::auto_ptr< std::vector<reco::Track> > outPtrP( new std::vector<reco::Track> );
     std::vector<int> used(tracks->size(),0);
 
     std::auto_ptr< std::vector<pat::PackedCandidate> > outPtrC( new std::vector<pat::PackedCandidate> );
 
     //Mark all tracks used in candidates    
     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()) {
         if(cand.trackRef().isNonnull() && cand.trackRef().id() ==tracks.id() && (*pf2pc)[r]->numberOfHits() > 0) // also check if packed candidates are storing the tracks for this one
         {
         used[cand.trackRef().key()]=1;
             }
     }
     }
 
     //Mark all tracks used in secondary vertices
     for(unsigned int i=0; i < vertices->size(); i++){
     const reco::Vertex & sv = (*vertices)[i]; 
     for(reco::Vertex::trackRef_iterator it = sv.tracks_begin(),e=sv.tracks_end(); it!=e;it++){
         if(used[it->key()]==0)  used[it->key()]=2; // mark as white list 
     }
     }
 
     std::vector<int> mapping(tracks->size(),-1);
     int j=0;
     for(unsigned int i=0; i < used.size(); i++)
     {
     const reco::Track & tr = (*tracks)[i];
     if(used[i] == 2 || 
       (used[i]==0 && tr.pt() > minPt_ && tr.numberOfValidHits() >= minHits_ && tr.hitPattern().numberOfValidPixelHits() >= minPixelHits_ ) 
           )
         {
             outPtrP->push_back(tr);
             reco::Candidate::PolarLorentzVector p4(tr.pt(),tr.eta(),tr.phi(),0.13957018);
             outPtrC->push_back(pat::PackedCandidate(p4,tr.vertex(),tr.phi(),211*tr.charge(),PV));
             outPtrC->back().setTrackProperties((*tracks)[i]);
                 if(PVOrig.trackWeight(edm::Ref<reco::TrackCollection>(tracks,i)) > 0.5) {
                         outPtrC->back().setAssociationQuality(pat::PackedCandidate::UsedInFitTight);
             }
 
             mapping[i]=j;
             j++;
         }
     } 
     iEvent.put(outPtrP);
     edm::OrphanHandle<pat::PackedCandidateCollection> oh =   iEvent.put(outPtrC);
     std::auto_ptr<edm::Association<pat::PackedCandidateCollection> > tk2pc(new edm::Association<pat::PackedCandidateCollection>(oh   ));
     edm::Association<pat::PackedCandidateCollection>::Filler tk2pcFiller(*tk2pc);
     tk2pcFiller.insert(tracks, mapping.begin(), mapping.end());
     tk2pcFiller.fill() ; 
     iEvent.put(tk2pc);
 
 }