PuppiProducer Class Reference

#include <PuppiProducer.h>

Inheritance diagram for PuppiProducer:

Public Types
typedef edm::View< reco::Candidate >	CandidateView
typedef math::XYZTLorentzVector	LorentzVector
typedef std::vector< LorentzVector >	LorentzVectorCollection
typedef std::vector< pat::PackedCandidate >	PackedOutputCollection
typedef std::vector< reco::PFCandidate >	PFInputCollection
typedef std::vector< reco::PFCandidate >	PFOutputCollection
typedef edm::View< reco::PFCandidate >	PFView
typedef reco::VertexCollection	VertexCollection
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Member Functions
	PuppiProducer (const edm::ParameterSet &)
	~PuppiProducer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
virtual void	beginJob ()
virtual void	endJob ()
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
bool	fClonePackedCands
float	fDZCut
double	fDZCutForChargedFromPUVtxs
double	fEtaMaxCharged
double	fEtaMaxPhotons
double	fEtaMinUseDZ
uint	fNumOfPUVtxsForCharged
std::string	fPFName
double	fPtMaxCharged
double	fPtMaxPhotons
std::unique_ptr< PuppiContainer >	fPuppiContainer
bool	fPuppiDiagnostics
std::string	fPuppiName
bool	fPuppiNoLep
std::string	fPVName
std::vector< RecoObj >	fRecoObjCollection
bool	fUseDZ
bool	fUseExistingWeights
bool	fUseFromPVLooseTight
bool	fUsePUProxyValue
int	fVtxNdofCut
double	fVtxZCut
edm::EDPutTokenT< std::vector< double > >	ptokenAlphas_
edm::EDPutTokenT< std::vector< double > >	ptokenAlphasMed_
edm::EDPutTokenT< std::vector< double > >	ptokenAlphasRms_
edm::EDPutTokenT< double >	ptokenNalgos_
edm::EDPutTokenT< edm::ValueMap< LorentzVector > >	ptokenP4PupOut_
edm::EDPutTokenT< pat::PackedCandidateCollection >	ptokenPackedPuppiCandidates_
edm::EDPutTokenT< edm::ValueMap< float > >	ptokenPupOut_
edm::EDPutTokenT< reco::PFCandidateCollection >	ptokenPuppiCandidates_
edm::EDPutTokenT< std::vector< double > >	ptokenRawAlphas_
edm::EDPutTokenT< edm::ValueMap< reco::CandidatePtr > >	ptokenValues_
edm::EDGetTokenT< double >	puProxyValueToken_
edm::EDGetTokenT< PackedOutputCollection >	tokenPackedPuppiCandidates_
edm::EDGetTokenT< CandidateView >	tokenPFCandidates_
edm::EDGetTokenT< PFOutputCollection >	tokenPuppiCandidates_
edm::EDGetTokenT< PuppiContainer >	tokenPuppiContainer_
edm::EDGetTokenT< VertexCollection >	tokenVertices_

Detailed Description

Definition at line 23 of file PuppiProducer.h.

Member Typedef Documentation

CandidateView

typedef edm::View<reco::Candidate> PuppiProducer::CandidateView

Definition at line 32 of file PuppiProducer.h.

LorentzVector

typedef math::XYZTLorentzVector PuppiProducer::LorentzVector

Definition at line 29 of file PuppiProducer.h.

LorentzVectorCollection

typedef std::vector<LorentzVector> PuppiProducer::LorentzVectorCollection

Definition at line 30 of file PuppiProducer.h.

PackedOutputCollection

typedef std::vector<pat::PackedCandidate> PuppiProducer::PackedOutputCollection

Definition at line 35 of file PuppiProducer.h.

PFInputCollection

typedef std::vector<reco::PFCandidate> PuppiProducer::PFInputCollection

Definition at line 33 of file PuppiProducer.h.

PFOutputCollection

typedef std::vector<reco::PFCandidate> PuppiProducer::PFOutputCollection

Definition at line 34 of file PuppiProducer.h.

PFView

typedef edm::View<reco::PFCandidate> PuppiProducer::PFView

Definition at line 36 of file PuppiProducer.h.

