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

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)

	~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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

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 edm::ESGetToken < ESChannelStatus, ESChannelStatusRcd >	esChannelStatusToken_

const edm::ESGetToken < ESEEIntercalibConstants, ESEEIntercalibConstantsRcd >	esEEInterCalibToken_

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
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

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

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

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

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...

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)

void	resetItemsToGetFrom (BranchType iType)

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 ( const edm::ParameterSet & iConfig )

explicit

Definition at line 76 of file PFEGammaProducer.cc.

References HLT_FULL_cff::applyCrackCorrections, caloClusterCollectionEBEEPutToken_, caloClusterCollectionESPutToken_, conversionCollectionPutToken_, esChannelStatusToken_, edm::EDConsumerBase::esConsumes(), esEEInterCalibToken_, gbrForests_, edm::ParameterSet::getParameter(), iConfig, PFEGammaAlgo::PFEGConfigInfo::mvaEleCut, pfCandidateEGammaExtraCollectionPutToken_, pfEGConfigInfo_, and superClusterCollectionPutToken_.

     : 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,
       },
       esEEInterCalibToken_(esConsumes()),
       esChannelStatusToken_(esConsumes()) {}

Member Function Documentation

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

private

Definition at line 310 of file PFEGammaProducer.cc.

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

                                                                                                               {
   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;
 }

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

static

Definition at line 366 of file PFEGammaProducer.cc.

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

                                                                                   {
   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);
 }

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

overridevirtual

Implements edm::global::EDProducerBase.

Definition at line 98 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
   auto esEEInterCalibHandle_ = iSetup.getHandle(esEEInterCalibToken_);
   auto esChannelStatusHandle_ = iSetup.getHandle(esChannelStatusToken_);
 
   //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

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

private

Definition at line 55 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 56 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 57 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 49 of file PFEGammaProducer.cc.

Referenced by produce().

const edm::ESGetToken<ESChannelStatus, ESChannelStatusRcd> PFEGammaProducer::esChannelStatusToken_

private

Definition at line 64 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

const edm::ESGetToken<ESEEIntercalibConstants, ESEEIntercalibConstantsRcd> PFEGammaProducer::esEEInterCalibToken_

private

Definition at line 63 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

const PFEGammaAlgo::GBRForests PFEGammaProducer::gbrForests_

private

Definition at line 61 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 48 of file PFEGammaProducer.cc.

Referenced by produce().

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

private

Definition at line 52 of file PFEGammaProducer.cc.

Referenced by produce().

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

private

Definition at line 53 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

const PFEGammaAlgo::PFEGConfigInfo PFEGammaProducer::pfEGConfigInfo_

private

particle flow algorithm configuration

Definition at line 60 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

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

private

Definition at line 54 of file PFEGammaProducer.cc.

Referenced by PFEGammaProducer(), and produce().

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

Member Function Documentation

Member Data Documentation