#include <InnerDeltaPhi.h>

Public Types
typedef Basic2DVector< float >	Point2D

Public Member Functions
	InnerDeltaPhi (const DetLayer &outlayer, const DetLayer &layer, const TrackingRegion &region, const edm::EventSetup &iSetup, bool precise=true, float extraTolerance=0.f)

PixelRecoRange< float >	operator() (float xHit, float yHit, float zHit, float errRPhi) const

bool	prefilter (float xHit, float yHit) const

Private Member Functions
void	initBarrelLayer (const DetLayer &layer)

void	initBarrelMS (const DetLayer &outLayer)

void	initForwardLayer (const DetLayer &layer, float zMinOrigin, float zMaxOrigin)

void	initForwardMS (const DetLayer &outLayer)

PixelRecoRange< float >	phiRange (const Point2D &hitXY, float zHit, float errRPhi) const

Private Attributes
bool	innerIsBarrel

int	ol

bool	outerIsBarrel

MultipleScatteringParametrisation	sigma

float	theA

float	theB

float	theDeltaScatt

float	theExtraTolerance

bool	thePrecise

float	thePtMin

float	theRCurvature

float	theRLayer

float	theROrigin

float	theScatt0

float	theThickness

Point2D	theVtx

float	theVtxZ

Detailed Description

Definition at line 19 of file InnerDeltaPhi.h.

Member Typedef Documentation

typedef Basic2DVector<float> InnerDeltaPhi::Point2D

Definition at line 21 of file InnerDeltaPhi.h.

Constructor & Destructor Documentation

InnerDeltaPhi::InnerDeltaPhi	(	const DetLayer &	outlayer,
		const DetLayer &	layer,
		const TrackingRegion &	region,
		const edm::EventSetup &	iSetup,
		bool	precise = `true`,
		float	extraTolerance = `0.f`
	)

Definition at line 83 of file InnerDeltaPhi.cc.

References PixelRecoUtilities::bendingRadius(), initBarrelLayer(), initBarrelMS(), initForwardLayer(), initForwardMS(), innerIsBarrel, TrackingRegion::originZBound(), outerIsBarrel, thePtMin, theRCurvature, and theVtxZ.

     : innerIsBarrel(layer.isBarrel()),
       outerIsBarrel(outlayer.isBarrel()),
       thePrecise(precise),
       ol(outlayer.seqNum()),
       theROrigin(region.originRBound()),
       theRLayer(0),
       theThickness(0),
       theExtraTolerance(extraTolerance),
       theA(0),
       theB(0),
       theVtxZ(region.origin().z()),
       thePtMin(region.ptMin()),
       theVtx(region.origin().x(), region.origin().y()),
       sigma(&layer, iSetup)
 
 {
   float zMinOrigin = theVtxZ - region.originZBound();
   float zMaxOrigin = theVtxZ + region.originZBound();
   theRCurvature = PixelRecoUtilities::bendingRadius(thePtMin, iSetup);
 
   if (innerIsBarrel)
     initBarrelLayer(layer);
   else
     initForwardLayer(layer, zMinOrigin, zMaxOrigin);
 
   if (outerIsBarrel)
     initBarrelMS(outlayer);
   else
     initForwardMS(outlayer);
 }

Member Function Documentation

void InnerDeltaPhi::initBarrelLayer ( const DetLayer & layer )

private

Definition at line 148 of file InnerDeltaPhi.cc.

References Surface::bounds(), BarrelDetLayer::specificSurface(), GeometricSearchDet::surface(), theRLayer, theThickness, and Bounds::thickness().

Referenced by InnerDeltaPhi().

                                                          {
   const BarrelDetLayer& bl = static_cast<const BarrelDetLayer&>(layer);
   float rLayer = bl.specificSurface().radius();
 
   // the maximal delta phi will be for the innermost hits
   theThickness = layer.surface().bounds().thickness();
   theRLayer = rLayer - 0.5f * theThickness;
 }

void InnerDeltaPhi::initBarrelMS ( const DetLayer & outLayer )

private

Definition at line 120 of file InnerDeltaPhi.cc.

References Surface::bounds(), Bounds::length(), ol, sigma, BarrelDetLayer::specificSurface(), GeometricSearchDet::surface(), theDeltaScatt, thePtMin, theScatt0, and SiStripMonitorCluster_cfi::zmax.