VertexCollection

typedef reco::VertexCollection PuppiProducer::VertexCollection

Definition at line 31 of file PuppiProducer.h.

Constructor & Destructor Documentation

PuppiProducer()

PuppiProducer::PuppiProducer ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 23 of file PuppiProducer.cc.

                                                           {
  fPuppiDiagnostics = iConfig.getParameter<bool>("puppiDiagnostics");
  fPuppiNoLep = iConfig.getParameter<bool>("puppiNoLep");
  fUseFromPVLooseTight = iConfig.getParameter<bool>("UseFromPVLooseTight");
  fUseDZ = iConfig.getParameter<bool>("UseDeltaZCut");
  fDZCut = iConfig.getParameter<double>("DeltaZCut");
  fEtaMinUseDZ = iConfig.getParameter<double>("EtaMinUseDeltaZ");
  fPtMaxCharged = iConfig.getParameter<double>("PtMaxCharged");
  fEtaMaxCharged = iConfig.getParameter<double>("EtaMaxCharged");
  fPtMaxPhotons = iConfig.getParameter<double>("PtMaxPhotons");
  fEtaMaxPhotons = iConfig.getParameter<double>("EtaMaxPhotons");
  fNumOfPUVtxsForCharged = iConfig.getParameter<uint>("NumOfPUVtxsForCharged");
  fDZCutForChargedFromPUVtxs = iConfig.getParameter<double>("DeltaZCutForChargedFromPUVtxs");
  fUseExistingWeights = iConfig.getParameter<bool>("useExistingWeights");
  fClonePackedCands = iConfig.getParameter<bool>("clonePackedCands");
  fVtxNdofCut = iConfig.getParameter<int>("vtxNdofCut");
  fVtxZCut = iConfig.getParameter<double>("vtxZCut");
  fPuppiContainer = std::unique_ptr<PuppiContainer>(new PuppiContainer(iConfig));
 
  tokenPFCandidates_ = consumes<CandidateView>(iConfig.getParameter<edm::InputTag>("candName"));
  tokenVertices_ = consumes<VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexName"));
 
  fUsePUProxyValue = iConfig.getParameter<bool>("usePUProxyValue");
 
  if (fUsePUProxyValue) {
    puProxyValueToken_ = consumes<double>(iConfig.getParameter<edm::InputTag>("PUProxyValue"));
  }
 
  ptokenPupOut_ = produces<edm::ValueMap<float>>();
  ptokenP4PupOut_ = produces<edm::ValueMap<LorentzVector>>();
  ptokenValues_ = produces<edm::ValueMap<reco::CandidatePtr>>();
 
  if (fUseExistingWeights || fClonePackedCands)
    ptokenPackedPuppiCandidates_ = produces<pat::PackedCandidateCollection>();
  else {
    ptokenPuppiCandidates_ = produces<reco::PFCandidateCollection>();
  }
 
  if (fPuppiDiagnostics) {
    ptokenNalgos_ = produces<double>("PuppiNAlgos");
    ptokenRawAlphas_ = produces<std::vector<double>>("PuppiRawAlphas");
    ptokenAlphas_ = produces<std::vector<double>>("PuppiAlphas");
    ptokenAlphasMed_ = produces<std::vector<double>>("PuppiAlphasMed");
    ptokenAlphasRms_ = produces<std::vector<double>>("PuppiAlphasRms");
  }
}

References fClonePackedCands, fDZCut, fDZCutForChargedFromPUVtxs, fEtaMaxCharged, fEtaMaxPhotons, fEtaMinUseDZ, fNumOfPUVtxsForCharged, fPtMaxCharged, fPtMaxPhotons, fPuppiContainer, fPuppiDiagnostics, fPuppiNoLep, fUseDZ, fUseExistingWeights, fUseFromPVLooseTight, fUsePUProxyValue, fVtxNdofCut, fVtxZCut, edm::ParameterSet::getParameter(), ptokenAlphas_, ptokenAlphasMed_, ptokenAlphasRms_, ptokenNalgos_, ptokenP4PupOut_, ptokenPackedPuppiCandidates_, ptokenPupOut_, ptokenPuppiCandidates_, ptokenRawAlphas_, ptokenValues_, puProxyValueToken_, tokenPFCandidates_, tokenVertices_, and parallelization::uint.

