RectangularEtaPhiTrackingRegion.h

Go to the documentation of this file.

#ifndef RectangularEtaPhiTrackingRegion_H
#define RectangularEtaPhiTrackingRegion_H

#include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h"
#include "RecoTracker/TkTrackingRegions/interface/TkTrackingRegionsMargin.h"
//#include "CommonDet/TrajectoryParametrization/interface/GlobalTrajectoryParameters.h"
#include "RecoTracker/TkTrackingRegions/interface/HitRZConstraint.h"
#include "FWCore/Framework/interface/EventSetup.h"
class OuterHitPhiPrediction;
class OuterEstimator;
class BarrelDetLayer;
class ForwardDetLayer;

class RectangularEtaPhiTrackingRegion GCC11_FINAL : public TrackingRegion {
public:

  typedef TkTrackingRegionsMargin<float> Margin;

  RectangularEtaPhiTrackingRegion( const GlobalVector & dir, 
                   const GlobalPoint & vertexPos,
                                   float ptMin, float rVertex, float zVertex,
                                   float deltaEta, float deltaPhi,
                                   float whereToUseMeasurementTracker = 0.,
                                   bool precise = true,
                                   const std::string & measurementTrackerName = "",
                   bool etaPhiRegion=false) 
    : TrackingRegionBase( dir, vertexPos, Range( -1/ptMin, 1/ptMin), rVertex, zVertex),
    thePhiMargin(std::abs(deltaPhi),std::abs(deltaPhi)),
    theMeasurementTrackerUsage(whereToUseMeasurementTracker), thePrecise(precise),
    theUseEtaPhi(etaPhiRegion), theMeasurementTrackerName(measurementTrackerName)
  { initEtaRange(dir, Margin( std::abs(deltaEta),std::abs(deltaEta))); }
 
  RectangularEtaPhiTrackingRegion( const GlobalVector & dir, 
                               const GlobalPoint & vertexPos,
                                   float ptMin, float rVertex, float zVertex,
                                   Margin etaMargin,
                                   Margin phiMargin,
                                   float whereToUseMeasurementTracker = 0.,
                   bool precise = true, 
                                   const std::string & measurementTrackerName = "",
                   bool etaPhiRegion=false) 
    : TrackingRegionBase( dir, vertexPos, Range( -1/ptMin, 1/ptMin), rVertex, zVertex), 
    thePhiMargin( phiMargin), theMeasurementTrackerUsage(whereToUseMeasurementTracker), 
    thePrecise(precise),theUseEtaPhi(etaPhiRegion),
    theMeasurementTrackerName(measurementTrackerName)
    { initEtaRange(dir, etaMargin); }

  RectangularEtaPhiTrackingRegion( const GlobalVector & dir, 
                               const GlobalPoint & vertexPos,
                                   Range invPtRange, 
                                   float rVertex, float zVertex,
                                   Margin etaMargin,
                                   Margin phiMargin,
                                   float whereToUseMeasurementTracker = 0.,
                                   bool precise = true,
                                   const std::string & measurementTrackerName = "",
                   bool etaPhiRegion=false) 
    : TrackingRegionBase( dir, vertexPos, invPtRange, rVertex, zVertex),
    thePhiMargin( phiMargin), theMeasurementTrackerUsage(whereToUseMeasurementTracker), thePrecise(precise),theUseEtaPhi(etaPhiRegion),
    theMeasurementTrackerName(measurementTrackerName)
    { initEtaRange(dir, etaMargin); }


  const Range & etaRange() const { return theEtaRange; }

  const Margin & phiMargin() const { return thePhiMargin; }

  bool  isPrecise() const { return thePrecise; }

  virtual TrackingRegion::Hits hits(
      const edm::Event& ev,  
      const edm::EventSetup& es, 
      const ctfseeding::SeedingLayer* layer) const;

  virtual HitRZCompatibility * checkRZ(const DetLayer* layer,  
                       const Hit &  outerHit,
                       const edm::EventSetup& iSetup,
                       const DetLayer* outerlayer=0,
                       float lr=0, float gz=0, float dr=0, float dz=0) const
  { return checkRZOld(layer,outerHit->hit(),iSetup); }

  virtual RectangularEtaPhiTrackingRegion* clone() const { 
    return new RectangularEtaPhiTrackingRegion(*this);
  }

  virtual std::string name() const { return "RectangularEtaPhiTrackingRegion"; }
  virtual std::string print() const;

private:
  HitRZCompatibility* checkRZOld(
      const DetLayer* layer, 
      const TrackingRecHit*  outerHit,
      const edm::EventSetup& iSetup) const;

  OuterEstimator * estimator(const BarrelDetLayer* layer,const edm::EventSetup& iSetup) const dso_internal;
  OuterEstimator * estimator(const ForwardDetLayer* layer,const edm::EventSetup& iSetup) const dso_internal;

  OuterHitPhiPrediction phiWindow(const edm::EventSetup& iSetup) const dso_internal;
  HitRZConstraint rzConstraint() const dso_internal;

  void  initEtaRange( const GlobalVector & dir, const Margin& margin);

private:

  Range theEtaRange;
  Range theLambdaRange;
  Margin thePhiMargin;
  float theMeanLambda;
  float theMeasurementTrackerUsage;
  bool thePrecise;
  bool theUseEtaPhi;
  std::string theMeasurementTrackerName;
};

#endif