Classes
struct	ClusParamsT

struct	CommonParams

struct	DetParams

struct	LayerGeometry

struct	ParamsOnGPU

Typedefs
using	ClusParams = ClusParamsT< MaxHitsInIter >

using	Frame = SOAFrame< float >

using	Rotation = SOARotation< float >

using	Status = SiPixelHitStatus

Functions
constexpr void	computeAnglesFromDet (DetParams const &__restrict__ detParams, float const x, float const y, float &cotalpha, float &cotbeta)

constexpr float	correction (int sizeM1, int q_f, int q_l, uint16_t upper_edge_first_pix, uint16_t lower_edge_last_pix, float lorentz_shift, float theThickness, float cot_angle, float pitch, bool first_is_big, bool last_is_big)

constexpr void	errorFromDB (CommonParams const &__restrict__ comParams, DetParams const &__restrict__ detParams, ClusParams &cp, uint32_t ic)

constexpr void	errorFromSize (CommonParams const &__restrict__ comParams, DetParams const &__restrict__ detParams, ClusParams &cp, uint32_t ic)

constexpr void	position (CommonParams const &__restrict__ comParams, DetParams const &__restrict__ detParams, ClusParams &cp, uint32_t ic)

Variables
constexpr int32_t	MaxHitsInIter = gpuClustering::maxHitsInIter()

Typedef Documentation

◆ ClusParams

using pixelCPEforGPU::ClusParams = typedef ClusParamsT<MaxHitsInIter>

Definition at line 110 of file pixelCPEforGPU.h.

◆ Frame

using pixelCPEforGPU::Frame = typedef SOAFrame<float>

Definition at line 18 of file pixelCPEforGPU.h.

◆ Rotation

using pixelCPEforGPU::Rotation = typedef SOARotation<float>

Definition at line 19 of file pixelCPEforGPU.h.

◆ Status

using pixelCPEforGPU::Status = typedef SiPixelHitStatus

Definition at line 17 of file pixelCPEforGPU.h.

Function Documentation

◆ computeAnglesFromDet()

constexpr void pixelCPEforGPU::computeAnglesFromDet	(	DetParams const &__restrict__	detParams,
		float const	x,
		float const	y,
		float &	cotalpha,
		float &	cotbeta
	)

inlineconstexpr

Definition at line 112 of file pixelCPEforGPU.h.

                                                                                                               {
     // x,y local position on det
     auto gvx = x - detParams.x0;
     auto gvy = y - detParams.y0;
     auto gvz = -1.f / detParams.z0;
     // normalization not required as only ratio used...
     // calculate angles
     cotalpha = gvx * gvz;
     cotbeta = gvy * gvz;
   }

Referenced by position().

◆ correction()

constexpr float pixelCPEforGPU::correction	(	int	sizeM1,
		int	q_f,
		int	q_l,
		uint16_t	upper_edge_first_pix,
		uint16_t	lower_edge_last_pix,
		float	lorentz_shift,
		float	theThickness,
		float	cot_angle,
		float	pitch,
		bool	first_is_big,
		bool	last_is_big
	)

inlineconstexpr

Parameters

q_f	Charge in the first pixel.
q_l	Charge in the last pixel.
upper_edge_first_pix	As the name says.
lower_edge_last_pix	As the name says.
lorentz_shift	L-shift at half thickness
cot_angle	cot of alpha_ or beta_
pitch	thePitchX or thePitchY
first_is_big	true if the first is big
last_is_big	true if the last is big