~PuppiProducer()

PuppiProducer::~PuppiProducer ( )

override

Definition at line 70 of file PuppiProducer.cc.

{}

Member Function Documentation

beginJob()

void PuppiProducer::beginJob ( void  )

privatevirtual

Definition at line 378 of file PuppiProducer.cc.

{}

endJob()

void PuppiProducer::endJob ( void  )

privatevirtual

Definition at line 380 of file PuppiProducer.cc.

{}

Referenced by o2olib.O2ORunMgr::executeJob().

fillDescriptions()

void PuppiProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 382 of file PuppiProducer.cc.

                                                                               {
  edm::ParameterSetDescription desc;
  desc.add<bool>("puppiDiagnostics", false);
  desc.add<bool>("puppiNoLep", false);
  desc.add<bool>("UseFromPVLooseTight", false);
  desc.add<bool>("UseDeltaZCut", true);
  desc.add<double>("DeltaZCut", 0.3);
  desc.add<double>("EtaMinUseDeltaZ", 0.);
  desc.add<double>("PtMaxCharged", -1.);
  desc.add<double>("EtaMaxCharged", 99999.);
  desc.add<double>("PtMaxPhotons", -1.);
  desc.add<double>("EtaMaxPhotons", 2.5);
  desc.add<double>("PtMaxNeutrals", 200.);
  desc.add<double>("PtMaxNeutralsStartSlope", 0.);
  desc.add<uint>("NumOfPUVtxsForCharged", 0);
  desc.add<double>("DeltaZCutForChargedFromPUVtxs", 0.2);
  desc.add<bool>("useExistingWeights", false);
  desc.add<bool>("clonePackedCands", false);
  desc.add<int>("vtxNdofCut", 4);
  desc.add<double>("vtxZCut", 24);
  desc.add<edm::InputTag>("candName", edm::InputTag("particleFlow"));
  desc.add<edm::InputTag>("vertexName", edm::InputTag("offlinePrimaryVertices"));
  desc.add<bool>("applyCHS", true);
  desc.add<bool>("invertPuppi", false);
  desc.add<bool>("useExp", false);
  desc.add<double>("MinPuppiWeight", .01);
  desc.add<bool>("usePUProxyValue", false);
  desc.add<edm::InputTag>("PUProxyValue", edm::InputTag(""));
 
  PuppiAlgo::fillDescriptionsPuppiAlgo(desc);
 
  descriptions.add("PuppiProducer", desc);
}

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), PuppiAlgo::fillDescriptionsPuppiAlgo(), HLT_2018_cff::InputTag, and parallelization::uint.

produce()

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

overrideprivate

