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"


#include "DataFormats/TrackerRecHit2D/interface/BaseTrackerRecHit.h"
#include "DataFormats/TrackingRecHit/interface/mayown_ptr.h"



class OuterHitPhiPrediction;
class BarrelDetLayer;
class ForwardDetLayer;
class MeasurementTrackerEvent;

class RectangularEtaPhiTrackingRegion final : public TrackingRegion {
public:
  enum class UseMeasurementTracker {
    kNever = -1,
    kForSiStrips = 0,
    kAlways = 1
  };

  static UseMeasurementTracker intToUseMeasurementTracker(int value) {
    assert(value >= -1 && value <= 1);
    return static_cast<UseMeasurementTracker>(value);
  }

  static UseMeasurementTracker doubleToUseMeasurementTracker(double value) {
    // mimic the old behaviour
    if(value >  0.5) return UseMeasurementTracker::kAlways;
    if(value > -0.5) return UseMeasurementTracker::kForSiStrips;
    return UseMeasurementTracker::kNever;
  }

  static UseMeasurementTracker stringToUseMeasurementTracker(const std::string& name);

  RectangularEtaPhiTrackingRegion(RectangularEtaPhiTrackingRegion const & rh) :
    TrackingRegion(rh),
    theEtaRange(rh.theEtaRange),
    theLambdaRange(rh.theLambdaRange),
    thePhiMargin(rh.thePhiMargin),
    theMeanLambda(rh.theMeanLambda),
    theMeasurementTrackerUsage(rh.theMeasurementTrackerUsage),
    thePrecise(rh.thePrecise),
    theUseEtaPhi(rh.theUseEtaPhi),
    theMeasurementTracker(rh.theMeasurementTracker) {}
  
  RectangularEtaPhiTrackingRegion& operator=(RectangularEtaPhiTrackingRegion const &)=delete;
  RectangularEtaPhiTrackingRegion(RectangularEtaPhiTrackingRegion &&)=default;
  RectangularEtaPhiTrackingRegion& operator=(RectangularEtaPhiTrackingRegion &&)=default;

  typedef TkTrackingRegionsMargin<float> Margin;

  RectangularEtaPhiTrackingRegion( const GlobalVector & dir, 
                   const GlobalPoint & vertexPos,
                                   float ptMin, float rVertex, float zVertex,
                                   float deltaEta, float deltaPhi,
                                   UseMeasurementTracker whereToUseMeasurementTracker = UseMeasurementTracker::kNever,
                                   bool precise = true,
                                   const MeasurementTrackerEvent *measurementTracker = nullptr,
                   bool etaPhiRegion=false) 
    : RectangularEtaPhiTrackingRegion(dir, vertexPos, Range( -1/ptMin, 1/ptMin), rVertex, zVertex,
                                      Margin(std::abs(deltaEta), std::abs(deltaEta)),
                                      Margin(std::abs(deltaPhi), std::abs(deltaPhi)),
                                      whereToUseMeasurementTracker, precise,
                                      measurementTracker, etaPhiRegion)
    {}
 
  RectangularEtaPhiTrackingRegion( const GlobalVector & dir, 
                               const GlobalPoint & vertexPos,
                                   float ptMin, float rVertex, float zVertex,
                                   Margin etaMargin,
                                   Margin phiMargin,
                                   UseMeasurementTracker whereToUseMeasurementTracker = UseMeasurementTracker::kNever,
                   bool precise = true, 
                                   const MeasurementTrackerEvent *measurementTracker = nullptr,
                   bool etaPhiRegion=false) 
    : RectangularEtaPhiTrackingRegion(dir, vertexPos, Range( -1/ptMin, 1/ptMin), rVertex, zVertex,
                                      etaMargin, phiMargin,
                                      whereToUseMeasurementTracker, precise,
                                      measurementTracker, etaPhiRegion)
    {}

  RectangularEtaPhiTrackingRegion( const GlobalVector & dir, 
                               const GlobalPoint & vertexPos,
                                   Range invPtRange, 
                                   float rVertex, float zVertex,
                                   Margin etaMargin,
                                   Margin phiMargin,
                                   UseMeasurementTracker whereToUseMeasurementTracker = UseMeasurementTracker::kNever,
                                   bool precise = true,
                                   const MeasurementTrackerEvent *measurementTracker = nullptr,
                   bool etaPhiRegion=false, bool useMS=true) 
    : TrackingRegionBase( dir, vertexPos, invPtRange, rVertex, zVertex),
    thePhiMargin( phiMargin), theMeasurementTrackerUsage(whereToUseMeasurementTracker), 
    thePrecise(precise),theUseMS(useMS),theUseEtaPhi(etaPhiRegion),
    theMeasurementTracker(measurementTracker)
    { initEtaRange(dir, etaMargin); }


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

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

  bool  isPrecise() const { return thePrecise; }

  virtual TrackingRegion::Hits hits(
      const edm::EventSetup& es,
      const SeedingLayerSetsHits::SeedingLayer& layer) const override;

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

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

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

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

  std::unique_ptr<MeasurementEstimator> estimator(const BarrelDetLayer* layer,const edm::EventSetup& iSetup) const dso_internal;
  std::unique_ptr<MeasurementEstimator> 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; // this is actually tanLambda
  Margin thePhiMargin;
  float theMeanLambda;
  const UseMeasurementTracker theMeasurementTrackerUsage = UseMeasurementTracker::kNever;
  bool thePrecise=false;
  bool theUseMS=false;
  bool theUseEtaPhi=false;
  const MeasurementTrackerEvent *theMeasurementTracker = nullptr;



  using cacheHitPointer = mayown_ptr<BaseTrackerRecHit>;
  using cacheHits=std::vector<cacheHitPointer>;

  

  /*  wait... think! 
   *  done? questions?  think again, look where this region is constructed
   *  still question? study tracker code for the next couple of weeks, then we may discuss.  
   */
  mutable cacheHits cache;

};

#endif