Definition at line 124 of file pixelCPEforGPU.h.

   {
     if (0 == sizeM1)  // size 1
       return 0;
  
     float w_eff = 0;
     bool simple = true;
     if (1 == sizeM1) {  // size 2
       //--- Width of the clusters minus the edge (first and last) pixels.
       //--- In the note, they are denoted x_F and x_L (and y_F and y_L)
       // assert(lower_edge_last_pix >= upper_edge_first_pix);
       auto w_inner = pitch * float(lower_edge_last_pix - upper_edge_first_pix);  // in cm
  
       //--- Predicted charge width from geometry
       auto w_pred = theThickness * cot_angle  // geometric correction (in cm)
                     - lorentz_shift;          // (in cm) &&& check fpix!
  
       w_eff = std::abs(w_pred) - w_inner;
  
       //--- If the observed charge width is inconsistent with the expectations
       //--- based on the track, do *not* use w_pred-w_inner.  Instead, replace
       //--- it with an *average* effective charge width, which is the average
       //--- length of the edge pixels.
  
       // this can produce "large" regressions for very small numeric differences
       simple = (w_eff < 0.0f) | (w_eff > pitch);
     }
  
     if (simple) {
       //--- Total length of the two edge pixels (first+last)
       float sum_of_edge = 2.0f;
       if (first_is_big)
         sum_of_edge += 1.0f;
       if (last_is_big)
         sum_of_edge += 1.0f;
       w_eff = pitch * 0.5f * sum_of_edge;  // ave. length of edge pixels (first+last) (cm)
     }
  
     //--- Finally, compute the position in this projection
     float qdiff = q_l - q_f;
     float qsum = q_l + q_f;
  
     //--- Temporary fix for clusters with both first and last pixel with charge = 0
     if (qsum == 0)
       qsum = 1.0f;
  
     return 0.5f * (qdiff / qsum) * w_eff;
   }

References funct::abs(), and dqmMemoryStats::float.

Referenced by position().

◆ errorFromDB()

constexpr void pixelCPEforGPU::errorFromDB	(	CommonParams const &__restrict__	comParams,
		DetParams const &__restrict__	detParams,
		ClusParams &	cp,
		uint32_t	ic
	)

inlineconstexpr

Definition at line 323 of file pixelCPEforGPU.h.

                                                  {
     // Edge cluster errors
     cp.xerr[ic] = 0.0050f;
     cp.yerr[ic] = 0.0085f;
  
     auto sx = cp.maxRow[ic] - cp.minRow[ic];
     auto sy = cp.maxCol[ic] - cp.minCol[ic];
  
     // is edgy ?  (size is set negative: see above)
     bool isEdgeX = cp.xsize[ic] < 1;
     bool isEdgeY = cp.ysize[ic] < 1;
     // is one and big?
     bool isOneX = (0 == sx);
     bool isOneY = (0 == sy);
     bool isBigX = phase1PixelTopology::isBigPixX(cp.minRow[ic]);
     bool isBigY = phase1PixelTopology::isBigPixY(cp.minCol[ic]);
  
     auto ch = cp.charge[ic];
     auto bin = 0;
     for (; bin < 4; ++bin)
       if (ch < detParams.minCh[bin + 1])
         break;
     assert(bin < 5);
  
     cp.status[ic].qBin = 4 - bin;
     cp.status[ic].isOneX = isOneX;
     cp.status[ic].isBigX = (isOneX & isBigX) | isEdgeX;
     cp.status[ic].isOneY = isOneY;
     cp.status[ic].isBigY = (isOneY & isBigY) | isEdgeY;
  
     auto xoff = 81.f * comParams.thePitchX;
     int jx = std::min(15, std::max(0, int(16.f * (cp.xpos[ic] + xoff) / (2 * xoff))));
  
     auto toCM = [](uint8_t x) { return float(x) * 1.e-4; };
  
     if (not isEdgeX) {
       cp.xerr[ic] = isOneX ? toCM(isBigX ? detParams.sx2 : detParams.sigmax1[jx])
                            : detParams.xfact[bin] * toCM(detParams.sigmax[jx]);
     }
  
     auto ey = cp.ysize[ic] > 8 ? detParams.sigmay[std::min(cp.ysize[ic] - 9, 15)] : detParams.sy1;
     if (not isEdgeY) {
       cp.yerr[ic] = isOneY ? toCM(isBigY ? detParams.sy2 : detParams.sy1) : detParams.yfact[bin] * toCM(ey);
     }
   }

References cms::cuda::assert(), newFWLiteAna::bin, f, dqmMemoryStats::float, phase1PixelTopology::isBigPixX(), phase1PixelTopology::isBigPixY(), phase1PixelTopology::isEdgeX(), phase1PixelTopology::isEdgeY(), SiStripPI::max, min(), fftjetcommon_cfi::sx, and fftjetcommon_cfi::sy.

Referenced by gpuPixelRecHits::__attribute__(), and PixelCPEFast::localPosition().

◆ errorFromSize()

constexpr void pixelCPEforGPU::errorFromSize	(	CommonParams const &__restrict__	comParams,
		DetParams const &__restrict__	detParams,
		ClusParams &	cp,
		uint32_t	ic
	)