Referenced by InnerDeltaPhi().

                                                          {
   const BarrelDetLayer& bl = static_cast<const BarrelDetLayer&>(outLayer);
   float rLayer = bl.specificSurface().radius();
   auto zmax = 0.5f * outLayer.surface().bounds().length();
   PixelRecoPointRZ zero(0., 0.);
   PixelRecoPointRZ point1(rLayer, 0.);
   PixelRecoPointRZ point2(rLayer, zmax);
   auto scatt1 = 3.f * sigma(thePtMin, zero, point1, ol);
   auto scatt2 = 3.f * sigma(thePtMin, zero, point2, ol);
   theDeltaScatt = (scatt2 - scatt1) / zmax;
   theScatt0 = scatt1;
 }

void InnerDeltaPhi::initForwardLayer	(	const DetLayer &	layer,
		float	zMinOrigin,
		float	zMaxOrigin
	)

private

Definition at line 157 of file InnerDeltaPhi.cc.

References Surface::bounds(), GeometricSearchDet::position(), ForwardDetLayer::specificSurface(), GeometricSearchDet::surface(), theA, theB, theRLayer, theThickness, Bounds::thickness(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by InnerDeltaPhi().

                                                                                               {
   const ForwardDetLayer& fl = static_cast<const ForwardDetLayer&>(layer);
   theRLayer = fl.specificSurface().innerRadius();
   float layerZ = layer.position().z();
   theThickness = layer.surface().bounds().thickness();
   float layerZmin = layerZ > 0 ? layerZ - 0.5f * theThickness : layerZ + 0.5f * theThickness;
   theB = layerZ > 0 ? zMaxOrigin : zMinOrigin;
   theA = layerZmin - theB;
 }

void InnerDeltaPhi::initForwardMS ( const DetLayer & outLayer )

private

Definition at line 133 of file InnerDeltaPhi.cc.

References HLT_2018_cff::minR, ol, GeometricSearchDet::position(), sigma, ForwardDetLayer::specificSurface(), theDeltaScatt, thePtMin, theScatt0, theVtxZ, and PV3DBase< T, PVType, FrameType >::z().

Referenced by InnerDeltaPhi().

                                                           {
   const ForwardDetLayer& fl = static_cast<const ForwardDetLayer&>(outLayer);
   auto minR = fl.specificSurface().innerRadius();
   auto maxR = fl.specificSurface().outerRadius();
   auto layerZ = outLayer.position().z();
   // compute min and max multiple scattering correction
   PixelRecoPointRZ zero(0., theVtxZ);
   PixelRecoPointRZ point1(minR, layerZ);
   PixelRecoPointRZ point2(maxR, layerZ);
   auto scatt1 = 3.f * sigma(thePtMin, zero, point1, ol);
   auto scatt2 = 3.f * sigma(thePtMin, zero, point2, ol);
   theDeltaScatt = (scatt2 - scatt1) / (maxR - minR);
   theScatt0 = scatt1 - theDeltaScatt * minR;
 }

PixelRecoRange<float> InnerDeltaPhi::operator()	(	float	xHit,
		float	yHit,
		float	zHit,
		float	errRPhi
	)		const

inline

Definition at line 32 of file InnerDeltaPhi.h.

                                                                                             {
     return phiRange(Point2D(xHit, yHit), zHit, errRPhi);
   }

PixelRecoRange< float > InnerDeltaPhi::phiRange	(	const Point2D &	hitXY,
		float	zHit,
		float	errRPhi
	)		const

private

Definition at line 167 of file InnerDeltaPhi.cc.

References funct::abs(), SiPixelRawToDigiRegional_cfi::deltaPhi, Basic2DVector< T >::dot(), dt, MillePedeFileConverter_cfg::e, f, dqmMemoryStats::float, innerIsBarrel, M_PI, Basic2DVector< T >::mag(), margin, SiStripPI::max, min(), EgammaValidation_cff::num, outerIsBarrel, funct::sqr(), mathSSE::sqrt(), OrderedSet::t, theA, theB, theDeltaScatt, theExtraTolerance, thePrecise, theRCurvature, theRLayer, theROrigin, theScatt0, theThickness, theVtx, Basic2DVector< T >::unit(), and w.

                                                                                                    {
   float rLayer = theRLayer;
   Point2D crossing;
 
   Point2D dHit = hitXY - theVtx;
   auto dHitmag = dHit.mag();
   float dLayer = 0.;
   float dL = 0.;
 
   // track is crossing layer with angle such as:
   // this factor should be taken in computation of eror projection
   float cosCross = 0;
 
   //
   // compute crossing of stright track with inner layer
   //
   if (!innerIsBarrel) {
     auto t = theA / (hitZ - theB);
     auto dt = std::abs(theThickness / (hitZ - theB));
     crossing = theVtx + t * dHit;
     rLayer = crossing.mag();
     dLayer = t * dHitmag;
     dL = dt * dHitmag;
     cosCross = std::abs(dHit.unit().dot(crossing.unit()));
   } else {
     //
     // compute crossing of track with layer
     // dHit - from VTX to outer hit
     // rLayer - layer radius
     // dLayer - distance from VTX to inner layer in direction of dHit
     // vect(rLayer) = vect(rVTX) + vect(dHit).unit * dLayer
     //     rLayer^2 = (vect(rVTX) + vect(dHit).unit * dLayer)^2 and we have square eqation for dLayer
     //
     // barrel case
     //
     auto vtxmag2 = theVtx.mag2();
     if (vtxmag2 < 1.e-10f) {
       dLayer = rLayer;
     } else {
       // there are cancellation here....
       double var_c = vtxmag2 - sqr(rLayer);
       double var_b = theVtx.dot(dHit.unit());
       double var_delta = sqr(var_b) - var_c;
       if (var_delta <= 0.)
         var_delta = 0;
       dLayer = -var_b + std::sqrt(var_delta);  //only the value along vector is OK.
     }
     crossing = theVtx + dHit.unit() * dLayer;
     cosCross = std::abs(dHit.unit().dot(crossing.unit()));
     dL = theThickness / cosCross;
   }
 
 #ifdef USE_VECTORS_HERE
   cms_float32x4_t num{dHitmag, dLayer, theROrigin * (dHitmag - dLayer), 1.f};
   cms_float32x4_t den{2 * theRCurvature, 2 * theRCurvature, dHitmag * dLayer, 1.f};
   auto phis = f_asin07f(num / den);
   phis = phis * dLayer / (rLayer * cosCross);
   auto deltaPhi = std::abs(phis[0] - phis[1]);
   auto deltaPhiOrig = phis[2];
 #else
 #warning no vector!
   auto alphaHit = cropped_asin(dHitmag / (2 * theRCurvature));
   auto OdeltaPhi = std::abs(alphaHit - cropped_asin(dLayer / (2 * theRCurvature)));
   OdeltaPhi *= dLayer / (rLayer * cosCross);
   // compute additional delta phi due to origin radius
   auto OdeltaPhiOrig = cropped_asin(theROrigin * (dHitmag - dLayer) / (dHitmag * dLayer));
   OdeltaPhiOrig *= dLayer / (rLayer * cosCross);
   // std::cout << "dphi " << OdeltaPhi<<'/'<<OdeltaPhiOrig << ' ' << deltaPhi<<'/'<<deltaPhiOrig << std::endl;
 
   auto deltaPhi = OdeltaPhi;
   auto deltaPhiOrig = OdeltaPhiOrig;
 #endif
 
   // additinal angle due to not perpendicular stright line crossing  (for displaced beam)
   //  double dPhiCrossing = (cosCross > 0.9999) ? 0 : dL *  sqrt(1-sqr(cosCross))/ rLayer;
   Point2D crossing2 = theVtx + dHit.unit() * (dLayer + dL);
   auto phicross2 = f_phi(crossing2);
   auto phicross1 = f_phi(crossing);
   auto dphicross = phicross2 - phicross1;
   if (dphicross < -float(M_PI))
     dphicross += float(2 * M_PI);
   if (dphicross > float(M_PI))
     dphicross -= float(2 * M_PI);
   if (dphicross > float(M_PI / 2))
     dphicross = 0.;  // something wrong?
   phicross2 = phicross1 + dphicross;
 
   // inner hit error taken as constant
   auto deltaPhiHit = theExtraTolerance / rLayer;
 
   // outer hit error
   //   double deltaPhiHitOuter = errRPhi/rLayer;
   auto deltaPhiHitOuter = errRPhi / hitXY.mag();
 
   auto margin = deltaPhi + deltaPhiOrig + deltaPhiHit + deltaPhiHitOuter;
 
   if (thePrecise) {
     // add multiple scattering correction
 
     /*
     PixelRecoPointRZ zero(0., theVtxZ);
     PixelRecoPointRZ point(hitXY.mag(), hitZ);
     auto scatt = 3.f*sigma(thePtMin,zero, point, ol); 
     */
 
     auto w = outerIsBarrel ? std::abs(hitZ) : hitXY.mag();
     auto nscatt = theScatt0 + theDeltaScatt * w;
 
     // std::cout << "scatt " << (outerIsBarrel ? "B" : "F") << (innerIsBarrel ? "B " : "F ")
     //          << scatt << ' ' << nscatt << ' ' << nscatt/scatt << std::endl;
 
     margin += nscatt / rLayer;
   }
 
   return PixelRecoRange<float>(std::min(phicross1, phicross2) - margin, std::max(phicross1, phicross2) + margin);
 }