LowPtGsfElectronSeedProducer.h

Go to the documentation of this file.

#ifndef RecoEgamma_EgammaElectronProducers_LowPtGsfElectronSeedProducer_h
#define RecoEgamma_EgammaElectronProducers_LowPtGsfElectronSeedProducer_h

#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/RefProd.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/EgammaReco/interface/ElectronSeed.h"
#include "DataFormats/EgammaReco/interface/ElectronSeedFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecTrack.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecTrackFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PreId.h"
#include "DataFormats/ParticleFlowReco/interface/PreIdFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "RecoEcal/EgammaCoreTools/interface/EcalClusterLazyTools.h"
#include "TrackingTools/PatternTools/interface/TrajectorySmoother.h"
#include "TrackingTools/TrackFitters/interface/TrajectoryFitter.h"

#include "LowPtGsfElectronSeedHeavyObjectCache.h"

class LowPtGsfElectronSeedProducer final
    : public edm::stream::EDProducer<edm::GlobalCache<lowptgsfeleseed::HeavyObjectCache> > {
public:
  using TrackIndxMap = std::unordered_map<reco::TrackRef::key_type, size_t>;
  explicit LowPtGsfElectronSeedProducer(const edm::ParameterSet&, const lowptgsfeleseed::HeavyObjectCache*);

  ~LowPtGsfElectronSeedProducer() override;

  static std::unique_ptr<lowptgsfeleseed::HeavyObjectCache> initializeGlobalCache(const edm::ParameterSet& conf) {
    return std::make_unique<lowptgsfeleseed::HeavyObjectCache>(lowptgsfeleseed::HeavyObjectCache(conf));
  }

  static void globalEndJob(lowptgsfeleseed::HeavyObjectCache const*) {}

  void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;

  void produce(edm::Event&, const edm::EventSetup&) override;

  static void fillDescriptions(edm::ConfigurationDescriptions&);

private:  // member functions
  template <typename T>
  void loop(const edm::Handle<std::vector<T> >& handle,
            edm::Handle<reco::PFClusterCollection>& hcalClusters,
            reco::ElectronSeedCollection& seeds,
            reco::PreIdCollection& ecalPreIds,
            reco::PreIdCollection& hcalPreIds,
            TrackIndxMap& trksToPreIdIndx,
            edm::Event&,
            const edm::EventSetup&);

  // Overloaded methods to retrieve reco::TrackRef

  reco::TrackRef getBaseRef(edm::Handle<std::vector<reco::Track> > handle, int idx) const;
  reco::TrackRef getBaseRef(edm::Handle<std::vector<reco::PFRecTrack> > handle, int idx) const;

  // Overloaded methods to populate PreIds (using PF or KF tracks)

  void propagateTrackToCalo(const reco::PFRecTrackRef& pfTrackRef,
                            const edm::Handle<reco::PFClusterCollection>& ecalClusters,
                            const edm::Handle<reco::PFClusterCollection>& hcalClusters,
                            std::vector<int>& matchedEcalClusters,
                            std::vector<int>& matchedHcalClusters,
                            reco::PreId& ecalPreId,
                            reco::PreId& hcalPreId);

  void propagateTrackToCalo(const reco::PFRecTrackRef& pfTrackRef,
                            const edm::Handle<reco::PFClusterCollection>& clusters,
                            std::vector<int>& matchedClusters,
                            reco::PreId& preId,
                            bool ecal);

  void propagateTrackToCalo(const reco::TrackRef& pfTrack,
                            const edm::Handle<reco::PFClusterCollection>& ecalClusters,
                            const edm::Handle<reco::PFClusterCollection>& hcalClusters,
                            std::vector<int>& matchedEcalClusters,
                            std::vector<int>& matchedHcalClusters,
                            reco::PreId& ecalPreId,
                            reco::PreId& hcalPreId);
  template <typename CollType>
  void fillPreIdRefValueMap(edm::Handle<CollType> tracksHandle,
                            const TrackIndxMap& trksToPreIdIndx,
                            const edm::OrphanHandle<reco::PreIdCollection>& preIdHandle,
                            edm::ValueMap<reco::PreIdRef>::Filler& filler);

  // Overloaded methods to evaluate BDTs (using PF or KF tracks)

  bool decision(const reco::PFRecTrackRef& pfTrackRef,
                reco::PreId& ecal,
                reco::PreId& hcal,
                double rho,
                const reco::BeamSpot& spot,
                noZS::EcalClusterLazyTools& ecalTools);

  bool decision(const reco::TrackRef& kfTrackRef,
                reco::PreId& ecal,
                reco::PreId& hcal,
                double rho,
                const reco::BeamSpot& spot,
                noZS::EcalClusterLazyTools& ecalTools);

  // Perform lightweight GSF tracking
  bool lightGsfTracking(reco::PreId&, const reco::TrackRef&, const reco::ElectronSeed&, const edm::EventSetup&);

private:  // member data
  edm::ESHandle<MagneticField> field_;
  std::unique_ptr<TrajectoryFitter> fitterPtr_;
  std::unique_ptr<TrajectorySmoother> smootherPtr_;
  edm::EDGetTokenT<reco::TrackCollection> kfTracks_;
  edm::EDGetTokenT<reco::PFRecTrackCollection> pfTracks_;
  const edm::EDGetTokenT<reco::PFClusterCollection> ecalClusters_;
  edm::EDGetTokenT<reco::PFClusterCollection> hcalClusters_;
  const edm::EDGetTokenT<EcalRecHitCollection> ebRecHits_;
  const edm::EDGetTokenT<EcalRecHitCollection> eeRecHits_;
  const edm::EDGetTokenT<double> rho_;
  const edm::EDGetTokenT<reco::BeamSpot> beamSpot_;
  const std::string fitter_;
  const std::string smoother_;
  const std::string builder_;
  const bool passThrough_;
  const bool usePfTracks_;
  const double minPtThreshold_;
  const double maxPtThreshold_;

  // pow( sinh(1.65), 2. )
  static constexpr double boundary_ = 2.50746495928 * 2.50746495928;
  // pow( ele_mass, 2. )
  static constexpr double mass_ = 0.000511 * 0.000511;
};

#endif  // RecoEgamma_EgammaElectronProducers_LowPtGsfElectronSeedProducer_h