CosmicTrackingRegion.h

Go to the documentation of this file.

#ifndef CosmicTrackingRegion_H
#define CosmicTrackingRegion_H

#include "RecoTracker/TkTrackingRegions/interface/TrackingRegionBase.h"
#include "RecoTracker/TkTrackingRegions/interface/HitRZConstraint.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "RecoTracker/TkSeedingLayers/interface/SeedingLayer.h"
#include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

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

#include <vector>

using SeedingHit = BaseTrackerRecHit const *;

class CosmicTrackingRegion : public TrackingRegionBase {
public:


  virtual ~CosmicTrackingRegion() { }

  CosmicTrackingRegion( const GlobalVector & dir, 
            const GlobalPoint & vertexPos,
            float ptMin, float rVertex, float zVertex,
            float deltaEta, float deltaPhi,
            float dummy = 0.,
                        const MeasurementTrackerEvent * measurementTracker = nullptr)
    : TrackingRegionBase( dir, vertexPos, Range( -1/ptMin, 1/ptMin), 
              rVertex, zVertex),
      theMeasurementTracker_(measurementTracker),
      measurementTrackerName_("")
  { }
  
  CosmicTrackingRegion(const GlobalVector & dir,
               const GlobalPoint & vertexPos,
               float ptMin, float rVertex, float zVertex,
               float deltaEta, float deltaPhi,
               const edm::ParameterSet & extra,
                       const MeasurementTrackerEvent * measurementTracker = nullptr)
    : TrackingRegionBase( dir, vertexPos, Range( -1/ptMin, 1/ptMin),
              rVertex, zVertex),
      theMeasurementTracker_(measurementTracker)
      {
    measurementTrackerName_ = extra.getParameter<std::string>("measurementTrackerName");
      }

  CosmicTrackingRegion(CosmicTrackingRegion const & rh) : 
  TrackingRegionBase(rh),
      theMeasurementTracker_(rh.theMeasurementTracker_),
      measurementTrackerName_(rh.measurementTrackerName_){}
  
  virtual TrackingRegion::ctfHits 
  hits(
       const edm::EventSetup& es, 
       const ctfseeding::SeedingLayer* layer) const;
  
   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=0,
      float lr=0, float gz=0, float dr=0, float dz=0) const override {return 0; }
   
   CosmicTrackingRegion * clone() const override {     return new CosmicTrackingRegion(*this);  }
   
   std::string name() const override { return "CosmicTrackingRegion"; }

private:
  template <typename T>
  void hits_(
      const edm::EventSetup& es,
      const T& layer, TrackingRegion::Hits & result) const;



  const MeasurementTrackerEvent *theMeasurementTracker_;
  std::string measurementTrackerName_;

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

  // not a solution!  here just to try to get this thing working....
  // in any case onDemand is NOT thread safe yet
  // actually this solution is absolutely safe. It lays in the effimeral nature of the region itself
  mutable cacheHits cache;



};

#endif