PFECALSuperClusterAlgo.h

Go to the documentation of this file.

#ifndef RecoEcal_EgammaClusterAlgos_PFECALSuperClusterAlgo_h
#define RecoEcal_EgammaClusterAlgos_PFECALSuperClusterAlgo_h
 
#include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFLayer.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
 
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/EgammaReco/interface/BasicClusterFwd.h"
 
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
 
#include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibration.h"
 
#include "RecoEcal/EgammaClusterAlgos/interface/SCEnergyCorrectorSemiParm.h"
 
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/EventSetup.h"
 
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/Utilities/interface/ESGetToken.h"
 
#include "CondFormats/ESObjects/interface/ESChannelStatus.h"
#include "CondFormats/DataRecord/interface/ESEEIntercalibConstantsRcd.h"
#include "CondFormats/DataRecord/interface/ESChannelStatusRcd.h"
#include "CondFormats/ESObjects/interface/ESEEIntercalibConstants.h"
 
#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h"
#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h"
#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h"
#include "CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h"
 
#include <vector>
#include <memory>
 
 
class PFECALSuperClusterAlgo {
public:
  enum clustering_type { kBOX = 1, kMustache = 2 };
  enum energy_weight { kRaw, kCalibratedNoPS, kCalibratedTotal };
 
  // simple class for associating calibrated energies
  class CalibratedPFCluster {
  public:
    CalibratedPFCluster(const edm::Ptr<reco::PFCluster>& p) : cluptr(p) {}
 
    double energy() const { return cluptr->correctedEnergy(); }
    double energy_nocalib() const { return cluptr->energy(); }
    double eta() const { return cluptr->positionREP().eta(); }
    double phi() const { return cluptr->positionREP().phi(); }
 
    edm::Ptr<reco::PFCluster> the_ptr() const { return cluptr; }
 
  private:
    edm::Ptr<reco::PFCluster> cluptr;
  };
  typedef std::shared_ptr<CalibratedPFCluster> CalibratedClusterPtr;
  typedef std::vector<CalibratedClusterPtr> CalibratedClusterPtrVector;
 
  PFECALSuperClusterAlgo();
 
  void setVerbosityLevel(bool verbose) { verbose_ = verbose; }
 
  void setClusteringType(clustering_type thetype) { _clustype = thetype; }
 
  void setEnergyWeighting(energy_weight thetype) { _eweight = thetype; }
 
  void setUseETForSeeding(bool useET) { threshIsET_ = useET; }
 
  void setUseDynamicDPhi(bool useit) { useDynamicDPhi_ = useit; }
 
  void setUseRegression(bool useRegression) { useRegression_ = useRegression; }
 
  void setThreshSuperClusterEt(double thresh) { threshSuperClusterEt_ = thresh; }
 
  void setThreshPFClusterSeedBarrel(double thresh) { threshPFClusterSeedBarrel_ = thresh; }
  void setThreshPFClusterBarrel(double thresh) { threshPFClusterBarrel_ = thresh; }
  void setThreshPFClusterSeedEndcap(double thresh) { threshPFClusterSeedEndcap_ = thresh; }
  void setThreshPFClusterEndcap(double thresh) { threshPFClusterEndcap_ = thresh; }
 
  void setPhiwidthSuperClusterBarrel(double phiwidth) { phiwidthSuperClusterBarrel_ = phiwidth; }
  void setEtawidthSuperClusterBarrel(double etawidth) { etawidthSuperClusterBarrel_ = etawidth; }
  void setPhiwidthSuperClusterEndcap(double phiwidth) { phiwidthSuperClusterEndcap_ = phiwidth; }
  void setEtawidthSuperClusterEndcap(double etawidth) { etawidthSuperClusterEndcap_ = etawidth; }
 
  void setPFClusterCalibration(const std::shared_ptr<PFEnergyCalibration>&);
 
