L3MumuTrackingRegion.h

Go to the documentation of this file.

#ifndef HLTrigger_btau_L3MumuTrackingRegion_H
#define HLTrigger_btau_L3MumuTrackingRegion_H
 
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
 
#include "RecoTracker/TkTrackingRegions/interface/TrackingRegionProducer.h"
#include "RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h"
#include "RecoTracker/TkTrackingRegions/interface/RectangularEtaPhiTrackingRegion.h"
#include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
 
class L3MumuTrackingRegion : public TrackingRegionProducer {
public:
  L3MumuTrackingRegion(const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC) {
    edm::ParameterSet regionPSet = cfg.getParameter<edm::ParameterSet>("RegionPSet");
 
    theVertexTag = regionPSet.getParameter<edm::InputTag>("vertexSrc");
    theVertex = (theVertexTag.label().length() > 1);
    theInputTrkTag = regionPSet.getParameter<edm::InputTag>("TrkSrc");
    useVtxTks = regionPSet.getParameter<bool>("UseVtxTks");
 
    if (theVertex)
      theVertexToken = iC.consumes<reco::VertexCollection>(theVertexTag);
    if (!(theVertex && useVtxTks))
      theInputTrkToken = iC.consumes<reco::TrackCollection>(theInputTrkTag);
 
    thePtMin = regionPSet.getParameter<double>("ptMin");
    theOriginRadius = regionPSet.getParameter<double>("originRadius");
    theOriginHalfLength = regionPSet.getParameter<double>("originHalfLength");
    theOriginZPos = regionPSet.getParameter<double>("vertexZDefault");
 
    theDeltaEta = regionPSet.getParameter<double>("deltaEtaRegion");
    theDeltaPhi = regionPSet.getParameter<double>("deltaPhiRegion");
    if (regionPSet.exists("searchOpt")) {
      m_searchOpt = regionPSet.getParameter<bool>("searchOpt");
    } else {
      m_searchOpt = false;
    }
    m_howToUseMeasurementTracker = RectangularEtaPhiTrackingRegion::stringToUseMeasurementTracker(
        regionPSet.getParameter<std::string>("howToUseMeasurementTracker"));
    if (m_howToUseMeasurementTracker != RectangularEtaPhiTrackingRegion::UseMeasurementTracker::kNever) {
      theMeasurementTrackerToken =
          iC.consumes<MeasurementTrackerEvent>(regionPSet.getParameter<edm::InputTag>("measurementTrackerName"));
    }
  }
 
  ~L3MumuTrackingRegion() override {}
 
  std::vector<std::unique_ptr<TrackingRegion> > regions(const edm::Event& ev,
                                                        const edm::EventSetup& es) const override {
    std::vector<std::unique_ptr<TrackingRegion> > result;
 
    const MeasurementTrackerEvent* measurementTracker = nullptr;
    if (!theMeasurementTrackerToken.isUninitialized()) {
      edm::Handle<MeasurementTrackerEvent> hmte;
      ev.getByToken(theMeasurementTrackerToken, hmte);
      measurementTracker = hmte.product();
    }
 
    // optional constraint for vertex
    // get highest Pt pixel vertex (if existing)
    double deltaZVertex = theOriginHalfLength;
    double originz = theOriginZPos;
    if (theVertex) {
      edm::Handle<reco::VertexCollection> vertices;
      ev.getByToken(theVertexToken, vertices);
      const reco::VertexCollection vertCollection = *(vertices.product());
      reco::VertexCollection::const_iterator ci = vertCollection.begin();
      if (!vertCollection.empty()) {
        originz = ci->z();
      } else {
        originz = theOriginZPos;
        deltaZVertex = 15.;
      }
      if (useVtxTks) {
        for (ci = vertCollection.begin(); ci != vertCollection.end(); ci++)
          for (reco::Vertex::trackRef_iterator trackIt = ci->tracks_begin(); trackIt != ci->tracks_end(); trackIt++) {
            reco::TrackRef iTrk = (*trackIt).castTo<reco::TrackRef>();
            GlobalVector dirVector((iTrk)->px(), (iTrk)->py(), (iTrk)->pz());
            result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(dirVector,
                                                                               GlobalPoint(0, 0, float(ci->z())),
                                                                               thePtMin,
                                                                               theOriginRadius,
                                                                               deltaZVertex,
                                                                               theDeltaEta,
                                                                               theDeltaPhi,
                                                                               m_howToUseMeasurementTracker,
                                                                               true,
                                                                               measurementTracker,
                                                                               m_searchOpt));
          }
        return result;
      }
    }
 
    edm::Handle<reco::TrackCollection> trks;
    if (!theInputTrkToken.isUninitialized())
      ev.getByToken(theInputTrkToken, trks);
    for (reco::TrackCollection::const_iterator iTrk = trks->begin(); iTrk != trks->end(); iTrk++) {
      GlobalVector dirVector((iTrk)->px(), (iTrk)->py(), (iTrk)->pz());
      result.push_back(std::make_unique<RectangularEtaPhiTrackingRegion>(dirVector,
                                                                         GlobalPoint(0, 0, float(originz)),
                                                                         thePtMin,
                                                                         theOriginRadius,
                                                                         deltaZVertex,
                                                                         theDeltaEta,
                                                                         theDeltaPhi,
                                                                         m_howToUseMeasurementTracker,
                                                                         true,
                                                                         measurementTracker,
                                                                         m_searchOpt));
    }
    return result;
  }
 
private:
  edm::InputTag theVertexTag;
  bool theVertex;
  edm::EDGetTokenT<reco::VertexCollection> theVertexToken;
  edm::InputTag theInputTrkTag;
  edm::EDGetTokenT<reco::TrackCollection> theInputTrkToken;
 
  bool useVtxTks;
 
  double thePtMin;
  double theOriginRadius;
  double theOriginHalfLength;
  double theOriginZPos;
 
  double theDeltaEta;
  double theDeltaPhi;
  edm::EDGetTokenT<MeasurementTrackerEvent> theMeasurementTrackerToken;
  RectangularEtaPhiTrackingRegion::UseMeasurementTracker m_howToUseMeasurementTracker;
  bool m_searchOpt;
};
 
#endif