GlobalTrackingRegion Class Reference

#include <GlobalTrackingRegion.h>

Inheritance diagram for GlobalTrackingRegion:

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
	GlobalTrackingRegion (float ptMin, const GlobalPoint &origin, float originRadius, float originHalfLength, bool precise=false, bool useMS=false, const MultipleScatteringParametrisationMaker *msmaker=nullptr)
	GlobalTrackingRegion (float ptMin=1., float originRadius=0.2, float originHalfLength=22.7, float originZPos=0., bool precise=false)
TrackingRegion::Hits	hits (const SeedingLayerSetsHits::SeedingLayer &layer) const override
	get hits from layer compatible with region constraints More...
std::string	name () const override
std::string	print () const 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
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 Attributes
const MultipleScatteringParametrisationMaker *	theMSMaker = nullptr
bool	thePrecise = false
bool	theUseMS = false

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

Detailed Description

An implementation of the TrackingRegion where the region of interest is global, ie there are no constraints on the allowed direction of particles of interest

Definition at line 14 of file GlobalTrackingRegion.h.

Constructor & Destructor Documentation

GlobalTrackingRegion() [1/2]

GlobalTrackingRegion::GlobalTrackingRegion ( float  ptMin, const GlobalPoint &  origin, float  originRadius, float  originHalfLength, bool  precise = false, bool  useMS = false, const MultipleScatteringParametrisationMaker *  msmaker = nullptr  )

inline

Construct from minimal track P_t, and origin size and position. The origin region is a cylinder of radius originRadius, half length originHalfLength, positioned at "origin". This class DOES provide the possibility to displace the origin in the transverse plane.

if useMS == true, msmaker needs to be given

Definition at line 24 of file GlobalTrackingRegion.h.

      : TrackingRegionBase(GlobalVector(0, 0, 0), origin, Range(-1 / ptMin, 1 / ptMin), originRadius, originHalfLength),
        theMSMaker(msmaker),
        thePrecise(precise),
        theUseMS(useMS) {}

GlobalTrackingRegion() [2/2]

GlobalTrackingRegion::GlobalTrackingRegion ( float  ptMin = 1., float  originRadius = 0.2, float  originHalfLength = 22.7, float  originZPos = 0., bool  precise = false  )

inline

Definition at line 37 of file GlobalTrackingRegion.h.

      : TrackingRegionBase(GlobalVector(0, 0, 0),
                           GlobalPoint(0, 0, originZPos),
                           Range(-1 / ptMin, 1 / ptMin),
                           originRadius,
                           originHalfLength),
        thePrecise(precise) {}

Member Function Documentation

checkRZ()

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

overridevirtual

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

Implements TrackingRegion.

Definition at line 31 of file GlobalTrackingRegion.cc.