Definition at line 72 of file PuppiProducer.cc.

                                                                         {
  // Get PFCandidate Collection
  edm::Handle<CandidateView> hPFProduct;
  iEvent.getByToken(tokenPFCandidates_, hPFProduct);
  const CandidateView* pfCol = hPFProduct.product();
 
  // Get vertex collection w/PV as the first entry?
  edm::Handle<reco::VertexCollection> hVertexProduct;
  iEvent.getByToken(tokenVertices_, hVertexProduct);
  const reco::VertexCollection* pvCol = hVertexProduct.product();
 
  double puProxyValue = 0.;
  if (fUsePUProxyValue) {
    puProxyValue = iEvent.get(puProxyValueToken_);
  } else {
    for (auto const& vtx : *pvCol) {
      if (!vtx.isFake() && vtx.ndof() >= fVtxNdofCut && std::abs(vtx.z()) <= fVtxZCut)
        ++puProxyValue;
    }
  }
 
  std::vector<double> lWeights;
  if (!fUseExistingWeights) {
    //Fill the reco objects
    fRecoObjCollection.clear();
    fRecoObjCollection.reserve(pfCol->size());
    for (auto const& aPF : *pfCol) {
      RecoObj pReco;
      pReco.pt = aPF.pt();
      pReco.eta = aPF.eta();
      pReco.phi = aPF.phi();
      pReco.m = aPF.mass();
      pReco.rapidity = aPF.rapidity();
      pReco.charge = aPF.charge();
      pReco.pdgId = aPF.pdgId();
      const reco::Vertex* closestVtx = nullptr;
      double pDZ = -9999;
      double pD0 = -9999;
      uint pVtxId = 0;
      bool isLepton = ((std::abs(pReco.pdgId) == 11) || (std::abs(pReco.pdgId) == 13));
      const pat::PackedCandidate* lPack = dynamic_cast<const pat::PackedCandidate*>(&aPF);
      if (lPack == nullptr) {
        const reco::PFCandidate* pPF = dynamic_cast<const reco::PFCandidate*>(&aPF);
        double curdz = 9999;
        int closestVtxForUnassociateds = -9999;
        const reco::TrackRef aTrackRef = pPF->trackRef();
        bool lFirst = true;
        for (auto const& aV : *pvCol) {
          if (lFirst) {
            if (aTrackRef.isNonnull()) {
              pDZ = aTrackRef->dz(aV.position());
              pD0 = aTrackRef->d0();
            } else if (pPF->gsfTrackRef().isNonnull()) {
              pDZ = pPF->gsfTrackRef()->dz(aV.position());
              pD0 = pPF->gsfTrackRef()->d0();
            }
            lFirst = false;
            if (pDZ > -9999)
              pVtxId = 0;
          }
          if (aTrackRef.isNonnull() && aV.trackWeight(pPF->trackRef()) > 0) {
            closestVtx = &aV;
            break;
          }
          // in case it's unassocciated, keep more info
          double tmpdz = 99999;
          if (aTrackRef.isNonnull())
            tmpdz = aTrackRef->dz(aV.position());
          else if (pPF->gsfTrackRef().isNonnull())
            tmpdz = pPF->gsfTrackRef()->dz(aV.position());
          if (std::abs(tmpdz) < curdz) {
            curdz = std::abs(tmpdz);
            closestVtxForUnassociateds = pVtxId;
          }
          pVtxId++;
        }
        int tmpFromPV = 0;
        // mocking the miniAOD definitions
        if (std::abs(pReco.charge) > 0) {
          if (closestVtx != nullptr && pVtxId > 0)
            tmpFromPV = 0;
          if (closestVtx != nullptr && pVtxId == 0)
            tmpFromPV = 3;
          if (closestVtx == nullptr && closestVtxForUnassociateds == 0)
            tmpFromPV = 2;
          if (closestVtx == nullptr && closestVtxForUnassociateds != 0)
            tmpFromPV = 1;
        }
        pReco.dZ = pDZ;
        pReco.d0 = pD0;
        pReco.id = 0;
        if (std::abs(pReco.charge) == 0) {
          pReco.id = 0;
        } else {
          if (fPuppiNoLep && isLepton)
            pReco.id = 3;
          else if (tmpFromPV == 0) {
            pReco.id = 2;
            if (fNumOfPUVtxsForCharged > 0 and (pVtxId <= fNumOfPUVtxsForCharged) and
                (std::abs(pDZ) < fDZCutForChargedFromPUVtxs))
              pReco.id = 1;
          } else if (tmpFromPV == 3)
            pReco.id = 1;
          else if (tmpFromPV == 1 || tmpFromPV == 2) {
            pReco.id = 0;
            if ((fPtMaxCharged > 0) and (pReco.pt > fPtMaxCharged))
              pReco.id = 1;
            else if (std::abs(pReco.eta) > fEtaMaxCharged)
              pReco.id = 1;
            else if ((fUseDZ) && (std::abs(pReco.eta) >= fEtaMinUseDZ))
              pReco.id = (std::abs(pDZ) < fDZCut) ? 1 : 2;
            else if (fUseFromPVLooseTight && tmpFromPV == 1)
              pReco.id = 2;
            else if (fUseFromPVLooseTight && tmpFromPV == 2)
              pReco.id = 1;
          }
        }
      } else if (lPack->vertexRef().isNonnull()) {
        pDZ = lPack->dz();
        pD0 = lPack->dxy();
        pReco.dZ = pDZ;
        pReco.d0 = pD0;
 
        pReco.id = 0;
        if (std::abs(pReco.charge) == 0) {
          pReco.id = 0;
        }
        if (std::abs(pReco.charge) > 0) {
          if (fPuppiNoLep && isLepton) {
            pReco.id = 3;
          } else if (lPack->fromPV() == 0) {
            pReco.id = 2;
            if ((fNumOfPUVtxsForCharged > 0) and (std::abs(pDZ) < fDZCutForChargedFromPUVtxs)) {
              for (size_t puVtx_idx = 1; puVtx_idx <= fNumOfPUVtxsForCharged && puVtx_idx < pvCol->size();
                   ++puVtx_idx) {
                if (lPack->fromPV(puVtx_idx) >= 2) {
                  pReco.id = 1;
                  break;
                }
              }
            }
          } else if (lPack->fromPV() == (pat::PackedCandidate::PVUsedInFit)) {
            pReco.id = 1;
          } else if (lPack->fromPV() == (pat::PackedCandidate::PVTight) ||
                     lPack->fromPV() == (pat::PackedCandidate::PVLoose)) {
            pReco.id = 0;
            if ((fPtMaxCharged > 0) and (pReco.pt > fPtMaxCharged))
              pReco.id = 1;
            else if (std::abs(pReco.eta) > fEtaMaxCharged)
              pReco.id = 1;
            else if ((fUseDZ) && (std::abs(pReco.eta) >= fEtaMinUseDZ))
              pReco.id = (std::abs(pDZ) < fDZCut) ? 1 : 2;
            else if (fUseFromPVLooseTight && lPack->fromPV() == (pat::PackedCandidate::PVLoose))
              pReco.id = 2;
            else if (fUseFromPVLooseTight && lPack->fromPV() == (pat::PackedCandidate::PVTight))
              pReco.id = 1;
          }
        }
      }
 
      fRecoObjCollection.push_back(pReco);
    }
 
    fPuppiContainer->initialize(fRecoObjCollection);
    fPuppiContainer->setPUProxy(puProxyValue);
 
    //Compute the weights and get the particles
    lWeights = fPuppiContainer->puppiWeights();
  } else {
    //Use the existing weights
    int lPackCtr = 0;
    for (auto const& aPF : *pfCol) {
      const pat::PackedCandidate* lPack = dynamic_cast<const pat::PackedCandidate*>(&aPF);
      float curpupweight = -1.;
      if (lPack == nullptr) {
        // throw error
        throw edm::Exception(edm::errors::LogicError,
                             "PuppiProducer: cannot get weights since inputs are not PackedCandidates");
      } else {
        if (fPuppiNoLep) {
          curpupweight = lPack->puppiWeightNoLep();
        } else {
          curpupweight = lPack->puppiWeight();
        }
      }
      // Protect high pT photons (important for gamma to hadronic recoil balance)
      if ((fPtMaxPhotons > 0) && (lPack->pdgId() == 22) && (std::abs(lPack->eta()) < fEtaMaxPhotons) &&
          (lPack->pt() > fPtMaxPhotons))
        curpupweight = 1;
      lWeights.push_back(curpupweight);
      lPackCtr++;
    }
  }
 
  //Fill it into the event
  edm::ValueMap<float> lPupOut;
  edm::ValueMap<float>::Filler lPupFiller(lPupOut);
  lPupFiller.insert(hPFProduct, lWeights.begin(), lWeights.end());
  lPupFiller.fill();
 
  // This is a dummy to access the "translate" method which is a
  // non-static member function even though it doesn't need to be.
  // Will fix in the future.
  static const reco::PFCandidate dummySinceTranslateIsNotStatic;
 
  // Fill a new PF/Packed Candidate Collection and write out the ValueMap of the new p4s.
  // Since the size of the ValueMap must be equal to the input collection, we need
  // to search the "puppi" particles to find a match for each input. If none is found,
  // the input is set to have a four-vector of 0,0,0,0
  PFOutputCollection fPuppiCandidates;
  PackedOutputCollection fPackedPuppiCandidates;
 
  edm::ValueMap<LorentzVector> p4PupOut;
  LorentzVectorCollection puppiP4s;
  std::vector<reco::CandidatePtr> values(hPFProduct->size());
 
  int iCand = -1;
  for (auto const& aCand : *hPFProduct) {
    ++iCand;
    std::unique_ptr<pat::PackedCandidate> pCand;
    std::unique_ptr<reco::PFCandidate> pfCand;
 
    if (fUseExistingWeights || fClonePackedCands) {
      const pat::PackedCandidate* cand = dynamic_cast<const pat::PackedCandidate*>(&aCand);
      if (!cand)
        throw edm::Exception(edm::errors::LogicError, "PuppiProducer: inputs are not PackedCandidates");
      pCand.reset(new pat::PackedCandidate(*cand));
    } else {
      auto id = dummySinceTranslateIsNotStatic.translatePdgIdToType(aCand.pdgId());
      const reco::PFCandidate* cand = dynamic_cast<const reco::PFCandidate*>(&aCand);
      pfCand.reset(new reco::PFCandidate(cand ? *cand : reco::PFCandidate(aCand.charge(), aCand.p4(), id)));
    }
 
    // Here, we are using new weights computed and putting them in the packed candidates.
    if (fClonePackedCands && (!fUseExistingWeights)) {
      if (fPuppiNoLep)
        pCand->setPuppiWeight(pCand->puppiWeight(), lWeights[iCand]);
      else
        pCand->setPuppiWeight(lWeights[iCand], pCand->puppiWeightNoLep());
    }
 
    puppiP4s.emplace_back(lWeights[iCand] * aCand.px(),
                          lWeights[iCand] * aCand.py(),
                          lWeights[iCand] * aCand.pz(),
                          lWeights[iCand] * aCand.energy());
 
    // Here, we are using existing weights, or we're using packed candidates.
    // That is, whether or not we recomputed the weights, we store the
    // source candidate appropriately, and set the p4 of the packed candidate.
    if (fUseExistingWeights || fClonePackedCands) {
      pCand->setP4(puppiP4s.back());
      pCand->setSourceCandidatePtr(aCand.sourceCandidatePtr(0));
      fPackedPuppiCandidates.push_back(*pCand);
    } else {
      pfCand->setP4(puppiP4s.back());
      pfCand->setSourceCandidatePtr(aCand.sourceCandidatePtr(0));
      fPuppiCandidates.push_back(*pfCand);
    }
  }
 
  //Compute the modified p4s
  edm::ValueMap<LorentzVector>::Filler p4PupFiller(p4PupOut);
  p4PupFiller.insert(hPFProduct, puppiP4s.begin(), puppiP4s.end());
  p4PupFiller.fill();
 
  iEvent.emplace(ptokenPupOut_, lPupOut);
  iEvent.emplace(ptokenP4PupOut_, p4PupOut);
  if (fUseExistingWeights || fClonePackedCands) {
    edm::OrphanHandle<pat::PackedCandidateCollection> oh =
        iEvent.emplace(ptokenPackedPuppiCandidates_, fPackedPuppiCandidates);
    for (unsigned int ic = 0, nc = oh->size(); ic < nc; ++ic) {
      reco::CandidatePtr pkref(oh, ic);
      values[ic] = pkref;
    }
  } else {
    edm::OrphanHandle<reco::PFCandidateCollection> oh = iEvent.emplace(ptokenPuppiCandidates_, fPuppiCandidates);
    for (unsigned int ic = 0, nc = oh->size(); ic < nc; ++ic) {
      reco::CandidatePtr pkref(oh, ic);
      values[ic] = pkref;
    }
  }
  edm::ValueMap<reco::CandidatePtr> pfMap_p;
  edm::ValueMap<reco::CandidatePtr>::Filler filler(pfMap_p);
  filler.insert(hPFProduct, values.begin(), values.end());
  filler.fill();
  iEvent.emplace(ptokenValues_, pfMap_p);
 
  if (fPuppiDiagnostics && !fUseExistingWeights) {
    // all the different alphas per particle
    // THE alpha per particle
    std::vector<double> theAlphas(fPuppiContainer->puppiAlphas());
    std::vector<double> theAlphasMed(fPuppiContainer->puppiAlphasMed());
    std::vector<double> theAlphasRms(fPuppiContainer->puppiAlphasRMS());
    std::vector<double> alphas(fPuppiContainer->puppiRawAlphas());
    double nalgos(fPuppiContainer->puppiNAlgos());
 
    iEvent.emplace(ptokenRawAlphas_, alphas);
    iEvent.emplace(ptokenNalgos_, nalgos);
    iEvent.emplace(ptokenAlphas_, theAlphas);
    iEvent.emplace(ptokenAlphasMed_, theAlphasMed);
    iEvent.emplace(ptokenAlphasRms_, theAlphasRms);
  }
}