inlineconstexpr

Definition at line 268 of file pixelCPEforGPU.h.

                                                    {
     // Edge cluster errors
     cp.xerr[ic] = 0.0050;
     cp.yerr[ic] = 0.0085;
  
     // FIXME these are errors form Run1
     constexpr float xerr_barrel_l1[] = {0.00115, 0.00120, 0.00088};
     constexpr float xerr_barrel_l1_def = 0.00200;  // 0.01030;
     constexpr float yerr_barrel_l1[] = {
         0.00375, 0.00230, 0.00250, 0.00250, 0.00230, 0.00230, 0.00210, 0.00210, 0.00240};
     constexpr float yerr_barrel_l1_def = 0.00210;
     constexpr float xerr_barrel_ln[] = {0.00115, 0.00120, 0.00088};
     constexpr float xerr_barrel_ln_def = 0.00200;  // 0.01030;
     constexpr float yerr_barrel_ln[] = {
         0.00375, 0.00230, 0.00250, 0.00250, 0.00230, 0.00230, 0.00210, 0.00210, 0.00240};
     constexpr float yerr_barrel_ln_def = 0.00210;
     constexpr float xerr_endcap[] = {0.0020, 0.0020};
     constexpr float xerr_endcap_def = 0.0020;
     constexpr float yerr_endcap[] = {0.00210};
     constexpr float yerr_endcap_def = 0.00210;
  
     auto sx = cp.maxRow[ic] - cp.minRow[ic];
     auto sy = cp.maxCol[ic] - cp.minCol[ic];
  
     // is edgy ?
     bool isEdgeX = cp.xsize[ic] < 1;
     bool isEdgeY = cp.ysize[ic] < 1;
     // is one and big?
     bool isBig1X = (0 == sx) && phase1PixelTopology::isBigPixX(cp.minRow[ic]);
     bool isBig1Y = (0 == sy) && phase1PixelTopology::isBigPixY(cp.minCol[ic]);
  
     if (!isEdgeX && !isBig1X) {
       if (not detParams.isBarrel) {
         cp.xerr[ic] = sx < std::size(xerr_endcap) ? xerr_endcap[sx] : xerr_endcap_def;
       } else if (detParams.layer == 1) {
         cp.xerr[ic] = sx < std::size(xerr_barrel_l1) ? xerr_barrel_l1[sx] : xerr_barrel_l1_def;
       } else {
         cp.xerr[ic] = sx < std::size(xerr_barrel_ln) ? xerr_barrel_ln[sx] : xerr_barrel_ln_def;
       }
     }
  
     if (!isEdgeY && !isBig1Y) {
       if (not detParams.isBarrel) {
         cp.yerr[ic] = sy < std::size(yerr_endcap) ? yerr_endcap[sy] : yerr_endcap_def;
       } else if (detParams.layer == 1) {
         cp.yerr[ic] = sy < std::size(yerr_barrel_l1) ? yerr_barrel_l1[sy] : yerr_barrel_l1_def;
       } else {
         cp.yerr[ic] = sy < std::size(yerr_barrel_ln) ? yerr_barrel_ln[sy] : yerr_barrel_ln_def;
       }
     }
   }

References phase1PixelTopology::isBigPixX(), phase1PixelTopology::isBigPixY(), phase1PixelTopology::isEdgeX(), phase1PixelTopology::isEdgeY(), findQualityFiles::size, fftjetcommon_cfi::sx, fftjetcommon_cfi::sy, HLT_FULL_cff::xerr_barrel_l1, HLT_FULL_cff::xerr_barrel_l1_def, HLT_FULL_cff::xerr_barrel_ln, HLT_FULL_cff::xerr_barrel_ln_def, HLT_FULL_cff::xerr_endcap, HLT_FULL_cff::xerr_endcap_def, HLT_FULL_cff::yerr_barrel_l1, HLT_FULL_cff::yerr_barrel_l1_def, HLT_FULL_cff::yerr_barrel_ln, HLT_FULL_cff::yerr_barrel_ln_def, HLT_FULL_cff::yerr_endcap, and HLT_FULL_cff::yerr_endcap_def.

◆ position()

