AreaSeededTrackingRegionsBuilder.h

Go to the documentation of this file.

#ifndef RecoTracker_TkTrackingRegions_AreaSeededTrackingRegionsBuilder_h
#define RecoTracker_TkTrackingRegions_AreaSeededTrackingRegionsBuilder_h
 
#include "RecoTracker/TkTrackingRegions/interface/RectangularEtaPhiTrackingRegion.h"
 
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "FWCore/Utilities/interface/VecArray.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
 
#include "TrackingSeedCandidates.h"
class AreaSeededTrackingRegionsBuilder {
public:
  using Origin = std::pair<GlobalPoint, float>;  // (origin, half-length in z)
  using Origins = std::vector<Origin>;
 
  class Area {
  public:
    Area() {}
 
    // phimin and phimax, and hence xmin+xmax and ymin+ymax are
    // ordered by which way one goes around the unit circle, so it may
    // happen that actually phimax < phimin
    Area(float rmin, float rmax, float phimin, float phimax, float zmin, float zmax) : m_zmin(zmin), m_zmax(zmax) {
      auto cosphimin = std::cos(phimin);
      auto sinphimin = std::sin(phimin);
      auto cosphimax = std::cos(phimax);
      auto sinphimax = std::sin(phimax);
 
      m_x_rmin_phimin = rmin * cosphimin;
      m_x_rmin_phimax = rmin * cosphimax;
      m_x_rmax_phimin = rmax * cosphimin;
      m_x_rmax_phimax = rmax * cosphimax;
 
      m_y_rmin_phimin = rmin * sinphimin;
      m_y_rmin_phimax = rmin * sinphimax;
      m_y_rmax_phimin = rmax * sinphimin;
      m_y_rmax_phimax = rmax * sinphimax;
    }
 
    float x_rmin_phimin() const { return m_x_rmin_phimin; }
    float x_rmin_phimax() const { return m_x_rmin_phimax; }
    float x_rmax_phimin() const { return m_x_rmax_phimin; }
    float x_rmax_phimax() const { return m_x_rmax_phimax; }
    float y_rmin_phimin() const { return m_y_rmin_phimin; }
    float y_rmin_phimax() const { return m_y_rmin_phimax; }
    float y_rmax_phimin() const { return m_y_rmax_phimin; }
    float y_rmax_phimax() const { return m_y_rmax_phimax; }
 
    float zmin() const { return m_zmin; }
    float zmax() const { return m_zmax; }
 
  private:
    // all of these are in global coordinates
    float m_x_rmin_phimin = 0;
    float m_x_rmin_phimax = 0;
    float m_x_rmax_phimin = 0;
    float m_x_rmax_phimax = 0;
 
    float m_y_rmin_phimin = 0;
    float m_y_rmin_phimax = 0;
    float m_y_rmax_phimin = 0;
    float m_y_rmax_phimax = 0;
 
    float m_zmin = 0;
    float m_zmax = 0;
  };
 
  class Builder {
  public:
    explicit Builder(const AreaSeededTrackingRegionsBuilder* conf) : m_conf(conf) {}
    ~Builder() = default;
 
    void setMeasurementTracker(const MeasurementTrackerEvent* mte) { m_measurementTracker = mte; }
    void setCandidates(const TrackingSeedCandidates::Objects cands) { candidates = cands; }
 
    std::vector<std::unique_ptr<TrackingRegion> > regions(const Origins& origins, const std::vector<Area>& areas) const;
    std::unique_ptr<TrackingRegion> region(const Origin& origin, const std::vector<Area>& areas) const;
    std::unique_ptr<TrackingRegion> region(const Origin& origin, const edm::VecArray<Area, 2>& areas) const;
 
  private:
    template <typename T>
    std::unique_ptr<TrackingRegion> regionImpl(const Origin& origin, const T& areas) const;
 
    const AreaSeededTrackingRegionsBuilder* m_conf = nullptr;
    const MeasurementTrackerEvent* m_measurementTracker = nullptr;
    TrackingSeedCandidates::Objects candidates;
  };
 
  AreaSeededTrackingRegionsBuilder(const edm::ParameterSet& regPSet, edm::ConsumesCollector&& iC)
      : AreaSeededTrackingRegionsBuilder(regPSet, iC) {}
  AreaSeededTrackingRegionsBuilder(const edm::ParameterSet& regPSet, edm::ConsumesCollector& iC);
  ~AreaSeededTrackingRegionsBuilder() = default;
 
  static void fillDescriptions(edm::ParameterSetDescription& desc);
 
  Builder beginEvent(const edm::Event& e) const;
 
private:
  std::vector<Area> m_areas;
  TrackingSeedCandidates candidates_;
  float m_extraPhi;
  float m_extraEta;
  float m_ptMin;
  float m_originRadius;
  bool m_precise;
  edm::EDGetTokenT<MeasurementTrackerEvent> token_measurementTracker;
  RectangularEtaPhiTrackingRegion::UseMeasurementTracker m_whereToUseMeasurementTracker;
  bool m_searchOpt;
};
 
#endif