References funct::abs(), RecoObj::charge, RecoObj::d0, pat::PackedCandidate::dxy(), RecoObj::dZ, pat::PackedCandidate::dz(), RecoObj::eta, pat::PackedCandidate::eta(), Exception, fClonePackedCands, fDZCut, fDZCutForChargedFromPUVtxs, fEtaMaxCharged, fEtaMaxPhotons, fEtaMinUseDZ, edm::helper::Filler< Map >::fill(), trigObjTnPSource_cfi::filler, fNumOfPUVtxsForCharged, fPtMaxCharged, fPtMaxPhotons, fPuppiContainer, fPuppiDiagnostics, fPuppiNoLep, fRecoObjCollection, pat::PackedCandidate::fromPV(), fUseDZ, fUseExistingWeights, fUseFromPVLooseTight, fUsePUProxyValue, fVtxNdofCut, fVtxZCut, reco::PFCandidate::gsfTrackRef(), RecoObj::id, triggerObjects_cff::id, iEvent, edm::helper::Filler< Map >::insert(), reco::isLepton(), edm::Ref< C, T, F >::isNonnull(), edm::errors::LogicError, RecoObj::m, RecoObj::pdgId, pat::PackedCandidate::pdgId(), RecoObj::phi, edm::Handle< T >::product(), RecoObj::pt, pat::PackedCandidate::pt(), ptokenAlphas_, ptokenAlphasMed_, ptokenAlphasRms_, ptokenNalgos_, ptokenP4PupOut_, ptokenPackedPuppiCandidates_, ptokenPupOut_, ptokenPuppiCandidates_, ptokenRawAlphas_, ptokenValues_, pat::PackedCandidate::puppiWeight(), pat::PackedCandidate::puppiWeightNoLep(), puProxyValueToken_, pat::PackedCandidate::PVLoose, pat::PackedCandidate::PVTight, pat::PackedCandidate::PVUsedInFit, RecoObj::rapidity, edm::View< T >::size(), tokenPFCandidates_, tokenVertices_, reco::PFCandidate::trackRef(), reco::PFCandidate::translatePdgIdToType(), parallelization::uint, contentValuesCheck::values, pat::PackedCandidate::vertexRef(), and badGlobalMuonTaggersAOD_cff::vtx.