  void setSatelliteMerging(const bool doit) { doSatelliteClusterMerge_ = doit; }
  void setSatelliteThreshold(const double t) { satelliteThreshold_ = t; }
  void setMajorityFraction(const double f) { fractionForMajority_ = f; }
  void setDropUnseedable(const bool d) { dropUnseedable_ = d; }
 
  void setIsOOTCollection(bool isOOTCollection) { isOOTCollection_ = isOOTCollection; }
 
  void setCrackCorrections(bool applyCrackCorrections) { applyCrackCorrections_ = applyCrackCorrections; }
 
  void setTokens(const edm::ParameterSet&, edm::ConsumesCollector&&);
  void update(const edm::EventSetup&);
  void updateSCParams(const edm::EventSetup&);
 
  std::unique_ptr<reco::SuperClusterCollection>& getEBOutputSCCollection() { return superClustersEB_; }
  std::unique_ptr<reco::SuperClusterCollection>& getEEOutputSCCollection() { return superClustersEE_; }
 
  void loadAndSortPFClusters(const edm::Event& evt);
 
  void run();
 
private:
  edm::EDGetTokenT<edm::View<reco::PFCluster> > inputTagPFClusters_;
  edm::EDGetTokenT<reco::PFCluster::EEtoPSAssociation> inputTagPFClustersES_;
  edm::EDGetTokenT<reco::BeamSpot> inputTagBeamSpot_;
 
  edm::ESGetToken<ESEEIntercalibConstants, ESEEIntercalibConstantsRcd> esEEInterCalibToken_;
  edm::ESGetToken<ESChannelStatus, ESChannelStatusRcd> esChannelStatusToken_;
  edm::ESGetToken<EcalMustacheSCParameters, EcalMustacheSCParametersRcd> ecalMustacheSCParametersToken_;
  edm::ESGetToken<EcalSCDynamicDPhiParameters, EcalSCDynamicDPhiParametersRcd> ecalSCDynamicDPhiParametersToken_;
 
  const reco::BeamSpot* beamSpot_;
  const ESChannelStatus* channelStatus_;
  const EcalMustacheSCParameters* mustacheSCParams_;
  const EcalSCDynamicDPhiParameters* scDynamicDPhiParams_;
 
  CalibratedClusterPtrVector _clustersEB;
  CalibratedClusterPtrVector _clustersEE;
  std::unique_ptr<reco::SuperClusterCollection> superClustersEB_;
  std::unique_ptr<reco::SuperClusterCollection> superClustersEE_;
  const reco::PFCluster::EEtoPSAssociation* EEtoPS_;
  std::shared_ptr<PFEnergyCalibration> _pfEnergyCalibration;
  clustering_type _clustype;
  energy_weight _eweight;
  void buildAllSuperClusters(CalibratedClusterPtrVector&, double seedthresh);
  void buildSuperCluster(CalibratedClusterPtr&, CalibratedClusterPtrVector&);
 
  bool verbose_;
 
  // regression
  bool useRegression_;
  std::unique_ptr<SCEnergyCorrectorSemiParm> regr_;
 
  double threshSuperClusterEt_;
 
  double threshPFClusterSeedBarrel_;
  double threshPFClusterBarrel_;
  double threshPFClusterSeedEndcap_;
  double threshPFClusterEndcap_;
 
  double phiwidthSuperClusterBarrel_;
  double etawidthSuperClusterBarrel_;
  double phiwidthSuperClusterEndcap_;
  double etawidthSuperClusterEndcap_;
 
  bool doSatelliteClusterMerge_;  //rock it
  double satelliteThreshold_, fractionForMajority_;
  bool dropUnseedable_;
 
  bool useDynamicDPhi_;
 
  bool applyCrackCorrections_;
  bool threshIsET_;
 
  // OOT photons
  bool isOOTCollection_;
  edm::EDGetTokenT<EcalRecHitCollection> inputTagBarrelRecHits_;
  edm::EDGetTokenT<EcalRecHitCollection> inputTagEndcapRecHits_;
  const EcalRecHitCollection* barrelRecHits_;
  const EcalRecHitCollection* endcapRecHits_;
};
 
#endif