ReducedEGProducer Class Reference

#include <ReducedEGProducer.h>

Inheritance diagram for ReducedEGProducer:

Public Member Functions
void	beginRun (edm::Run const &, const edm::EventSetup &) final
void	produce (edm::Event &evt, const edm::EventSetup &es) final
	ReducedEGProducer (const edm::ParameterSet &ps)
	~ReducedEGProducer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

Private Member Functions
void	linkCaloCluster (const reco::CaloClusterPtr &caloCluster, reco::CaloClusterCollection &caloClusters, std::map< reco::CaloClusterPtr, unsigned int > &caloClusterMap)
void	linkCaloClusters (const reco::SuperCluster &superCluster, reco::CaloClusterCollection &ebeeClusters, std::map< reco::CaloClusterPtr, unsigned int > &ebeeClusterMap, std::unordered_set< DetId > &rechitMap, const edm::Handle< EcalRecHitCollection > &barrelHitHandle, const edm::Handle< EcalRecHitCollection > &endcapHitHandle, const CaloTopology *caloTopology, reco::CaloClusterCollection &esClusters, std::map< reco::CaloClusterPtr, unsigned int > &esClusterMap)
void	linkConversion (const reco::ConversionRef &convref, reco::ConversionCollection &conversions, std::map< reco::ConversionRef, unsigned int > &conversionMap)
void	linkConversions (const reco::ConversionRefVector &convrefs, reco::ConversionCollection &conversions, std::map< reco::ConversionRef, unsigned int > &conversionMap)
void	linkConversionsByTrackRef (const edm::Handle< reco::ConversionCollection > &conversionHandle, const reco::GsfElectron &gsfElectron, reco::ConversionCollection &conversions, std::map< reco::ConversionRef, unsigned int > &conversionMap)
void	linkConversionsByTrackRef (const edm::Handle< reco::ConversionCollection > &conversionHandle, const reco::SuperCluster &superCluster, reco::ConversionCollection &conversions, std::map< reco::ConversionRef, unsigned int > &conversionMap)
template<typename T , typename U >
void	linkCore (const T &core, U &cores, std::map< T, unsigned int > &coreMap)
void	linkHcalHits (const reco::SuperCluster &superClus, const HBHERecHitCollection &recHits, std::unordered_set< DetId > &hcalDetIds)
void	linkSuperCluster (const reco::SuperClusterRef &superCluster, std::map< reco::SuperClusterRef, unsigned int > &superClusterMap, reco::SuperClusterCollection &superClusters, const bool relink, std::unordered_set< unsigned int > &superClusterFullRelinkMap)
void	relinkCaloClusters (reco::SuperCluster &superCluster, const std::map< reco::CaloClusterPtr, unsigned int > &ebeeClusterMap, const std::map< reco::CaloClusterPtr, unsigned int > &esClusterMap, const edm::OrphanHandle< reco::CaloClusterCollection > &outEBEEClusterHandle, const edm::OrphanHandle< reco::CaloClusterCollection > &outESClusterHandle)
void	relinkConversions (reco::PhotonCore &photonCore, const reco::ConversionRefVector &convrefs, const std::map< reco::ConversionRef, unsigned int > &conversionMap, const edm::OrphanHandle< reco::ConversionCollection > &outConversionHandle)
void	relinkGsfElectronCore (reco::GsfElectron &gsfElectron, const std::map< reco::GsfElectronCoreRef, unsigned int > &gsfElectronCoreMap, const edm::OrphanHandle< reco::GsfElectronCoreCollection > &outGsfElectronCoreHandle)
void	relinkGsfTrack (reco::GsfElectronCore &electroncore, const std::map< reco::GsfTrackRef, unsigned int > &gsfTrackMap, const edm::OrphanHandle< reco::GsfTrackCollection > &outGsfTrackHandle)
void	relinkPhotonCore (reco::Photon &photon, const std::map< reco::PhotonCoreRef, unsigned int > &photonCoreMap, const edm::OrphanHandle< reco::PhotonCoreCollection > &outPhotonCoreHandle)
template<typename T >
void	relinkSuperCluster (T &core, const std::map< reco::SuperClusterRef, unsigned int > &superClusterMap, const edm::OrphanHandle< reco::SuperClusterCollection > &outSuperClusterHandle)
template<typename T >
void	setToken (edm::EDGetTokenT< T > &token, const edm::ParameterSet &config, const std::string &name)

Static Private Member Functions
static void	calibrateElectron (reco::GsfElectron &gsfElectron, const reco::GsfElectronRef &oldEleRef, const edm::ValueMap< float > &energyMap, const edm::ValueMap< float > &energyErrMap, const edm::ValueMap< float > &ecalEnergyMap, const edm::ValueMap< float > &ecalEnergyErrMap)
static void	calibratePhoton (reco::Photon &photon, const reco::PhotonRef &oldPhoRef, const edm::ValueMap< float > &energyMap, const edm::ValueMap< float > &energyErrMap)

Private Attributes
const bool	applyGsfElectronCalibOnData_
const bool	applyGsfElectronCalibOnMC_
const bool	applyPhotonCalibOnData_
const bool	applyPhotonCalibOnMC_
const edm::EDGetTokenT< EcalRecHitCollection >	barrelEcalHits_
const edm::EDGetTokenT< reco::ConversionCollection >	conversionT_
const bool	doPreshowerEcalHits_
const edm::EDGetTokenT< EcalRecHitCollection >	endcapEcalHits_
edm::EDGetTokenT< edm::ValueMap< float > >	gsfElectronCalibEcalEnergyErrT_
edm::EDGetTokenT< edm::ValueMap< float > >	gsfElectronCalibEcalEnergyT_
edm::EDGetTokenT< edm::ValueMap< float > >	gsfElectronCalibEnergyErrT_
edm::EDGetTokenT< edm::ValueMap< float > >	gsfElectronCalibEnergyT_
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > >	gsfElectronFloatValueMapTs_
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > >	gsfElectronIdTs_
const edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > >	gsfElectronPfCandMapT_
const edm::EDGetTokenT< reco::GsfElectronCollection >	gsfElectronT_
const edm::EDGetTokenT< reco::GsfTrackCollection >	gsfTrackT_
const edm::EDGetTokenT< HBHERecHitCollection >	hbheHits_
EGHcalRecHitSelector	hcalHitSel_
const StringCutObjectSelector< reco::GsfElectron >	keepGsfElectronSel_
const StringCutObjectSelector< reco::Photon >	keepOOTPhotonSel_
const StringCutObjectSelector< reco::Photon >	keepPhotonSel_
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > >	ootPhotonFloatValueMapTs_
edm::EDGetTokenT< reco::PhotonCollection >	ootPhotonT_
const std::string	outConversions_
const std::string	outEBEEClusters_
const std::string	outEBRecHits_
const std::string	outEERecHits_
const std::string	outESClusters_
const std::string	outESRecHits_
const std::string	outGsfElectronCores_
const std::vector< std::string >	outGsfElectronFloatValueMaps_
const std::vector< std::string >	outGsfElectronIds_
const std::string	outGsfElectronPfCandMap_
const std::string	outGsfElectrons_
const std::string	outGsfTracks_
const std::string	outHBHERecHits_
const std::string	outOOTEBEEClusters_
const std::string	outOOTESClusters_
const std::string	outOOTPhotonCores_
const std::vector< std::string >	outOOTPhotonFloatValueMaps_
const std::string	outOOTPhotons_
const std::string	outOOTSuperClusters_
const std::string	outPhotonCores_
const std::vector< std::string >	outPhotonFloatValueMaps_
const std::vector< std::string >	outPhotonIds_
const std::string	outPhotonPfCandMap_
const std::string	outPhotons_
const std::string	outSingleConversions_
const std::string	outSuperClusters_
edm::EDGetTokenT< edm::ValueMap< float > >	photonCalibEnergyErrT_
edm::EDGetTokenT< edm::ValueMap< float > >	photonCalibEnergyT_
std::vector< edm::EDGetTokenT< edm::ValueMap< float > > >	photonFloatValueMapTs_
std::vector< edm::EDGetTokenT< edm::ValueMap< bool > > >	photonIdTs_
const edm::EDGetTokenT< edm::ValueMap< std::vector< reco::PFCandidateRef > > >	photonPfCandMapT_
const edm::EDGetTokenT< reco::PhotonCollection >	photonT_
const edm::EDGetTokenT< EcalRecHitCollection >	preshowerEcalHits_
const StringCutObjectSelector< reco::GsfElectron >	relinkGsfElectronSel_
const StringCutObjectSelector< reco::Photon >	relinkOOTPhotonSel_
const StringCutObjectSelector< reco::Photon >	relinkPhotonSel_
const edm::EDGetTokenT< reco::ConversionCollection >	singleConversionT_
const StringCutObjectSelector< reco::GsfElectron >	slimRelinkGsfElectronSel_
const StringCutObjectSelector< reco::Photon >	slimRelinkOOTPhotonSel_
const StringCutObjectSelector< reco::Photon >	slimRelinkPhotonSel_

Additional Inherited Members
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

Detailed Description

Select subset of electrons and photons from input collections and produced consistently relinked output collections including associated SuperClusters, CaloClusters and ecal RecHits

Author

J.Bendavid (CERN) : K. McDermott(Cornell) : refactored code + out of time photons

Definition at line 47 of file ReducedEGProducer.h.

Constructor & Destructor Documentation

ReducedEGProducer::ReducedEGProducer

(

const edm::ParameterSet &

ps

)

Definition at line 47 of file ReducedEGProducer.cc.