Member Data Documentation

fClonePackedCands

bool PuppiProducer::fClonePackedCands

private

Definition at line 75 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fDZCut

float PuppiProducer::fDZCut

private

Definition at line 66 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fDZCutForChargedFromPUVtxs

double PuppiProducer::fDZCutForChargedFromPUVtxs

private

Definition at line 73 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fEtaMaxCharged

double PuppiProducer::fEtaMaxCharged

private

Definition at line 69 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fEtaMaxPhotons

double PuppiProducer::fEtaMaxPhotons

private

Definition at line 71 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fEtaMinUseDZ

double PuppiProducer::fEtaMinUseDZ

private

Definition at line 67 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fNumOfPUVtxsForCharged

uint PuppiProducer::fNumOfPUVtxsForCharged

private

Definition at line 72 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fPFName

std::string PuppiProducer::fPFName

private

Definition at line 60 of file PuppiProducer.h.

fPtMaxCharged

double PuppiProducer::fPtMaxCharged

private

Definition at line 68 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fPtMaxPhotons

double PuppiProducer::fPtMaxPhotons

private

Definition at line 70 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fPuppiContainer

std::unique_ptr<PuppiContainer> PuppiProducer::fPuppiContainer

private

Definition at line 79 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fPuppiDiagnostics

bool PuppiProducer::fPuppiDiagnostics

