Inheritance diagram for pat::PATPackedCandidateProducer:

Public Member Functions
bool	candsOrdering (pat::PackedCandidate i, pat::PackedCandidate j) const

	PATPackedCandidateProducer (const edm::ParameterSet &)

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

template<typename T >
std::vector< size_t >	sort_indexes (const std::vector< T > &v) const

	~PATPackedCandidateProducer ()

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)

	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 Member Functions
float	calcDxy (float dx, float dy, float phi) const

float	calcDz (reco::Candidate::Point p, reco::Candidate::Point v, const reco::Candidate &c) const

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

const double	minPtForTrackProperties_

const edm::EDGetTokenT < std::vector < reco::PFCandidate > >	PuppiCands_

const edm::EDGetTokenT < edm::ValueMap < reco::CandidatePtr > >	PuppiCandsMap_

const edm::EDGetTokenT < std::vector < reco::PFCandidate > >	PuppiCandsNoLep_

const edm::EDGetTokenT < edm::ValueMap< float > >	PuppiWeight_

const edm::EDGetTokenT < edm::ValueMap< float > >	PuppiWeightNoLep_

const edm::EDGetTokenT < edm::Association < reco::VertexCollection > >	PVAsso_

const edm::EDGetTokenT < edm::ValueMap< int > >	PVAssoQuality_

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

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

const edm::EDGetTokenT < edm::View < reco::CompositePtrCandidate > >	SVWhiteList_

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

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 36 of file PATPackedCandidateProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 90 of file PATPackedCandidateProducer.cc.

                                                                                         :
   Cands_(consumes<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("inputCollection"))),
   PVs_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("inputVertices"))),
   PVAsso_(consumes<edm::Association<reco::VertexCollection> >(iConfig.getParameter<edm::InputTag>("vertexAssociator"))),
   PVAssoQuality_(consumes<edm::ValueMap<int> >(iConfig.getParameter<edm::InputTag>("vertexAssociator"))),
   PVOrigs_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("originalVertices"))),
   TKOrigs_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("originalTracks"))),
   PuppiWeight_(consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("PuppiSrc"))),
   PuppiWeightNoLep_(consumes<edm::ValueMap<float> >(iConfig.getParameter<edm::InputTag>("PuppiNoLepSrc"))),
   PuppiCandsMap_(consumes<edm::ValueMap<reco::CandidatePtr> >(iConfig.getParameter<edm::InputTag>("PuppiSrc"))),
   PuppiCands_(consumes<std::vector< reco::PFCandidate > >(iConfig.getParameter<edm::InputTag>("PuppiSrc"))),
   PuppiCandsNoLep_(consumes<std::vector< reco::PFCandidate > >(iConfig.getParameter<edm::InputTag>("PuppiNoLepSrc"))),
   SVWhiteList_(consumes<edm::View< reco::CompositePtrCandidate > >(iConfig.getParameter<edm::InputTag>("secondaryVerticesForWhiteList"))),
   minPtForTrackProperties_(iConfig.getParameter<double>("minPtForTrackProperties"))
 {
   produces< std::vector<pat::PackedCandidate> > ();
   produces< edm::Association<pat::PackedCandidateCollection> > ();
   produces< edm::Association<reco::PFCandidateCollection> > ();
 }

pat::PATPackedCandidateProducer::~PATPackedCandidateProducer ( )

Definition at line 110 of file PATPackedCandidateProducer.cc.

110 {}

Member Function Documentation

float pat::PATPackedCandidateProducer::calcDxy	(	float	dx,
		float	dy,
		float	phi
	)		const

inlineprivate

Definition at line 81 of file PATPackedCandidateProducer.cc.

References funct::cos(), and funct::sin().

                                                                {
                 return - dx * std::sin(phi) + dy * std::cos(phi);
             }

float pat::PATPackedCandidateProducer::calcDz	(	reco::Candidate::Point	p,
		reco::Candidate::Point	v,
		const reco::Candidate &	c
	)		const

inlineprivate

Definition at line 84 of file PATPackedCandidateProducer.cc.

References reco::Candidate::pt(), reco::Candidate::px(), reco::Candidate::py(), and reco::Candidate::pz().

                                                                                                    {
                 return p.Z()-v.Z() - ((p.X()-v.X()) * c.px() + (p.Y()-v.Y())*c.py()) * c.pz()/(c.pt()*c.pt());
             }