constexpr void pixelCPEforGPU::position	(	CommonParams const &__restrict__	comParams,
		DetParams const &__restrict__	detParams,
		ClusParams &	cp,
		uint32_t	ic
	)

inlineconstexpr

Definition at line 183 of file pixelCPEforGPU.h.

                                               {
     //--- Upper Right corner of Lower Left pixel -- in measurement frame
     uint16_t llx = cp.minRow[ic] + 1;
     uint16_t lly = cp.minCol[ic] + 1;
  
     //--- Lower Left corner of Upper Right pixel -- in measurement frame
     uint16_t urx = cp.maxRow[ic];
     uint16_t ury = cp.maxCol[ic];
  
     auto llxl = phase1PixelTopology::localX(llx);
     auto llyl = phase1PixelTopology::localY(lly);
     auto urxl = phase1PixelTopology::localX(urx);
     auto uryl = phase1PixelTopology::localY(ury);
  
     auto mx = llxl + urxl;
     auto my = llyl + uryl;
  
     auto xsize = int(urxl) + 2 - int(llxl);
     auto ysize = int(uryl) + 2 - int(llyl);
     assert(xsize >= 0);  // 0 if bixpix...
     assert(ysize >= 0);
  
     if (phase1PixelTopology::isBigPixX(cp.minRow[ic]))
       ++xsize;
     if (phase1PixelTopology::isBigPixX(cp.maxRow[ic]))
       ++xsize;
     if (phase1PixelTopology::isBigPixY(cp.minCol[ic]))
       ++ysize;
     if (phase1PixelTopology::isBigPixY(cp.maxCol[ic]))
       ++ysize;
  
     int unbalanceX = 8.f * std::abs(float(cp.q_f_X[ic] - cp.q_l_X[ic])) / float(cp.q_f_X[ic] + cp.q_l_X[ic]);
     int unbalanceY = 8.f * std::abs(float(cp.q_f_Y[ic] - cp.q_l_Y[ic])) / float(cp.q_f_Y[ic] + cp.q_l_Y[ic]);
     xsize = 8 * xsize - unbalanceX;
     ysize = 8 * ysize - unbalanceY;
  
     cp.xsize[ic] = std::min(xsize, 1023);
     cp.ysize[ic] = std::min(ysize, 1023);
  
     if (cp.minRow[ic] == 0 || cp.maxRow[ic] == phase1PixelTopology::lastRowInModule)
       cp.xsize[ic] = -cp.xsize[ic];
     if (cp.minCol[ic] == 0 || cp.maxCol[ic] == phase1PixelTopology::lastColInModule)
       cp.ysize[ic] = -cp.ysize[ic];
  
     // apply the lorentz offset correction
     auto xPos = detParams.shiftX + comParams.thePitchX * (0.5f * float(mx) + float(phase1PixelTopology::xOffset));
     auto yPos = detParams.shiftY + comParams.thePitchY * (0.5f * float(my) + float(phase1PixelTopology::yOffset));
  
     float cotalpha = 0, cotbeta = 0;
  
     computeAnglesFromDet(detParams, xPos, yPos, cotalpha, cotbeta);
  
     auto thickness = detParams.isBarrel ? comParams.theThicknessB : comParams.theThicknessE;
  
     auto xcorr = correction(cp.maxRow[ic] - cp.minRow[ic],
                             cp.q_f_X[ic],
                             cp.q_l_X[ic],
                             llxl,
                             urxl,
                             detParams.chargeWidthX,  // lorentz shift in cm
                             thickness,
                             cotalpha,
                             comParams.thePitchX,
                             phase1PixelTopology::isBigPixX(cp.minRow[ic]),
                             phase1PixelTopology::isBigPixX(cp.maxRow[ic]));
  
     auto ycorr = correction(cp.maxCol[ic] - cp.minCol[ic],
                             cp.q_f_Y[ic],
                             cp.q_l_Y[ic],
                             llyl,
                             uryl,
                             detParams.chargeWidthY,  // lorentz shift in cm
                             thickness,
                             cotbeta,
                             comParams.thePitchY,
                             phase1PixelTopology::isBigPixY(cp.minCol[ic]),
                             phase1PixelTopology::isBigPixY(cp.maxCol[ic]));
  
     cp.xpos[ic] = xPos + xcorr;
     cp.ypos[ic] = yPos + ycorr;
   }