GoodSeedProducer.h

Go to the documentation of this file.

#ifndef RecoParticleFlow_PFTracking_GoodSeedProducer_H
#define RecoParticleFlow_PFTracking_GoodSeedProducer_H
// system include files
#include <memory>

// user include files

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PreIdFwd.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "TMVA/Reader.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h"
#include "TrackingTools/PatternTools/interface/Trajectory.h"
#include "RecoParticleFlow/PFTracking/interface/PFGeometry.h"

#include "CondFormats/EgammaObjects/interface/GBRForest.h"

#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h"


//namespace reco {
class PFResolutionMap;
// }

class PFTrackTransformer;
class TrajectoryFitter;
class TrajectorySmoother;
class TrackerGeometry;
class TrajectoryStateOnSurface;



namespace goodseedhelpers {
  class HeavyObjectCache {
    constexpr static unsigned int kMaxWeights = 9;
  public:
    HeavyObjectCache(const edm::ParameterSet& conf);
    std::array<std::unique_ptr<const GBRForest>,kMaxWeights> gbr;    
  private:
    // for temporary variable binding while reading
    float eP,eta,pt,nhit,dpt,chired,chiRatio;
    float chikfred,trk_ecalDeta,trk_ecalDphi;    
  };
}

class GoodSeedProducer final : public edm::stream::EDProducer<edm::GlobalCache<goodseedhelpers::HeavyObjectCache> > {
  typedef TrajectoryStateOnSurface TSOS;
 public:
  explicit GoodSeedProducer(const edm::ParameterSet&, const goodseedhelpers::HeavyObjectCache*);
  
  static std::unique_ptr<goodseedhelpers::HeavyObjectCache> 
    initializeGlobalCache( const edm::ParameterSet& conf ) {
       return std::unique_ptr<goodseedhelpers::HeavyObjectCache>(new goodseedhelpers::HeavyObjectCache(conf));
   }
  
  static void globalEndJob(goodseedhelpers::HeavyObjectCache const* ) {
  }

   private:
      virtual void beginRun(const edm::Run & run,const edm::EventSetup&) override;
      virtual void produce(edm::Event&, const edm::EventSetup&) override;
 
      int getBin(float,float);

      void fillPreIdRefValueMap( edm::Handle<reco::TrackCollection> tkhandle,
                 const edm::OrphanHandle<reco::PreIdCollection>&,
                 edm::ValueMap<reco::PreIdRef>::Filler & filler);
      // ----------member data ---------------------------

      std::string preidckf_;

      std::string preidgsf_;

      std::string preidname_;

      std::unique_ptr<TrajectoryFitter> fitter_;

      std::unique_ptr<TrajectorySmoother> smoother_;

      // needed by the above
      TkClonerImpl hitCloner;

      std::unique_ptr<PFTrackTransformer> pfTransformer_;

      int nHitsInSeed_;

      double minPt_;
      double maxPt_;
      double maxEta_;
      
      double HcalIsolWindow_;
      double EcalStripSumE_minClusEnergy_;
      double EcalStripSumE_deltaEta_;
      double EcalStripSumE_deltaPhiOverQ_minValue_;
      double EcalStripSumE_deltaPhiOverQ_maxValue_;
      double minEoverP_;
      double maxHoverP_;

      double clusThreshold_;

      double minEp_;
      double maxEp_;

      bool produceCkfseed_;

      bool disablePreId_;

      bool producePreId_;
      
      double PtThresholdSavePredId_;

      float thr[150];

      // ----------access to event data
      edm::ParameterSet conf_;
      edm::EDGetTokenT<reco::PFClusterCollection> pfCLusTagPSLabel_;
      edm::EDGetTokenT<reco::PFClusterCollection> pfCLusTagECLabel_;
      edm::EDGetTokenT<reco::PFClusterCollection> pfCLusTagHCLabel_;
      std::vector<edm::EDGetTokenT<std::vector<Trajectory> > > trajContainers_;
      std::vector<edm::EDGetTokenT<reco::TrackCollection > > tracksContainers_;
      
      std::string fitterName_;
      std::string smootherName_;
      std::string propagatorName_;
      std::string trackerRecHitBuilderName_;

      std::unique_ptr<PFResolutionMap> resMapEtaECAL_;
      std::unique_ptr<PFResolutionMap> resMapPhiECAL_;

      bool useQuality_;
      reco::TrackBase::TrackQuality trackQuality_;
      
      float eP,eta,pt,nhit,dpt,chired,chiRatio;
      float chikfred,trk_ecalDeta,trk_ecalDphi;                      
      double Min_dr_;

      bool useTmva_;

      std::string method_;

      math::XYZVector B_;

      std::map<reco::TrackRef,unsigned> refMap_;

      PFGeometry pfGeometry_;
};
#endif