bool pat::PATPackedCandidateProducer::candsOrdering	(	pat::PackedCandidate	i,
		pat::PackedCandidate	j
	)		const

inline

Definition at line 44 of file PATPackedCandidateProducer.cc.

References funct::abs(), pat::PackedCandidate::charge(), pat::PackedCandidate::eta(), edm::Ref< C, T, F >::key(), minPtForTrackProperties_, pat::PackedCandidate::pt(), and pat::PackedCandidate::vertexRef().

Referenced by sort_indexes().

                                                                                 {
                 if (std::abs(i.charge()) == std::abs(j.charge())) {
                     if(i.charge()!=0){
                         if(i.pt() > minPtForTrackProperties_ and j.pt() <= minPtForTrackProperties_ ) return true;
                         if(i.pt() <= minPtForTrackProperties_ and j.pt() > minPtForTrackProperties_ ) return false;
                   }
                    if(i.vertexRef() == j.vertexRef()) 
                       return i.eta() > j.eta();
                    else 
                       return i.vertexRef().key() < j.vertexRef().key();
                 }
                 return std::abs(i.charge()) > std::abs(j.charge());
             }

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

overridevirtual

Implements edm::global::EDProducerBase.

Definition at line 114 of file PATPackedCandidateProducer.cc.

References funct::abs(), EnergyCorrector::c, reco::TrackBase::dz(), edm::helper::Filler< Map >::fill(), edm::Event::getByToken(), reco::PFCandidate::gsfTrackRef(), reco::HitPattern::hasValidHitInFirstPixelBarrel(), reco::TrackBase::highPurity, reco::TrackBase::hitPattern(), i, edm::HandleBase::id(), edm::Ptr< T >::id(), edm::Ref< C, T, F >::id(), cuy::ii, edm::helper::Filler< Map >::insert(), edm::Ref< C, T, F >::isNonnull(), edm::HandleBase::isValid(), j, edm::Ptr< T >::key(), edm::Ref< C, T, F >::key(), relval_steps::key, reco::HitPattern::MISSING_INNER_HITS, pat::PackedCandidate::moreLostInnerHits, reco::PFCandidate::muonRef(), pat::PackedCandidate::noLostInnerHits, reco::HitPattern::numberOfLostHits(), pat::PackedCandidate::oneLostInnerHit, reco::LeafCandidate::pdgId(), reco::LeafCandidate::phi(), reco::TrackBase::phi(), reco::LeafCandidate::polarP4(), edm::Handle< T >::product(), reco::LeafCandidate::pt(), edm::Event::put(), HLT_25ns14e33_v1_cff::quality, pat::qualityMap, reco::TrackBase::referencePoint(), edm::View< T >::size(), reco::PFCandidate::trackRef(), pat::PackedCandidate::UsedInFitTight, pat::PackedCandidate::validHitInFirstPixelBarrelLayer, and reco::PFCandidate::vertex().

                                                                                                             {
 
     edm::Handle<reco::PFCandidateCollection> cands;
     iEvent.getByToken( Cands_, cands );
     std::vector<reco::Candidate>::const_iterator cand;
 
     edm::Handle< edm::ValueMap<float> > puppiWeight;
     iEvent.getByToken( PuppiWeight_, puppiWeight );
     edm::Handle<edm::ValueMap<reco::CandidatePtr> > puppiCandsMap;
     iEvent.getByToken( PuppiCandsMap_, puppiCandsMap );
     edm::Handle<std::vector< reco::PFCandidate > > puppiCands;
     iEvent.getByToken( PuppiCands_, puppiCands );
     std::vector<int> mappingPuppi(puppiCands->size());
 
     edm::Handle< edm::ValueMap<float> > puppiWeightNoLep;
     iEvent.getByToken( PuppiWeightNoLep_, puppiWeightNoLep );
     edm::Handle<std::vector< reco::PFCandidate > > puppiCandsNoLep;
     iEvent.getByToken( PuppiCandsNoLep_, puppiCandsNoLep );  
 
     std::vector<reco::CandidatePtr> puppiCandsNoLepPtrs;
     if (puppiCandsNoLep.isValid()){
       for (auto pup : *puppiCandsNoLep){
         puppiCandsNoLepPtrs.push_back(pup.sourceCandidatePtr(0));
       }
     }
     auto const& puppiCandsNoLepV = puppiCandsNoLep.product();
 
     edm::Handle<reco::VertexCollection> PVOrigs;
     iEvent.getByToken( PVOrigs_, PVOrigs );
 
     edm::Handle<edm::Association<reco::VertexCollection> > assoHandle;
     iEvent.getByToken(PVAsso_,assoHandle);
     edm::Handle<edm::ValueMap<int> > assoQualityHandle;
     iEvent.getByToken(PVAssoQuality_,assoQualityHandle);
     const edm::Association<reco::VertexCollection> &  associatedPV=*(assoHandle.product());
     const edm::ValueMap<int>  &  associationQuality=*(assoQualityHandle.product());
            
     edm::Handle<edm::View<reco::CompositePtrCandidate > > svWhiteListHandle;
     iEvent.getByToken(SVWhiteList_,svWhiteListHandle);
     const edm::View<reco::CompositePtrCandidate > &  svWhiteList=*(svWhiteListHandle.product());
     std::set<unsigned int> whiteList;
     for(unsigned int i=0; i<svWhiteList.size();i++)
     {
       for(unsigned int j=0; j< svWhiteList[i].numberOfSourceCandidatePtrs(); j++) {
           const edm::Ptr<reco::Candidate> & c = svWhiteList[i].sourceCandidatePtr(j);
           if(c.id() == cands.id()) whiteList.insert(c.key());
       }
     }
  
 
     edm::Handle<reco::VertexCollection> PVs;
     iEvent.getByToken( PVs_, PVs );
     reco::VertexRef PV(PVs.id());
     reco::VertexRefProd PVRefProd(PVs);
     math::XYZPoint  PVpos;
 
 
     edm::Handle<reco::TrackCollection> TKOrigs;
     iEvent.getByToken( TKOrigs_, TKOrigs );
     std::auto_ptr< std::vector<pat::PackedCandidate> > outPtrP( new std::vector<pat::PackedCandidate> );
     std::vector<int> mapping(cands->size());
     std::vector<int> mappingReverse(cands->size());
     std::vector<int> mappingTk(TKOrigs->size(), -1);
 
     for(unsigned int ic=0, nc = cands->size(); ic < nc; ++ic) {
         const reco::PFCandidate &cand=(*cands)[ic];
         float phiAtVtx = cand.phi();
         const reco::Track *ctrack = 0;
         if ((abs(cand.pdgId()) == 11 || cand.pdgId() == 22) && cand.gsfTrackRef().isNonnull()) {
             ctrack = &*cand.gsfTrackRef();
         } else if (cand.trackRef().isNonnull()) {
             ctrack = &*cand.trackRef();
         }
         if (ctrack) {
           float dist=1e99;
           int pvi=-1;
           for(size_t ii=0;ii<PVs->size();ii++){
             float dz=std::abs(ctrack->dz( ((*PVs)[ii]).position()));
             if(dz<dist) {pvi=ii;dist=dz; }
           }
           PV = reco::VertexRef(PVs, pvi);
           math::XYZPoint vtx = cand.vertex();
           pat::PackedCandidate::LostInnerHits lostHits = pat::PackedCandidate::noLostInnerHits;
           const reco::VertexRef & PVOrig = associatedPV[reco::CandidatePtr(cands,ic)];
           if(PVOrig.isNonnull()) PV = reco::VertexRef(PVs, PVOrig.key()); // WARNING: assume the PV slimmer is keeping same order
           int quality=associationQuality[reco::CandidatePtr(cands,ic)];
 //          if ((size_t)pvi!=PVOrig.key()) std::cout << "not closest in Z" << pvi << " " << PVOrig.key() << " " << cand.pt() << " " << quality << std::endl;
           //          TrajectoryStateOnSurface tsos = extrapolator.extrapolate(trajectoryStateTransform::initialFreeState(*ctrack,&*magneticField), RecoVertex::convertPos(PV->position()));
           //   vtx = tsos.globalPosition();
           //          phiAtVtx = tsos.globalDirection().phi();
           vtx = ctrack->referencePoint();
           phiAtVtx = ctrack->phi();
           int nlost = ctrack->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
           if (nlost == 0) { 
             if (ctrack->hitPattern().hasValidHitInFirstPixelBarrel()) {
               lostHits = pat::PackedCandidate::validHitInFirstPixelBarrelLayer;
             }
           } else {
             lostHits = ( nlost == 1 ? pat::PackedCandidate::oneLostInnerHit : pat::PackedCandidate::moreLostInnerHits);
           }
 
 
           outPtrP->push_back( pat::PackedCandidate(cand.polarP4(), vtx, phiAtVtx, cand.pdgId(), PVRefProd, PV.key()));
           outPtrP->back().setAssociationQuality(pat::PackedCandidate::PVAssociationQuality(qualityMap[quality]));
           if(cand.trackRef().isNonnull() && PVOrig->trackWeight(cand.trackRef()) > 0.5 && quality == 7) {
                   outPtrP->back().setAssociationQuality(pat::PackedCandidate::UsedInFitTight);
           }
           // properties of the best track 
           outPtrP->back().setLostInnerHits( lostHits );
           if(outPtrP->back().pt() > minPtForTrackProperties_ || whiteList.find(ic)!=whiteList.end()) {
             outPtrP->back().setTrackProperties(*ctrack);
             //outPtrP->back().setTrackProperties(*ctrack,tsos.curvilinearError());
           }
 
           // these things are always for the CKF track
           outPtrP->back().setTrackHighPurity( cand.trackRef().isNonnull() && cand.trackRef()->quality(reco::Track::highPurity) );
           if (cand.muonRef().isNonnull()) {
             outPtrP->back().setMuonID(cand.muonRef()->isStandAloneMuon(), cand.muonRef()->isGlobalMuon());
           }
         } else {
 
           if (!PVs->empty()) {
             PV = reco::VertexRef(PVs, 0);
             PVpos = PV->position();
           }
 
           outPtrP->push_back( pat::PackedCandidate(cand.polarP4(), PVpos, cand.phi(), cand.pdgId(), PVRefProd, PV.key()));
           outPtrP->back().setAssociationQuality(pat::PackedCandidate::PVAssociationQuality(pat::PackedCandidate::UsedInFitTight));
         }
     
         if (puppiWeight.isValid()){
            reco::PFCandidateRef pkref( cands, ic );
                  // outPtrP->back().setPuppiWeight( (*puppiWeight)[pkref]);
            
            float puppiWeightVal = (*puppiWeight)[pkref];
            float puppiWeightNoLepVal = 0.0;
 
            // Check the "no lepton" puppi weights. 
            // If present, then it is not a lepton, use stored weight
            // If absent, it is a lepton, so set the weight to 1.0
            if ( puppiWeightNoLep.isValid() ) {
              // Look for the pointer inside the "no lepton" candidate collection.
              auto pkrefPtr = pkref->sourceCandidatePtr(0);
 
              bool foundNoLep = false;
              for ( size_t ipcnl = 0; ipcnl < puppiCandsNoLepPtrs.size(); ipcnl++){
               if (puppiCandsNoLepPtrs[ipcnl] == pkrefPtr){
                 foundNoLep = true;
                   puppiWeightNoLepVal = puppiCandsNoLepV->at(ipcnl).pt()/cand.pt(); // a hack for now, should use the value map
                   break;
                 }
               }
               if ( !foundNoLep || puppiWeightNoLepVal > 1 ) {
                 puppiWeightNoLepVal = 1.0;
               }
             }
           outPtrP->back().setPuppiWeight( puppiWeightVal, puppiWeightNoLepVal );
 
           mappingPuppi[((*puppiCandsMap)[pkref]).key()]=ic;
         }
     
         mapping[ic] = ic; // trivial at the moment!
         if (cand.trackRef().isNonnull() && cand.trackRef().id() == TKOrigs.id()) {
       mappingTk[cand.trackRef().key()] = ic;        
         }
 
     }
 
     std::auto_ptr< std::vector<pat::PackedCandidate> > outPtrPSorted( new std::vector<pat::PackedCandidate> );
     std::vector<size_t> order=sort_indexes(*outPtrP);
     std::vector<size_t> reverseOrder(order.size());
     for(size_t i=0,nc=cands->size();i<nc;i++) {
         outPtrPSorted->push_back((*outPtrP)[order[i]]);
         reverseOrder[order[i]] = i;
         mappingReverse[order[i]]=i;
     }
 
     // Fix track association for sorted candidates
     for(size_t i=0,ntk=mappingTk.size();i<ntk;i++){
         if(mappingTk[i] >= 0)
           mappingTk[i]=reverseOrder[mappingTk[i]];
     }
 
     for(size_t i=0,ntk=mappingPuppi.size();i<ntk;i++){
         mappingPuppi[i]=reverseOrder[mappingPuppi[i]];
     }
 
     edm::OrphanHandle<pat::PackedCandidateCollection> oh = iEvent.put( outPtrPSorted );
 
     // now build the two maps
     std::auto_ptr<edm::Association<pat::PackedCandidateCollection> > pf2pc(new edm::Association<pat::PackedCandidateCollection>(oh   ));
     std::auto_ptr<edm::Association<reco::PFCandidateCollection   > > pc2pf(new edm::Association<reco::PFCandidateCollection   >(cands));
     edm::Association<pat::PackedCandidateCollection>::Filler pf2pcFiller(*pf2pc);
     edm::Association<reco::PFCandidateCollection   >::Filler pc2pfFiller(*pc2pf);
     pf2pcFiller.insert(cands, mappingReverse.begin(), mappingReverse.end());
     pc2pfFiller.insert(oh   , order.begin(), order.end());
     // include also the mapping track -> packed PFCand
     pf2pcFiller.insert(TKOrigs, mappingTk.begin(), mappingTk.end());
     pf2pcFiller.insert(puppiCands, mappingPuppi.begin(), mappingPuppi.end());
 
     pf2pcFiller.fill();
     pc2pfFiller.fill();
     iEvent.put(pf2pc);
     iEvent.put(pc2pf);
 
 }

