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;

  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;
  }

  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