ReducedEGProducer.h

Go to the documentation of this file.

#ifndef RecoEgamma_EgammaPhotonProducers_ReducedEGProducer_h
#define RecoEgamma_EgammaPhotonProducers_ReducedEGProducer_h

#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
#include "Geometry/CaloTopology/interface/CaloTopology.h"
#include "DataFormats/EgammaCandidates/interface/Conversion.h"
#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/EgammaCandidates/interface/Photon.h"
#include "DataFormats/EgammaCandidates/interface/PhotonCore.h"
#include "DataFormats/EgammaReco/interface/BasicClusterShapeAssociation.h"
#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h"
#include "RecoEcal/EgammaCoreTools/interface/PositionCalc.h"
#include "DataFormats/EgammaReco/interface/ElectronSeedFwd.h"
#include "RecoEcal/EgammaCoreTools/interface/EcalClusterTools.h"
#include "RecoEgamma/PhotonIdentification/interface/PFPhotonIsolationCalculator.h"
#include "RecoEgamma/PhotonIdentification/interface/PhotonIsolationCalculator.h"
#include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h"
#include "RecoEgamma/PhotonIdentification/interface/PhotonMIPHaloTagger.h"
#include "RecoEcal/EgammaCoreTools/interface/EcalClusterFunctionFactory.h"
#include "RecoEcal/EgammaCoreTools/interface/EcalClusterFunctionBaseClass.h" 
#include "CondFormats/EcalObjects/interface/EcalFunctionParameters.h" 
#include "RecoEgamma/EgammaPhotonAlgos/interface/PhotonEnergyCorrector.h"

#include "DataFormats/EgammaCandidates/interface/PhotonFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"

#include "CommonTools/UtilAlgos/interface/StringCutObjectSelector.h"


// ReducedEGProducer inherits from EDProducer, so it can be a module:
class ReducedEGProducer : public edm::stream::EDProducer<> {

 public:

  ReducedEGProducer (const edm::ParameterSet& ps);
  ~ReducedEGProducer() override;

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

 private:

