PFElecTkProducer.h

Go to the documentation of this file.

#ifndef PFElecTkProducer_H
#define PFElecTkProducer_H
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedVertex.h"
#include "DataFormats/ParticleFlowReco/interface/PFConversion.h"
#include "DataFormats/ParticleFlowReco/interface/PFV0.h"

#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "DataFormats/ParticleFlowReco/interface/GsfPFRecTrackFwd.h"
#include "DataFormats/ParticleFlowReco/interface/GsfPFRecTrack.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecTrack.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
#include "TrackingTools/GsfTools/interface/MultiTrajectoryStateMode.h"
#include "TrackingTools/GsfTools/interface/MultiTrajectoryStateTransform.h"
#include "DataFormats/EgammaReco/interface/ElectronSeed.h"
#include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedVertexFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFConversionFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFV0Fwd.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedTrackerVertex.h"

#include "RecoParticleFlow/PFTracking/interface/ConvBremHeavyObjectCache.h"

class PFTrackTransformer;
class GsfTrack;
class MagneticField;
class TrackerGeometry;
class ConvBremPFTrackFinder;


#include <unordered_map>


class PFElecTkProducer final : public edm::stream::EDProducer<edm::GlobalCache<convbremhelpers::HeavyObjectCache> > {
 public:
  
  explicit PFElecTkProducer(const edm::ParameterSet&, const convbremhelpers::HeavyObjectCache*);


  static std::unique_ptr<convbremhelpers::HeavyObjectCache> 
    initializeGlobalCache( const edm::ParameterSet& conf ) {
       return std::unique_ptr<convbremhelpers::HeavyObjectCache>(new convbremhelpers::HeavyObjectCache(conf));
   }
  
  static void globalEndJob(convbremhelpers::HeavyObjectCache const* ) {
  }

     ~PFElecTkProducer() override;

   private:
      void beginRun(const edm::Run&,const edm::EventSetup&) override;
      void endRun(const edm::Run&,const edm::EventSetup&) override;

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

    
      int FindPfRef(const reco::PFRecTrackCollection & PfRTkColl, 
            const reco::GsfTrack&, bool);
      


      bool applySelection(const reco::GsfTrack&);
      
      bool resolveGsfTracks(const std::vector<reco::GsfPFRecTrack> &GsfPFVec,
                unsigned int ngsf,
                std::vector<unsigned int> &secondaries,
                const reco::PFClusterCollection & theEClus);

      float minTangDist(const reco::GsfPFRecTrack& primGsf,
            const reco::GsfPFRecTrack& secGsf); 
      
      bool isSameEgSC(const reco::ElectronSeed& nSeed,
              const reco::ElectronSeed& iSeed,
              bool& bothGsfEcalDriven,
              float& SCEnergy);

      bool isSharingEcalEnergyWithEgSC(const reco::GsfPFRecTrack& nGsfPFRecTrack,
                       const reco::GsfPFRecTrack& iGsfPFRecTrack,
                       const reco::ElectronSeed& nSeed,
                       const reco::ElectronSeed& iSeed,
                       const reco::PFClusterCollection& theEClus,
                       bool& bothGsfTrackerDriven,
                       bool& nEcalDriven,
                       bool& iEcalDriven,
                       float& nEnergy,
                       float& iEnergy);
      
      bool isInnerMost(const reco::GsfTrackRef& nGsfTrack,
               const reco::GsfTrackRef& iGsfTrack,
               bool& sameLayer);
      
      bool isInnerMostWithLostHits(const reco::GsfTrackRef& nGsfTrack,
                   const reco::GsfTrackRef& iGsfTrack,
                   bool& sameLayer);
      
      void createGsfPFRecTrackRef(const edm::OrphanHandle<reco::GsfPFRecTrackCollection>& gsfPfHandle,
                  std::vector<reco::GsfPFRecTrack>& gsfPFRecTrackPrimary,
                  const std::map<unsigned int, std::vector<reco::GsfPFRecTrack> >& MapPrimSec);
    
      // ----------member data ---------------------------
      reco::GsfPFRecTrack pftrack_;
      reco::GsfPFRecTrack secpftrack_;
      edm::ParameterSet conf_;
      edm::EDGetTokenT<reco::GsfTrackCollection> gsfTrackLabel_;
      edm::EDGetTokenT<reco::PFRecTrackCollection> pfTrackLabel_;
      edm::EDGetTokenT<reco::VertexCollection> primVtxLabel_;
      edm::EDGetTokenT<reco::PFClusterCollection> pfEcalClusters_;
      edm::EDGetTokenT<reco::PFDisplacedTrackerVertexCollection>  pfNuclear_;
      edm::EDGetTokenT<reco::PFConversionCollection> pfConv_;
      edm::EDGetTokenT<reco::PFV0Collection>  pfV0_;
      bool useNuclear_;
      bool useConversions_;
      bool useV0_;
      bool applyAngularGsfClean_;
      double detaCutGsfClean_;
      double dphiCutGsfClean_;

      std::unique_ptr<PFTrackTransformer> pfTransformer_;     
      MultiTrajectoryStateTransform  mtsTransform_;
      std::unique_ptr<ConvBremPFTrackFinder> convBremFinder_;


      bool trajinev_;
      bool modemomentum_;
      bool applySel_;
      bool applyGsfClean_;
      bool useFifthStepForEcalDriven_;
      bool useFifthStepForTrackDriven_;
      //   bool useFifthStepSec_;
      bool debugGsfCleaning_;
      double SCEne_;
      double detaGsfSC_;
      double dphiGsfSC_;
      double maxPtConvReco_;
      
      bool useConvBremFinder_;

      double mvaConvBremFinderIDBarrelLowPt_;
      double mvaConvBremFinderIDBarrelHighPt_;
      double mvaConvBremFinderIDEndcapsLowPt_;
      double mvaConvBremFinderIDEndcapsHighPt_;
      std::string path_mvaWeightFileConvBremBarrelLowPt_;
      std::string path_mvaWeightFileConvBremBarrelHighPt_;
      std::string path_mvaWeightFileConvBremEndcapsLowPt_;
      std::string path_mvaWeightFileConvBremEndcapsHighPt_;
  
      // cache for multitrajectory states
      std::vector<double> gsfInnerMomentumCache_;

};
#endif