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/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:
  ~CosmicTrackingRegion() override {}
 
  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_) {}
 
  TrackingRegion::Hits hits(const edm::EventSetup& es, const SeedingLayerSetsHits::SeedingLayer& layer) const override;
 
  std::unique_ptr<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 nullptr;
  }
 
  std::unique_ptr<TrackingRegion> clone() const override { return std::make_unique<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