  template <typename T, typename U>
  void linkCore(const T& core, U& cores, std::map<T, unsigned int>& coreMap);
    
  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 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);
  
  void linkConversion(const reco::ConversionRef& convref,
              reco::ConversionCollection& conversions, 
              std::map<reco::ConversionRef, unsigned int>& conversionMap);

  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 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);
  
  template <typename T> 
  void relinkSuperCluster(T& core,
              const std::map<reco::SuperClusterRef, unsigned int>& superClusterMap, 
              const edm::OrphanHandle<reco::SuperClusterCollection>& outSuperClusterHandle);

  void relinkGsfTrack(reco::GsfElectronCore& electroncore,
              const std::map<reco::GsfTrackRef, unsigned int>& gsfTrackMap,
              const edm::OrphanHandle<reco::GsfTrackCollection>& outGsfTrackHandle);
  
  void relinkConversions(reco::PhotonCore& photonCore, 
             const reco::ConversionRefVector& convrefs,
             const std::map<reco::ConversionRef, unsigned int>& conversionMap,
             const edm::OrphanHandle<reco::ConversionCollection> &outConversionHandle);

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

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

  static void calibratePhoton(reco::Photon& photon, 
                  const reco::PhotonRef& oldPhoRef,
                  const edm::ValueMap<float>& energyMap,
                  const edm::ValueMap<float>& energyErrMap);
  
  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);


  template <typename T>
  void setToken(edm::EDGetTokenT<T>& token,const edm::ParameterSet& config,const std::string& name){
    token = consumes<T>(config.getParameter<edm::InputTag>(name));
  }


 //tokens for input collections
 const edm::EDGetTokenT<reco::PhotonCollection> photonT_;
 const edm::EDGetTokenT<reco::PhotonCollection> ootPhotonT_;
 const edm::EDGetTokenT<reco::GsfElectronCollection> gsfElectronT_;
 const edm::EDGetTokenT<reco::GsfTrackCollection> gsfTrackT_;
 const edm::EDGetTokenT<reco::ConversionCollection> conversionT_;
 const edm::EDGetTokenT<reco::ConversionCollection> singleConversionT_;
 
 const edm::EDGetTokenT<EcalRecHitCollection> barrelEcalHits_;
 const edm::EDGetTokenT<EcalRecHitCollection> endcapEcalHits_;
 const bool                                   doPreshowerEcalHits_;
 const edm::EDGetTokenT<EcalRecHitCollection> preshowerEcalHits_;
 
 const edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef> > > photonPfCandMapT_;
 const edm::EDGetTokenT<edm::ValueMap<std::vector<reco::PFCandidateRef> > > gsfElectronPfCandMapT_;
 
 std::vector<edm::EDGetTokenT<edm::ValueMap<bool> > > photonIdTs_;
 std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > gsfElectronIdTs_;

 std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > photonFloatValueMapTs_;
 std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > ootPhotonFloatValueMapTs_;
 std::vector<edm::EDGetTokenT<edm::ValueMap<float> > > gsfElectronFloatValueMapTs_;

 const bool applyPhotonCalibOnData_;
 const bool applyPhotonCalibOnMC_;
 const bool applyGsfElectronCalibOnData_;
 const bool applyGsfElectronCalibOnMC_;
 edm::EDGetTokenT<edm::ValueMap<float> > photonCalibEnergyT_;
 edm::EDGetTokenT<edm::ValueMap<float> > photonCalibEnergyErrT_;
 edm::EDGetTokenT<edm::ValueMap<float> > gsfElectronCalibEnergyT_;
 edm::EDGetTokenT<edm::ValueMap<float> > gsfElectronCalibEnergyErrT_;
 edm::EDGetTokenT<edm::ValueMap<float> > gsfElectronCalibEcalEnergyT_;
 edm::EDGetTokenT<edm::ValueMap<float> > gsfElectronCalibEcalEnergyErrT_;

 //names for output collections
 const std::string outPhotons_;
 const std::string outPhotonCores_;
 const std::string outOOTPhotons_;
 const std::string outOOTPhotonCores_;
 const std::string outGsfElectrons_;
 const std::string outGsfElectronCores_;
 const std::string outGsfTracks_;
 const std::string outConversions_;
 const std::string outSingleConversions_;
 const std::string outSuperClusters_;
 const std::string outEBEEClusters_;
 const std::string outESClusters_;
 const std::string outOOTSuperClusters_;
 const std::string outOOTEBEEClusters_;
 const std::string outOOTESClusters_;
 const std::string outEBRecHits_;
 const std::string outEERecHits_;
 const std::string outESRecHits_;
 const std::string outPhotonPfCandMap_;
 const std::string outGsfElectronPfCandMap_;
 const std::vector<std::string> outPhotonIds_;
 const std::vector<std::string> outGsfElectronIds_;
 const std::vector<std::string> outPhotonFloatValueMaps_;
 const std::vector<std::string> outOOTPhotonFloatValueMaps_;
 const std::vector<std::string> outGsfElectronFloatValueMaps_;
  
 const StringCutObjectSelector<reco::Photon> keepPhotonSel_;
 const StringCutObjectSelector<reco::Photon> slimRelinkPhotonSel_; 
 const StringCutObjectSelector<reco::Photon> relinkPhotonSel_;
 const StringCutObjectSelector<reco::Photon> keepOOTPhotonSel_;
 const StringCutObjectSelector<reco::Photon> slimRelinkOOTPhotonSel_; 
 const StringCutObjectSelector<reco::Photon> relinkOOTPhotonSel_;
 const StringCutObjectSelector<reco::GsfElectron> keepGsfElectronSel_;
 const StringCutObjectSelector<reco::GsfElectron> slimRelinkGsfElectronSel_;
 const StringCutObjectSelector<reco::GsfElectron> relinkGsfElectronSel_; 
};
#endif