private

Definition at line 62 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fPuppiName

std::string PuppiProducer::fPuppiName

private

Definition at line 59 of file PuppiProducer.h.

fPuppiNoLep

bool PuppiProducer::fPuppiNoLep

private

Definition at line 63 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fPVName

std::string PuppiProducer::fPVName

private

Definition at line 61 of file PuppiProducer.h.

fRecoObjCollection

std::vector<RecoObj> PuppiProducer::fRecoObjCollection

private

Definition at line 80 of file PuppiProducer.h.

Referenced by produce().

fUseDZ

bool PuppiProducer::fUseDZ

private

Definition at line 65 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fUseExistingWeights

bool PuppiProducer::fUseExistingWeights

private

Definition at line 74 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fUseFromPVLooseTight

bool PuppiProducer::fUseFromPVLooseTight

private

Definition at line 64 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fUsePUProxyValue

bool PuppiProducer::fUsePUProxyValue

private

Definition at line 78 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fVtxNdofCut

int PuppiProducer::fVtxNdofCut

private

Definition at line 76 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fVtxZCut

double PuppiProducer::fVtxZCut

private

Definition at line 77 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenAlphas_

edm::EDPutTokenT<std::vector<double> > PuppiProducer::ptokenAlphas_

private

Definition at line 56 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenAlphasMed_