template<typename T >

std::vector<size_t> pat::PATPackedCandidateProducer::sort_indexes ( const std::vector< T > & v ) const

inline

Definition at line 58 of file PATPackedCandidateProducer.cc.

References candsOrdering(), i, customizeTrackingMonitorSeedNumber::idx, python.multivaluedict::sort(), and findQualityFiles::v.

                                                                          {
               std::vector<size_t> idx(v.size());
               for (size_t i = 0; i != idx.size(); ++i) idx[i] = i;
               std::sort(idx.begin(), idx.end(),[&v,this](size_t i1, size_t i2) { return candsOrdering(v[i1],v[i2]);});
               return idx;
            }

Member Data Documentation

const edm::EDGetTokenT<reco::PFCandidateCollection> pat::PATPackedCandidateProducer::Cands_

private

Definition at line 66 of file PATPackedCandidateProducer.cc.

const double pat::PATPackedCandidateProducer::minPtForTrackProperties_

private

Definition at line 79 of file PATPackedCandidateProducer.cc.

Referenced by candsOrdering().

const edm::EDGetTokenT<std::vector< reco::PFCandidate > > pat::PATPackedCandidateProducer::PuppiCands_

private

Definition at line 75 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT<edm::ValueMap<reco::CandidatePtr> > pat::PATPackedCandidateProducer::PuppiCandsMap_

