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<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

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

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
double	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::make_unique<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(), submitPVResolutionJobs::desc, PuppiAlgo::fillDescriptionsPuppiAlgo(), HLT_FULL_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 = std::make_unique<pat::PackedCandidate>(*cand);
    } else {
      auto id = dummySinceTranslateIsNotStatic.translatePdgIdToType(aCand.pdgId());
      const reco::PFCandidate* cand = dynamic_cast<const reco::PFCandidate*>(&aCand);
      pfCand = std::make_unique<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, if(), 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 extraflags_cff::vtx.

Member Data Documentation

fClonePackedCands

bool PuppiProducer::fClonePackedCands

private

Definition at line 75 of file PuppiProducer.h.

Referenced by produce(), and PuppiProducer().

fDZCut

double 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().