CosmicTrackingRegion Class Reference

#include <CosmicTrackingRegion.h>

Inheritance diagram for CosmicTrackingRegion:

Public Member Functions
std::unique_ptr< HitRZCompatibility >	checkRZ (const DetLayer *layer, const Hit &outerHit, const DetLayer *outerlayer=nullptr, float lr=0, float gz=0, float dr=0, float dz=0) const override
void	checkTracks (reco::TrackCollection const &tracks, std::vector< bool > &mask) const override
std::unique_ptr< TrackingRegion >	clone () const override
	CosmicTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, float deltaEta, float deltaPhi, const MagneticField &magField, float dummy=0., const MeasurementTrackerEvent *measurementTracker=nullptr)
	CosmicTrackingRegion (const GlobalVector &dir, const GlobalPoint &vertexPos, float ptMin, float rVertex, float zVertex, float deltaEta, float deltaPhi, const MagneticField &magField, const MeasurementTrackerEvent *measurementTracker=nullptr)
	CosmicTrackingRegion (CosmicTrackingRegion const &rh)
TrackingRegion::Hits	hits (const SeedingLayerSetsHits::SeedingLayer &layer) const override
	get hits from layer compatible with region constraints More...
std::string	name () const override
	~CosmicTrackingRegion () override
Public Member Functions inherited from TrackingRegion
std::vector< bool >	checkTracks (reco::TrackCollection const &tracks) const
	return a boolean mask over the TrackCollection reflecting the compatibility of each track with the region constraints More...
GlobalVector const &	direction () const
	the direction around which region is constructed More...
Range	invPtRange () const
	inverse pt range More...
GlobalPoint const &	origin () const
float	originRBound () const
	bounds the particle vertex in the transverse plane More...
float	originZBound () const
	bounds the particle vertex in the longitudinal plane More...
float	phiDirection () const
virtual std::string	print () const
float	ptMin () const
	minimal pt of interest More...
std::unique_ptr< TrackingRegion >	restrictedRegion (const GlobalPoint &originPos, const float &originRBound, const float &originZBound) const
	clone region with new vertex position More...
	TrackingRegion ()
	TrackingRegion (const GlobalVector &direction, const GlobalPoint &originPos, const Range &invPtRange, const float &originRBound, const float &originZBound)
GlobalVector const &	unitDirection () const
virtual	~TrackingRegion ()

Private Types
using	cacheHitPointer = mayown_ptr< BaseTrackerRecHit >
using	cacheHits = std::vector< cacheHitPointer >

Private Member Functions
template<typename T >
void	hits_ (const T &layer, TrackingRegion::Hits &result) const

Private Attributes
cacheHits	cache
const MagneticField *	theMagneticField_
const MeasurementTrackerEvent *	theMeasurementTracker_

Additional Inherited Members
Public Types inherited from TrackingRegion
typedef SeedingLayerSetsHits::ConstRecHitPointer	Hit
typedef SeedingLayerSetsHits::Hits	Hits
typedef PixelRecoRange< float >	Range

Detailed Description

A concrete implementation of TrackingRegion. Apart of vertex constraint from TrackingRegion in this implementation the region of interest is further constrainted in phi and eta around the direction of the region

Definition at line 23 of file CosmicTrackingRegion.h.

Member Typedef Documentation

cacheHitPointer

using CosmicTrackingRegion::cacheHitPointer = mayown_ptr<BaseTrackerRecHit>

private

Definition at line 110 of file CosmicTrackingRegion.h.

cacheHits

using CosmicTrackingRegion::cacheHits = std::vector<cacheHitPointer>

private

Definition at line 111 of file CosmicTrackingRegion.h.

Constructor & Destructor Documentation

~CosmicTrackingRegion()

CosmicTrackingRegion::~CosmicTrackingRegion ( )

inlineoverride

Definition at line 25 of file CosmicTrackingRegion.h.

{}

CosmicTrackingRegion() [1/3]

CosmicTrackingRegion::CosmicTrackingRegion ( const GlobalVector &  dir, const GlobalPoint &  vertexPos, float  ptMin, float  rVertex, float  zVertex, float  deltaEta, float  deltaPhi, const MagneticField &  magField, float  dummy = 0., const MeasurementTrackerEvent *  measurementTracker = nullptr  )

inline

constructor (symmetric eta and phi margins).
dir - the direction around which region is constructed
the initial direction of the momentum of the particle should be in the range
phi of dir +- deltaPhi
eta of dir +- deltaEta

vertexPos - the position of the vertex (origin) of the of the region.
It is a centre of cylinder constraind with rVertex, zVertex. The track of the particle should cross the cylinder
WARNING: in the current implementaion the vertexPos is supposed to be placed on the beam line, i.e. to be of the form (0,0,float)