References applyGsfElectronCalibOnData_, applyGsfElectronCalibOnMC_, applyPhotonCalibOnData_, applyPhotonCalibOnMC_, doPreshowerEcalHits_, edm::ParameterSet::getParameter(), gsfElectronCalibEcalEnergyErrT_, gsfElectronCalibEcalEnergyT_, gsfElectronCalibEnergyErrT_, gsfElectronCalibEnergyT_, gsfElectronFloatValueMapTs_, gsfElectronIdTs_, edm::EDGetTokenT< T >::isUninitialized(), edm::InputTag::label(), ootPhotonFloatValueMapTs_, ootPhotonT_, outConversions_, outEBEEClusters_, outEBRecHits_, outEERecHits_, outESClusters_, outESRecHits_, outGsfElectronCores_, outGsfElectronFloatValueMaps_, outGsfElectronIds_, outGsfElectronPfCandMap_, outGsfElectrons_, outGsfTracks_, outHBHERecHits_, outOOTEBEEClusters_, outOOTESClusters_, outOOTPhotonCores_, outOOTPhotonFloatValueMaps_, outOOTPhotons_, outOOTSuperClusters_, outPhotonCores_, outPhotonFloatValueMaps_, outPhotonIds_, outPhotonPfCandMap_, outPhotons_, outSingleConversions_, outSuperClusters_, photonCalibEnergyErrT_, photonCalibEnergyT_, photonFloatValueMapTs_, photonIdTs_, setToken(), AlCaHLTBitMon_QueryRunRegistry::string, and GlobalPosition_Frontier_DevDB_cff::tag.

                                                                  :
  photonT_(consumes<reco::PhotonCollection>(config.getParameter<edm::InputTag>("photons"))),
  gsfElectronT_(consumes<reco::GsfElectronCollection>(config.getParameter<edm::InputTag>("gsfElectrons"))),
  gsfTrackT_(consumes<reco::GsfTrackCollection>(config.getParameter<edm::InputTag>("gsfTracks"))),
  conversionT_(consumes<reco::ConversionCollection>(config.getParameter<edm::InputTag>("conversions"))),
  singleConversionT_(consumes<reco::ConversionCollection>(config.getParameter<edm::InputTag>("singleConversions"))),
  barrelEcalHits_(consumes<EcalRecHitCollection>(config.getParameter<edm::InputTag>("barrelEcalHits"))),
  endcapEcalHits_(consumes<EcalRecHitCollection>(config.getParameter<edm::InputTag>("endcapEcalHits"))),
  doPreshowerEcalHits_(!config.getParameter<edm::InputTag>("preshowerEcalHits").label().empty()),
  preshowerEcalHits_(doPreshowerEcalHits_ ? consumes<EcalRecHitCollection>(config.getParameter<edm::InputTag>("preshowerEcalHits")) : edm::EDGetTokenT<EcalRecHitCollection>()),
  hbheHits_(consumes<HBHERecHitCollection>(config.getParameter<edm::InputTag>("hbheHits"))),
  photonPfCandMapT_(consumes<edm::ValueMap<std::vector<reco::PFCandidateRef> > >(config.getParameter<edm::InputTag>("photonsPFValMap"))),  
  gsfElectronPfCandMapT_(consumes<edm::ValueMap<std::vector<reco::PFCandidateRef> > >(config.getParameter<edm::InputTag>("gsfElectronsPFValMap"))),
  //calibration flags
  applyPhotonCalibOnData_(config.getParameter<bool>("applyPhotonCalibOnData")),
  applyPhotonCalibOnMC_(config.getParameter<bool>("applyPhotonCalibOnMC")),
  applyGsfElectronCalibOnData_(config.getParameter<bool>("applyGsfElectronCalibOnData")),
  applyGsfElectronCalibOnMC_(config.getParameter<bool>("applyGsfElectronCalibOnMC")),
  //output collections    
  outPhotons_("reducedGedPhotons"),
  outPhotonCores_("reducedGedPhotonCores"),
  outOOTPhotons_("reducedOOTPhotons"),
  outOOTPhotonCores_("reducedOOTPhotonCores"),
  outGsfElectrons_("reducedGedGsfElectrons"),
  outGsfElectronCores_("reducedGedGsfElectronCores"),
  outGsfTracks_("reducedGsfTracks"),
  outConversions_("reducedConversions"),
  outSingleConversions_("reducedSingleLegConversions"),
  outSuperClusters_("reducedSuperClusters"),
  outEBEEClusters_("reducedEBEEClusters"),
  outESClusters_("reducedESClusters"),
  outOOTSuperClusters_("reducedOOTSuperClusters"),
  outOOTEBEEClusters_("reducedOOTEBEEClusters"),
  outOOTESClusters_("reducedOOTESClusters"),
  outEBRecHits_("reducedEBRecHits"),
  outEERecHits_("reducedEERecHits"),
  outESRecHits_("reducedESRecHits"),
  outHBHERecHits_("reducedHBHEHits"),
  outPhotonPfCandMap_("reducedPhotonPfCandMap"),
  outGsfElectronPfCandMap_("reducedGsfElectronPfCandMap"),
  outPhotonIds_(config.getParameter<std::vector<std::string> >("photonIDOutput")),
  outGsfElectronIds_(config.getParameter<std::vector<std::string> >("gsfElectronIDOutput")),
  outPhotonFloatValueMaps_(config.getParameter<std::vector<std::string> >("photonFloatValueMapOutput")),
  outOOTPhotonFloatValueMaps_(config.getParameter<std::vector<std::string> >("ootPhotonFloatValueMapOutput")),
  outGsfElectronFloatValueMaps_(config.getParameter<std::vector<std::string> >("gsfElectronFloatValueMapOutput")),
  keepPhotonSel_(config.getParameter<std::string>("keepPhotons")),
  slimRelinkPhotonSel_(config.getParameter<std::string>("slimRelinkPhotons")),
  relinkPhotonSel_(config.getParameter<std::string>("relinkPhotons")),
  keepOOTPhotonSel_(config.getParameter<std::string>("keepOOTPhotons")),
  slimRelinkOOTPhotonSel_(config.getParameter<std::string>("slimRelinkOOTPhotons")),
  relinkOOTPhotonSel_(config.getParameter<std::string>("relinkOOTPhotons")),
  keepGsfElectronSel_(config.getParameter<std::string>("keepGsfElectrons")),
  slimRelinkGsfElectronSel_(config.getParameter<std::string>("slimRelinkGsfElectrons")),
  relinkGsfElectronSel_(config.getParameter<std::string>("relinkGsfElectrons")),
  hcalHitSel_(config.getParameter<edm::ParameterSet>("hcalHitSel"))
{  

  const edm::InputTag& aTag = config.getParameter<edm::InputTag>("ootPhotons");
  if (not aTag.label().empty()) ootPhotonT_ = consumes<reco::PhotonCollection>(aTag);  
  
  const std::vector<edm::InputTag>& photonidinputs = 
    config.getParameter<std::vector<edm::InputTag> >("photonIDSources");
  for (const edm::InputTag &tag : photonidinputs) {
    photonIdTs_.emplace_back(consumes<edm::ValueMap<bool> >(tag));
  }
  
  const std::vector<edm::InputTag>& gsfelectronidinputs = 
    config.getParameter<std::vector<edm::InputTag> >("gsfElectronIDSources");
  for (const edm::InputTag &tag : gsfelectronidinputs) {
    gsfElectronIdTs_.emplace_back(consumes<edm::ValueMap<float> >(tag));
  }  
  
  const std::vector<edm::InputTag>&  photonpfclusterisoinputs = 
    config.getParameter<std::vector<edm::InputTag> >("photonFloatValueMapSources");
  for (const edm::InputTag &tag : photonpfclusterisoinputs) {
    photonFloatValueMapTs_.emplace_back(consumes<edm::ValueMap<float> >(tag));
  }  

  const std::vector<edm::InputTag>&  ootphotonpfclusterisoinputs = 
    config.getParameter<std::vector<edm::InputTag> >("ootPhotonFloatValueMapSources");
  for (const edm::InputTag &tag : ootphotonpfclusterisoinputs) {
    ootPhotonFloatValueMapTs_.emplace_back(consumes<edm::ValueMap<float> >(tag));
  }  

  const std::vector<edm::InputTag>& gsfelectronpfclusterisoinputs = 
    config.getParameter<std::vector<edm::InputTag> >("gsfElectronFloatValueMapSources");
  for (const edm::InputTag &tag : gsfelectronpfclusterisoinputs) {
    gsfElectronFloatValueMapTs_.emplace_back(consumes<edm::ValueMap<float> >(tag));
  } 

  if(applyPhotonCalibOnData_ || applyPhotonCalibOnMC_){
    setToken(photonCalibEnergyT_,config,"photonCalibEnergySource");
    setToken(photonCalibEnergyErrT_,config,"photonCalibEnergyErrSource");
  }
  if(applyGsfElectronCalibOnData_ || applyGsfElectronCalibOnMC_){
    setToken(gsfElectronCalibEnergyT_,config,"gsfElectronCalibEnergySource");
    setToken(gsfElectronCalibEnergyErrT_,config,"gsfElectronCalibEnergyErrSource");  
    setToken(gsfElectronCalibEcalEnergyT_,config,"gsfElectronCalibEcalEnergySource");
    setToken(gsfElectronCalibEcalEnergyErrT_,config,"gsfElectronCalibEcalEnergyErrSource");
  }

  produces< reco::PhotonCollection >(outPhotons_);
  produces< reco::PhotonCoreCollection >(outPhotonCores_);
  if(!ootPhotonT_.isUninitialized()){ 
    produces< reco::PhotonCollection >(outOOTPhotons_);
    produces< reco::PhotonCoreCollection >(outOOTPhotonCores_);
  }
  produces< reco::GsfElectronCollection >(outGsfElectrons_);
  produces< reco::GsfElectronCoreCollection >(outGsfElectronCores_);
  produces< reco::GsfTrackCollection >(outGsfTracks_);
  produces< reco::ConversionCollection >(outConversions_);
  produces< reco::ConversionCollection >(outSingleConversions_);
  produces< reco::SuperClusterCollection >(outSuperClusters_);  
  produces< reco::CaloClusterCollection >(outEBEEClusters_);
  produces< reco::CaloClusterCollection >(outESClusters_);
  if(!ootPhotonT_.isUninitialized()){
    produces< reco::SuperClusterCollection >(outOOTSuperClusters_);  
    produces< reco::CaloClusterCollection >(outOOTEBEEClusters_);
    produces< reco::CaloClusterCollection >(outOOTESClusters_);
  }
  produces< EcalRecHitCollection >(outEBRecHits_);
  produces< EcalRecHitCollection >(outEERecHits_);
  if (doPreshowerEcalHits_) produces< EcalRecHitCollection >(outESRecHits_);    
  produces< HBHERecHitCollection >(outHBHERecHits_);
  produces< edm::ValueMap<std::vector<reco::PFCandidateRef> > >(outPhotonPfCandMap_);    
  produces< edm::ValueMap<std::vector<reco::PFCandidateRef> > >(outGsfElectronPfCandMap_);   
  for (const std::string &outid : outPhotonIds_) {
    produces< edm::ValueMap<bool> >(outid);   
  }
  for (const std::string &outid : outGsfElectronIds_) {
    produces< edm::ValueMap<float> >(outid);   
  }  
  for (const std::string &outid : outPhotonFloatValueMaps_) {
    produces< edm::ValueMap<float> >(outid);   
  }
  if(!ootPhotonT_.isUninitialized()){
    for (const std::string &outid : outOOTPhotonFloatValueMaps_) {
      produces< edm::ValueMap<float> >(outid);   
    }
  }
  for (const std::string &outid : outGsfElectronFloatValueMaps_) {
    produces< edm::ValueMap<float> >(outid);   
  }
}

ReducedEGProducer::~ReducedEGProducer ( )

override

Definition at line 192 of file ReducedEGProducer.cc.

{
}

Member Function Documentation

void ReducedEGProducer::beginRun ( edm::Run const &  run, const edm::EventSetup &  iSetup  )

final

Definition at line 196 of file ReducedEGProducer.cc.

References hcalHitSel_, and EGHcalRecHitSelector::setup().

{
  hcalHitSel_.setup(iSetup);
}

void ReducedEGProducer::calibrateElectron ( reco::GsfElectron &  gsfElectron, const reco::GsfElectronRef &  oldEleRef, const edm::ValueMap< float > &  energyMap, const edm::ValueMap< float > &  energyErrMap, const edm::ValueMap< float > &  ecalEnergyMap, const edm::ValueMap< float > &  ecalEnergyErrMap  )

staticprivate

Definition at line 1065 of file ReducedEGProducer.cc.

References corr, reco::GsfElectron::correctMomentum(), reco::GsfElectron::p4(), reco::GsfElectron::setCorrectedEcalEnergy(), reco::GsfElectron::setCorrectedEcalEnergyError(), and reco::GsfElectron::trackMomentumError().

Referenced by produce().

{
  const float newEnergy = energyMap[oldEleRef];
  const float newEnergyErr = energyErrMap[oldEleRef];
  const float newEcalEnergy = ecalEnergyMap[oldEleRef];
  const float newEcalEnergyErr = ecalEnergyErrMap[oldEleRef];

  //make a copy of this as the setCorrectedEcalEnergy call with modifiy the electrons p4
  const math::XYZTLorentzVector oldP4 = electron.p4(); 
  const float corr = newEnergy / oldP4.E();
  
  electron.setCorrectedEcalEnergy(newEcalEnergy);
  electron.setCorrectedEcalEnergyError(newEcalEnergyErr);
 
  math::XYZTLorentzVector newP4 = math::XYZTLorentzVector(oldP4.x() * corr,
                              oldP4.y() * corr,
                              oldP4.z() * corr,
                              newEnergy);
  electron.correctMomentum(newP4, electron.trackMomentumError(), newEnergyErr); 

}

void ReducedEGProducer::calibratePhoton ( reco::Photon &  photon, const reco::PhotonRef &  oldPhoRef, const edm::ValueMap< float > &  energyMap, const edm::ValueMap< float > &  energyErrMap  )

staticprivate

Definition at line 1054 of file ReducedEGProducer.cc.

References reco::Photon::setCorrectedEnergy().

Referenced by produce().

{
  float newEnergy = energyMap[oldPhoRef];
  float newEnergyErr = energyErrMap[oldPhoRef];
  photon.setCorrectedEnergy(reco::Photon::P4type::regression2, newEnergy, newEnergyErr, true);
 
}

void ReducedEGProducer::linkCaloCluster ( const reco::CaloClusterPtr &  caloCluster, reco::CaloClusterCollection &  caloClusters, std::map< reco::CaloClusterPtr, unsigned int > &  caloClusterMap  )

private

Definition at line 877 of file ReducedEGProducer.cc.

Referenced by linkCaloClusters(), and produce().

{
  if (!caloClusterMap.count(caloCluster)) {
    caloClusters.push_back(*caloCluster);
    caloClusterMap[caloCluster] = caloClusters.size() - 1;
  }
}

void ReducedEGProducer::linkCaloClusters ( const reco::SuperCluster &  superCluster, reco::CaloClusterCollection &  ebeeClusters, std::map< reco::CaloClusterPtr, unsigned int > &  ebeeClusterMap, std::unordered_set< DetId > &  rechitMap, const edm::Handle< EcalRecHitCollection > &  barrelHitHandle, const edm::Handle< EcalRecHitCollection > &  endcapHitHandle, const CaloTopology *  caloTopology, reco::CaloClusterCollection &  esClusters, std::map< reco::CaloClusterPtr, unsigned int > &  esClusterMap  )

private

Definition at line 887 of file ReducedEGProducer.cc.

References Reference_intrackfit_cff::barrel, reco::SuperCluster::clusters(), DetId::Ecal, EcalBarrel, EcalEndcap, CaloTopology::getSubdetectorTopology(), CaloSubdetectorTopology::getWindow(), linkCaloCluster(), reco::SuperCluster::preshowerClusters(), edm::Handle< T >::product(), and SurveyInfoScenario_cff::seed.

Referenced by produce().

{
  for (const auto& cluster : superCluster.clusters()) {
    linkCaloCluster(cluster, ebeeClusters, ebeeClusterMap);

    for (const auto& hitfrac : cluster->hitsAndFractions()) {
      rechitMap.insert(hitfrac.first);
    }
    //make sure to also take all hits in the 5x5 around the max energy xtal
    bool barrel = cluster->hitsAndFractions().front().first.subdetId()==EcalBarrel;
    const EcalRecHitCollection *rhcol = barrel ? barrelHitHandle.product() : endcapHitHandle.product();
    DetId seed = EcalClusterTools::getMaximum(*cluster, rhcol).first;
    
    std::vector<DetId> dets5x5 = caloTopology->getSubdetectorTopology(DetId::Ecal, barrel ? EcalBarrel : EcalEndcap)->getWindow(seed,5,5);
    for (const auto& detid : dets5x5) {
      rechitMap.insert(detid);
    }
  }
  for (const auto& cluster : superCluster.preshowerClusters()) {
    linkCaloCluster(cluster, esClusters, esClusterMap);

    for (const auto& hitfrac : cluster->hitsAndFractions()) {
      rechitMap.insert(hitfrac.first);
    }      
  }
}

void ReducedEGProducer::linkConversion ( const reco::ConversionRef &  convref, reco::ConversionCollection &  conversions, std::map< reco::ConversionRef, unsigned int > &  conversionMap  )

private

Definition at line 867 of file ReducedEGProducer.cc.

Referenced by linkConversions(), and linkConversionsByTrackRef().

{
  if (!conversionMap.count(convref)) {
    conversions.push_back(*convref);
    conversionMap[convref] = conversions.size() - 1;
  }
}

void ReducedEGProducer::linkConversions ( const reco::ConversionRefVector &  convrefs, reco::ConversionCollection &  conversions, std::map< reco::ConversionRef, unsigned int > &  conversionMap  )

private

Definition at line 824 of file ReducedEGProducer.cc.

References linkConversion().

Referenced by produce().

{
  for (const auto& convref : convrefs) {
    linkConversion(convref, conversions, conversionMap);
  }
}

void ReducedEGProducer::linkConversionsByTrackRef ( const edm::Handle< reco::ConversionCollection > &  conversionHandle, const reco::GsfElectron &  gsfElectron, reco::ConversionCollection &  conversions, std::map< reco::ConversionRef, unsigned int > &  conversionMap  )

private

Definition at line 833 of file ReducedEGProducer.cc.

References edm::conversion(), linkConversion(), electrons_cff::matched, and ConversionTools::matchesConversion().

Referenced by produce().

{
  int index = 0;
  for (const auto& conversion : *conversionHandle) {

    reco::ConversionRef convref(conversionHandle,index++);
    
    bool matched = ConversionTools::matchesConversion(gsfElectron,conversion,true,true);
    if (!matched) continue;
      
    linkConversion(convref, conversions, conversionMap);
  }
}

void ReducedEGProducer::linkConversionsByTrackRef ( const edm::Handle< reco::ConversionCollection > &  conversionHandle, const reco::SuperCluster &  superCluster, reco::ConversionCollection &  conversions, std::map< reco::ConversionRef, unsigned int > &  conversionMap  )

private

Definition at line 850 of file ReducedEGProducer.cc.

References edm::conversion(), linkConversion(), electrons_cff::matched, and ConversionTools::matchesConversion().

{
  int index = 0;
  for (const auto& conversion : *conversionHandle) {

    reco::ConversionRef convref(conversionHandle,index++);
    
    bool matched = ConversionTools::matchesConversion(superCluster,conversion,0.2);
    if (!matched) continue;
 
    linkConversion(convref, conversions, conversionMap);
  }
}

template<typename T , typename U >

void ReducedEGProducer::linkCore ( const T &  core, U &  cores, std::map< T, unsigned int > &  coreMap  )

private

Definition at line 793 of file ReducedEGProducer.cc.

Referenced by produce().

{
  if (!coreMap.count(core)) {
    cores.push_back(*core);
    coreMap[core] = cores.size() - 1;
  }
}

void ReducedEGProducer::linkHcalHits ( const reco::SuperCluster &  superClus, const HBHERecHitCollection &  recHits, std::unordered_set< DetId > &  hcalDetIds  )

private

Definition at line 922 of file ReducedEGProducer.cc.

References EGHcalRecHitSelector::addDetIds(), and hcalHitSel_.

Referenced by produce().

{
  hcalHitSel_.addDetIds(superClus,recHits,hcalDetIds);
}

void ReducedEGProducer::linkSuperCluster ( const reco::SuperClusterRef &  superCluster, std::map< reco::SuperClusterRef, unsigned int > &  superClusterMap, reco::SuperClusterCollection &  superClusters, const bool  relink, std::unordered_set< unsigned int > &  superClusterFullRelinkMap  )

private

Definition at line 801 of file ReducedEGProducer.cc.

Referenced by produce().

{
  const auto &mappedsc = superClusterMap.find(superCluster);
  //get index in output collection in order to keep track whether superCluster
  //will be subject to full relinking
  unsigned int mappedscidx = 0;
  if (mappedsc==superClusterMap.end()) {
    superClusters.push_back(*superCluster);
    mappedscidx = superClusters.size() - 1;
    superClusterMap[superCluster] = mappedscidx;
  }
  else {
    mappedscidx = mappedsc->second;
  }

  //additionally mark supercluster for full relinking
  if (relink) superClusterFullRelinkMap.insert(mappedscidx);
}

void ReducedEGProducer::produce ( edm::Event &  evt, const edm::EventSetup &  es  )

final

Definition at line 202 of file ReducedEGProducer.cc.

References applyGsfElectronCalibOnData_, applyGsfElectronCalibOnMC_, applyPhotonCalibOnData_, applyPhotonCalibOnMC_, barrelEcalHits_, calibrateElectron(), calibratePhoton(), printConversionInfo::conversionHandle, conversions_cfi::conversions, conversionT_, doPreshowerEcalHits_, endcapEcalHits_, ev, Exception, objects.autophobj::filler, edm::EventSetup::get(), edm::Event::getByToken(), gsfElectronCalibEcalEnergyErrT_, gsfElectronCalibEcalEnergyT_, gsfElectronCalibEnergyErrT_, gsfElectronCalibEnergyT_, gsfElectronCores_cfi::gsfElectronCores, gsfElectronFloatValueMapTs_, gsfElectronIdTs_, gsfElectronPfCandMapT_, gsfElectrons_cfi::gsfElectrons, gsfElectronT_, gedGsfElectronCores_cfi::gsfTracks, gsfTrackT_, hbheHits_, edm::EventBase::isRealData(), edm::EDGetTokenT< T >::isUninitialized(), keep, keepGsfElectronSel_, keepOOTPhotonSel_, keepPhotonSel_, linkCaloCluster(), linkCaloClusters(), linkConversions(), linkConversionsByTrackRef(), linkCore(), linkHcalHits(), linkSuperCluster(), eostools::move(), ootPhotonCore_cff::ootPhotonCore, ootPhotonFloatValueMapTs_, ootPhotons_cff::ootPhotons, ootPhotonT_, outConversions_, outEBEEClusters_, outEBRecHits_, outEERecHits_, outESClusters_, outESRecHits_, outGsfElectronCores_, outGsfElectronFloatValueMaps_, outGsfElectronIds_, outGsfElectronPfCandMap_, outGsfElectrons_, outGsfTracks_, outHBHERecHits_, outOOTEBEEClusters_, outOOTESClusters_, outOOTPhotonCores_, outOOTPhotonFloatValueMaps_, outOOTPhotons_, outOOTSuperClusters_, outPhotonCores_, outPhotonFloatValueMaps_, outPhotonIds_, outPhotonPfCandMap_, outPhotons_, outSingleConversions_, outSuperClusters_, muons2muons_cfi::photon, photonCalibEnergyErrT_, photonCalibEnergyT_, photonCore_cfi::photonCore, photonFloatValueMapTs_, photonIdTs_, photonPfCandMapT_, nano_cff::photons, photonT_, preshowerEcalHits_, edm::Event::put(), relinkCaloClusters(), relinkConversions(), relinkGsfElectronCore(), relinkGsfElectronSel_, relinkGsfTrack(), relinkOOTPhotonSel_, relinkPhotonCore(), relinkPhotonSel_, relinkSuperCluster(), reducedEgamma_cfi::singleConversions, singleConversionT_, slimRelinkGsfElectronSel_, slimRelinkOOTPhotonSel_, slimRelinkPhotonSel_, AlCaHLTBitMon_QueryRunRegistry::string, and create_public_pileup_plots::vals.

                                                                                      {

  //get input collections
  
  edm::Handle<reco::PhotonCollection> photonHandle;
  theEvent.getByToken(photonT_, photonHandle);

  edm::Handle<reco::PhotonCollection> ootPhotonHandle;
  if(!ootPhotonT_.isUninitialized())theEvent.getByToken(ootPhotonT_, ootPhotonHandle);

  edm::Handle<reco::GsfElectronCollection> gsfElectronHandle;
  theEvent.getByToken(gsfElectronT_, gsfElectronHandle);  

  edm::Handle<reco::GsfTrackCollection> gsfTrackHandle;
  theEvent.getByToken(gsfTrackT_, gsfTrackHandle);
 
  edm::Handle<reco::ConversionCollection> conversionHandle;
  theEvent.getByToken(conversionT_, conversionHandle);  

  edm::Handle<reco::ConversionCollection> singleConversionHandle;
  theEvent.getByToken(singleConversionT_, singleConversionHandle);    
  
  edm::Handle<EcalRecHitCollection> barrelHitHandle;
  theEvent.getByToken(barrelEcalHits_, barrelHitHandle);  
  
  edm::Handle<EcalRecHitCollection> endcapHitHandle;
  theEvent.getByToken(endcapEcalHits_, endcapHitHandle);

  edm::Handle<EcalRecHitCollection> preshowerHitHandle;
  if (doPreshowerEcalHits_) theEvent.getByToken(preshowerEcalHits_, preshowerHitHandle);
  
  edm::Handle<HBHERecHitCollection> hbheHitHandle;
  theEvent.getByToken(hbheHits_, hbheHitHandle);

  edm::Handle<edm::ValueMap<std::vector<reco::PFCandidateRef> > > photonPfCandMapHandle;
  theEvent.getByToken(photonPfCandMapT_, photonPfCandMapHandle);  

  edm::Handle<edm::ValueMap<std::vector<reco::PFCandidateRef> > > gsfElectronPfCandMapHandle;
  theEvent.getByToken(gsfElectronPfCandMapT_, gsfElectronPfCandMapHandle);    

  std::vector<edm::Handle<edm::ValueMap<bool> > > photonIdHandles(photonIdTs_.size());
  int index = 0; // universal index for range based loops
  for (const auto& photonIdT : photonIdTs_) {
    theEvent.getByToken(photonIdT,photonIdHandles[index++]);
  }
  
  std::vector<edm::Handle<edm::ValueMap<float> > > gsfElectronIdHandles(gsfElectronIdTs_.size());
  index = 0;
  for (const auto& gsfElectronIdT : gsfElectronIdTs_) {
    theEvent.getByToken(gsfElectronIdT,gsfElectronIdHandles[index++]);
  }  
  
  std::vector<edm::Handle<edm::ValueMap<float> > > photonFloatValueMapHandles(photonFloatValueMapTs_.size());
  index = 0;
  for (const auto& photonFloatValueMapT : photonFloatValueMapTs_) {
    theEvent.getByToken(photonFloatValueMapT,photonFloatValueMapHandles[index++]);
  }  

  std::vector<edm::Handle<edm::ValueMap<float> > > ootPhotonFloatValueMapHandles(ootPhotonFloatValueMapTs_.size());
  if (!ootPhotonT_.isUninitialized()){ 
    index = 0;
    for (const auto& ootPhotonFloatValueMapT : ootPhotonFloatValueMapTs_) {
      theEvent.getByToken(ootPhotonFloatValueMapT,ootPhotonFloatValueMapHandles[index++]);
    }  
  }

  std::vector<edm::Handle<edm::ValueMap<float> > > gsfElectronFloatValueMapHandles(gsfElectronFloatValueMapTs_.size());
  index = 0;
  for (const auto& gsfElectronFloatValueMapT : gsfElectronFloatValueMapTs_) {
    theEvent.getByToken(gsfElectronFloatValueMapT,gsfElectronFloatValueMapHandles[index++]);
  }  
 
 
  edm::Handle<edm::ValueMap<float> > gsfElectronCalibEnergyHandle;  
  edm::Handle<edm::ValueMap<float> > gsfElectronCalibEnergyErrHandle;
  edm::Handle<edm::ValueMap<float> > gsfElectronCalibEcalEnergyHandle;  
  edm::Handle<edm::ValueMap<float> > gsfElectronCalibEcalEnergyErrHandle;
  if(applyGsfElectronCalibOnData_ || applyGsfElectronCalibOnMC_) {
    theEvent.getByToken(gsfElectronCalibEnergyT_,gsfElectronCalibEnergyHandle);
    theEvent.getByToken(gsfElectronCalibEnergyErrT_,gsfElectronCalibEnergyErrHandle);
    theEvent.getByToken(gsfElectronCalibEcalEnergyT_,gsfElectronCalibEcalEnergyHandle);
    theEvent.getByToken(gsfElectronCalibEcalEnergyErrT_,gsfElectronCalibEcalEnergyErrHandle);
  }
  edm::Handle<edm::ValueMap<float> > photonCalibEnergyHandle;  
  edm::Handle<edm::ValueMap<float> > photonCalibEnergyErrHandle;
  if(applyPhotonCalibOnData_ || applyPhotonCalibOnMC_){
    theEvent.getByToken(photonCalibEnergyT_,photonCalibEnergyHandle);
    theEvent.getByToken(photonCalibEnergyErrT_,photonCalibEnergyErrHandle);
  }

  edm::ESHandle<CaloTopology> theCaloTopology;
  theEventSetup.get<CaloTopologyRecord>().get(theCaloTopology);  
  const CaloTopology *caloTopology = & (*theCaloTopology);  

  //initialize output collections
  auto photons = std::make_unique<reco::PhotonCollection>();
  auto photonCores = std::make_unique<reco::PhotonCoreCollection>();
  auto ootPhotons = std::make_unique<reco::PhotonCollection>();
  auto ootPhotonCores = std::make_unique<reco::PhotonCoreCollection>();
  auto gsfElectrons = std::make_unique<reco::GsfElectronCollection>();
  auto gsfElectronCores = std::make_unique<reco::GsfElectronCoreCollection>();
  auto gsfTracks = std::make_unique<reco::GsfTrackCollection>();
  auto conversions = std::make_unique<reco::ConversionCollection>();
  auto singleConversions = std::make_unique<reco::ConversionCollection>();
  auto superClusters = std::make_unique<reco::SuperClusterCollection>();
  auto ebeeClusters = std::make_unique<reco::CaloClusterCollection>();
  auto esClusters = std::make_unique<reco::CaloClusterCollection>();
  auto ootSuperClusters = std::make_unique<reco::SuperClusterCollection>();
  auto ootEbeeClusters = std::make_unique<reco::CaloClusterCollection>();
  auto ootEsClusters = std::make_unique<reco::CaloClusterCollection>();
  auto ebRecHits = std::make_unique<EcalRecHitCollection>();
  auto eeRecHits = std::make_unique<EcalRecHitCollection>();
  auto esRecHits = std::make_unique<EcalRecHitCollection>();
  auto hbheRecHits = std::make_unique<HBHERecHitCollection>();
  auto photonPfCandMap = std::make_unique<edm::ValueMap<std::vector<reco::PFCandidateRef>>>();
  auto gsfElectronPfCandMap = std::make_unique<edm::ValueMap<std::vector<reco::PFCandidateRef>>>();

  //maps to collection indices of output objects
  std::map<reco::PhotonCoreRef, unsigned int> photonCoreMap;
  std::map<reco::PhotonCoreRef, unsigned int> ootPhotonCoreMap;
  std::map<reco::GsfElectronCoreRef, unsigned int> gsfElectronCoreMap;
  std::map<reco::GsfTrackRef, unsigned int> gsfTrackMap;
  std::map<reco::ConversionRef, unsigned int> conversionMap;
  std::map<reco::ConversionRef, unsigned int> singleConversionMap;
  std::map<reco::SuperClusterRef, unsigned int> superClusterMap;
  std::map<reco::CaloClusterPtr, unsigned int> ebeeClusterMap;
  std::map<reco::CaloClusterPtr, unsigned int> esClusterMap;
  std::map<reco::SuperClusterRef, unsigned int> ootSuperClusterMap;
  std::map<reco::CaloClusterPtr, unsigned int> ootEbeeClusterMap;
  std::map<reco::CaloClusterPtr, unsigned int> ootEsClusterMap;
  std::unordered_set<DetId> rechitMap;
  std::unordered_set<DetId> hcalRechitMap;
  
  std::unordered_set<unsigned int> superClusterFullRelinkMap;
  std::unordered_set<unsigned int> ootSuperClusterFullRelinkMap;
  
  //vectors for pfcandidate valuemaps
  std::vector<std::vector<reco::PFCandidateRef> > pfCandIsoPairVecPho;  
  std::vector<std::vector<reco::PFCandidateRef> > pfCandIsoPairVecEle;
  
  //vectors for id valuemaps
  std::vector<std::vector<bool> > photonIdVals(photonIdHandles.size());
  std::vector<std::vector<float> > gsfElectronIdVals(gsfElectronIdHandles.size());
  std::vector<std::vector<float> > photonFloatValueMapVals(photonFloatValueMapHandles.size());
  std::vector<std::vector<float> > ootPhotonFloatValueMapVals(ootPhotonFloatValueMapHandles.size());
  std::vector<std::vector<float> > gsfElectronFloatValueMapVals(gsfElectronFloatValueMapHandles.size());
  
  //loop over photons and fill maps
  index = -1;
  for (const auto& photon : *photonHandle) {
    index++;

    reco::PhotonRef photonref(photonHandle,index);
    photons->push_back(photon);
    auto& newPhoton = photons->back();
   
    if( (applyPhotonCalibOnData_ && theEvent.isRealData()) ||
    (applyPhotonCalibOnMC_ && !theEvent.isRealData()) ){
      calibratePhoton(newPhoton,photonref,            
              *photonCalibEnergyHandle,*photonCalibEnergyErrHandle);
    }
      
    //we do this after calibration
    bool keep = keepPhotonSel_(newPhoton);
    if (!keep){
      photons->pop_back();
      continue;
    }    
    
    //fill pf candidate value map vector
    pfCandIsoPairVecPho.push_back((*photonPfCandMapHandle)[photonref]);

    //fill photon id valuemap vectors
    int subindex = 0;
    for (const auto& photonIdHandle : photonIdHandles) {
      photonIdVals[subindex++].push_back((*photonIdHandle)[photonref]);
    }    

    subindex = 0;
    for (const auto& photonFloatValueMapHandle : photonFloatValueMapHandles) {
      photonFloatValueMapVals[subindex++].push_back((*photonFloatValueMapHandle)[photonref]);
    }    
    
    //link photon core
    const reco::PhotonCoreRef &photonCore = photon.photonCore();
    linkCore(photonCore, *photonCores, photonCoreMap);
    
    bool slimRelink = slimRelinkPhotonSel_(newPhoton);
    //no supercluster relinking unless slimRelink selection is satisfied
    if (!slimRelink) continue;
    
    bool relink = relinkPhotonSel_(newPhoton);
    
    //link supercluster
    const reco::SuperClusterRef &superCluster = photon.superCluster();
    linkSuperCluster(superCluster, superClusterMap, *superClusters, relink, superClusterFullRelinkMap);
    
    //conversions only for full relinking
    if (!relink) continue;
    
    const reco::ConversionRefVector &convrefs = photon.conversions();
    linkConversions(convrefs, *conversions, conversionMap);

    //explicitly references conversions
    const reco::ConversionRefVector &singleconvrefs = photon.conversionsOneLeg();
    linkConversions(singleconvrefs, *singleConversions, singleConversionMap);

    //hcal hits
    linkHcalHits(*photon.superCluster(),*hbheHitHandle,hcalRechitMap);

  }

  //loop over oot photons and fill maps
  //special note1: since not PFCand --> no PF isolation, IDs (but we do have FloatValueMap!)
  //special note2: conversion sequence not run over bcs from oot phos, so skip relinking of oot phos
  //special note3: clusters and superclusters in own collections!
  if(!ootPhotonT_.isUninitialized()) {
    index = -1;
    for (const auto& ootPhoton : *ootPhotonHandle) {
      index++;
      
      bool keep = keepOOTPhotonSel_(ootPhoton);
      if (!keep) continue;

      reco::PhotonRef ootPhotonref(ootPhotonHandle,index);
      
      ootPhotons->push_back(ootPhoton);
      
      //fill photon pfclusteriso valuemap vectors
      int subindex = 0;
      for (const auto& ootPhotonFloatValueMapHandle : ootPhotonFloatValueMapHandles) {
    ootPhotonFloatValueMapVals[subindex++].push_back((*ootPhotonFloatValueMapHandle)[ootPhotonref]);
      }    
      
      //link photon core
      const reco::PhotonCoreRef &ootPhotonCore = ootPhoton.photonCore();
      linkCore(ootPhotonCore, *ootPhotonCores, ootPhotonCoreMap);
      
      bool slimRelink = slimRelinkOOTPhotonSel_(ootPhoton);
      //no supercluster relinking unless slimRelink selection is satisfied
      if (!slimRelink) continue;
      
      bool relink = relinkOOTPhotonSel_(ootPhoton);
      
      const reco::SuperClusterRef &ootSuperCluster = ootPhoton.superCluster();
      linkSuperCluster(ootSuperCluster, ootSuperClusterMap, *ootSuperClusters, relink, ootSuperClusterFullRelinkMap);
      //hcal hits
      linkHcalHits(*ootPhoton.superCluster(),*hbheHitHandle,hcalRechitMap);

    }
  }

  //loop over electrons and fill maps
  index = -1;
  for (const auto& gsfElectron : *gsfElectronHandle) {
    index++;

    reco::GsfElectronRef gsfElectronref(gsfElectronHandle,index);
    gsfElectrons->push_back(gsfElectron);
    auto& newGsfElectron = gsfElectrons->back();
    if( (applyGsfElectronCalibOnData_ && theEvent.isRealData()) ||
    (applyGsfElectronCalibOnMC_ && !theEvent.isRealData()) ){
      calibrateElectron(newGsfElectron, gsfElectronref,     
            *gsfElectronCalibEnergyHandle,*gsfElectronCalibEnergyErrHandle,
            *gsfElectronCalibEcalEnergyHandle,*gsfElectronCalibEcalEnergyErrHandle);
            
    }
    
    bool keep = keepGsfElectronSel_(newGsfElectron);    
    if (!keep) {
      gsfElectrons->pop_back();
      continue;
    }    
  
    pfCandIsoPairVecEle.push_back((*gsfElectronPfCandMapHandle)[gsfElectronref]);
    
    //fill electron id valuemap vectors
    int subindex = 0;
    for (const auto& gsfElectronIdHandle : gsfElectronIdHandles) {
      gsfElectronIdVals[subindex++].push_back((*gsfElectronIdHandle)[gsfElectronref]);
    }    

    subindex = 0;
    for (const auto& gsfElectronFloatValueMapHandle : gsfElectronFloatValueMapHandles) {
      gsfElectronFloatValueMapVals[subindex++].push_back((*gsfElectronFloatValueMapHandle)[gsfElectronref]);
    }    

    const reco::GsfElectronCoreRef &gsfElectronCore = gsfElectron.core();
    linkCore(gsfElectronCore, *gsfElectronCores, gsfElectronCoreMap);

    const reco::GsfTrackRef &gsfTrack = gsfElectron.gsfTrack();
    
    // Save the main gsfTrack
    if (!gsfTrackMap.count(gsfTrack)) {
      gsfTracks->push_back(*gsfTrack);
      gsfTrackMap[gsfTrack] = gsfTracks->size() - 1;
    }
    
    // Save additional ambiguous gsf tracks in a map:
    for (reco::GsfTrackRefVector::const_iterator igsf = gsfElectron.ambiguousGsfTracksBegin(); igsf != gsfElectron.ambiguousGsfTracksEnd(); ++igsf) {
      const reco::GsfTrackRef &ambigGsfTrack = *igsf;
      if (!gsfTrackMap.count(ambigGsfTrack)) {
    gsfTracks->push_back(*ambigGsfTrack);
    gsfTrackMap[ambigGsfTrack] = gsfTracks->size() - 1;
      }
    }
  
    bool slimRelink = slimRelinkGsfElectronSel_(newGsfElectron);
    //no supercluster relinking unless slimRelink selection is satisfied
    if (!slimRelink) continue;
    
    bool relink = relinkGsfElectronSel_(newGsfElectron);
    
    const reco::SuperClusterRef &superCluster = gsfElectron.superCluster();
    linkSuperCluster(superCluster, superClusterMap, *superClusters, relink, superClusterFullRelinkMap);    

    //conversions only for full relinking
    if (!relink) continue;
    
    const reco::ConversionRefVector &convrefs = gsfElectron.core()->conversions();
    linkConversions(convrefs, *conversions, conversionMap);
    
    //explicitly references conversions
    const reco::ConversionRefVector &singleconvrefs = gsfElectron.core()->conversionsOneLeg();
    linkConversions(singleconvrefs, *singleConversions, singleConversionMap);

    //conversions matched by trackrefs
    linkConversionsByTrackRef(conversionHandle, gsfElectron, *conversions, conversionMap);
    
    //single leg conversions matched by trackrefs
    linkConversionsByTrackRef(singleConversionHandle, gsfElectron, *singleConversions, singleConversionMap);

    //hcal hits
    linkHcalHits(*gsfElectron.superCluster(),*hbheHitHandle,hcalRechitMap);

  }

  //loop over output SuperClusters and fill maps
  index = 0;
  for (auto& superCluster : *superClusters) {
    
    //link seed cluster no matter what
    const reco::CaloClusterPtr &seedCluster = superCluster.seed();
    linkCaloCluster(seedCluster, *ebeeClusters, ebeeClusterMap);
        
    //only proceed if superCluster is marked for full relinking
    bool fullrelink = superClusterFullRelinkMap.count(index++);
    if (!fullrelink) {
      //zero detid vector which is anyways not useful without stored rechits
      superCluster.clearHitsAndFractions();
      continue; 
    }
    
    // link calo clusters
    linkCaloClusters(superCluster, *ebeeClusters, ebeeClusterMap, rechitMap, barrelHitHandle, endcapHitHandle, caloTopology, *esClusters, esClusterMap);
    
    //conversions matched geometrically
    linkConversionsByTrackRef(conversionHandle, superCluster, *conversions, conversionMap);
    
    //single leg conversions matched by trackrefs
    linkConversionsByTrackRef(singleConversionHandle, superCluster, *singleConversions, singleConversionMap);    
  }

  //loop over output OOTSuperClusters and fill maps
  if(!ootPhotonT_.isUninitialized()) {
    index = 0;
    for (auto& ootSuperCluster : *ootSuperClusters) {
      
      //link seed cluster no matter what
      const reco::CaloClusterPtr &ootSeedCluster = ootSuperCluster.seed();
      linkCaloCluster(ootSeedCluster, *ootEbeeClusters, ootEbeeClusterMap);
      
      //only proceed if ootSuperCluster is marked for full relinking
      bool fullrelink = ootSuperClusterFullRelinkMap.count(index++);
      if (!fullrelink) {
    //zero detid vector which is anyways not useful without stored rechits
    ootSuperCluster.clearHitsAndFractions();
    continue; 
      }
      
      // link calo clusters
      linkCaloClusters(ootSuperCluster, *ootEbeeClusters, ootEbeeClusterMap, rechitMap, barrelHitHandle, endcapHitHandle, caloTopology, *ootEsClusters, ootEsClusterMap);
    }
  }
  //now finalize and add to the event collections in "reverse" order
  
  //rechits (fill output collections of rechits to be stored)
  for (const EcalRecHit &rechit : *barrelHitHandle) {
    if (rechitMap.count(rechit.detid())) {
      ebRecHits->push_back(rechit);
    }
  }
  
  for (const EcalRecHit &rechit : *endcapHitHandle) {
    if (rechitMap.count(rechit.detid())) {
      eeRecHits->push_back(rechit);
    }
  }

  theEvent.put(std::move(ebRecHits),outEBRecHits_);
  theEvent.put(std::move(eeRecHits),outEERecHits_);

  if (doPreshowerEcalHits_) { 
    for (const EcalRecHit &rechit : *preshowerHitHandle) {
      if (rechitMap.count(rechit.detid())) {
    esRecHits->push_back(rechit);
      }
    }
    theEvent.put(std::move(esRecHits),outESRecHits_);  
  }
  
  for (const HBHERecHit &rechit : *hbheHitHandle) {
    if (hcalRechitMap.count(rechit.detid())) {
      hbheRecHits->push_back(rechit);
    }
  }
  theEvent.put(std::move(hbheRecHits),outHBHERecHits_);

  //CaloClusters
  //put calocluster output collections in event and get orphan handles to create ptrs
  const edm::OrphanHandle<reco::CaloClusterCollection> &outEBEEClusterHandle = theEvent.put(std::move(ebeeClusters),outEBEEClusters_);
  const edm::OrphanHandle<reco::CaloClusterCollection> &outESClusterHandle = theEvent.put(std::move(esClusters),outESClusters_);;  

  //Loop over SuperClusters and relink GEDPhoton + GSFElectron CaloClusters
  for (reco::SuperCluster &superCluster : *superClusters) {
    relinkCaloClusters(superCluster, ebeeClusterMap, esClusterMap, outEBEEClusterHandle, outESClusterHandle);
  }

  //OOTCaloClusters
  //put ootcalocluster output collections in event and get orphan handles to create ptrs
  edm::OrphanHandle<reco::CaloClusterCollection> outOOTEBEEClusterHandle;
  edm::OrphanHandle<reco::CaloClusterCollection> outOOTESClusterHandle;
  //Loop over OOTSuperClusters and relink OOTPhoton CaloClusters
  if(!ootPhotonT_.isUninitialized()) {
    outOOTEBEEClusterHandle = theEvent.put(std::move(ootEbeeClusters),outOOTEBEEClusters_);
    outOOTESClusterHandle = theEvent.put(std::move(ootEsClusters),outOOTESClusters_);  
    for (reco::SuperCluster &ootSuperCluster : *ootSuperClusters) {
      relinkCaloClusters(ootSuperCluster, ootEbeeClusterMap, ootEsClusterMap, outOOTEBEEClusterHandle, outOOTESClusterHandle);
    }
  }
  //put superclusters and conversions in the event
  const edm::OrphanHandle<reco::SuperClusterCollection> &outSuperClusterHandle = theEvent.put(std::move(superClusters),outSuperClusters_);
  const edm::OrphanHandle<reco::ConversionCollection> &outConversionHandle = theEvent.put(std::move(conversions),outConversions_);
  const edm::OrphanHandle<reco::ConversionCollection> &outSingleConversionHandle = theEvent.put(std::move(singleConversions),outSingleConversions_);
  const edm::OrphanHandle<reco::GsfTrackCollection> &outGsfTrackHandle = theEvent.put(std::move(gsfTracks),outGsfTracks_);

  //Loop over PhotonCores and relink GEDPhoton SuperClusters (and conversions)
  for (reco::PhotonCore &photonCore : *photonCores) {
    // superclusters
    relinkSuperCluster(photonCore, superClusterMap, outSuperClusterHandle);

    //conversions
    const reco::ConversionRefVector &convrefs = photonCore.conversions();
    relinkConversions(photonCore, convrefs, conversionMap, outConversionHandle);

    //single leg conversions
    const reco::ConversionRefVector &singleconvrefs = photonCore.conversionsOneLeg();
    relinkConversions(photonCore, singleconvrefs, singleConversionMap, outSingleConversionHandle);
  }

  //Relink GSFElectron SuperClusters and main GSF Tracks
  for (reco::GsfElectronCore &gsfElectronCore : *gsfElectronCores) {
    relinkSuperCluster(gsfElectronCore, superClusterMap, outSuperClusterHandle);
    relinkGsfTrack(gsfElectronCore, gsfTrackMap, outGsfTrackHandle);
  }

  //put ootsuperclusters in the event
  edm::OrphanHandle<reco::SuperClusterCollection> outOOTSuperClusterHandle;
  if(!ootPhotonT_.isUninitialized()) outOOTSuperClusterHandle = theEvent.put(std::move(ootSuperClusters),outOOTSuperClusters_);
  
  //Relink OOTPhoton SuperClusters
  for (reco::PhotonCore &ootPhotonCore : *ootPhotonCores) {
    relinkSuperCluster(ootPhotonCore, ootSuperClusterMap, outOOTSuperClusterHandle);
  }

  //put photoncores and gsfelectroncores into the event
  const edm::OrphanHandle<reco::PhotonCoreCollection> &outPhotonCoreHandle = theEvent.put(std::move(photonCores),outPhotonCores_);
  edm::OrphanHandle<reco::PhotonCoreCollection> outOOTPhotonCoreHandle;
  if(!ootPhotonT_.isUninitialized()) outOOTPhotonCoreHandle = theEvent.put(std::move(ootPhotonCores),outOOTPhotonCores_);
  const edm::OrphanHandle<reco::GsfElectronCoreCollection> &outgsfElectronCoreHandle = theEvent.put(std::move(gsfElectronCores),outGsfElectronCores_);

  //loop over photons, oot photons, and electrons and relink the cores
  for (reco::Photon &photon : *photons) {
    relinkPhotonCore(photon, photonCoreMap, outPhotonCoreHandle);
  }

  if(!ootPhotonT_.isUninitialized()) {
    for (reco::Photon &ootPhoton : *ootPhotons) {
      relinkPhotonCore(ootPhoton, ootPhotonCoreMap, outOOTPhotonCoreHandle);
    }
  }

  for (reco::GsfElectron &gsfElectron : *gsfElectrons) {
    relinkGsfElectronCore(gsfElectron, gsfElectronCoreMap, outgsfElectronCoreHandle);

    // -----
    // Also in this loop let's relink ambiguous tracks
    std::vector<reco::GsfTrackRef> ambigTracksInThisElectron;
    // Here we loop over the ambiguous tracks and save them in a vector
    for (reco::GsfTrackRefVector::const_iterator igsf = gsfElectron.ambiguousGsfTracksBegin(); igsf != gsfElectron.ambiguousGsfTracksEnd(); ++igsf) {
      ambigTracksInThisElectron.push_back(*igsf);
    }
    
    // Now we need to clear them (they are the refs to original collection):
    gsfElectron.clearAmbiguousGsfTracks();
    
    // And here we add them back, now from a new reduced collection:
    for (const auto &it : ambigTracksInThisElectron) {
      const auto &gsftkmapped = gsfTrackMap.find(it);
      
      if (gsftkmapped != gsfTrackMap.end()) {
    reco::GsfTrackRef gsftkref(outGsfTrackHandle, gsftkmapped->second);
    gsfElectron.addAmbiguousGsfTrack(gsftkref);
      }
      else
    throw cms::Exception("There must be a problem with linking and mapping of ambiguous gsf tracks...");
    }
    
    if (gsfElectron.ambiguousGsfTracksSize() > 0)
      gsfElectron.setAmbiguous(true); // Set the flag

    ambigTracksInThisElectron.clear();
    
  }

  //(finally) store the output photon and electron collections
  const edm::OrphanHandle<reco::PhotonCollection> &outPhotonHandle = theEvent.put(std::move(photons),outPhotons_);  
  edm::OrphanHandle<reco::PhotonCollection> outOOTPhotonHandle;
  if(!ootPhotonT_.isUninitialized()) outOOTPhotonHandle = theEvent.put(std::move(ootPhotons),outOOTPhotons_);  
  const edm::OrphanHandle<reco::GsfElectronCollection> &outGsfElectronHandle = theEvent.put(std::move(gsfElectrons),outGsfElectrons_);
  
  //still need to output relinked valuemaps
  
  //photon pfcand isolation valuemap
  edm::ValueMap<std::vector<reco::PFCandidateRef>>::Filler fillerPhotons(*photonPfCandMap);
  fillerPhotons.insert(outPhotonHandle,pfCandIsoPairVecPho.begin(),pfCandIsoPairVecPho.end());
  fillerPhotons.fill();   
  
  //electron pfcand isolation valuemap
  edm::ValueMap<std::vector<reco::PFCandidateRef>>::Filler fillerGsfElectrons(*gsfElectronPfCandMap);
  fillerGsfElectrons.insert(outGsfElectronHandle,pfCandIsoPairVecEle.begin(),pfCandIsoPairVecEle.end());
  fillerGsfElectrons.fill();
  
  theEvent.put(std::move(photonPfCandMap),outPhotonPfCandMap_);
  theEvent.put(std::move(gsfElectronPfCandMap),outGsfElectronPfCandMap_);
  
  auto fillMap = [](auto refH, auto& vec, edm::Event& ev, const std::string& cAl = ""){
    typedef  edm::ValueMap<typename std::decay<decltype(vec)>::type::value_type> MapType;
    auto oMap = std::make_unique<MapType>();
    {
      typename MapType::Filler filler(*oMap);
      filler.insert(refH, vec.begin(), vec.end());
      filler.fill();
    }
    ev.put(std::move(oMap), cAl);
  };

  //photon id value maps
  index = 0;
  for (auto const& vals : photonIdVals){ 
    fillMap(outPhotonHandle, vals, theEvent, outPhotonIds_[index++]);
  }

  //electron id value maps
  index = 0;
  for (auto const& vals : gsfElectronIdVals){ 
    fillMap(outGsfElectronHandle, vals, theEvent, outGsfElectronIds_[index++]);
  }
  
  // photon iso value maps
  index = 0;
  for (auto const& vals : photonFloatValueMapVals){
    fillMap(outPhotonHandle, vals, theEvent, outPhotonFloatValueMaps_[index++]);
  }

  if(!ootPhotonT_.isUninitialized()) {
    //oot photon iso value maps
    index = 0;
    for (auto const& vals : ootPhotonFloatValueMapVals){
      fillMap(outOOTPhotonHandle, vals, theEvent, outOOTPhotonFloatValueMaps_[index++]);
    }
  }

  //electron iso value maps
  index = 0;
  for (auto const& vals : gsfElectronFloatValueMapVals){
    fillMap(outGsfElectronHandle, vals, theEvent, outGsfElectronFloatValueMaps_[index++]);
  }
}

void ReducedEGProducer::relinkCaloClusters ( reco::SuperCluster &  superCluster, const std::map< reco::CaloClusterPtr, unsigned int > &  ebeeClusterMap, const std::map< reco::CaloClusterPtr, unsigned int > &  esClusterMap, const edm::OrphanHandle< reco::CaloClusterCollection > &  outEBEEClusterHandle, const edm::OrphanHandle< reco::CaloClusterCollection > &  outESClusterHandle  )

private

Definition at line 929 of file ReducedEGProducer.cc.

References edm::PtrVectorBase::clear(), fastPrimaryVertexProducer_cfi::clusters, reco::SuperCluster::clusters(), edm::PtrVectorBase::empty(), reco::SuperCluster::preshowerClusters(), edm::PtrVector< T >::push_back(), reco::SuperCluster::seed(), reco::SuperCluster::setClusters(), reco::SuperCluster::setPreshowerClusters(), and reco::SuperCluster::setSeed().

Referenced by produce().

{
  //remap seed cluster
  const auto &seedmapped = ebeeClusterMap.find(superCluster.seed());
  if (seedmapped != ebeeClusterMap.end()) {
    //make new ptr
    reco::CaloClusterPtr clusptr(outEBEEClusterHandle,seedmapped->second);
    superCluster.setSeed(clusptr);
  }

 //remap all clusters
  reco::CaloClusterPtrVector clusters;
  for (const auto &cluster : superCluster.clusters()) {
    const auto &clustermapped = ebeeClusterMap.find(cluster);
    if (clustermapped != ebeeClusterMap.end()) {
      //make new ptr
      reco::CaloClusterPtr clusptr(outEBEEClusterHandle,clustermapped->second);
      clusters.push_back(clusptr);
    }
    else {
      //can only relink if all clusters are being relinked, so if one is missing, then skip the relinking completely
      clusters.clear();
      break;
    }
  }
  if (!clusters.empty()) {
    superCluster.setClusters(clusters);
  }
  
  //remap preshower clusters
  reco::CaloClusterPtrVector esclusters;
  for (const auto& cluster : superCluster.preshowerClusters()) {
    const auto &clustermapped = esClusterMap.find(cluster);
    if (clustermapped != esClusterMap.end()) {
      //make new ptr
      reco::CaloClusterPtr clusptr(outESClusterHandle,clustermapped->second);
      esclusters.push_back(clusptr);
    }
    else {
      //can only relink if all clusters are being relinked, so if one is missing, then skip the relinking completely
      esclusters.clear();
      break;
    }
  }
  if (!esclusters.empty()) {
    superCluster.setPreshowerClusters(esclusters);
  }
}