private

Definition at line 74 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT<std::vector< reco::PFCandidate > > pat::PATPackedCandidateProducer::PuppiCandsNoLep_

private

Definition at line 76 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT< edm::ValueMap<float> > pat::PATPackedCandidateProducer::PuppiWeight_

private

Definition at line 72 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT< edm::ValueMap<float> > pat::PATPackedCandidateProducer::PuppiWeightNoLep_

private

Definition at line 73 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT<edm::Association<reco::VertexCollection> > pat::PATPackedCandidateProducer::PVAsso_

private

Definition at line 68 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT<edm::ValueMap<int> > pat::PATPackedCandidateProducer::PVAssoQuality_

private

Definition at line 69 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT<reco::VertexCollection> pat::PATPackedCandidateProducer::PVOrigs_

private

Definition at line 70 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT<reco::VertexCollection> pat::PATPackedCandidateProducer::PVs_

private

Definition at line 67 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT<edm::View<reco::CompositePtrCandidate> > pat::PATPackedCandidateProducer::SVWhiteList_

private

Definition at line 77 of file PATPackedCandidateProducer.cc.

const edm::EDGetTokenT<reco::TrackCollection> pat::PATPackedCandidateProducer::TKOrigs_

private

Definition at line 71 of file PATPackedCandidateProducer.cc.

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation