Merge pull request #34439 from SohamBhattacharya/clean_FromMultiCl_12…

…_0_0_pre3

Clean/rename FromMultiCl HGCal egamma collections

DQMOffline/EGamma/python/egammaDQMOffline_cff.py

@@ -13,13 +13,14 @@
 photonAnalysis.standAlone = cms.bool(False)
 
 
-stdPhotonAnalysis = DQMOffline.EGamma.photonAnalyzer_cfi.photonAnalysis.clone()
-stdPhotonAnalysis.ComponentName = cms.string('stdPhotonAnalysis')
-stdPhotonAnalysis.analyzerName = cms.string('stdPhotonAnalyzer')
-stdPhotonAnalysis.phoProducer = cms.InputTag('photons')
-stdPhotonAnalysis.OutputMEsInRootFile = cms.bool(False)
-stdPhotonAnalysis.Verbosity = cms.untracked.int32(0)
-stdPhotonAnalysis.standAlone = cms.bool(False)
+stdPhotonAnalysis = DQMOffline.EGamma.photonAnalyzer_cfi.photonAnalysis.clone(
+  ComponentName = cms.string('stdPhotonAnalysis'),
+  analyzerName = cms.string('stdPhotonAnalyzer'),
+  phoProducer = cms.InputTag('photons'),
+  OutputMEsInRootFile = cms.bool(False),
+  Verbosity = cms.untracked.int32(0),
+  standAlone = cms.bool(False),
+)
 
 piZeroAnalysis.OutputMEsInRootFile = cms.bool(False)
 piZeroAnalysis.Verbosity = cms.untracked.int32(0)
@@ -33,14 +34,15 @@
 
 # HGCal customizations
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
-stdPhotonAnalysisHGCal = stdPhotonAnalysis.clone()
-stdPhotonAnalysisHGCal.ComponentName = 'stdPhotonAnalyzerHGCalFromMultiCl'
-stdPhotonAnalysisHGCal.analyzerName = 'stdPhotonAnalyzerHGCalFromMultiCl'
-stdPhotonAnalysisHGCal.phoProducer = 'photonsFromMultiCl'
-stdPhotonAnalysisHGCal.isolationStrength = 2
-stdPhotonAnalysisHGCal.etaMin = -3.0
-stdPhotonAnalysisHGCal.etaMax = 3.0
-stdPhotonAnalysisHGCal.maxPhoEta = 3.0
+stdPhotonAnalysisHGCal = stdPhotonAnalysis.clone(
+  ComponentName = 'stdPhotonAnalyzerHGCal',
+  analyzerName = 'stdPhotonAnalyzerHGCal',
+  phoProducer = 'photonsHGC',
+  isolationStrength = 2,
+  etaMin = -3.0,
+  etaMax = 3.0,
+  maxPhoEta = 3.0,
+)
 
 egammaDQMOffline = cms.Sequence(photonAnalysis*stdPhotonAnalysis*zmumugammaOldAnalysis*zmumugammaAnalysis*piZeroAnalysis*electronAnalyzerSequence)
 _egammaDQMOfflineHGCal = egammaDQMOffline.copy()

DQMOffline/EGamma/python/electronAnalyzerSequence_cff.py

@@ -48,28 +48,28 @@
  * dqmElectronTagProbeAnalysis
 )
 
-mergedSuperClustersFromMultiCl = mergedSuperClusters.clone()
-mergedSuperClustersFromMultiCl.src = cms.VInputTag(
+mergedSuperClustersHGC = mergedSuperClusters.clone()
+mergedSuperClustersHGC.src = cms.VInputTag(
    cms.InputTag("particleFlowSuperClusterECAL","particleFlowSuperClusterECALBarrel"),
-   cms.InputTag("particleFlowSuperClusterHGCalFromMultiCl","")
+   cms.InputTag("particleFlowSuperClusterHGCal","")
  )
-dqmElectronAnalysisAllElectronsFromMultiCl = dqmElectronAnalysisAllElectrons.clone()
-dqmElectronAnalysisAllElectronsFromMultiCl.OutputFolderName = 'Egamma/Electrons/Ele2FromMultiCl_All'
-dqmElectronAnalysisAllElectronsFromMultiCl.MaxAbsEtaMatchingObject = 3.0
-dqmElectronAnalysisAllElectronsFromMultiCl.EtaMax = 3.0
-dqmElectronAnalysisAllElectronsFromMultiCl.EtaMin = -3.0
-dqmElectronAnalysisAllElectronsFromMultiCl.MaxAbsEta = 3.0
-dqmElectronAnalysisAllElectronsFromMultiCl.ElectronCollection = 'ecalDrivenGsfElectronsFromMultiCl'
-dqmElectronAnalysisAllElectronsFromMultiCl.MatchingObjectCollection = 'mergedSuperClustersFromMultiCl'
-
-_electronAnalyzerSequenceFromMultiCl = electronAnalyzerSequence.copy()
-_electronAnalyzerSequenceFromMultiCl += cms.Sequence(mergedSuperClustersFromMultiCl+dqmElectronAnalysisAllElectronsFromMultiCl)
+dqmElectronAnalysisAllElectronsHGC = dqmElectronAnalysisAllElectrons.clone()
+dqmElectronAnalysisAllElectronsHGC.OutputFolderName = 'Egamma/Electrons/Ele2HGC_All'
+dqmElectronAnalysisAllElectronsHGC.MaxAbsEtaMatchingObject = 3.0
+dqmElectronAnalysisAllElectronsHGC.EtaMax = 3.0
+dqmElectronAnalysisAllElectronsHGC.EtaMin = -3.0
+dqmElectronAnalysisAllElectronsHGC.MaxAbsEta = 3.0
+dqmElectronAnalysisAllElectronsHGC.ElectronCollection = 'ecalDrivenGsfElectronsHGC'
+dqmElectronAnalysisAllElectronsHGC.MatchingObjectCollection = 'mergedSuperClustersHGC'
+
+_electronAnalyzerSequenceHGC = electronAnalyzerSequence.copy()
+_electronAnalyzerSequenceHGC += cms.Sequence(mergedSuperClustersHGC+dqmElectronAnalysisAllElectronsHGC)
 
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
 phase2_hgcal.toModify( mergedSuperClusters, src = cms.VInputTag( cms.InputTag("particleFlowSuperClusterECAL","particleFlowSuperClusterECALBarrel"), cms.InputTag("particleFlowSuperClusterHGCal","") ) )
 
 phase2_hgcal.toReplaceWith(
-electronAnalyzerSequence, _electronAnalyzerSequenceFromMultiCl
+electronAnalyzerSequence, _electronAnalyzerSequenceHGC
 )
 
 

DQMOffline/EGamma/python/electronOfflineClientSequence_cff.py

@@ -6,9 +6,9 @@
 dqmElectronClientAllElectrons.InputFolderName = cms.string("Egamma/Electrons/Ele2_All") ;
 dqmElectronClientAllElectrons.OutputFolderName = cms.string("Egamma/Electrons/Ele2_All") ;
 
-dqmElectronClientAllElectronsFromMultiCl = dqmElectronOfflineClient.clone() ;
-dqmElectronClientAllElectronsFromMultiCl.InputFolderName = cms.string("Egamma/Electrons/Ele2FromMultiCl_All") ;
-dqmElectronClientAllElectronsFromMultiCl.OutputFolderName = cms.string("Egamma/Electrons/Ele2FromMultiCl_All") ;
+dqmElectronClientAllElectronsHGC = dqmElectronOfflineClient.clone() ;
+dqmElectronClientAllElectronsHGC.InputFolderName = cms.string("Egamma/Electrons/Ele2HGC_All") ;
+dqmElectronClientAllElectronsHGC.OutputFolderName = cms.string("Egamma/Electrons/Ele2HGC_All") ;
 
 dqmElectronClientSelectionEt = dqmElectronOfflineClient.clone() ;
 dqmElectronClientSelectionEt.InputFolderName = cms.string("Egamma/Electrons/Ele3_Et10") ;
@@ -34,11 +34,11 @@
 # * dqmElectronClientSelectionEtIsoElID
  * dqmElectronClientTagAndProbe
 )
-_electronOfflineClientSequenceFromMultiCl = electronOfflineClientSequence.copy()
-_electronOfflineClientSequenceFromMultiCl += dqmElectronClientAllElectronsFromMultiCl
+_electronOfflineClientSequenceHGC = electronOfflineClientSequence.copy()
+_electronOfflineClientSequenceHGC += dqmElectronClientAllElectronsHGC
 
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
 phase2_hgcal.toReplaceWith(
-  electronOfflineClientSequence, _electronOfflineClientSequenceFromMultiCl
+  electronOfflineClientSequence, _electronOfflineClientSequenceHGC
 )
 

DQMOffline/EGamma/python/photonOfflineDQMClient_cff.py

@@ -10,7 +10,7 @@
 
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
 stdPhotonOfflineClientHGCal = stdPhotonOfflineClient.clone()
-stdPhotonOfflineClientHGCal.analyzerName = 'stdPhotonAnalyzerHGCalFromMultiCl'
+stdPhotonOfflineClientHGCal.analyzerName = 'stdPhotonAnalyzerHGCal'
 from DQMOffline.EGamma.egammaDQMOffline_cff import stdPhotonAnalysisHGCal
 stdPhotonOfflineClientHGCal.etaBin = stdPhotonAnalysisHGCal.etaBin
 stdPhotonOfflineClientHGCal.etaMin = stdPhotonAnalysisHGCal.etaMin

PhysicsTools/PatAlgos/python/slimming/MicroEventContent_cff.py

@@ -186,7 +186,7 @@
 cms.untracked.PSet(branch = cms.untracked.string("EcalRecHitsSorted_reducedEgamma_reducedESRecHits_*"),splitLevel=cms.untracked.int32(99)),
 ])
 
-_phase2_hgc_extraCommands = ["keep *_slimmedElectronsFromMultiCl_*_*", "keep *_slimmedPhotonsFromMultiCl_*_*"]
+_phase2_hgc_extraCommands = ["keep *_slimmedElectronsHGC_*_*", "keep *_slimmedPhotonsHGC_*_*"]
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
 phase2_hgcal.toModify(MicroEventContentMC, outputCommands = MicroEventContentMC.outputCommands + _phase2_hgc_extraCommands)
 

PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py

@@ -534,8 +534,8 @@ def _add_deepMET(process):
     # EGamma objects from HGCal are not yet in GED
     # so add companion collections for Phase-II MiniAOD production
     from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
-    process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff")
-    phase2_hgcal.toModify(task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask))
+    process.load("RecoEgamma.EgammaTools.slimmedEgammaHGC_cff")
+    phase2_hgcal.toModify(task, func=lambda t: t.add(process.slimmedEgammaHGCTask))
 
     # L1 pre-firing weights for 2016, 2017, and 2018
     from Configuration.Eras.Modifier_run2_L1prefiring_cff import run2_L1prefiring

RecoEcal/Configuration/python/RecoEcal_EventContent_cff.py

@@ -26,9 +26,7 @@
         'keep recoCaloClusters_particleFlowSuperClusterOOTECAL_*_*')
 )
 _phase2_hgcal_scCommandsAOD = ['keep recoSuperClusters_particleFlowSuperClusterHGCal__*',
-                               'keep recoCaloClusters_particleFlowSuperClusterHGCal__*',
-                               'keep recoSuperClusters_particleFlowSuperClusterHGCalFromMultiCl__*',
-                               'keep recoCaloClusters_particleFlowSuperClusterHGCalFromMultiCl__*']
+                               'keep recoCaloClusters_particleFlowSuperClusterHGCal__*']
 
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
 phase2_hgcal.toModify(RecoEcalAOD,
@@ -65,8 +63,7 @@
         'drop recoSuperClusters_multi5x5SuperClusters_multi5x5BarrelSuperClusters_*')
 )
 RecoEcalRECO.outputCommands.extend(RecoEcalAOD.outputCommands)
-_phase2_hgcal_scCommands = ['keep *_particleFlowSuperClusterHGCal_*_*',
-                            'keep *_particleFlowSuperClusterHGCalFromMultiCl_*_*']
+_phase2_hgcal_scCommands = ['keep *_particleFlowSuperClusterHGCal_*_*']
 phase2_hgcal.toModify(RecoEcalRECO,
     outputCommands = RecoEcalRECO.outputCommands + _phase2_hgcal_scCommands)
 

RecoEcal/EgammaClusterProducers/python/particleFlowSuperClusteringSequence_cff.py

@@ -16,7 +16,7 @@
 phase2_hgcal.toModify(
     particleFlowSuperClusterHGCal,
     PFClusters                     = 'particleFlowClusterHGCal',
-    useRegression                  = False, #no HGCal regression yet
+    useRegression                  = True,
     use_preshower                  = False,
     PFBasicClusterCollectionEndcap = "",
     PFSuperClusterCollectionEndcap = "",
@@ -25,13 +25,7 @@
     dropUnseedable                 = True,
 )
 
-particleFlowSuperClusterHGCalFromMultiCl = particleFlowSuperClusterHGCal.clone()
-phase2_hgcal.toModify(
-    particleFlowSuperClusterHGCalFromMultiCl,
-    PFClusters = 'particleFlowClusterHGCalFromMultiCl',
-    useRegression  = True,
-)
-phase2_hgcal.toModify( particleFlowSuperClusterHGCalFromMultiCl.regressionConfig,
+phase2_hgcal.toModify( particleFlowSuperClusterHGCal.regressionConfig,
     regressionKeyEE = "superclus_hgcal_mean_offline",
     uncertaintyKeyEE = "superclus_hgcal_sigma_offline",
     isPhaseII = True,
@@ -40,7 +34,6 @@
 )
 _phase2_hgcal_particleFlowSuperClusteringTask = particleFlowSuperClusteringTask.copy()
 _phase2_hgcal_particleFlowSuperClusteringTask.add(particleFlowSuperClusterHGCal)
-_phase2_hgcal_particleFlowSuperClusteringTask.add(particleFlowSuperClusterHGCalFromMultiCl)
 
 phase2_hgcal.toReplaceWith( particleFlowSuperClusteringTask, _phase2_hgcal_particleFlowSuperClusteringTask )
 

RecoEgamma/Configuration/python/RecoEgamma_EventContent_cff.py

@@ -52,10 +52,10 @@
 # mods for HGCAL
 _phase2_hgcal_RecoEgamma_tokeep = [ 'keep *_ecalDrivenGsfElectronCores_*_*',
                                     'keep *_ecalDrivenGsfElectrons_*_*',
-                                    'keep *_ecalDrivenGsfElectronCoresFromMultiCl_*_*',
-                                    'keep *_ecalDrivenGsfElectronsFromMultiCl_*_*',
-                                    'keep *_photonCoreFromMultiCl_*_*',
-                                    'keep *_photonsFromMultiCl_*_*']
+                                    'keep *_ecalDrivenGsfElectronCoresHGC_*_*',
+                                    'keep *_ecalDrivenGsfElectronsHGC_*_*',
+                                    'keep *_photonCoreHGC_*_*',
+                                    'keep *_photonsHGC_*_*']
 
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
 phase2_hgcal.toModify( RecoEgammaAOD,  

RecoEgamma/EgammaElectronProducers/plugins/GsfElectronCoreEcalDrivenProducer.cc

@@ -21,6 +21,7 @@ class GsfElectronCoreEcalDrivenProducer : public edm::global::EDProducer<> {
 
 private:
   const bool useGsfPfRecTracks_;
+  const bool hgcalOnly_;
 
   const edm::EDGetTokenT<reco::GsfPFRecTrackCollection> gsfPfRecTracksToken_;
   const edm::EDGetTokenT<reco::GsfTrackCollection> gsfTracksToken_;
@@ -41,11 +42,13 @@ void GsfElectronCoreEcalDrivenProducer::fillDescriptions(edm::ConfigurationDescr
   desc.add<edm::InputTag>("gsfTracks", {"electronGsfTracks"});
   desc.add<edm::InputTag>("ctfTracks", {"generalTracks"});
   desc.add<bool>("useGsfPfRecTracks", true);
+  desc.add<bool>("hgcalOnly", false);
   descriptions.add("ecalDrivenGsfElectronCores", desc);
 }
 
 GsfElectronCoreEcalDrivenProducer::GsfElectronCoreEcalDrivenProducer(const edm::ParameterSet& config)
     : useGsfPfRecTracks_(config.getParameter<bool>("useGsfPfRecTracks")),
+      hgcalOnly_(config.getParameter<bool>("hgcalOnly")),
       gsfPfRecTracksToken_(mayConsume<GsfPFRecTrackCollection>(config.getParameter<edm::InputTag>("gsfPfRecTracks"))),
       gsfTracksToken_(consumes<reco::GsfTrackCollection>(config.getParameter<edm::InputTag>("gsfTracks"))),
       ctfTracksToken_(consumes<reco::TrackCollection>(config.getParameter<edm::InputTag>("ctfTracks"))),
@@ -74,7 +77,11 @@ void GsfElectronCoreEcalDrivenProducer::produce(edm::StreamID, edm::Event& event
 
     auto scRef = gsfTrackRef->extra()->seedRef().castTo<ElectronSeedRef>()->caloCluster().castTo<SuperClusterRef>();
     if (!scRef.isNull()) {
-      eleCore.setSuperCluster(scRef);
+      // if hgcalOnly flag is true but this seed is not from HGCAL, skip it.
+      if (hgcalOnly_ && !scRef->seed()->caloID().detector(reco::CaloID::DET_HGCAL_ENDCAP))
+        electrons.pop_back();
+      else
+        eleCore.setSuperCluster(scRef);
     } else {
       electrons.pop_back();
       edm::LogWarning("GsfElectronCoreEcalDrivenProducer") << "Seed CaloCluster is not a SuperCluster, unexpected...";

RecoEgamma/EgammaElectronProducers/python/ecalDrivenElectronSeeds_cff.py

@@ -25,6 +25,3 @@
                            LowPtThreshold =1.0,
                            applyHOverECut = False) 
 
-# create ecal driven seeds for electron using HGCal Multiclusters
-ecalDrivenElectronSeedsFromMultiCl = ecalDrivenElectronSeeds.clone(
-  endcapSuperClusters = 'particleFlowSuperClusterHGCalFromMultiCl')

RecoEgamma/EgammaElectronProducers/python/ecalDrivenGsfElectronCoresHGC_cff.py

@@ -0,0 +1,7 @@
+from RecoEgamma.EgammaElectronProducers.ecalDrivenGsfElectronCores_cfi import ecalDrivenGsfElectronCores
+
+ecalDrivenGsfElectronCoresHGC = ecalDrivenGsfElectronCores.clone(
+  gsfTracks = 'electronGsfTracks',
+  useGsfPfRecTracks = False,
+  hgcalOnly = True,
+)

RecoEgamma/EgammaElectronProducers/python/gsfElectronSequence_cff.py

@@ -7,16 +7,16 @@
 #==============================================================================
 
 from RecoEgamma.EgammaElectronProducers.ecalDrivenGsfElectronCores_cfi import ecalDrivenGsfElectronCores
-from RecoEgamma.EgammaElectronProducers.ecalDrivenGsfElectronCoresFromMultiCl_cff import ecalDrivenGsfElectronCoresFromMultiCl
+from RecoEgamma.EgammaElectronProducers.ecalDrivenGsfElectronCoresHGC_cff import ecalDrivenGsfElectronCoresHGC
 from RecoEgamma.EgammaElectronProducers.gsfElectrons_cfi import *
 
 gsfEcalDrivenElectronTask = cms.Task(ecalDrivenGsfElectronCores,ecalDrivenGsfElectrons)
 gsfEcalDrivenElectronSequence = cms.Sequence(gsfEcalDrivenElectronTask)
 
-_gsfEcalDrivenElectronTaskFromMultiCl = gsfEcalDrivenElectronTask.copy()
-_gsfEcalDrivenElectronTaskFromMultiCl.add(cms.Task(ecalDrivenGsfElectronCoresFromMultiCl,ecalDrivenGsfElectronsFromMultiCl))
+_gsfEcalDrivenElectronTaskHGC = gsfEcalDrivenElectronTask.copy()
+_gsfEcalDrivenElectronTaskHGC.add(cms.Task(ecalDrivenGsfElectronCoresHGC,ecalDrivenGsfElectronsHGC))
 
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
 phase2_hgcal.toReplaceWith(
-  gsfEcalDrivenElectronTask, _gsfEcalDrivenElectronTaskFromMultiCl
+  gsfEcalDrivenElectronTask, _gsfEcalDrivenElectronTaskHGC
 )

RecoEgamma/EgammaElectronProducers/python/gsfElectrons_cfi.py

@@ -28,8 +28,8 @@
 pp_on_AA.toModify(ecalDrivenGsfElectrons.preselection, minSCEtBarrel = 15.0)
 pp_on_AA.toModify(ecalDrivenGsfElectrons.preselection, minSCEtEndcaps = 15.0)
 
-ecalDrivenGsfElectronsFromMultiCl = ecalDrivenGsfElectrons.clone(
-    gsfElectronCoresTag = "ecalDrivenGsfElectronCoresFromMultiCl",
+ecalDrivenGsfElectronsHGC = ecalDrivenGsfElectrons.clone(
+    gsfElectronCoresTag = "ecalDrivenGsfElectronCoresHGC",
     useGsfPfRecTracks = False,
     useDefaultEnergyCorrection = False,
     ambClustersOverlapStrategy = 0,

RecoEgamma/EgammaElectronProducers/python/uncleanedOnlyElectronSequence_cff.py

@@ -135,7 +135,7 @@
 #
 
 from RecoEgamma.EgammaElectronProducers.ecalDrivenGsfElectronCores_cfi import ecalDrivenGsfElectronCores
-from RecoEgamma.EgammaElectronProducers.ecalDrivenGsfElectronCoresFromMultiCl_cff import ecalDrivenGsfElectronCoresFromMultiCl
+from RecoEgamma.EgammaElectronProducers.ecalDrivenGsfElectronCoresHGC_cff import ecalDrivenGsfElectronCoresHGC
 uncleanedOnlyGsfElectronCores = ecalDrivenGsfElectronCores.clone(
     gsfTracks      = "uncleanedOnlyElectronGsfTracks",
     gsfPfRecTracks = "uncleanedOnlyPfTrackElec"

RecoEgamma/EgammaPhotonProducers/python/photonCore_cfi.py

@@ -13,12 +13,15 @@
     pixelSeedProducer = cms.InputTag('electronMergedSeeds'),
     minSCEt = cms.double(10.0),
     risolveConversionAmbiguity = cms.bool(True),
+    endcapOnly = cms.bool(False),
 #    MVA_weights_location = cms.string('RecoEgamma/EgammaTools/data/TMVAnalysis_Likelihood.weights.txt')
 )
 
-photonCoreFromMultiCl = photonCore.clone(
-    scIslandEndcapProducer = 'particleFlowSuperClusterHGCalFromMultiCl',
-    pixelSeedProducer = 'electronMergedSeedsFromMultiCl'
+photonCoreHGC = photonCore.clone(
+    scHybridBarrelProducer = "",
+    scIslandEndcapProducer = 'particleFlowSuperClusterHGCal',
+    pixelSeedProducer = 'electronMergedSeeds',
+    endcapOnly = True,
 )
 
 islandPhotonCore = photonCore.clone(

RecoEgamma/EgammaPhotonProducers/python/photonSequence_cff.py

@@ -10,15 +10,15 @@
 photonTask = cms.Task(photonCore,photons)
 photonSequence = cms.Sequence(photonTask)
 
-_photonTaskFromMultiCl = photonTask.copy()
-_photonTaskFromMultiCl.add(photonCoreFromMultiCl,photonsFromMultiCl)
+_photonTaskHGC = photonTask.copy()
+_photonTaskHGC.add(photonCoreHGC,photonsHGC)
 _photonTaskWithIsland = photonTask.copy()
 _photonTaskWithIsland.add(islandPhotonCore,islandPhotons)
 
 
 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
 phase2_hgcal.toReplaceWith(
- photonTask, _photonTaskFromMultiCl
+ photonTask, _photonTaskHGC
 )
 
 from Configuration.Eras.Modifier_pA_2016_cff import pA_2016

RecoEgamma/EgammaPhotonProducers/python/photons_cfi.py

@@ -88,8 +88,8 @@
     checkHcalStatus = cms.bool(True)
 )
 
-photonsFromMultiCl = photons.clone(
-  photonProducer = 'photonCoreFromMultiCl'
+photonsHGC = photons.clone(
+  photonProducer = 'photonCoreHGC'
 )
 
 islandPhotons = cms.EDProducer("PhotonProducer",

RecoEgamma/EgammaPhotonProducers/src/PhotonCoreProducer.cc

@@ -55,6 +55,7 @@ class PhotonCoreProducer : public edm::stream::EDProducer<> {
   edm::ParameterSet conf_;
   bool validPixelSeeds_;
   bool risolveAmbiguity_;
+  bool endcapOnly_;
 };
 
 #include "FWCore/Framework/interface/MakerMacros.h"
@@ -74,6 +75,7 @@ PhotonCoreProducer::PhotonCoreProducer(const edm::ParameterSet& config)
   pixelSeedProducer_ = consumes<reco::ElectronSeedCollection>(conf_.getParameter<edm::InputTag>("pixelSeedProducer"));
   minSCEt_ = conf_.getParameter<double>("minSCEt");
   risolveAmbiguity_ = conf_.getParameter<bool>("risolveConversionAmbiguity");
+  endcapOnly_ = conf_.getParameter<bool>("endcapOnly");
 
   // Register the product
   produces<reco::PhotonCoreCollection>(PhotonCoreCollection_);
@@ -90,9 +92,13 @@ void PhotonCoreProducer::produce(edm::Event& theEvent, const edm::EventSetup& th
 
   // Get the  Barrel Super Cluster collection
   bool validBarrelSCHandle = true;
+  if (endcapOnly_) {
+    validBarrelSCHandle = false;
+  }
+
   Handle<reco::SuperClusterCollection> scBarrelHandle;
   theEvent.getByToken(scHybridBarrelProducer_, scBarrelHandle);
-  if (!scBarrelHandle.isValid()) {
+  if (!endcapOnly_ && !scBarrelHandle.isValid()) {
     edm::LogError("PhotonCoreProducer") << "Error! Can't get the scHybridBarrelProducer";
     validBarrelSCHandle = false;
   }