void ReducedEGProducer::relinkConversions ( reco::PhotonCore &  photonCore, const reco::ConversionRefVector &  convrefs, const std::map< reco::ConversionRef, unsigned int > &  conversionMap, const edm::OrphanHandle< reco::ConversionCollection > &  outConversionHandle  )

private

Definition at line 1006 of file ReducedEGProducer.cc.

References edm::RefVector< C, T, F >::clear(), edm::RefVector< C, T, F >::empty(), and reco::PhotonCore::setConversions().

Referenced by produce().

{
  reco::ConversionRefVector outconvrefs;
  for (const auto& convref : convrefs) {
    const auto &convmapped = conversionMap.find(convref);
    if (convmapped != conversionMap.end()) {
      //make new ref
        reco::ConversionRef outref(outConversionHandle,convmapped->second);
    }
    else {
      //can only relink if all conversions are being relinked, so if one is missing, then skip the relinking completely
      outconvrefs.clear();
      break;
    }
  }
  if (!outconvrefs.empty()) {
    photonCore.setConversions(outconvrefs);
  }
}

void ReducedEGProducer::relinkGsfElectronCore ( reco::GsfElectron &  gsfElectron, const std::map< reco::GsfElectronCoreRef, unsigned int > &  gsfElectronCoreMap, const edm::OrphanHandle< reco::GsfElectronCoreCollection > &  outGsfElectronCoreHandle  )

private

Definition at line 1041 of file ReducedEGProducer.cc.

References reco::GsfElectron::core(), and reco::GsfElectron::setCore().

Referenced by produce().

{
  const auto &coremapped = gsfElectronCoreMap.find(gsfElectron.core());
  if (coremapped != gsfElectronCoreMap.end()) {
    //make new ref
    reco::GsfElectronCoreRef coreref(outgsfElectronCoreHandle,coremapped->second);
    gsfElectron.setCore(coreref);
  }
}

void ReducedEGProducer::relinkGsfTrack ( reco::GsfElectronCore &  electroncore, const std::map< reco::GsfTrackRef, unsigned int > &  gsfTrackMap, const edm::OrphanHandle< reco::GsfTrackCollection > &  outGsfTrackHandle  )

private

Definition at line 995 of file ReducedEGProducer.cc.