ptMin - minimal pt of interest
rVertex - radius of the cylinder around beam line where the tracks of interest should point to.
zVertex - half height of the cylinder around the beam line where the tracks of interest should point to.
deltaEta - allowed deviation of the initial direction of particle in eta in respect to direction of the region
deltaPhi - allowed deviation of the initial direction of particle in phi in respect to direction of the region

Definition at line 51 of file CosmicTrackingRegion.h.

      : TrackingRegionBase(dir, vertexPos, Range(-1 / ptMin, 1 / ptMin), rVertex, zVertex),
        theMeasurementTracker_(measurementTracker),
        theMagneticField_(&magField) {}

CosmicTrackingRegion() [2/3]

CosmicTrackingRegion::CosmicTrackingRegion ( const GlobalVector &  dir, const GlobalPoint &  vertexPos, float  ptMin, float  rVertex, float  zVertex, float  deltaEta, float  deltaPhi, const MagneticField &  magField, const MeasurementTrackerEvent *  measurementTracker = nullptr  )

inline

Definition at line 65 of file CosmicTrackingRegion.h.

      : TrackingRegionBase(dir, vertexPos, Range(-1 / ptMin, 1 / ptMin), rVertex, zVertex),
        theMeasurementTracker_(measurementTracker),
        theMagneticField_(&magField) {}

CosmicTrackingRegion() [3/3]

CosmicTrackingRegion::CosmicTrackingRegion ( CosmicTrackingRegion const &  rh )

inline

Definition at line 78 of file CosmicTrackingRegion.h.

      : TrackingRegionBase(rh),
        theMeasurementTracker_(rh.theMeasurementTracker_),
        theMagneticField_(rh.theMagneticField_) {}

Member Function Documentation

checkRZ()

std::unique_ptr<HitRZCompatibility> CosmicTrackingRegion::checkRZ ( const DetLayer *  layer, const Hit &  outerHit, const DetLayer *  outerlayer = nullptr, float  lr = 0, float  gz = 0, float  dr = 0, float  dz = 0  ) const

inlineoverridevirtual

utility to check eta/theta hit compatibility with region constraints and outer hit constraint

Implements TrackingRegion.

Definition at line 85 of file CosmicTrackingRegion.h.

                                                                           {
    return nullptr;
  }

checkTracks()

void CosmicTrackingRegion::checkTracks ( reco::TrackCollection const &  tracks, std::vector< bool > &  mask  ) const

overridevirtual

Set the elements of the mask corresponding to the tracks that are compatable with the region. Does not reset the elements corresponding to the tracks that are not compatible.

Implements TrackingRegion.

Definition at line 25 of file CosmicTrackingRegion.cc.

References funct::abs(), cms::cuda::assert(), mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, ptMin, HLT_2023v12_cff::track, DiMuonV_cfg::tracks, and x.

                                                                                                     {
  const math::XYZPoint regOrigin(origin().x(), origin().y(), origin().z());

  assert(mask.size() == tracks.size());
  int i = -1;
  for (auto const& track : tracks) {
    i++;
    if (mask[i])
      continue;

    if (track.pt() < ptMin()) {
      continue;
    }
    if (std::abs(track.dxy(regOrigin)) > originRBound()) {
      continue;
    }
    if (std::abs(track.dz(regOrigin)) > originZBound()) {
      continue;
    }

    mask[i] = true;
  }
}

clone()

std::unique_ptr<TrackingRegion> CosmicTrackingRegion::clone ( void  ) const

inlineoverridevirtual

Implements TrackingRegion.

Definition at line 99 of file CosmicTrackingRegion.h.

{ return std::make_unique<CosmicTrackingRegion>(*this); }

hits()

TrackingRegion::Hits CosmicTrackingRegion::hits ( const SeedingLayerSetsHits::SeedingLayer &  layer ) const

overridevirtual

get hits from layer compatible with region constraints

Implements TrackingRegion.

Definition at line 49 of file CosmicTrackingRegion.cc.

References mps_fire::result.

                                                                                                 {
  TrackingRegion::Hits result;
  hits_(layer, result);
  return result;
}

hits_()

template<typename T >

void CosmicTrackingRegion::hits_ ( const T &  layer, TrackingRegion::Hits &  result  ) const

private

Definition at line 56 of file CosmicTrackingRegion.cc.