edm::EDPutTokenT<std::vector<double> > PuppiProducer::ptokenAlphasMed_

private

Definition at line 57 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenAlphasRms_

edm::EDPutTokenT<std::vector<double> > PuppiProducer::ptokenAlphasRms_

private

Definition at line 58 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenNalgos_

edm::EDPutTokenT<double> PuppiProducer::ptokenNalgos_

private

Definition at line 54 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenP4PupOut_

edm::EDPutTokenT<edm::ValueMap<LorentzVector> > PuppiProducer::ptokenP4PupOut_

private

Definition at line 50 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenPackedPuppiCandidates_

edm::EDPutTokenT<pat::PackedCandidateCollection> PuppiProducer::ptokenPackedPuppiCandidates_

private

Definition at line 52 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenPupOut_

edm::EDPutTokenT<edm::ValueMap<float> > PuppiProducer::ptokenPupOut_

private

Definition at line 49 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenPuppiCandidates_

edm::EDPutTokenT<reco::PFCandidateCollection> PuppiProducer::ptokenPuppiCandidates_

private

Definition at line 53 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenRawAlphas_

edm::EDPutTokenT<std::vector<double> > PuppiProducer::ptokenRawAlphas_

private

Definition at line 55 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

ptokenValues_

edm::EDPutTokenT<edm::ValueMap<reco::CandidatePtr> > PuppiProducer::ptokenValues_

private

Definition at line 51 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

puProxyValueToken_

edm::EDGetTokenT<double> PuppiProducer::puProxyValueToken_

private

Definition at line 48 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

tokenPackedPuppiCandidates_

edm::EDGetTokenT<PackedOutputCollection> PuppiProducer::tokenPackedPuppiCandidates_

private

Definition at line 47 of file PuppiProducer.h.

tokenPFCandidates_

edm::EDGetTokenT<CandidateView> PuppiProducer::tokenPFCandidates_

private

Definition at line 43 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

tokenPuppiCandidates_

edm::EDGetTokenT<PFOutputCollection> PuppiProducer::tokenPuppiCandidates_

private

Definition at line 46 of file PuppiProducer.h.

tokenPuppiContainer_

edm::EDGetTokenT<PuppiContainer> PuppiProducer::tokenPuppiContainer_

private

Definition at line 45 of file PuppiProducer.h.

tokenVertices_

edm::EDGetTokenT<VertexCollection> PuppiProducer::tokenVertices_

private

Definition at line 44 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().