References alignCSCRings::corr, PixelRecoLineRZ::cotLine(), SimpleLineRZ::cotLine(), l1ctLayer1_cff::dr, PVValHelper::dz, GeomDetEnumerators::isBarrel(), fastTrackerRecHitType::isPixel(), phase1PixelTopology::layer, nSigmaPhi, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, ptMin, DetLayer::seqNum(), sqr(), mathSSE::sqrt(), UNLIKELY, vtxMean(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                  {
  bool isBarrel = layer->isBarrel();
  bool isPixel = (layer->subDetector() == PixelBarrel || layer->subDetector() == PixelEndcap);

  if UNLIKELY (!outerlayer) {
    GlobalPoint ohit = outerHit->globalPosition();
    lr = std::sqrt(sqr(ohit.x() - origin().x()) + sqr(ohit.y() - origin().y()));
    gz = ohit.z();
    dr = outerHit->errorGlobalR();
    dz = outerHit->errorGlobalZ();
  }

  PixelRecoPointRZ outerred(lr, gz);

  PixelRecoPointRZ vtxR = (gz > origin().z() + originZBound())
                              ? PixelRecoPointRZ(-originRBound(), origin().z() + originZBound())
                              : PixelRecoPointRZ(originRBound(), origin().z() + originZBound());
  PixelRecoPointRZ vtxL = (gz < origin().z() - originZBound())
                              ? PixelRecoPointRZ(-originRBound(), origin().z() - originZBound())
                              : PixelRecoPointRZ(originRBound(), origin().z() - originZBound());

  if UNLIKELY ((!thePrecise) && (isPixel)) {
    auto VcotMin = PixelRecoLineRZ(vtxR, outerred).cotLine();
    auto VcotMax = PixelRecoLineRZ(vtxL, outerred).cotLine();
    return std::make_unique<HitEtaCheck>(isBarrel, outerred, VcotMax, VcotMin);
  }

  constexpr float nSigmaPhi = 3.;

  dr *= nSigmaPhi;
  dz *= nSigmaPhi;

  PixelRecoPointRZ outerL, outerR;
  if (isBarrel) {
    outerL = PixelRecoPointRZ(lr, gz - dz);
    outerR = PixelRecoPointRZ(lr, gz + dz);
  } else if (gz > 0) {
    outerL = PixelRecoPointRZ(lr + dr, gz);
    outerR = PixelRecoPointRZ(lr - dr, gz);
  } else {
    outerL = PixelRecoPointRZ(lr - dr, gz);
    outerR = PixelRecoPointRZ(lr + dr, gz);
  }

  auto corr = isBarrel ? dz : dr;

  SimpleLineRZ leftLine(vtxL, outerL);
  SimpleLineRZ rightLine(vtxR, outerR);
  HitRZConstraint rzConstraint(leftLine, rightLine);

  if UNLIKELY (theUseMS) {
    MultipleScatteringParametrisation iSigma = theMSMaker->parametrisation(layer);
    PixelRecoPointRZ vtxMean(0., origin().z());

    float innerScatt = 3.f * (outerlayer ? iSigma(ptMin(), vtxMean, outerred, outerlayer->seqNum())
                                         : iSigma(ptMin(), vtxMean, outerred));

    float cotTheta = SimpleLineRZ(vtxMean, outerred).cotLine();

    if (isBarrel) {
      float sinTheta = 1 / std::sqrt(1 + sqr(cotTheta));
      corr = innerScatt / sinTheta + dz;
    } else {
      float cosTheta = 1 / std::sqrt(1 + sqr(1 / cotTheta));
      corr = innerScatt / cosTheta + dr;
    }
  }

  if (isBarrel) {
    return std::make_unique<HitZCheck>(rzConstraint, HitZCheck::Margin(corr, corr));
  } else {
    return std::make_unique<HitRCheck>(rzConstraint, HitRCheck::Margin(corr, corr));
  }
}

checkTracks()

void GlobalTrackingRegion::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 112 of file GlobalTrackingRegion.cc.

References funct::abs(), cms::cuda::assert(), mps_fire::i, gpuClustering::pixelStatus::mask, ptMin, HLT_2022v14_cff::track, 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> GlobalTrackingRegion::clone ( void  ) const

inlineoverridevirtual

Implements TrackingRegion.

Definition at line 63 of file GlobalTrackingRegion.h.

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

hits()

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

overridevirtual

get hits from layer compatible with region constraints

Implements TrackingRegion.

Definition at line 27 of file GlobalTrackingRegion.cc.

References phase1PixelTopology::layer.

Referenced by SimpleCosmicBONSeeder::triplets().

                                                                                                 {
  return layer.hits();
}

name()

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

inlineoverridevirtual

Reimplemented from TrackingRegion.

Definition at line 65 of file GlobalTrackingRegion.h.

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

{ return "GlobalTrackingRegion"; }

print()

std::string GlobalTrackingRegion::print ( void  ) const

overridevirtual

Reimplemented from TrackingRegion.

Definition at line 21 of file GlobalTrackingRegion.cc.

References TrackingRegion::print(), and str.

                                            {
  std::ostringstream str;
  str << TrackingRegionBase::print() << "precise: " << thePrecise;
  return str.str();
}

Member Data Documentation

theMSMaker

const MultipleScatteringParametrisationMaker* GlobalTrackingRegion::theMSMaker = nullptr

private

Definition at line 69 of file GlobalTrackingRegion.h.

thePrecise

bool GlobalTrackingRegion::thePrecise = false

private

Definition at line 70 of file GlobalTrackingRegion.h.

theUseMS

bool GlobalTrackingRegion::theUseMS = false

private

Definition at line 71 of file GlobalTrackingRegion.h.