/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/RecoTracker/TkTrackingRegions/interface/TrackingRegion.h

Go to the documentation of this file.

#ifndef TrackingRegion_H
#define TrackingRegion_H

#include "DataFormats/GeometryVector/interface/GlobalVector.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"

#include "RecoTracker/TkMSParametrization/interface/PixelRecoRange.h"
#include "TrackingTools/DetLayers/interface/DetLayer.h"
#include "RecoTracker/TkTrackingRegions/interface/HitRZCompatibility.h"
#include "RecoTracker/TkTrackingRegions/interface/HitEtaCheck.h"
#include "RecoTracker/TkTrackingRegions/interface/HitRCheck.h"
#include "RecoTracker/TkTrackingRegions/interface/HitZCheck.h"


#include "FWCore/Framework/interface/EventSetup.h"
#include "RecoTracker/TkSeedingLayers/interface/SeedingLayer.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"

#include <utility>

#include <sstream>

#include <vector>
#include <string>

#include "FWCore/Utilities/interface/GCC11Compatibility.h"

class DetLayer;
class HitRZCompatibility;
class BarrelDetLayer;
class ForwardDetLayer;

namespace edm { class Event;  }

class TrackingRegion {
public:

public:
  virtual ~TrackingRegion(){}
  typedef PixelRecoRange<float> Range;
  typedef TransientTrackingRecHit::ConstRecHitPointer Hit;
  typedef std::vector<Hit> Hits;


public:

  TrackingRegion( const GlobalVector & direction,
                  const GlobalPoint &  originPos,
                  const Range        & invPtRange,
                  const float &        originRBound,
                  const float &        originZBound)
    : theDirection( direction), theVertexPos( originPos), 
      theInvPtRange( invPtRange),
      thePtMin(1.f/std::max( std::abs(invPtRange.max()), std::abs(invPtRange.min()) )),
      theVertexRBound( originRBound),
      theVertexZBound( originZBound) { }    


  GlobalVector const & direction() const { return theDirection; } 

  GlobalPoint  const & origin() const { return theVertexPos; }

  float originRBound() const { return theVertexRBound; }

  float originZBound() const { return theVertexZBound; }

  float ptMin()  const { return thePtMin;}

  Range invPtRange() const { return theInvPtRange; }


  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 = 0;


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

  TrackingRegion* restrictedRegion( const GlobalPoint &  originPos,
      const float & originRBound, const float & originZBound) const {
      TrackingRegion* restr = clone();
      restr->theVertexPos = originPos;
      restr->theVertexRBound = originRBound;
      restr->theVertexZBound = originZBound;
      return restr;
  } 

  virtual TrackingRegion* clone() const = 0;

  virtual std::string name() const { return "TrackingRegion"; }
  virtual std::string print() const {
    std::ostringstream str;
    str << name() <<" dir:"<<theDirection<<" vtx:"<<theVertexPos 
        <<" dr:"<<theVertexRBound<<" dz:"<<theVertexZBound<<" pt:"<<1./theInvPtRange.max();
    return str.str();
  }

  void setDirection(const GlobalVector & dir ) { theDirection = dir; }

private:
  
  GlobalVector theDirection;
  GlobalPoint  theVertexPos;
  Range        theInvPtRange;
  float        thePtMin;
  float        theVertexRBound;
  float        theVertexZBound;

};

using TrackingRegionBase = TrackingRegion;

#endif