References alongMomentum, AnalyticalPropagator_cfi::AnalyticalPropagator, cms::cuda::assert(), Plane::build(), utilities::cache(), GeometricSearchDet::compatibleDets(), funct::cos(), DeadROC_duringRun::dir, PV3DBase< T, PVType, FrameType >::eta(), TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::globalPosition(), trackerHitRTTI::isUndef(), TrajectoryStateOnSurface::isValid(), LogDebug, LayerMeasurements::measurements(), PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), mps_fire::result, makeMuonMisalignmentScenario::rot, funct::sin(), GeometricSearchDet::surface(), and L1BJetProducer_cff::vtx.

                                                                                 {
  //get and name collections
  //++++++++++++++++++++++++

  //detector layer
  const DetLayer* detLayer = layer.detLayer();
  LogDebug("CosmicTrackingRegion") << "Looking at hits on subdet/layer " << layer.name();
  EtaPhiMeasurementEstimator est(0.3, 0.3);

  //region
  const GlobalPoint vtx = origin();
  GlobalVector dir = direction();
  LogDebug("CosmicTrackingRegion") << "The initial region characteristics are:"
                                   << "\n"
                                   << " Origin    = " << origin() << "\n"
                                   << " Direction = " << direction() << "\n"
                                   << " Eta = " << origin().eta() << "\n"
                                   << " Phi = " << origin().phi();

  //trajectory state on surface
  float phi = dir.phi();
  Surface::RotationType rot(sin(phi), -cos(phi), 0, 0, 0, -1, cos(phi), sin(phi), 0);

  Plane::PlanePointer surface = Plane::build(vtx, rot);
  FreeTrajectoryState fts(GlobalTrajectoryParameters(vtx, dir, 1, theMagneticField_));
  TrajectoryStateOnSurface tsos(fts, *surface);
  LogDebug("CosmicTrackingRegion") << "The state used to find measurement with the measurement tracker is:\n" << tsos;

  //propagator
  AnalyticalPropagator prop(theMagneticField_, alongMomentum);

  //propagation verification (debug)
  //++++++++++++++++++++++++++++++++

  //creation of the state
  TrajectoryStateOnSurface stateOnLayer = prop.propagate(*tsos.freeState(), detLayer->surface());

  //verification of the state
  if (stateOnLayer.isValid()) {
    LogDebug("CosmicTrackingRegion") << "The initial state propagates to the layer surface: \n"
                                     << stateOnLayer << "R   = " << stateOnLayer.globalPosition().perp() << "\n"
                                     << "Eta = " << stateOnLayer.globalPosition().eta() << "\n"
                                     << "Phi = " << stateOnLayer.globalPosition().phi();

  } else {
    LogDebug("CosmicTrackingRegion") << "The initial state does not propagate to the layer surface.";
  }

  //number of compatible dets
  typedef DetLayer::DetWithState DetWithState;
  vector<DetWithState> compatDets = detLayer->compatibleDets(tsos, prop, est);
  LogDebug("CosmicTrackingRegion") << "Compatible dets = " << compatDets.size();

  //get hits
  //++++++++

  //measurement tracker (find hits)
  LayerMeasurements lm(theMeasurementTracker_->measurementTracker(), *theMeasurementTracker_);
  vector<TrajectoryMeasurement> meas = lm.measurements(*detLayer, tsos, prop, est);
  LogDebug("CosmicTrackingRegion") << "Number of Trajectory measurements = " << meas.size()
                                   << " but the last one is always an invalid hit, by construction.";

  //trajectory measurement

  // std::cout <<"CRegion b " << cache.size() << std::endl;

  // waiting for a migration at LayerMeasurements level and at seed builder level
  for (auto const& im : meas) {
    if (!im.recHit()->isValid())
      continue;
    assert(!trackerHitRTTI::isUndef(*im.recHit()->hit()));
    auto ptrHit = (BaseTrackerRecHit*)(im.recHit()->hit()->clone());
    cache.emplace_back(ptrHit);
    result.emplace_back(ptrHit);
  }

  // std::cout <<"CRegion a " << cache.size() << std::endl;
}

name()

std::string CosmicTrackingRegion::name ( void  ) const

inlineoverridevirtual

Reimplemented from TrackingRegion.

Definition at line 101 of file CosmicTrackingRegion.h.

Referenced by config.CFG::__str__(), and validation.Sample::digest().

{ return "CosmicTrackingRegion"; }

Member Data Documentation

cache

cacheHits CosmicTrackingRegion::cache

mutableprivate

Definition at line 116 of file CosmicTrackingRegion.h.

theMagneticField_

const MagneticField* CosmicTrackingRegion::theMagneticField_

private

Definition at line 108 of file CosmicTrackingRegion.h.

theMeasurementTracker_

const MeasurementTrackerEvent* CosmicTrackingRegion::theMeasurementTracker_

private

Definition at line 107 of file CosmicTrackingRegion.h.