Producer for particle flow reconstructed particles (PFCandidates) More...

Inheritance diagram for PFEGammaProducer:

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

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

Public Member Functions inherited from edm::global::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

EDProducer &	operator= (const EDProducer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
reco::ConversionCollection	createSingleLegConversions (reco::PFCandidateEGammaExtraCollection &extras, const edm::RefProd< reco::ConversionCollection > &convProd) const

Private Attributes
const edm::EDPutTokenT< reco::CaloClusterCollection >	caloClusterCollectionEBEEPutToken_

const edm::EDPutTokenT< reco::CaloClusterCollection >	caloClusterCollectionESPutToken_

const edm::EDPutTokenT< reco::ConversionCollection >	conversionCollectionPutToken_

const edm::EDGetTokenT< reco::PFCluster::EEtoPSAssociation >	eetopsSrc_

const PFEGammaAlgo::GBRForests	gbrForests_

const edm::EDGetTokenT< reco::PFBlockCollection >	inputTagBlocks_

const edm::EDPutTokenT< reco::PFCandidateCollection >	pfCandidateCollectionPutToken_

const edm::EDPutTokenT< reco::PFCandidateEGammaExtraCollection >	pfCandidateEGammaExtraCollectionPutToken_

const PFEGammaAlgo::PFEGConfigInfo	pfEGConfigInfo_
	particle flow algorithm configuration More...

const edm::EDPutTokenT< reco::SuperClusterCollection >	superClusterCollectionPutToken_

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

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Producer for particle flow reconstructed particles (PFCandidates)

This producer makes use of PFAlgo, the particle flow algorithm.

Author: Colin Bernet

Date: July 2006

Definition at line 36 of file PFEGammaProducer.cc.

Constructor & Destructor Documentation

◆ PFEGammaProducer()

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

explicit

Definition at line 73 of file PFEGammaProducer.cc.

     : inputTagBlocks_(consumes<reco::PFBlockCollection>(iConfig.getParameter<edm::InputTag>("blocks"))),
       eetopsSrc_(consumes<reco::PFCluster::EEtoPSAssociation>(iConfig.getParameter<edm::InputTag>("EEtoPS_source"))),
       vertices_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexCollection"))),
       pfCandidateCollectionPutToken_{produces<reco::PFCandidateCollection>()},
       pfCandidateEGammaExtraCollectionPutToken_{produces<reco::PFCandidateEGammaExtraCollection>()},
       superClusterCollectionPutToken_{produces<reco::SuperClusterCollection>()},
       caloClusterCollectionEBEEPutToken_{produces<reco::CaloClusterCollection>("EBEEClusters")},
       caloClusterCollectionESPutToken_{produces<reco::CaloClusterCollection>("ESClusters")},
       conversionCollectionPutToken_{produces<reco::ConversionCollection>()},
       pfEGConfigInfo_{
           .mvaEleCut = iConfig.getParameter<double>("pf_electron_mvaCut"),
           .applyCrackCorrections = iConfig.getParameter<bool>("pf_electronID_crackCorrection"),
           .produceEGCandsWithNoSuperCluster = iConfig.getParameter<bool>("produceEGCandsWithNoSuperCluster"),
           .mvaConvCut = iConfig.getParameter<double>("pf_conv_mvaCut"),
       },
       gbrForests_{
           iConfig,
       } {}

Member Function Documentation

◆ createSingleLegConversions()

reco::ConversionCollection PFEGammaProducer::createSingleLegConversions	(	reco::PFCandidateEGammaExtraCollection &	extras,
		const edm::RefProd< reco::ConversionCollection > &	convProd
	)		const

private

Definition at line 308 of file PFEGammaProducer.cc.

                                                                                                               {
   reco::ConversionCollection oneLegConversions{};
   math::Error<3>::type error;
   for (auto& extra : extras) {
     for (const auto& tkrefmva : extra.singleLegConvTrackRefMva()) {
       const reco::Track& trk = *tkrefmva.first;
  
       const reco::Vertex convVtx(trk.innerPosition(), error);
       std::vector<reco::TrackRef> OneLegConvVector;
       OneLegConvVector.push_back(tkrefmva.first);
       std::vector<float> OneLegMvaVector;
       OneLegMvaVector.push_back(tkrefmva.second);
       std::vector<reco::CaloClusterPtr> dummymatchingBC;
       reco::CaloClusterPtrVector scPtrVec;
       scPtrVec.push_back(edm::refToPtr(extra.superClusterRef()));
  
       std::vector<math::XYZPointF> trackPositionAtEcalVec;
       std::vector<math::XYZPointF> innPointVec;
       std::vector<math::XYZVectorF> trackPinVec;
       std::vector<math::XYZVectorF> trackPoutVec;
       math::XYZPointF trackPositionAtEcal(trk.outerPosition().X(), trk.outerPosition().Y(), trk.outerPosition().Z());
       trackPositionAtEcalVec.push_back(trackPositionAtEcal);
  
       math::XYZPointF innPoint(trk.innerPosition().X(), trk.innerPosition().Y(), trk.innerPosition().Z());
       innPointVec.push_back(innPoint);
  
       math::XYZVectorF trackPin(trk.innerMomentum().X(), trk.innerMomentum().Y(), trk.innerMomentum().Z());
       trackPinVec.push_back(trackPin);
  
       math::XYZVectorF trackPout(trk.outerMomentum().X(), trk.outerMomentum().Y(), trk.outerMomentum().Z());
       trackPoutVec.push_back(trackPout);
  
       float DCA = trk.d0();
       float mvaval = tkrefmva.second;
       reco::Conversion singleLegConvCandidate(scPtrVec,
                                               OneLegConvVector,
                                               trackPositionAtEcalVec,
                                               convVtx,
                                               dummymatchingBC,
                                               DCA,
                                               innPointVec,
                                               trackPinVec,
                                               trackPoutVec,
                                               mvaval,
                                               reco::Conversion::pflow);
       singleLegConvCandidate.setOneLegMVA(OneLegMvaVector);
       oneLegConversions.push_back(singleLegConvCandidate);
  
       reco::ConversionRef convref(convProd, oneLegConversions.size() - 1);
       extra.addSingleLegConversionRef(convref);
     }
   }
   return oneLegConversions;
 }

References reco::TrackBase::d0(), relativeConstraints::error, reco::Track::innerMomentum(), reco::Track::innerPosition(), reco::Track::outerMomentum(), reco::Track::outerPosition(), reco::Conversion::pflow, edm::PtrVector< T >::push_back(), edm::refToPtr(), and reco::Conversion::setOneLegMVA().

Referenced by produce().

◆ fillDescriptions()

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

static

Definition at line 364 of file PFEGammaProducer.cc.

                                                                                   {
   edm::ParameterSetDescription desc;
   desc.add<bool>("produceEGCandsWithNoSuperCluster", false)
       ->setComment("Allow building of candidates with no input or output supercluster?");
   desc.add<double>("pf_electron_mvaCut", -0.1);
   desc.add<bool>("pf_electronID_crackCorrection", false);
   desc.add<double>("pf_conv_mvaCut", 0.0);
   desc.add<edm::InputTag>("blocks", edm::InputTag("particleFlowBlock"))->setComment("PF Blocks label");
   desc.add<edm::InputTag>("EEtoPS_source", edm::InputTag("particleFlowClusterECAL"))
       ->setComment("EE to PS association");
   desc.add<edm::InputTag>("vertexCollection", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::FileInPath>("pf_electronID_mvaWeightFile",
                             edm::FileInPath("RecoParticleFlow/PFProducer/data/PfElectrons23Jan_BDT.weights.xml.gz"));
   desc.add<edm::FileInPath>("pf_convID_mvaWeightFile",
                             edm::FileInPath("RecoParticleFlow/PFProducer/data/pfConversionAug0411_BDT.weights.xml.gz"));
   descriptions.add("particleFlowEGamma", desc);
 }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

◆ produce()

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

overridevirtual

Implements edm::global::EDProducerBase.

Definition at line 93 of file PFEGammaProducer.cc.

                                                                                                {
   LOGDRESSED("PFEGammaProducer") << "START event: " << iEvent.id().event() << " in run " << iEvent.id().run()
                                  << std::endl;
  
   // output collections
   reco::PFCandidateCollection egCandidates{};
   reco::PFCandidateEGammaExtraCollection egExtra{};
   reco::SuperClusterCollection sClusters{};
  
   // preshower conditions
   edm::ESHandle<ESEEIntercalibConstants> esEEInterCalibHandle_;
   iSetup.get<ESEEIntercalibConstantsRcd>().get(esEEInterCalibHandle_);
  
   edm::ESHandle<ESChannelStatus> esChannelStatusHandle_;
   iSetup.get<ESChannelStatusRcd>().get(esChannelStatusHandle_);
  
   //Assign the PFAlgo Parameters
   auto const& primaryVertices = iEvent.get(vertices_);
   auto const* primaryVertex = &primaryVertices.front();
   for (auto const& pv : primaryVertices) {
     if (pv.isValid() && !pv.isFake()) {
       primaryVertex = &pv;
       break;
     }
   }
  
   PFEGammaAlgo pfEGammaAlgo{pfEGConfigInfo_,
                             gbrForests_,
                             iEvent.get(eetopsSrc_),
                             *esEEInterCalibHandle_,
                             *esChannelStatusHandle_,
                             *primaryVertex};
  
   // get the collection of blocks
  
   LOGDRESSED("PFEGammaProducer") << "getting blocks" << std::endl;
   auto blocks = iEvent.getHandle(inputTagBlocks_);
  
   LOGDRESSED("PFEGammaProducer") << "EGPFlow is starting..." << std::endl;
  
 #ifdef PFLOW_DEBUG
   assert(blocks.isValid() && "edm::Handle to blocks was null!");
   std::ostringstream str;
   //str<<(*pfAlgo_)<<std::endl;
   //    cout << (*pfAlgo_) << std::endl;
   LOGDRESSED("PFEGammaProducer") << str.str() << std::endl;
 #endif
  
   // sort elements in three lists:
   std::list<reco::PFBlockRef> hcalBlockRefs;
   std::list<reco::PFBlockRef> ecalBlockRefs;
   std::list<reco::PFBlockRef> hoBlockRefs;
   std::list<reco::PFBlockRef> otherBlockRefs;
  
   for (unsigned i = 0; i < blocks->size(); ++i) {
     reco::PFBlockRef blockref(blocks, i);
  
     const edm::OwnVector<reco::PFBlockElement>& elements = blockref->elements();
  
     LOGDRESSED("PFEGammaProducer") << "Found " << elements.size() << " PFBlockElements in block: " << i << std::endl;
  
     bool singleEcalOrHcal = false;
     if (elements.size() == 1) {
       switch (elements[0].type()) {
         case reco::PFBlockElement::SC:
           edm::LogError("PFEGammaProducer") << "PFBLOCKALGO BUG!!!! Found a SuperCluster in a block by itself!";
           break;
         case reco::PFBlockElement::PS1:
         case reco::PFBlockElement::PS2:
         case reco::PFBlockElement::ECAL:
           ecalBlockRefs.push_back(blockref);
           singleEcalOrHcal = true;
           break;
         case reco::PFBlockElement::HFEM:
         case reco::PFBlockElement::HFHAD:
         case reco::PFBlockElement::HCAL:
           if (elements[0].clusterRef()->flags() & reco::CaloCluster::badHcalMarker)
             continue;
           hcalBlockRefs.push_back(blockref);
           singleEcalOrHcal = true;
           break;
         case reco::PFBlockElement::HO:
           // Single HO elements are likely to be noise. Not considered for now.
           hoBlockRefs.push_back(blockref);
           singleEcalOrHcal = true;
           break;
         default:
           break;
       }
     }
  
     if (!singleEcalOrHcal) {
       otherBlockRefs.push_back(blockref);
     }
   }  //loop blocks
  
   // loop on blocks that are not single ecal, single ps1, single ps2 , or
   // single hcal and produce unbiased collection of EGamma Candidates
  
   //printf("loop over blocks\n");
   unsigned nblcks = 0;
  
   // this auto is a const reco::PFBlockRef&
   for (const auto& blockref : otherBlockRefs) {
     ++nblcks;
     // this auto is a: const edm::OwnVector< reco::PFBlockElement >&
     const auto& elements = blockref->elements();
     // make a copy of the link data, which will be edited.
     //PFBlock::LinkData linkData =  block.linkData();
  
     auto output = pfEGammaAlgo(blockref);
  
     if (!output.candidates.empty()) {
       LOGDRESSED("PFEGammaProducer") << "Block with " << elements.size() << " elements produced "
                                      << output.candidates.size() << " e-g candidates!" << std::endl;
     }
  
     const size_t egsize = egCandidates.size();
     egCandidates.resize(egsize + output.candidates.size());
     std::move(output.candidates.begin(), output.candidates.end(), egCandidates.begin() + egsize);
  
     const size_t egxsize = egExtra.size();
     egExtra.resize(egxsize + output.candidateExtras.size());
     std::move(output.candidateExtras.begin(), output.candidateExtras.end(), egExtra.begin() + egxsize);
  
     const size_t rscsize = sClusters.size();
     sClusters.resize(rscsize + output.refinedSuperClusters.size());
     std::move(output.refinedSuperClusters.begin(), output.refinedSuperClusters.end(), sClusters.begin() + rscsize);
   }
  
   LOGDRESSED("PFEGammaProducer") << "Running PFEGammaAlgo on all blocks produced = " << egCandidates.size()
                                  << " e-g candidates!" << std::endl;
  
   auto sClusterProd = iEvent.getRefBeforePut<reco::SuperClusterCollection>();
   auto egXtraProd = iEvent.getRefBeforePut<reco::PFCandidateEGammaExtraCollection>();
  
   //set the correct references to refined SC and EG extra using the refprods
   for (unsigned int i = 0; i < egCandidates.size(); ++i) {
     reco::PFCandidate& cand = egCandidates.at(i);
     reco::PFCandidateEGammaExtra& xtra = egExtra.at(i);
  
     reco::PFCandidateEGammaExtraRef extraref(egXtraProd, i);
     reco::SuperClusterRef refinedSCRef(sClusterProd, i);
  
     xtra.setSuperClusterRef(refinedSCRef);
     cand.setSuperClusterRef(refinedSCRef);
     cand.setPFEGammaExtraRef(extraref);
   }
  
   //build collections of output CaloClusters from the used PFClusters
   reco::CaloClusterCollection caloClustersEBEE{};
   reco::CaloClusterCollection caloClustersES{};
  
   std::map<edm::Ptr<reco::CaloCluster>, unsigned int> pfClusterMapEBEE;  //maps of pfclusters to caloclusters
   std::map<edm::Ptr<reco::CaloCluster>, unsigned int> pfClusterMapES;
  
   for (const auto& sc : sClusters) {
     for (reco::CaloCluster_iterator pfclus = sc.clustersBegin(); pfclus != sc.clustersEnd(); ++pfclus) {
       if (!pfClusterMapEBEE.count(*pfclus)) {
         reco::CaloCluster caloclus(**pfclus);
         caloClustersEBEE.push_back(caloclus);
         pfClusterMapEBEE[*pfclus] = caloClustersEBEE.size() - 1;
       } else {
         throw cms::Exception("PFEgammaProducer::produce")
             << "Found an EB/EE pfcluster matched to more than one supercluster!" << std::dec << std::endl;
       }
     }
     for (reco::CaloCluster_iterator pfclus = sc.preshowerClustersBegin(); pfclus != sc.preshowerClustersEnd();
          ++pfclus) {
       if (!pfClusterMapES.count(*pfclus)) {
         reco::CaloCluster caloclus(**pfclus);
         caloClustersES.push_back(caloclus);
         pfClusterMapES[*pfclus] = caloClustersES.size() - 1;
       } else {
         throw cms::Exception("PFEgammaProducer::produce")
             << "Found an ES pfcluster matched to more than one supercluster!" << std::dec << std::endl;
       }
     }
   }
  
   //put calocluster output collections in event and get orphan handles to create ptrs
   auto const& caloClusHandleEBEE = iEvent.emplace(caloClusterCollectionEBEEPutToken_, std::move(caloClustersEBEE));
   auto const& caloClusHandleES = iEvent.emplace(caloClusterCollectionESPutToken_, std::move(caloClustersES));
  
   //relink superclusters to output caloclusters
   for (auto& sc : sClusters) {
     edm::Ptr<reco::CaloCluster> seedptr(caloClusHandleEBEE, pfClusterMapEBEE[sc.seed()]);
     sc.setSeed(seedptr);
  
     reco::CaloClusterPtrVector clusters;
     for (reco::CaloCluster_iterator pfclus = sc.clustersBegin(); pfclus != sc.clustersEnd(); ++pfclus) {
       edm::Ptr<reco::CaloCluster> clusptr(caloClusHandleEBEE, pfClusterMapEBEE[*pfclus]);
       clusters.push_back(clusptr);
     }
     sc.setClusters(clusters);
  
     reco::CaloClusterPtrVector psclusters;
     for (reco::CaloCluster_iterator pfclus = sc.preshowerClustersBegin(); pfclus != sc.preshowerClustersEnd();
          ++pfclus) {
       edm::Ptr<reco::CaloCluster> clusptr(caloClusHandleES, pfClusterMapES[*pfclus]);
       psclusters.push_back(clusptr);
     }
     sc.setPreshowerClusters(psclusters);
   }
  
   //create and fill references to single leg conversions
   auto singleLegConv = createSingleLegConversions(egExtra, iEvent.getRefBeforePut<reco::ConversionCollection>());
  
   // release our demonspawn into the wild to cause havoc
   iEvent.emplace(superClusterCollectionPutToken_, std::move(sClusters));
   iEvent.emplace(pfCandidateEGammaExtraCollectionPutToken_, std::move(egExtra));
   iEvent.emplace(conversionCollectionPutToken_, std::move(singleLegConv));
   iEvent.emplace(pfCandidateCollectionPutToken_, std::move(egCandidates));
 }

Member Data Documentation

◆ caloClusterCollectionEBEEPutToken_

const edm::EDPutTokenT<reco::CaloClusterCollection> PFEGammaProducer::caloClusterCollectionEBEEPutToken_

private

Definition at line 55 of file PFEGammaProducer.cc.

Referenced by produce().

◆ caloClusterCollectionESPutToken_

const edm::EDPutTokenT<reco::CaloClusterCollection> PFEGammaProducer::caloClusterCollectionESPutToken_

private

Definition at line 56 of file PFEGammaProducer.cc.

Referenced by produce().

◆ conversionCollectionPutToken_

const edm::EDPutTokenT<reco::ConversionCollection> PFEGammaProducer::conversionCollectionPutToken_

private

Definition at line 57 of file PFEGammaProducer.cc.

Referenced by produce().

◆ eetopsSrc_

const edm::EDGetTokenT<reco::PFCluster::EEtoPSAssociation> PFEGammaProducer::eetopsSrc_

private

Definition at line 49 of file PFEGammaProducer.cc.

Referenced by produce().

◆ gbrForests_

const PFEGammaAlgo::GBRForests PFEGammaProducer::gbrForests_

private

Definition at line 61 of file PFEGammaProducer.cc.

Referenced by produce().

◆ inputTagBlocks_

const edm::EDGetTokenT<reco::PFBlockCollection> PFEGammaProducer::inputTagBlocks_

private

Definition at line 48 of file PFEGammaProducer.cc.

Referenced by produce().

◆ pfCandidateCollectionPutToken_

const edm::EDPutTokenT<reco::PFCandidateCollection> PFEGammaProducer::pfCandidateCollectionPutToken_

private

Definition at line 52 of file PFEGammaProducer.cc.

Referenced by produce().

◆ pfCandidateEGammaExtraCollectionPutToken_

const edm::EDPutTokenT<reco::PFCandidateEGammaExtraCollection> PFEGammaProducer::pfCandidateEGammaExtraCollectionPutToken_

private

Definition at line 53 of file PFEGammaProducer.cc.

Referenced by produce().

◆ pfEGConfigInfo_

const PFEGammaAlgo::PFEGConfigInfo PFEGammaProducer::pfEGConfigInfo_

private

particle flow algorithm configuration

Definition at line 60 of file PFEGammaProducer.cc.

Referenced by produce().

◆ superClusterCollectionPutToken_

const edm::EDPutTokenT<reco::SuperClusterCollection> PFEGammaProducer::superClusterCollectionPutToken_

private

Definition at line 54 of file PFEGammaProducer.cc.

Referenced by produce().

◆ vertices_

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

private

Definition at line 50 of file PFEGammaProducer.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PFEGammaProducer()

Member Function Documentation

◆ createSingleLegConversions()

◆ fillDescriptions()

◆ produce()

Member Data Documentation

◆ caloClusterCollectionEBEEPutToken_

◆ caloClusterCollectionESPutToken_

◆ conversionCollectionPutToken_

◆ eetopsSrc_

◆ gbrForests_

◆ inputTagBlocks_

◆ pfCandidateCollectionPutToken_

◆ pfCandidateEGammaExtraCollectionPutToken_

◆ pfEGConfigInfo_

◆ superClusterCollectionPutToken_

◆ vertices_