References reco::GsfElectronCore::gsfTrack(), and reco::GsfElectronCore::setGsfTrack().

Referenced by produce().

{
  const auto &gsftkmapped = gsfTrackMap.find(gsfElectronCore.gsfTrack());
  if (gsftkmapped != gsfTrackMap.end()) {
    reco::GsfTrackRef gsftkref(outGsfTrackHandle, gsftkmapped->second);
    gsfElectronCore.setGsfTrack(gsftkref);
  }
}   

void ReducedEGProducer::relinkPhotonCore ( reco::Photon &  photon, const std::map< reco::PhotonCoreRef, unsigned int > &  photonCoreMap, const edm::OrphanHandle< reco::PhotonCoreCollection > &  outPhotonCoreHandle  )

private

Definition at line 1029 of file ReducedEGProducer.cc.

References reco::Photon::photonCore(), and reco::Photon::setPhotonCore().

Referenced by produce().

{
  const auto &coremapped = photonCoreMap.find(photon.photonCore());
  if (coremapped != photonCoreMap.end()) {
    //make new ref
    reco::PhotonCoreRef coreref(outPhotonCoreHandle,coremapped->second);
    photon.setPhotonCore(coreref);
  }
}

template<typename T >

void ReducedEGProducer::relinkSuperCluster ( T &  core, const std::map< reco::SuperClusterRef, unsigned int > &  superClusterMap, const edm::OrphanHandle< reco::SuperClusterCollection > &  outSuperClusterHandle  )

private

Definition at line 983 of file ReducedEGProducer.cc.

Referenced by produce().

{
  const auto &scmapped = superClusterMap.find(core.superCluster());
  if (scmapped != superClusterMap.end()) {
    //make new ref
    reco::SuperClusterRef scref(outSuperClusterHandle,scmapped->second);
    core.setSuperCluster(scref);
  }
}   

template<typename T >

void ReducedEGProducer::setToken ( edm::EDGetTokenT< T > &  token, const edm::ParameterSet &  config, const std::string &  name  )

inlineprivate

Definition at line 145 of file ReducedEGProducer.h.

References edm::ParameterSet::getParameter(), and dataset::name.

Referenced by ReducedEGProducer().

                                                                                             {
    token = consumes<T>(config.getParameter<edm::InputTag>(name));
  }

Member Data Documentation

const bool ReducedEGProducer::applyGsfElectronCalibOnData_

private

Definition at line 176 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const bool ReducedEGProducer::applyGsfElectronCalibOnMC_

private

Definition at line 177 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const bool ReducedEGProducer::applyPhotonCalibOnData_

private

Definition at line 174 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const bool ReducedEGProducer::applyPhotonCalibOnMC_

private

Definition at line 175 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const edm::EDGetTokenT<EcalRecHitCollection> ReducedEGProducer::barrelEcalHits_

private

Definition at line 158 of file ReducedEGProducer.h.

Referenced by produce().

const edm::EDGetTokenT<reco::ConversionCollection> ReducedEGProducer::conversionT_

private

Definition at line 155 of file ReducedEGProducer.h.

Referenced by produce().

const bool ReducedEGProducer::doPreshowerEcalHits_

private

Definition at line 160 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const edm::EDGetTokenT<EcalRecHitCollection> ReducedEGProducer::endcapEcalHits_

private

Definition at line 159 of file ReducedEGProducer.h.

Referenced by produce().

edm::EDGetTokenT<edm::ValueMap<float> > ReducedEGProducer::gsfElectronCalibEcalEnergyErrT_

private

Definition at line 183 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

edm::EDGetTokenT<edm::ValueMap<float> > ReducedEGProducer::gsfElectronCalibEcalEnergyT_

private

Definition at line 182 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

edm::EDGetTokenT<edm::ValueMap<float> > ReducedEGProducer::gsfElectronCalibEnergyErrT_

private

Definition at line 181 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

edm::EDGetTokenT<edm::ValueMap<float> > ReducedEGProducer::gsfElectronCalibEnergyT_

private

Definition at line 180 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > ReducedEGProducer::gsfElectronFloatValueMapTs_

private

Definition at line 172 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > ReducedEGProducer::gsfElectronIdTs_

private

Definition at line 168 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef> > > ReducedEGProducer::gsfElectronPfCandMapT_

private

Definition at line 165 of file ReducedEGProducer.h.

Referenced by produce().

const edm::EDGetTokenT<reco::GsfElectronCollection> ReducedEGProducer::gsfElectronT_

private

Definition at line 153 of file ReducedEGProducer.h.

Referenced by produce().

const edm::EDGetTokenT<reco::GsfTrackCollection> ReducedEGProducer::gsfTrackT_

private

Definition at line 154 of file ReducedEGProducer.h.

Referenced by produce().

const edm::EDGetTokenT<HBHERecHitCollection> ReducedEGProducer::hbheHits_

private

Definition at line 162 of file ReducedEGProducer.h.

Referenced by produce().

EGHcalRecHitSelector ReducedEGProducer::hcalHitSel_

private

Definition at line 223 of file ReducedEGProducer.h.

Referenced by beginRun(), and linkHcalHits().

const StringCutObjectSelector<reco::GsfElectron> ReducedEGProducer::keepGsfElectronSel_

private

Definition at line 219 of file ReducedEGProducer.h.

Referenced by produce().

const StringCutObjectSelector<reco::Photon> ReducedEGProducer::keepOOTPhotonSel_

private

Definition at line 216 of file ReducedEGProducer.h.

Referenced by produce().

const StringCutObjectSelector<reco::Photon> ReducedEGProducer::keepPhotonSel_

private

Definition at line 213 of file ReducedEGProducer.h.

Referenced by produce().

std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > ReducedEGProducer::ootPhotonFloatValueMapTs_

private

Definition at line 171 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

edm::EDGetTokenT<reco::PhotonCollection> ReducedEGProducer::ootPhotonT_

private

Definition at line 152 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outConversions_

private

Definition at line 193 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outEBEEClusters_

private

Definition at line 196 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outEBRecHits_

private

Definition at line 201 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outEERecHits_

private

Definition at line 202 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outESClusters_

private

Definition at line 197 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outESRecHits_

private

Definition at line 203 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outGsfElectronCores_

private

Definition at line 191 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::vector<std::string> ReducedEGProducer::outGsfElectronFloatValueMaps_

private

Definition at line 211 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::vector<std::string> ReducedEGProducer::outGsfElectronIds_

private

Definition at line 208 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outGsfElectronPfCandMap_

private

Definition at line 206 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outGsfElectrons_

private

Definition at line 190 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outGsfTracks_

private

Definition at line 192 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outHBHERecHits_

private

Definition at line 204 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outOOTEBEEClusters_

private

Definition at line 199 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outOOTESClusters_

private

Definition at line 200 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outOOTPhotonCores_

private

Definition at line 189 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::vector<std::string> ReducedEGProducer::outOOTPhotonFloatValueMaps_

private

Definition at line 210 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outOOTPhotons_

private

Definition at line 188 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outOOTSuperClusters_

private

Definition at line 198 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outPhotonCores_

private

Definition at line 187 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::vector<std::string> ReducedEGProducer::outPhotonFloatValueMaps_

private

Definition at line 209 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::vector<std::string> ReducedEGProducer::outPhotonIds_

private

Definition at line 207 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outPhotonPfCandMap_

private

Definition at line 205 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outPhotons_

private

Definition at line 186 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outSingleConversions_

private

Definition at line 194 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const std::string ReducedEGProducer::outSuperClusters_

private

Definition at line 195 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

edm::EDGetTokenT<edm::ValueMap<float> > ReducedEGProducer::photonCalibEnergyErrT_

private

Definition at line 179 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

edm::EDGetTokenT<edm::ValueMap<float> > ReducedEGProducer::photonCalibEnergyT_

private

Definition at line 178 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > ReducedEGProducer::photonFloatValueMapTs_

private

Definition at line 170 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

std::vector<edm::EDGetTokenT<edm::ValueMap<bool> > > ReducedEGProducer::photonIdTs_

private

Definition at line 167 of file ReducedEGProducer.h.

Referenced by produce(), and ReducedEGProducer().

const edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef> > > ReducedEGProducer::photonPfCandMapT_

private

Definition at line 164 of file ReducedEGProducer.h.

Referenced by produce().

const edm::EDGetTokenT<reco::PhotonCollection> ReducedEGProducer::photonT_

private

Definition at line 151 of file ReducedEGProducer.h.

Referenced by produce().

const edm::EDGetTokenT<EcalRecHitCollection> ReducedEGProducer::preshowerEcalHits_

private

Definition at line 161 of file ReducedEGProducer.h.

Referenced by produce().

const StringCutObjectSelector<reco::GsfElectron> ReducedEGProducer::relinkGsfElectronSel_

private

Definition at line 221 of file ReducedEGProducer.h.

Referenced by produce().

const StringCutObjectSelector<reco::Photon> ReducedEGProducer::relinkOOTPhotonSel_

private

Definition at line 218 of file ReducedEGProducer.h.

Referenced by produce().

const StringCutObjectSelector<reco::Photon> ReducedEGProducer::relinkPhotonSel_

private

Definition at line 215 of file ReducedEGProducer.h.

Referenced by produce().

const edm::EDGetTokenT<reco::ConversionCollection> ReducedEGProducer::singleConversionT_

private

Definition at line 156 of file ReducedEGProducer.h.

Referenced by produce().

const StringCutObjectSelector<reco::GsfElectron> ReducedEGProducer::slimRelinkGsfElectronSel_

private

Definition at line 220 of file ReducedEGProducer.h.

Referenced by produce().

const StringCutObjectSelector<reco::Photon> ReducedEGProducer::slimRelinkOOTPhotonSel_

private

Definition at line 217 of file ReducedEGProducer.h.

Referenced by produce().

const StringCutObjectSelector<reco::Photon> ReducedEGProducer::slimRelinkPhotonSel_

private

Definition at line 214 of file ReducedEGProducer.h.

Referenced by produce().