SiPixelTemplate Class Reference

#include <SiPixelTemplate.h>

Public Member Functions
float	chi2xavg (int i)
	averaage x chi^2 in 4 charge bins More...
float	chi2xavgc2m (int i)
	1st pass chi2 min search: average x-chisq for merged clusters More...
float	chi2xavgone ()
	//!< average x chi^2 for 1 pixel clusters More...
float	chi2xmin (int i)
	minimum y chi^2 in 4 charge bins More...
float	chi2xminc2m (int i)
	1st pass chi2 min search: minimum x-chisq for merged clusters More...
float	chi2xminone ()
	//!< minimum of x chi^2 for 1 pixel clusters More...
float	chi2yavg (int i)
	average y chi^2 in 4 charge bins More...
float	chi2yavgc2m (int i)
	1st pass chi2 min search: average y-chisq for merged clusters More...
float	chi2yavgone ()
	//!< average y chi^2 for 1 pixel clusters More...
float	chi2ymin (int i)
	minimum y chi^2 in 4 charge bins More...
float	chi2yminc2m (int i)
	1st pass chi2 min search: minimum y-chisq for merged clusters More...
float	chi2yminone ()
	//!< minimum of y chi^2 for 1 pixel clusters More...
float	clslenx ()
	x-size of smaller interpolated template in pixels More...
float	clsleny ()
	y-size of smaller interpolated template in pixels More...
int	cxtemp ()
	Return central pixel of x-template pixels above readout threshold. More...
int	cytemp ()
	Return central pixel of y template pixels above readout threshold. More...
float	dxone ()
	mean offset/correction for one pixel x-clusters More...
float	dxtwo ()
	mean offset/correction for one double-pixel x-clusters More...
float	dyone ()
	mean offset/correction for one pixel y-clusters More...
float	dytwo ()
	mean offset/correction for one double-pixel y-clusters More...
float	fbin (int i)
	Return lower bound of Qbin definition. More...
float	fracxone ()
	The simulated fraction of single pixel x-clusters. More...
float	fracxtwo ()
	The simulated fraction of single double-size pixel x-clusters. More...
float	fracyone ()
	The simulated fraction of single pixel y-clusters. More...
float	fracytwo ()
	The simulated fraction of single double-size pixel y-clusters. More...
bool	interpolate (int id, float cotalpha, float cotbeta, float locBz, float locBx)
bool	interpolate (int id, float cotalpha, float cotbeta, float locBz)
bool	interpolate (int id, float cotalpha, float cotbeta)
float	kappavav ()
	kappa parameter for Vavilov distribution More...
float	kappavav2 ()
	kappa parameter for 2-cluster Vavilov distribution More...
float	lorxbias ()
	signed lorentz x-width (microns) More...
float	lorxwidth ()
	signed lorentz x-width (microns) More...
float	lorybias ()
	signed lorentz y-width (microns) More...
float	lorywidth ()
	signed lorentz y-width (microns) More...
float	mpvvav ()
	most probable charge in Vavilov distribution (not actually for larger kappa) More...
float	mpvvav2 ()
	most probable charge in 2-cluster Vavilov distribution (not actually for larger kappa) More...
float	pixmax ()
	maximum pixel charge More...
float	qavg ()
	average cluster charge for this set of track angles More...
int	qbin (int id, float cotalpha, float cotbeta, float locBz, float locBx, float qclus, float &pixmx, float &sigmay, float &deltay, float &sigmax, float &deltax, float &sy1, float &dy1, float &sy2, float &dy2, float &sx1, float &dx1, float &sx2, float &dx2)
int	qbin (int id, float cotalpha, float cotbeta, float locBz, float qclus, float &pixmx, float &sigmay, float &deltay, float &sigmax, float &deltax, float &sy1, float &dy1, float &sy2, float &dy2, float &sx1, float &dx1, float &sx2, float &dx2)
int	qbin (int id, float cotalpha, float cotbeta, float qclus)
int	qbin (int id, float cotbeta, float qclus)
void	qbin_dist (int id, float cotalpha, float cotbeta, float qbin_frac[4], float &ny1_frac, float &ny2_frac, float &nx1_frac, float &nx2_frac)
float	qmin ()
	minimum cluster charge for valid hit (keeps 99.9% of simulated hits) More...
float	qmin (int i)
	minimum cluster charge for valid hit (keeps 99.9% or 99.8% of simulated hits) More...
float	qscale ()
	charge scaling factor More...
float	r_qMeas_qTrue ()
	ratio of measured to true cluster charge More...
float	s50 ()
	1/2 of the pixel threshold signal in electrons More...
float	sigmavav ()
	"sigma" scale fctor for Vavilov distribution More...
float	sigmavav2 ()
	"sigma" scale fctor for 2-cluster Vavilov distribution More...
bool	simpletemplate2D (float xhitp, float yhitp, std::vector< bool > &ydouble, std::vector< bool > &xdouble, float template2d[13+2][21+2])
	Make simple 2-D templates from track angles set in interpolate and hit position. More...
	SiPixelTemplate (const std::vector< SiPixelTemplateStore > &thePixelTemp)
	Constructor for cases in which template store already exists. More...
float	ss50 ()
	1/2 of the single pixel per double column threshold in electrons More...
float	sxmax ()
	average pixel signal for x-projection of cluster More...
float	sxone ()
	rms for one pixel x-clusters More...
float	sxtwo ()
	rms for one double-pixel x-clusters More...
float	symax ()
	average pixel signal for y-projection of cluster More...
float	syone ()
	rms for one pixel y-clusters More...
float	sytwo ()
	rms for one double-pixel y-clusters More...
void	temperrors (int id, float cotalpha, float cotbeta, int qBin, float &sigmay, float &sigmax, float &sy1, float &sy2, float &sx1, float &sx2)
void	vavilov2_pars (double &mpv, double &sigma, double &kappa)
void	vavilov_pars (double &mpv, double &sigma, double &kappa)
float	xavg (int i)
	average x-bias of reconstruction binned in 4 charge bins More...
float	xavgc2m (int i)
	1st pass chi2 min search: average x-bias of reconstruction binned in 4 charge bins More...
float	xflcorr (int binq, float qflx)
float	xgsig (int i)
	average sigma_x from Gaussian fit binned in 4 charge bins More...
float	xgx0 (int i)
	average x0 from Gaussian fit binned in 4 charge bins More...
float	xrms (int i)
	average x-rms of reconstruction binned in 4 charge bins More...
float	xrmsc2m (int i)
	1st pass chi2 min search: average x-rms of reconstruction binned in 4 charge bins More...
void	xsigma2 (int fxpix, int lxpix, float sxthr, float xsum[13+4], float xsig2[13+4])
float	xsize ()
	pixel x-size (microns) More...
void	xtemp (int fxbin, int lxbin, float xtemplate[41][13+4])
void	xtemp3d (int j, int k, std::vector< float > &xtemplate)
void	xtemp3d_int (int nxpix, int &nxbins)
float	xxratio ()
	fractional distance in x between cotalpha templates More...
float	yavg (int i)
	average y-bias of reconstruction binned in 4 charge bins More...
float	yavgc2m (int i)
	1st pass chi2 min search: average y-bias of reconstruction binned in 4 charge bins More...
float	yflcorr (int binq, float qfly)
float	ygsig (int i)
	average sigma_y from Gaussian fit binned in 4 charge bins More...
float	ygx0 (int i)
	average y0 from Gaussian fit binned in 4 charge bins More...
float	yratio ()
	fractional distance in y between cotbeta templates More...
float	yrms (int i)
	average y-rms of reconstruction binned in 4 charge bins More...
float	yrmsc2m (int i)
	1st pass chi2 min search: average y-rms of reconstruction binned in 4 charge bins More...
void	ysigma2 (int fypix, int lypix, float sythr, float ysum[21+4], float ysig2[21+4])
void	ysigma2 (float qpixel, int index, float &ysig2)
float	ysize ()
	pixel y-size (microns) More...
void	ytemp (int fybin, int lybin, float ytemplate[41][21+4])
void	ytemp3d (int j, int k, std::vector< float > &ytemplate)
void	ytemp3d_int (int nypix, int &nybins)
float	yxratio ()
	fractional distance in y between cotalpha templates slices More...
float	zsize ()
	pixel z-size or thickness (microns) More...

Static Public Member Functions
static void	postInit (std::vector< SiPixelTemplateStore > &thePixelTemp_)
static bool	pushfile (int filenum, std::vector< SiPixelTemplateStore > &pixelTemp, std::string dir="CalibTracker/SiPixelESProducers/data/")
static bool	pushfile (const SiPixelTemplateDBObject &dbobject, std::vector< SiPixelTemplateStore > &pixelTemp)

Private Attributes
float	abs_cotb_
	absolute value of cot beta More...
float	chi2xavg_ [4]
	average x chi^2 in 4 charge bins More...
float	chi2xavgc2m_ [4]
	1st pass chi2 min search: average x-chisq for merged clusters More...
float	chi2xavgone_
	average x chi^2 for 1 pixel clusters More...
float	chi2xmin_ [4]
	minimum of x chi^2 in 4 charge bins More...
float	chi2xminc2m_ [4]
	1st pass chi2 min search: minimum x-chisq for merged clusters More...
float	chi2xminone_
	minimum of x chi^2 for 1 pixel clusters More...
float	chi2yavg_ [4]
	average y chi^2 in 4 charge bins More...
float	chi2yavgc2m_ [4]
	1st pass chi2 min search: average y-chisq for merged clusters More...
float	chi2yavgone_
	average y chi^2 for 1 pixel clusters More...
float	chi2ymin_ [4]
	minimum of y chi^2 in 4 charge bins More...
float	chi2yminc2m_ [4]
	1st pass chi2 min search: minimum y-chisq for merged clusters More...
float	chi2yminone_
	minimum of y chi^2 for 1 pixel clusters More...
float	clslenx_
	x-cluster length of smaller interpolated template in pixels More...
float	clsleny_
	y-cluster length of smaller interpolated template in pixels More...
float	cota_current_
	current cot alpha More...
float	cotb_current_
	current cot beta More...
float	delyavg_
	average difference between clsleny_ and cluster length [with threshold effects] More...
float	delysig_
	rms of difference between clsleny_ and cluster length [with threshold effects] More...
int	dtype_
	flags BPix (=0) or FPix (=1) More...
float	dxone_
	mean offset/correction for one pixel x-clusters More...
float	dxtwo_
	mean offset/correction for one double-pixel x-clusters More...
float	dyone_
	mean offset/correction for one pixel y-clusters More...
float	dytwo_
	mean offset/correction for one double-pixel y-clusters More...
const SiPixelTemplateEntry *	entry_sideloaded_
const SiPixelTemplateEntry *	entx00_
const SiPixelTemplateEntry *	entx02_
const SiPixelTemplateEntry *	entx20_
const SiPixelTemplateEntry *	entx21_
const SiPixelTemplateEntry *	entx22_
const SiPixelTemplateEntry *	enty0_
const SiPixelTemplateEntry *	enty1_
float	fbin_ [3]
	The QBin definitions in Q_clus/Q_avg. More...
bool	flip_x_
	flip x sign-sensitive quantities More...
bool	flip_y_
	flip y sign-sensitive quantities More...
float	fracxone_
	The simulated fraction of single pixel x-clusters. More...
float	fracxtwo_
	The simulated fraction of single double-size pixel x-clusters. More...
float	fracyone_
	The simulated fraction of single pixel y-clusters. More...
float	fracytwo_
	The simulated fraction of single double-size pixel y-clusters. More...
int	id_current_
	current id More...
int	index_id_
	current index More...
float	kappavav2_
	kappa parameter for 2-cluster Vavilov distribution More...
float	kappavav_
	kappa parameter for Vavilov distribution More...
float	lorxbias_
	Lorentz x-bias. More...
float	lorxwidth_
	Lorentz x-width. More...
float	lorybias_
	Lorentz y-bias. More...
float	lorywidth_
	Lorentz y-width (sign corrected for fpix frame) More...
float	mpvvav2_
	most probable charge in 2-cluster Vavilov distribution (not actually for larger kappa) More...
float	mpvvav_
	most probable charge in Vavilov distribution (not actually for larger kappa) More...
float	nxbins_
	number of bins in each dimension of the x-splitting template More...
float	nybins_
	number of bins in each dimension of the y-splitting template More...
float	offsetx_ [4]
	x-offset in charge bins More...
float	offsety_ [4]
	y-offset in charge bins More...
float	pixmax_
	maximum pixel charge More...
float	qavg_
	average cluster charge for this set of track angles More...
float	qavg_avg_
	average of cluster charge less than qavg More...
float	qmin2_
	tighter minimum cluster charge for valid hit (keeps 99.8% of simulated hits) More...
float	qmin_
	minimum cluster charge for valid hit (keeps 99.9% of simulated hits) More...
float	qscale_
	charge scaling factor More...
float	r_qMeas_qTrue_
	ratio of measured to true cluster charges More...
float	s50_
	1/2 of the pixel single col threshold signal in electrons More...
float	scalex_ [4]
	x-error scale factor in charge bins More...
float	scalexavg_
	average x-error scale factor More...
float	scaley_ [4]
	y-error scale factor in charge bins More...
float	scaleyavg_
	average y-error scale factor More...
float	sigmavav2_
	"sigma" scale fctor for 2-cluster Vavilov distribution More...
float	sigmavav_
	"sigma" scale fctor for Vavilov distribution More...
float	ss50_
	1/2 of the pixel double col threshold signal in electrons More...
bool	success_
	true if cotalpha, cotbeta are inside of the acceptance (dynamically loaded) More...
float	sxmax_
	average pixel signal for x-projection of cluster More...
float	sxone_
	rms for one pixel x-clusters More...
float	sxparmax_
	maximum pixel signal for parameterization of x uncertainties More...
float	sxtwo_
	rms for one double-pixel x-clusters More...
float	symax_
	average pixel signal for y-projection of cluster More...
float	syone_
	rms for one pixel y-clusters More...
float	syparmax_
	maximum pixel signal for parameterization of y uncertainties More...
float	sytwo_
	rms for one double-pixel y-clusters More...
boost::multi_array< float, 2 >	temp2dx_
	2d-primitive for spltting 3-d template More...
boost::multi_array< float, 2 >	temp2dy_
	2d-primitive for spltting 3-d template More...
const std::vector < SiPixelTemplateStore > &	thePixelTemp_
float	xavg_ [4]
	average x-bias of reconstruction binned in 4 charge bins More...
float	xavgc2m_ [4]
	1st pass chi2 min search: average x-bias of reconstruction binned in 4 charge bins More...
float	xflparhh_ [4][6]
	Aqfl-parameterized x-correction in 4 charge bins for larger cotbeta, cotalpha. More...
float	xflparhl_ [4][6]
	Aqfl-parameterized x-correction in 4 charge bins for larger cotbeta, smaller cotalpha. More...
float	xflparlh_ [4][6]
	Aqfl-parameterized x-correction in 4 charge bins for smaller cotbeta, larger cotalpha. More...
float	xflparll_ [4][6]
	Aqfl-parameterized x-correction in 4 charge bins for smaller cotbeta, cotalpha. More...
float	xgsig_ [4]
	sigma from Gaussian fit binned in 4 charge bins More...
float	xgx0_ [4]
	average x0 from Gaussian fit binned in 4 charge bins More...
float	xpar0_ [2][5]
	projected x-pixel uncertainty parameterization for central cotalpha More...
float	xparh_ [2][5]
	projected x-pixel uncertainty parameterization for larger cotalpha More...
float	xparhy0_ [2][5]
	projected x-pixel uncertainty parameterization for larger cotbeta (central alpha) More...
float	xparl_ [2][5]
	projected x-pixel uncertainty parameterization for smaller cotalpha More...
float	xparly0_ [2][5]
	projected x-pixel uncertainty parameterization for smaller cotbeta (central alpha) More...
float	xrms_ [4]
	average x-rms of reconstruction binned in 4 charge bins More...
float	xrmsc2m_ [4]
	1st pass chi2 min search: average x-rms of reconstruction binned in 4 charge bins More...
float	xsize_
	Pixel x-size. More...
float	xtemp_ [9][13+4]
	templates for x-reconstruction (binned over 5 central pixels) More...
float	xxratio_
	fractional distance in x between cotalpha templates More...
float	yavg_ [4]
	average y-bias of reconstruction binned in 4 charge bins More...
float	yavgc2m_ [4]
	1st pass chi2 min search: average y-bias of reconstruction binned in 4 charge bins More...
float	yflparh_ [4][6]
	Aqfl-parameterized y-correction in 4 charge bins for larger cotbeta. More...
float	yflparl_ [4][6]
	Aqfl-parameterized y-correction in 4 charge bins for smaller cotbeta. More...
float	ygsig_ [4]
	average sigma_y from Gaussian fit binned in 4 charge bins More...
float	ygx0_ [4]
	average y0 from Gaussian fit binned in 4 charge bins More...
float	yparh_ [2][5]
	projected y-pixel uncertainty parameterization for larger cotbeta More...
float	yparl_ [2][5]
	projected y-pixel uncertainty parameterization for smaller cotbeta More...
float	yratio_
	fractional distance in y between cotbeta templates More...
float	yrms_ [4]
	average y-rms of reconstruction binned in 4 charge bins More...
float	yrmsc2m_ [4]
	1st pass chi2 min search: average y-rms of reconstruction binned in 4 charge bins More...
float	ysize_
	Pixel y-size. More...
float	ytemp_ [9][21+4]
	templates for y-reconstruction (binned over 5 central pixels) More...
float	yxratio_
	fractional distance in y between x-slices of cotalpha templates More...
float	zsize_
	Pixel z-size (thickness) More...

Detailed Description

A template management class. SiPixelTemplate contains thePixelTemp (a std::vector of SiPixelTemplateStore, each of which is a collection of many SiPixelTemplateEntries). Each SiPixelTemplateStore corresponds to a given detector condition, and is valid for a range of runs. We allow more than one Store since the may change over time.

This class reads templates from files via pushfile() method.

The main functionality of SiPixelTemplate is interpolate(), which produces a template on the fly, given a specific track's alpha and beta. The results are kept in data members and accessed via inline getters.

The resulting template is then used by PixelTempReco2D() (a global function) which get the reference for SiPixelTemplate & templ and uses the current template to reconstruct the SiPixelRecHit.

Definition at line 246 of file SiPixelTemplate.h.

Constructor & Destructor Documentation

SiPixelTemplate::SiPixelTemplate ( const std::vector< SiPixelTemplateStore > &  thePixelTemp )

inline

Constructor for cases in which template store already exists.

Definition at line 248 of file SiPixelTemplate.h.

References cota_current_, cotb_current_, entry_sideloaded_, id_current_, and index_id_.

Member Function Documentation

float SiPixelTemplate::chi2xavg ( int  i )

inline

averaage x chi^2 in 4 charge bins

Definition at line 542 of file SiPixelTemplate.h.

References cms::cuda::assert(), chi2xavg_, Exception, and mps_fire::i.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

float SiPixelTemplate::chi2xavgc2m ( int  i )

inline

1st pass chi2 min search: average x-chisq for merged clusters

Definition at line 624 of file SiPixelTemplate.h.

References cms::cuda::assert(), chi2xavgc2m_, Exception, and mps_fire::i.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::chi2xavgone ( )

inline

//!< average x chi^2 for 1 pixel clusters

Definition at line 659 of file SiPixelTemplate.h.

References chi2xavgone_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::chi2xmin ( int  i )

inline

minimum y chi^2 in 4 charge bins

Definition at line 552 of file SiPixelTemplate.h.

References cms::cuda::assert(), chi2xmin_, Exception, and mps_fire::i.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

float SiPixelTemplate::chi2xminc2m ( int  i )

inline

1st pass chi2 min search: minimum x-chisq for merged clusters

Definition at line 635 of file SiPixelTemplate.h.

References cms::cuda::assert(), chi2xminc2m_, Exception, and mps_fire::i.

float SiPixelTemplate::chi2xminone ( )

inline

//!< minimum of x chi^2 for 1 pixel clusters

Definition at line 660 of file SiPixelTemplate.h.

References chi2xminone_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::chi2yavg ( int  i )

inline

average y chi^2 in 4 charge bins

Definition at line 522 of file SiPixelTemplate.h.

References cms::cuda::assert(), chi2yavg_, Exception, and mps_fire::i.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

float SiPixelTemplate::chi2yavgc2m ( int  i )

inline

1st pass chi2 min search: average y-chisq for merged clusters

Definition at line 582 of file SiPixelTemplate.h.

References cms::cuda::assert(), chi2yavgc2m_, Exception, and mps_fire::i.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::chi2yavgone ( )

inline

//!< average y chi^2 for 1 pixel clusters

Definition at line 657 of file SiPixelTemplate.h.

References chi2yavgone_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::chi2ymin ( int  i )

inline

minimum y chi^2 in 4 charge bins

Definition at line 532 of file SiPixelTemplate.h.

References cms::cuda::assert(), chi2ymin_, Exception, and mps_fire::i.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

float SiPixelTemplate::chi2yminc2m ( int  i )

inline

1st pass chi2 min search: minimum y-chisq for merged clusters

Definition at line 593 of file SiPixelTemplate.h.

References cms::cuda::assert(), chi2yminc2m_, Exception, and mps_fire::i.

float SiPixelTemplate::chi2yminone ( )

inline

//!< minimum of y chi^2 for 1 pixel clusters

Definition at line 658 of file SiPixelTemplate.h.

References chi2yminone_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::clslenx ( )

inline

x-size of smaller interpolated template in pixels

Definition at line 438 of file SiPixelTemplate.h.

References clslenx_.

float SiPixelTemplate::clsleny ( )

inline

y-size of smaller interpolated template in pixels

Definition at line 437 of file SiPixelTemplate.h.

References clsleny_.

Referenced by PixelCPEClusterRepair::checkRecommend2D().

int SiPixelTemplate::cxtemp

(

)

Return central pixel of x-template pixels above readout threshold.

Definition at line 2709 of file SiPixelTemplate.cc.

References BXM1, BXM2, BXSIZE, and dqmiolumiharvest::j.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

{
  // Retrieve already interpolated quantities

  // Local variables
  int j;

  // Analyze only pixels along the central entry
  // First, find the maximum signal and then work out to the edges

  float sigmax = 0.f;
  float qedge = 2. * s50_;
  int jmax = -1;

  for (j = 0; j < BXSIZE; ++j) {
    if (xtemp_[4][j] > sigmax) {
      sigmax = xtemp_[4][j];
      jmax = j;
    }
  }
  if (sigmax < qedge) {
    qedge = s50_;
  }
  if (sigmax < qedge || jmax < 1 || jmax > BXM2) {
    return -1;
  }

  //  Now search forward and backward

  int jend = jmax;

  for (j = jmax + 1; j < BXM1; ++j) {
    if (xtemp_[4][j] < qedge)
      break;
    jend = j;
  }

  int jbeg = jmax;

  for (j = jmax - 1; j > 0; --j) {
    if (xtemp_[4][j] < qedge)
      break;
    jbeg = j;
  }

  return (jbeg + jend) / 2;

}  // End cxtemp

int SiPixelTemplate::cytemp

(

)

Return central pixel of y template pixels above readout threshold.

Definition at line 2656 of file SiPixelTemplate.cc.

References BYM1, BYM2, BYSIZE, and dqmiolumiharvest::j.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

{
  // Retrieve already interpolated quantities

  // Local variables
  int j;

  // Analyze only pixels along the central entry
  // First, find the maximum signal and then work out to the edges

  float sigmax = 0.f;
  float qedge = 2. * s50_;
  int jmax = -1;

  for (j = 0; j < BYSIZE; ++j) {
    if (ytemp_[4][j] > sigmax) {
      sigmax = ytemp_[4][j];
      jmax = j;
    }
  }
  if (sigmax < qedge) {
    qedge = s50_;
  }
  if (sigmax < qedge || jmax < 1 || jmax > BYM2) {
    return -1;
  }

  //  Now search forward and backward

  int jend = jmax;

  for (j = jmax + 1; j < BYM1; ++j) {
    if (ytemp_[4][j] < qedge)
      break;
    jend = j;
  }

  int jbeg = jmax;

  for (j = jmax - 1; j > 0; --j) {
    if (ytemp_[4][j] < qedge)
      break;
    jbeg = j;
  }

  return (jbeg + jend) / 2;

}  // End cytemp

float SiPixelTemplate::dxone ( )

inline

mean offset/correction for one pixel x-clusters

Definition at line 418 of file SiPixelTemplate.h.

References dxone_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::dxtwo ( )

inline

mean offset/correction for one double-pixel x-clusters

Definition at line 420 of file SiPixelTemplate.h.

References dxtwo_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::dyone ( )

inline

mean offset/correction for one pixel y-clusters

Definition at line 413 of file SiPixelTemplate.h.

References dyone_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::dytwo ( )

inline

mean offset/correction for one double-pixel y-clusters

Definition at line 415 of file SiPixelTemplate.h.

References dytwo_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::fbin ( int  i )

inline

Return lower bound of Qbin definition.

Definition at line 646 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, fbin_, and mps_fire::i.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

float SiPixelTemplate::fracxone ( )

inline

The simulated fraction of single pixel x-clusters.

Definition at line 680 of file SiPixelTemplate.h.

References fracxone_.

float SiPixelTemplate::fracxtwo ( )

inline

The simulated fraction of single double-size pixel x-clusters.

Definition at line 682 of file SiPixelTemplate.h.

References fracxtwo_.

float SiPixelTemplate::fracyone ( )

inline

The simulated fraction of single pixel y-clusters.

Definition at line 679 of file SiPixelTemplate.h.

References fracyone_.

float SiPixelTemplate::fracytwo ( )

inline

The simulated fraction of single double-size pixel y-clusters.

Definition at line 681 of file SiPixelTemplate.h.

References fracytwo_.

bool SiPixelTemplate::interpolate	(	int	id,
		float	cotalpha,
		float	cotbeta,
		float	locBz,
		float	locBx
	)

Interpolate input alpha and beta angles to produce a working template for each individual hit.

Parameters

id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014)
locBz	- (input) the sign of this quantity is used to determine whether to flip cot(beta)<0 quantities from cot(beta)>0 (FPix only) for Phase 0 FPix IP-related tracks, locBz < 0 for cot(beta) > 0 and locBz > 0 for cot(beta) < 0 for Phase 1 FPix IP-related tracks, see next comment
locBx	- (input) the sign of this quantity is used to determine whether to flip cot(alpha/beta)<0 quantities from cot(alpha/beta)>0 (FPix only) for Phase 1 FPix IP-related tracks, locBx/locBz > 0 for cot(alpha) > 0 and locBx/locBz < 0 for cot(alpha) < 0 for Phase 1 FPix IP-related tracks, locBx > 0 for cot(beta) > 0 and locBx < 0 for cot(beta) < 0

Definition at line 1328 of file SiPixelTemplate.cc.

References funct::abs(), cms::cuda::assert(), BXM1, BXM2, BXM3, BYM1, BYM2, BYM3, gather_cfg::cout, Exception, validate-o2o-wbm::f, edm::for(), mps_fire::i, gpuClustering::id, if(), edm::isFinite(), dqmiolumiharvest::j, PixelTestBeamValidation_cfi::Ny, mathSSE::sqrt(), TXSIZE, and TYSIZE.

Referenced by SiPixelLorentzAnglePCLWorker::analyze(), PixelCPEClusterRepair::checkRecommend2D(), interpolate(), SiPixelTemplateReco::PixelTempReco1D(), SiPixelTemplateSplit::PixelTempSplit(), PixelTemplateSmearerBase::smearHit(), and PixelTemplateSmearerBase::smearMergeGroup().

                                                                                                 {
  // Interpolate for a new set of track angles

  // Local variables
  int i, j;
  int ilow, ihigh, iylow, iyhigh, Ny, Nxx, Nyx, imidy, imaxx;
  float yxratio, xxratio, sxmax, qcorrect, qxtempcor, symax, chi2xavgone, chi2xminone, cota, cotb, cotalpha0, cotbeta0;
  float chi2xavg[4], chi2xmin[4], chi2xavgc2m[4], chi2xminc2m[4];

  // If the sideloading is turned on, xtemp_ and ytemp_ are already set to what they need to be.
  // So we'll just exit.
  if (entry_sideloaded_ != nullptr) {
    success_ = true;
    return success_;
  }

  // Check to see if interpolation is valid
  if (id != id_current_ || cotalpha != cota_current_ || cotbeta != cotb_current_) {
    cota_current_ = cotalpha;
    cotb_current_ = cotbeta;
    success_ = true;

    if (id != id_current_) {
      // Find the index corresponding to id

      index_id_ = -1;
      for (i = 0; i < (int)thePixelTemp_.size(); ++i) {
        //std::cout<<i<<" "<<id<<" "<<thePixelTemp_[i].head.ID<<std::endl;

        if (id == thePixelTemp_[i].head.ID) {
          index_id_ = i;
          id_current_ = id;

          // Copy the detector type to the private variable

          dtype_ = thePixelTemp_[index_id_].head.Dtype;

          // Copy the charge scaling factor to the private variable

          qscale_ = thePixelTemp_[index_id_].head.qscale;

          // Copy the pseudopixel signal size to the private variable

          s50_ = thePixelTemp_[index_id_].head.s50;

          // Copy Qbinning info to private variables

          for (j = 0; j < 3; ++j) {
            fbin_[j] = thePixelTemp_[index_id_].head.fbin[j];
          }
          //std::cout<<" set fbin  "<< fbin_[0]<<" "<<fbin_[1]<<" "<<fbin_[2]<<std::endl;

          // Pixel sizes to the private variables

          xsize_ = thePixelTemp_[index_id_].head.xsize;
          ysize_ = thePixelTemp_[index_id_].head.ysize;
          zsize_ = thePixelTemp_[index_id_].head.zsize;

          break;
        }
      }
    }

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
    if (index_id_ < 0 || index_id_ >= (int)thePixelTemp_.size()) {
      throw cms::Exception("DataCorrupt")
          << "SiPixelTemplate::interpolate can't find needed template ID = " << id << std::endl;
    }

    //check for nan's
    if (!edm::isFinite(cotalpha) || !edm::isFinite(cotbeta)) {
      success_ = false;
      return success_;
    }
#else
    assert(index_id_ >= 0 && index_id_ < (int)thePixelTemp_.size());
#endif

    //  qcorrect corrects the cot(alpha)=0 cluster charge for non-zero cot(alpha)

    cotalpha0 = thePixelTemp_[index_id_].enty[0].cotalpha;
    qcorrect =
        std::sqrt((1.f + cotbeta * cotbeta + cotalpha * cotalpha) / (1.f + cotbeta * cotbeta + cotalpha0 * cotalpha0));

    // for some cosmics, the ususal gymnastics are incorrect
    cota = cotalpha;
    cotb = abs_cotb_ = std::abs(cotbeta);
    flip_x_ = false;
    flip_y_ = false;
    switch (dtype_) {
      case 0:
        if (cotbeta < 0.f) {
          flip_y_ = true;
        }
        break;
      case 1:
        if (locBz < 0.f) {
          cotb = cotbeta;
        } else {
          cotb = -cotbeta;
          flip_y_ = true;
        }
        break;
      case 2:
      case 3:
      case 4:
      case 5:
        if (locBx * locBz < 0.f) {
          cota = -cotalpha;
          flip_x_ = true;
        }
        if (locBx > 0.f) {
          cotb = cotbeta;
        } else {
          cotb = -cotbeta;
          flip_y_ = true;
        }
        break;
      default:
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
        throw cms::Exception("DataCorrupt") << "SiPixelTemplate::illegal subdetector ID = " << dtype_ << std::endl;
#else
        std::cout << "SiPixelTemplate::illegal subdetector ID = " << dtype_ << std::endl;
#endif
    }

    Ny = thePixelTemp_[index_id_].head.NTy;
    Nyx = thePixelTemp_[index_id_].head.NTyx;
    Nxx = thePixelTemp_[index_id_].head.NTxx;

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
    if (Ny < 2 || Nyx < 1 || Nxx < 2) {
      throw cms::Exception("DataCorrupt")
          << "template ID = " << id_current_ << "has too few entries: Ny/Nyx/Nxx = " << Ny << "/" << Nyx << "/" << Nxx
          << std::endl;
    }
#else
    assert(Ny > 1 && Nyx > 0 && Nxx > 1);
#endif
    imaxx = Nyx - 1;
    imidy = Nxx / 2;

    // next, loop over all y-angle entries

    ilow = 0;
    yratio_ = 0.f;

    if (cotb >= thePixelTemp_[index_id_].enty[Ny - 1].cotbeta) {
      ilow = Ny - 2;
      yratio_ = 1.;
      success_ = false;

    } else {
      if (cotb >= thePixelTemp_[index_id_].enty[0].cotbeta) {
        for (i = 0; i < Ny - 1; ++i) {
          if (thePixelTemp_[index_id_].enty[i].cotbeta <= cotb && cotb < thePixelTemp_[index_id_].enty[i + 1].cotbeta) {
            ilow = i;
            yratio_ = (cotb - thePixelTemp_[index_id_].enty[i].cotbeta) /
                      (thePixelTemp_[index_id_].enty[i + 1].cotbeta - thePixelTemp_[index_id_].enty[i].cotbeta);
            break;
          }
        }
      } else {
        success_ = false;
      }
    }

    ihigh = ilow + 1;

    // Use pointers to the three angle pairs used in the interpolation
    //
    enty0_ = &thePixelTemp_[index_id_].enty[ilow];
    enty1_ = &thePixelTemp_[index_id_].enty[ihigh];

    // Interpolate/store all y-related quantities (flip displacements when flip_y_)

    qavg_ = (1.f - yratio_) * enty0_->qavg + yratio_ * enty1_->qavg;
    qavg_ *= qcorrect;
    symax = (1.f - yratio_) * enty0_->symax + yratio_ * enty1_->symax;
    syparmax_ = symax;
    sxmax = (1.f - yratio_) * enty0_->sxmax + yratio_ * enty1_->sxmax;
    dyone_ = (1.f - yratio_) * enty0_->dyone + yratio_ * enty1_->dyone;
    if (flip_y_) {
      dyone_ = -dyone_;
    }
    syone_ = (1.f - yratio_) * enty0_->syone + yratio_ * enty1_->syone;
    dytwo_ = (1.f - yratio_) * enty0_->dytwo + yratio_ * enty1_->dytwo;
    if (flip_y_) {
      dytwo_ = -dytwo_;
    }
    sytwo_ = (1.f - yratio_) * enty0_->sytwo + yratio_ * enty1_->sytwo;
    qmin_ = (1.f - yratio_) * enty0_->qmin + yratio_ * enty1_->qmin;
    qmin_ *= qcorrect;
    qmin2_ = (1.f - yratio_) * enty0_->qmin2 + yratio_ * enty1_->qmin2;
    qmin2_ *= qcorrect;
    mpvvav_ = (1.f - yratio_) * enty0_->mpvvav + yratio_ * enty1_->mpvvav;
    mpvvav_ *= qcorrect;
    sigmavav_ = (1.f - yratio_) * enty0_->sigmavav + yratio_ * enty1_->sigmavav;
    kappavav_ = (1.f - yratio_) * enty0_->kappavav + yratio_ * enty1_->kappavav;
    mpvvav2_ = (1.f - yratio_) * enty0_->mpvvav2 + yratio_ * enty1_->mpvvav2;
    mpvvav2_ *= qcorrect;
    sigmavav2_ = (1.f - yratio_) * enty0_->sigmavav2 + yratio_ * enty1_->sigmavav2;
    kappavav2_ = (1.f - yratio_) * enty0_->kappavav2 + yratio_ * enty1_->kappavav2;
    clsleny_ = fminf(enty0_->clsleny, enty1_->clsleny);
    qavg_avg_ = (1.f - yratio_) * enty0_->qavg_avg + yratio_ * enty1_->qavg_avg;
    qavg_avg_ *= qcorrect;
    for (i = 0; i < 2; ++i) {
      for (j = 0; j < 5; ++j) {
        // Charge loss switches sides when cot(beta) changes sign

        if (flip_y_) {
          yparl_[1 - i][j] = enty0_->ypar[i][j];
          yparh_[1 - i][j] = enty1_->ypar[i][j];
        } else {
          yparl_[i][j] = enty0_->ypar[i][j];
          yparh_[i][j] = enty1_->ypar[i][j];
        }
        if (flip_x_) {
          xparly0_[1 - i][j] = enty0_->xpar[i][j];
          xparhy0_[1 - i][j] = enty1_->xpar[i][j];
        } else {
          xparly0_[i][j] = enty0_->xpar[i][j];
          xparhy0_[i][j] = enty1_->xpar[i][j];
        }
      }
    }

    for (i = 0; i < 4; ++i) {
      yavg_[i] = (1.f - yratio_) * thePixelTemp_[index_id_].enty[ilow].yavg[i] +
                 yratio_ * thePixelTemp_[index_id_].enty[ihigh].yavg[i];
      if (flip_y_) {
        yavg_[i] = -yavg_[i];
      }
      yavg_[i] = (1.f - yratio_) * enty0_->yavg[i] + yratio_ * enty1_->yavg[i];
      if (flip_y_) {
        yavg_[i] = -yavg_[i];
      }
      yrms_[i] = (1.f - yratio_) * enty0_->yrms[i] + yratio_ * enty1_->yrms[i];
      chi2yavg_[i] = (1.f - yratio_) * enty0_->chi2yavg[i] + yratio_ * enty1_->chi2yavg[i];
      chi2ymin_[i] = (1.f - yratio_) * enty0_->chi2ymin[i] + yratio_ * enty1_->chi2ymin[i];
      chi2xavg[i] = (1.f - yratio_) * enty0_->chi2xavg[i] + yratio_ * enty1_->chi2xavg[i];
      chi2xmin[i] = (1.f - yratio_) * enty0_->chi2xmin[i] + yratio_ * enty1_->chi2xmin[i];
      yavgc2m_[i] = (1.f - yratio_) * enty0_->yavgc2m[i] + yratio_ * enty1_->yavgc2m[i];
      if (flip_y_) {
        yavgc2m_[i] = -yavgc2m_[i];
      }
      yrmsc2m_[i] = (1.f - yratio_) * enty0_->yrmsc2m[i] + yratio_ * enty1_->yrmsc2m[i];
      chi2yavgc2m_[i] = (1.f - yratio_) * enty0_->chi2yavgc2m[i] + yratio_ * enty1_->chi2yavgc2m[i];
      //          if(flip_y_) {chi2yavgc2m_[i] = -chi2yavgc2m_[i];}
      chi2yminc2m_[i] = (1.f - yratio_) * enty0_->chi2yminc2m[i] + yratio_ * enty1_->chi2yminc2m[i];
      //          xrmsc2m[i]=(1.f - yratio_)*enty0_->xrmsc2m[i] + yratio_*enty1_->xrmsc2m[i];
      chi2xavgc2m[i] = (1.f - yratio_) * enty0_->chi2xavgc2m[i] + yratio_ * enty1_->chi2xavgc2m[i];
      chi2xminc2m[i] = (1.f - yratio_) * enty0_->chi2xminc2m[i] + yratio_ * enty1_->chi2xminc2m[i];
      for (j = 0; j < 6; ++j) {
        yflparl_[i][j] = enty0_->yflpar[i][j];
        yflparh_[i][j] = enty1_->yflpar[i][j];

        // Since Q_fl is odd under cotbeta, it flips qutomatically, change only even terms

        if (flip_y_ && (j == 0 || j == 2 || j == 4)) {
          yflparl_[i][j] = -yflparl_[i][j];
          yflparh_[i][j] = -yflparh_[i][j];
        }
      }
    }


    chi2yavgone_ = (1.f - yratio_) * enty0_->chi2yavgone + yratio_ * enty1_->chi2yavgone;
    chi2yminone_ = (1.f - yratio_) * enty0_->chi2yminone + yratio_ * enty1_->chi2yminone;
    chi2xavgone = (1.f - yratio_) * enty0_->chi2xavgone + yratio_ * enty1_->chi2xavgone;
    chi2xminone = (1.f - yratio_) * enty0_->chi2xminone + yratio_ * enty1_->chi2xminone;

    fracyone_ = (1.f - yratio_) * enty0_->fracyone + yratio_ * enty1_->fracyone;
    fracytwo_ = (1.f - yratio_) * enty0_->fracytwo + yratio_ * enty1_->fracytwo;
    //       If using y-spares
    //       for(i=0; i<10; ++i) {
    //          pyspare[i]=(1.f - yratio_)*enty0_->yspare[i] + yratio_*enty1_->yspare[i];
    //       }

    // Interpolate and build the y-template

    for (i = 0; i < 9; ++i) {
      ytemp_[i][0] = 0.f;
      ytemp_[i][1] = 0.f;
      ytemp_[i][BYM2] = 0.f;
      ytemp_[i][BYM1] = 0.f;
      for (j = 0; j < TYSIZE; ++j) {
        // Flip the basic y-template when the cotbeta is negative

        if (flip_y_) {
          ytemp_[8 - i][BYM3 - j] = (1.f - yratio_) * enty0_->ytemp[i][j] + yratio_ * enty1_->ytemp[i][j];
        } else {
          ytemp_[i][j + 2] = (1.f - yratio_) * enty0_->ytemp[i][j] + yratio_ * enty1_->ytemp[i][j];
        }
      }
    }

    // next, loop over all x-angle entries, first, find relevant y-slices

    iylow = 0;
    yxratio = 0.f;

    if (abs_cotb_ >= thePixelTemp_[index_id_].entx[Nyx - 1][0].cotbeta) {
      iylow = Nyx - 2;
      yxratio = 1.f;

    } else if (abs_cotb_ >= thePixelTemp_[index_id_].entx[0][0].cotbeta) {
      for (i = 0; i < Nyx - 1; ++i) {
        if (thePixelTemp_[index_id_].entx[i][0].cotbeta <= abs_cotb_ &&
            abs_cotb_ < thePixelTemp_[index_id_].entx[i + 1][0].cotbeta) {
          iylow = i;
          yxratio = (abs_cotb_ - thePixelTemp_[index_id_].entx[i][0].cotbeta) /
                    (thePixelTemp_[index_id_].entx[i + 1][0].cotbeta - thePixelTemp_[index_id_].entx[i][0].cotbeta);
          break;
        }
      }
    }

    iyhigh = iylow + 1;

    ilow = 0;
    xxratio = 0.f;

    if (cota >= thePixelTemp_[index_id_].entx[0][Nxx - 1].cotalpha) {
      ilow = Nxx - 2;
      xxratio = 1.f;
      success_ = false;

    } else {
      if (cota >= thePixelTemp_[index_id_].entx[0][0].cotalpha) {
        for (i = 0; i < Nxx - 1; ++i) {
          if (thePixelTemp_[index_id_].entx[0][i].cotalpha <= cota &&
              cota < thePixelTemp_[index_id_].entx[0][i + 1].cotalpha) {
            ilow = i;
            xxratio = (cota - thePixelTemp_[index_id_].entx[0][i].cotalpha) /
                      (thePixelTemp_[index_id_].entx[0][i + 1].cotalpha - thePixelTemp_[index_id_].entx[0][i].cotalpha);
            break;
          }
        }
      } else {
        success_ = false;
      }
    }

    ihigh = ilow + 1;

    // Interpolate/store all x-related quantities

    yxratio_ = yxratio;
    xxratio_ = xxratio;

    // sxparmax defines the maximum charge for which the parameters xpar are defined (not rescaled by cotbeta)

    sxparmax_ = (1.f - xxratio) * thePixelTemp_[index_id_].entx[imaxx][ilow].sxmax +
                xxratio * thePixelTemp_[index_id_].entx[imaxx][ihigh].sxmax;
    sxmax_ = sxparmax_;
    if (thePixelTemp_[index_id_].entx[imaxx][imidy].sxmax != 0.f) {
      sxmax_ = sxmax_ / thePixelTemp_[index_id_].entx[imaxx][imidy].sxmax * sxmax;
    }
    symax_ = (1.f - xxratio) * thePixelTemp_[index_id_].entx[imaxx][ilow].symax +
             xxratio * thePixelTemp_[index_id_].entx[imaxx][ihigh].symax;
    if (thePixelTemp_[index_id_].entx[imaxx][imidy].symax != 0.f) {
      symax_ = symax_ / thePixelTemp_[index_id_].entx[imaxx][imidy].symax * symax;
    }
    dxone_ = (1.f - xxratio) * thePixelTemp_[index_id_].entx[0][ilow].dxone +
             xxratio * thePixelTemp_[index_id_].entx[0][ihigh].dxone;
    if (flip_x_) {
      dxone_ = -dxone_;
    }
    sxone_ = (1.f - xxratio) * thePixelTemp_[index_id_].entx[0][ilow].sxone +
             xxratio * thePixelTemp_[index_id_].entx[0][ihigh].sxone;
    dxtwo_ = (1.f - xxratio) * thePixelTemp_[index_id_].entx[0][ilow].dxtwo +
             xxratio * thePixelTemp_[index_id_].entx[0][ihigh].dxtwo;
    if (flip_x_) {
      dxtwo_ = -dxtwo_;
    }
    sxtwo_ = (1.f - xxratio) * thePixelTemp_[index_id_].entx[0][ilow].sxtwo +
             xxratio * thePixelTemp_[index_id_].entx[0][ihigh].sxtwo;
    clslenx_ = fminf(thePixelTemp_[index_id_].entx[0][ilow].clslenx, thePixelTemp_[index_id_].entx[0][ihigh].clslenx);

    for (i = 0; i < 2; ++i) {
      for (j = 0; j < 5; ++j) {
        // Charge loss switches sides when cot(alpha) changes sign
        if (flip_x_) {
          xpar0_[1 - i][j] = thePixelTemp_[index_id_].entx[imaxx][imidy].xpar[i][j];
          xparl_[1 - i][j] = thePixelTemp_[index_id_].entx[imaxx][ilow].xpar[i][j];
          xparh_[1 - i][j] = thePixelTemp_[index_id_].entx[imaxx][ihigh].xpar[i][j];
        } else {
          xpar0_[i][j] = thePixelTemp_[index_id_].entx[imaxx][imidy].xpar[i][j];
          xparl_[i][j] = thePixelTemp_[index_id_].entx[imaxx][ilow].xpar[i][j];
          xparh_[i][j] = thePixelTemp_[index_id_].entx[imaxx][ihigh].xpar[i][j];
        }
      }
    }
    // Pointers to the currently interpolated point.
    entx00_ = &thePixelTemp_[index_id_].entx[iylow][ilow];
    entx02_ = &thePixelTemp_[index_id_].entx[iylow][ihigh];
    entx20_ = &thePixelTemp_[index_id_].entx[iyhigh][ilow];
    entx22_ = &thePixelTemp_[index_id_].entx[iyhigh][ihigh];
    entx21_ = &thePixelTemp_[index_id_].entx[iyhigh][imidy];

    // pixmax is the maximum allowed pixel charge (used for truncation)
    pixmax_ = (1.f - yxratio) * ((1.f - xxratio) * entx00_->pixmax + xxratio * entx02_->pixmax) +
              yxratio * ((1.f - xxratio) * entx20_->pixmax + xxratio * entx22_->pixmax);

    r_qMeas_qTrue_ = (1.f - yxratio) * ((1.f - xxratio) * entx00_->r_qMeas_qTrue + xxratio * entx02_->r_qMeas_qTrue) +
                     yxratio * ((1.f - xxratio) * entx20_->r_qMeas_qTrue + xxratio * entx22_->r_qMeas_qTrue);

    for (i = 0; i < 4; ++i) {
      xavg_[i] = (1.f - yxratio) * ((1.f - xxratio) * entx00_->xavg[i] + xxratio * entx02_->xavg[i]) +
                 yxratio * ((1.f - xxratio) * entx20_->xavg[i] + xxratio * entx22_->xavg[i]);
      if (flip_x_) {
        xavg_[i] = -xavg_[i];
      }

      xrms_[i] = (1.f - yxratio) * ((1.f - xxratio) * entx00_->xrms[i] + xxratio * entx02_->xrms[i]) +
                 yxratio * ((1.f - xxratio) * entx20_->xrms[i] + xxratio * entx22_->xrms[i]);

      xavgc2m_[i] = (1.f - yxratio) * ((1.f - xxratio) * entx00_->xavgc2m[i] + xxratio * entx02_->xavgc2m[i]) +
                    yxratio * ((1.f - xxratio) * entx20_->xavgc2m[i] + xxratio * entx22_->xavgc2m[i]);
      if (flip_x_) {
        xavgc2m_[i] = -xavgc2m_[i];
      }

      xrmsc2m_[i] = (1.f - yxratio) * ((1.f - xxratio) * entx00_->xrmsc2m[i] + xxratio * entx02_->xrmsc2m[i]) +
                    yxratio * ((1.f - xxratio) * entx20_->xrmsc2m[i] + xxratio * entx22_->xrmsc2m[i]);
      //
      //  Try new interpolation scheme instead
      //
      //
      //          chi2xavgc2m_[i]=(1.f - yxratio)*((1.f - xxratio)*entx00_->chi2xavgc2m[i] + xxratio*entx02_->chi2xavgc2m[i])
      //                  +yxratio*((1.f - xxratio)*entx20_->chi2xavgc2m[i] + xxratio*entx22_->chi2xavgc2m[i]);

      //          chi2xminc2m_[i]=(1.f - yxratio)*((1.f - xxratio)*entx00_->chi2xminc2m[i] + xxratio*entx02_->chi2xminc2m[i])
      //                  +yxratio*((1.f - xxratio)*entx20_->chi2xminc2m[i] + xxratio*entx22_->chi2xminc2m[i]);
      //
      //          chi2xavg_[i]=((1.f - xxratio)*thePixelTemp_[index_id_].entx[imaxx][ilow].chi2xavg[i] + xxratio*thePixelTemp_[index_id_].entx[imaxx][ihigh].chi2xavg[i]);
      //          if(thePixelTemp_[index_id_].entx[imaxx][imidy].chi2xavg[i] != 0.f) {chi2xavg_[i]=chi2xavg_[i]/thePixelTemp_[index_id_].entx[imaxx][imidy].chi2xavg[i]*chi2xavg[i];}
      //
      //          chi2xmin_[i]=((1.f - xxratio)*thePixelTemp_[index_id_].entx[imaxx][ilow].chi2xmin[i] + xxratio*thePixelTemp_[index_id_].entx[imaxx][ihigh].chi2xmin[i]);
      //          if(thePixelTemp_[index_id_].entx[imaxx][imidy].chi2xmin[i] != 0.f) {chi2xmin_[i]=chi2xmin_[i]/thePixelTemp_[index_id_].entx[imaxx][imidy].chi2xmin[i]*chi2xmin[i];}
      //
      chi2xavg_[i] = ((1.f - xxratio) * entx20_->chi2xavg[i] + xxratio * entx22_->chi2xavg[i]);
      if (entx21_->chi2xavg[i] != 0.f) {
        chi2xavg_[i] = chi2xavg_[i] / entx21_->chi2xavg[i] * chi2xavg[i];
      }

      chi2xmin_[i] = ((1.f - xxratio) * entx20_->chi2xmin[i] + xxratio * entx22_->chi2xmin[i]);
      if (entx21_->chi2xmin[i] != 0.f) {
        chi2xmin_[i] = chi2xmin_[i] / entx21_->chi2xmin[i] * chi2xmin[i];
      }

      chi2xavgc2m_[i] = ((1.f - xxratio) * entx20_->chi2xavgc2m[i] + xxratio * entx22_->chi2xavgc2m[i]);
      if (entx21_->chi2xavgc2m[i] != 0.f) {
        chi2xavgc2m_[i] = chi2xavgc2m_[i] / entx21_->chi2xavgc2m[i] * chi2xavgc2m[i];
      }

      chi2xminc2m_[i] = ((1.f - xxratio) * entx20_->chi2xminc2m[i] + xxratio * entx22_->chi2xminc2m[i]);
      if (entx21_->chi2xminc2m[i] != 0.f) {
        chi2xminc2m_[i] = chi2xminc2m_[i] / entx21_->chi2xminc2m[i] * chi2xminc2m[i];
      }

      for (j = 0; j < 6; ++j) {
        xflparll_[i][j] = entx00_->xflpar[i][j];
        xflparlh_[i][j] = entx02_->xflpar[i][j];
        xflparhl_[i][j] = entx20_->xflpar[i][j];
        xflparhh_[i][j] = entx22_->xflpar[i][j];
        // Since Q_fl is odd under cotalpha, it flips qutomatically, change only even terms
        if (flip_x_ && (j == 0 || j == 2 || j == 4)) {
          xflparll_[i][j] = -xflparll_[i][j];
          xflparlh_[i][j] = -xflparlh_[i][j];
          xflparhl_[i][j] = -xflparhl_[i][j];
          xflparhh_[i][j] = -xflparhh_[i][j];
        }
      }
    }

    // Do the spares next

    chi2xavgone_ = ((1.f - xxratio) * entx20_->chi2xavgone + xxratio * entx22_->chi2xavgone);
    if (entx21_->chi2xavgone != 0.f) {
      chi2xavgone_ = chi2xavgone_ / entx21_->chi2xavgone * chi2xavgone;
    }

    chi2xminone_ = ((1.f - xxratio) * entx20_->chi2xminone + xxratio * entx22_->chi2xminone);
    if (entx21_->chi2xminone != 0.f) {
      chi2xminone_ = chi2xminone_ / entx21_->chi2xminone * chi2xminone;
    }

    fracxone_ = (1.f - yxratio) * ((1.f - xxratio) * entx00_->fracxone + xxratio * entx02_->fracxone) +
                yxratio * ((1.f - xxratio) * entx20_->fracxone + xxratio * entx22_->fracxone);
    fracxtwo_ = (1.f - yxratio) * ((1.f - xxratio) * entx00_->fracxtwo + xxratio * entx02_->fracxtwo) +
                yxratio * ((1.f - xxratio) * entx20_->fracxtwo + xxratio * entx22_->fracxtwo);

    //       If using x-spares
    //       for(i=0; i<10; ++i) {
    //        pxspare[i]=(1.f - yxratio)*((1.f - xxratio)*entx00_->xspare[i] + xxratio*entx02_->xspare[i])
    //                +yxratio*((1.f - xxratio)*entx20_->xspare[i] + xxratio*entx22_->xspare[i]);
    //       }

    // Interpolate and build the x-template

    //  qxtempcor corrects the total charge to the actual track angles (not actually needed for the template fits, but useful for Guofan)

    cotbeta0 = thePixelTemp_[index_id_].entx[iyhigh][0].cotbeta;
    qxtempcor =
        std::sqrt((1.f + cotbeta * cotbeta + cotalpha * cotalpha) / (1.f + cotbeta0 * cotbeta0 + cotalpha * cotalpha));

    for (i = 0; i < 9; ++i) {
      xtemp_[i][0] = 0.f;
      xtemp_[i][1] = 0.f;
      xtemp_[i][BXM2] = 0.f;
      xtemp_[i][BXM1] = 0.f;
      for (j = 0; j < TXSIZE; ++j) {
        //  Take next largest x-slice for the x-template (it reduces bias in the forward direction after irradiation)
        //         xtemp_[i][j+2]=(1.f - xxratio)*thePixelTemp_[index_id_].entx[imaxx][ilow].xtemp[i][j] + xxratio*thePixelTemp_[index_id_].entx[imaxx][ihigh].xtemp[i][j];
        //         xtemp_[i][j+2]=(1.f - xxratio)*entx20_->xtemp[i][j] + xxratio*entx22_->xtemp[i][j];
        if (flip_x_) {
          xtemp_[8 - i][BXM3 - j] =
              qxtempcor * ((1.f - xxratio) * entx20_->xtemp[i][j] + xxratio * entx22_->xtemp[i][j]);
        } else {
          xtemp_[i][j + 2] = qxtempcor * ((1.f - xxratio) * entx20_->xtemp[i][j] + xxratio * entx22_->xtemp[i][j]);
        }
      }
    }

    lorywidth_ = thePixelTemp_[index_id_].head.lorywidth;
    lorxwidth_ = thePixelTemp_[index_id_].head.lorxwidth;
    lorybias_ = thePixelTemp_[index_id_].head.lorybias;
    lorxbias_ = thePixelTemp_[index_id_].head.lorxbias;
    if (flip_x_) {
      lorxwidth_ = -lorxwidth_;
      lorxbias_ = -lorxbias_;
    }
    if (flip_y_) {
      lorywidth_ = -lorywidth_;
      lorybias_ = -lorybias_;
    }
  }

  return success_;
}  // interpolate

bool SiPixelTemplate::interpolate	(	int	id,
		float	cotalpha,
		float	cotbeta,
		float	locBz
	)

Interpolate input alpha and beta angles to produce a working template for each individual hit.

Parameters

id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014) Use this for Phase 0, IP related hits

Definition at line 1901 of file SiPixelTemplate.cc.

References interpolate().

                                                                                    {
  // Interpolate for a new set of track angles

  // Local variables
  float locBx = 1.f;
  return SiPixelTemplate::interpolate(id, cotalpha, cotbeta, locBz, locBx);
}

bool SiPixelTemplate::interpolate	(	int	id,
		float	cotalpha,
		float	cotbeta
	)

Interpolate input alpha and beta angles to produce a working template for each individual hit.

Parameters

id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014) Use this for Phase 1, IP related hits

Definition at line 1879 of file SiPixelTemplate.cc.

References validate-o2o-wbm::f, and interpolate().

                                                                       {
  // Interpolate for a new set of track angles

  // Local variables
  float locBx = 1.f;
  if (cotbeta < 0.f) {
    locBx = -1.f;
  }
  float locBz = locBx;
  if (cotalpha < 0.f) {
    locBz = -locBx;
  }
  return SiPixelTemplate::interpolate(id, cotalpha, cotbeta, locBz, locBx);
}

float SiPixelTemplate::kappavav ( )

inline

kappa parameter for Vavilov distribution

Definition at line 669 of file SiPixelTemplate.h.

References kappavav_.

Referenced by vavilov_pars().

float SiPixelTemplate::kappavav2 ( )

inline

kappa parameter for 2-cluster Vavilov distribution

Definition at line 674 of file SiPixelTemplate.h.

References kappavav2_.

Referenced by vavilov2_pars().

float SiPixelTemplate::lorxbias ( )

inline

signed lorentz x-width (microns)

Definition at line 666 of file SiPixelTemplate.h.

References lorxbias_.

Referenced by PixelCPETemplateReco::localPosition().

float SiPixelTemplate::lorxwidth ( )

inline

signed lorentz x-width (microns)

Definition at line 662 of file SiPixelTemplate.h.

References lorxwidth_.

float SiPixelTemplate::lorybias ( )

inline

signed lorentz y-width (microns)

Definition at line 665 of file SiPixelTemplate.h.

References lorybias_.

Referenced by PixelCPETemplateReco::localPosition().

float SiPixelTemplate::lorywidth ( )

inline

signed lorentz y-width (microns)

Definition at line 661 of file SiPixelTemplate.h.

References lorywidth_.

float SiPixelTemplate::mpvvav ( )

inline

most probable charge in Vavilov distribution (not actually for larger kappa)

Definition at line 667 of file SiPixelTemplate.h.

References mpvvav_.

Referenced by vavilov_pars().

float SiPixelTemplate::mpvvav2 ( )

inline

most probable charge in 2-cluster Vavilov distribution (not actually for larger kappa)

Definition at line 670 of file SiPixelTemplate.h.

References mpvvav2_.

Referenced by vavilov2_pars().

float SiPixelTemplate::pixmax ( )

inline

maximum pixel charge

Definition at line 408 of file SiPixelTemplate.h.

References pixmax_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

void SiPixelTemplate::postInit ( std::vector< SiPixelTemplateStore > &  thePixelTemp_ )

static

Definition at line 1288 of file SiPixelTemplate.cc.

References edm::for().

                                                                             {
  /*
    std::cout << "SiPixelTemplate size " << thePixelTemp_.size() << std::endl;
    #ifndef SI_PIXEL_TEMPLATE_USE_BOOST
    std::cout <<"uses C arrays" << std::endl;
    #endif
    
    int i=0;
    for (auto & templ : thePixelTemp_) {
    std::cout << i <<':' << templ.head.ID << ' ' << templ.head.NTy <<','<< templ.head.NTyx <<','<< templ.head.NTxx << std::endl;
    for ( auto iy=1; iy<templ.head.NTy; ++iy  ) { auto & ent = templ.enty[iy]; std::cout << ent.cotbeta <<',' << ent.cotbeta-templ.enty[iy-1].cotbeta << ' '; }
    std::cout << std::endl;
    for ( auto ix=1; ix<templ.head.NTxx; ++ix  ){ auto & ent = templ.entx[0][ix]; std::cout << ent.cotalpha <<','<< ent.cotalpha-templ.entx[0][ix-1].cotalpha << ' ';}
    std::cout << std::endl;
    ++i;
    }
    */

  for (auto& templ : thePixelTemp_) {
    for (auto iy = 0; iy < templ.head.NTy; ++iy)
      templ.cotbetaY[iy] = templ.enty[iy].cotbeta;
    for (auto iy = 0; iy < templ.head.NTyx; ++iy)
      templ.cotbetaX[iy] = templ.entx[iy][0].cotbeta;
    for (auto ix = 0; ix < templ.head.NTxx; ++ix)
      templ.cotalphaX[ix] = templ.entx[0][ix].cotalpha;
  }
}

bool SiPixelTemplate::pushfile ( int  filenum, std::vector< SiPixelTemplateStore > &  pixelTemp, std::string  dir = "CalibTracker/SiPixelESProducers/data/"  )

static

This routine initializes the global template structures from an external file template_summary_zpNNNN where NNNN are four digits of filenum.

Parameters

filenum

- an integer NNNN used in the filename template_summary_zpNNNN

Alt implementation: for (unsigned cnt=4-tempfile.length(); cnt > 0; cnt– ){ tempfile = "0" + tempfile; }

Definition at line 130 of file SiPixelTemplate.cc.

References SiPixelTemplateEntry::alpha, SiPixelTemplateEntry::beta, SiPixelTemplateHeader::Bfield, c, SiPixelTemplateEntry::chi2xavg, SiPixelTemplateEntry::chi2xavgc2m, SiPixelTemplateEntry::chi2xavgone, SiPixelTemplateEntry::chi2xmin, SiPixelTemplateEntry::chi2xminc2m, SiPixelTemplateEntry::chi2xminone, SiPixelTemplateEntry::chi2yavg, SiPixelTemplateEntry::chi2yavgc2m, SiPixelTemplateEntry::chi2yavgone, SiPixelTemplateEntry::chi2ymin, SiPixelTemplateEntry::chi2yminc2m, SiPixelTemplateEntry::chi2yminone, SiPixelTemplateEntry::clslenx, SiPixelTemplateEntry::clsleny, SiPixelTemplateEntry::costrk, SiPixelTemplateEntry::cotalpha, SiPixelTemplateStore::cotalphaX, SiPixelTemplateEntry::cotbeta, SiPixelTemplateStore::cotbetaX, SiPixelTemplateStore::cotbetaY, SiPixelTemplateHeader::Dtype, SiPixelTemplateEntry::dxone, SiPixelTemplateEntry::dxtwo, SiPixelTemplateEntry::dyone, SiPixelTemplateEntry::dytwo, ENDL, SiPixelTemplateStore::entx, SiPixelTemplateStore::enty, SiPixelTemplateHeader::fbin, mergeVDriftHistosByStation::file, SiPixelTemplateHeader::fluence, SiPixelTemplateEntry::fracxone, SiPixelTemplateEntry::fracxtwo, SiPixelTemplateEntry::fracyone, SiPixelTemplateEntry::fracytwo, edm::FileInPath::fullPath(), SiPixelTemplateStore::head, mps_fire::i, SiPixelTemplateHeader::ID, dqmiolumiharvest::j, isotrackApplyRegressor::k, SiPixelTemplateEntry::kappavav, SiPixelTemplateEntry::kappavav2, cmsLHEtoEOSManager::l, LOGERROR, LOGINFO, SiPixelTemplateHeader::lorxbias, SiPixelTemplateHeader::lorxwidth, SiPixelTemplateHeader::lorybias, SiPixelTemplateHeader::lorywidth, SiPixelTemplateEntry::mpvvav, SiPixelTemplateEntry::mpvvav2, SiPixelTemplateHeader::NTxx, SiPixelTemplateHeader::NTy, SiPixelTemplateHeader::NTyx, SiPixelTemplateEntry::pixmax, SiPixelTemplateEntry::qavg, SiPixelTemplateEntry::qavg_avg, SiPixelTemplateEntry::qbfrac, SiPixelTemplateEntry::qmin, SiPixelTemplateEntry::qmin2, SiPixelTemplateHeader::qscale, SiPixelTemplateEntry::r_qMeas_qTrue, SiPixelTemplateEntry::runnum, SiPixelTemplateHeader::s50, SiPixelTemplateEntry::sigmavav, SiPixelTemplateEntry::sigmavav2, SiPixelTemplateEntry::spare, SiPixelTemplateHeader::ss50, AlCaHLTBitMon_QueryRunRegistry::string, SiPixelTemplateEntry::sxmax, SiPixelTemplateEntry::sxone, SiPixelTemplateEntry::sxtwo, SiPixelTemplateEntry::symax, SiPixelTemplateEntry::syone, SiPixelTemplateEntry::sytwo, SiPixelTemplateHeader::temperature, SiPixelTemplateHeader::templ_version, SiPixelTemplateHeader::title, cond::impl::to_string(), TXSIZE, TYSIZE, SiPixelTemplateHeader::Vbias, SiPixelTemplateEntry::xavg, SiPixelTemplateEntry::xavgc2m, SiPixelTemplateEntry::xavggen, SiPixelTemplateEntry::xflpar, SiPixelTemplateEntry::xgsig, SiPixelTemplateEntry::xgsiggen, SiPixelTemplateEntry::xgx0, SiPixelTemplateEntry::xgx0gen, SiPixelTemplateEntry::xpar, SiPixelTemplateEntry::xrms, SiPixelTemplateEntry::xrmsc2m, SiPixelTemplateEntry::xrmsgen, SiPixelTemplateHeader::xsize, SiPixelTemplateEntry::xtemp, SiPixelTemplateEntry::yavg, SiPixelTemplateEntry::yavgc2m, SiPixelTemplateEntry::yavggen, SiPixelTemplateEntry::yflpar, SiPixelTemplateEntry::ygsig, SiPixelTemplateEntry::ygsiggen, SiPixelTemplateEntry::ygx0, SiPixelTemplateEntry::ygx0gen, SiPixelTemplateEntry::ypar, SiPixelTemplateEntry::yrms, SiPixelTemplateEntry::yrmsc2m, SiPixelTemplateEntry::yrmsgen, SiPixelTemplateHeader::ysize, SiPixelTemplateEntry::ytemp, and SiPixelTemplateHeader::zsize.

Referenced by TrackingRecHitProducer::beginRun(), SiPixelLorentzAnglePCLWorker::dqmBeginRun(), PixelCPEClusterRepair::PixelCPEClusterRepair(), PixelCPETemplateReco::PixelCPETemplateReco(), and PixelTemplateSmearerBase::PixelTemplateSmearerBase().

                                                                                                     {
  // Add template stored in external file numbered filenum to theTemplateStore

  // Local variables
  int i, j, k, l;
  float qavg_avg;
  char c;
  const int code_version = {17};

  //  Create a filename for this run
  std::string tempfile = std::to_string(filenum);

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  // If integer filenum has less than 4 digits, prepend 0's until we have four numerical characters, e.g. "0292"
  int nzeros = 4 - tempfile.length();
  if (nzeros > 0)
    tempfile = std::string(nzeros, '0') + tempfile;

  tempfile = dir + "template_summary_zp" + tempfile + ".out";
  edm::FileInPath file(tempfile);  // Find the file in CMSSW
  tempfile = file.fullPath();      // Put it back with the whole path.

#else
  // This is the same as above, but more elegant.  (Elegance not allowed in CMSSW...)
  std::ostringstream tout;
  tout << "template_summary_zp" << std::setw(4) << std::setfill('0') << std::right << filenum << ".out" << std::ends;
  tempfile = tout.str();

#endif

  //  Open the template file
  //
  std::ifstream in_file(tempfile);
  if (in_file.is_open() && in_file.good()) {
    // Create a local template storage entry

    SiPixelTemplateStore theCurrentTemp;

    // Read-in a header string first and print it

    for (i = 0; (c = in_file.get()) != '\n'; ++i) {
      if (i < 79) {
        theCurrentTemp.head.title[i] = c;
      }
    }
    if (i > 78) {
      i = 78;
    }
    theCurrentTemp.head.title[i + 1] = '\0';
    LOGINFO("SiPixelTemplate") << "Loading Pixel Template File - " << theCurrentTemp.head.title << ENDL;

    // next, the header information

    in_file >> theCurrentTemp.head.ID >> theCurrentTemp.head.templ_version >> theCurrentTemp.head.Bfield >>
        theCurrentTemp.head.NTy >> theCurrentTemp.head.NTyx >> theCurrentTemp.head.NTxx >> theCurrentTemp.head.Dtype >>
        theCurrentTemp.head.Vbias >> theCurrentTemp.head.temperature >> theCurrentTemp.head.fluence >>
        theCurrentTemp.head.qscale >> theCurrentTemp.head.s50 >> theCurrentTemp.head.lorywidth >>
        theCurrentTemp.head.lorxwidth >> theCurrentTemp.head.ysize >> theCurrentTemp.head.xsize >>
        theCurrentTemp.head.zsize;

    if (in_file.fail()) {
      LOGERROR("SiPixelTemplate") << "Error reading file 0A, no template load" << ENDL;
      return false;
    }

    if (theCurrentTemp.head.templ_version > 17) {
      in_file >> theCurrentTemp.head.ss50 >> theCurrentTemp.head.lorybias >> theCurrentTemp.head.lorxbias >>
          theCurrentTemp.head.fbin[0] >> theCurrentTemp.head.fbin[1] >> theCurrentTemp.head.fbin[2];

      if (in_file.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 0B, no template load" << ENDL;
        return false;
      }
    } else {
      theCurrentTemp.head.ss50 = theCurrentTemp.head.s50;
      theCurrentTemp.head.lorybias = theCurrentTemp.head.lorywidth / 2.f;
      theCurrentTemp.head.lorxbias = theCurrentTemp.head.lorxwidth / 2.f;
      theCurrentTemp.head.fbin[0] = 1.5f;
      theCurrentTemp.head.fbin[1] = 1.00f;
      theCurrentTemp.head.fbin[2] = 0.85f;
    }

    LOGINFO("SiPixelTemplate") << "Template ID = " << theCurrentTemp.head.ID << ", Template Version "
                               << theCurrentTemp.head.templ_version << ", Bfield = " << theCurrentTemp.head.Bfield
                               << ", NTy = " << theCurrentTemp.head.NTy << ", NTyx = " << theCurrentTemp.head.NTyx
                               << ", NTxx = " << theCurrentTemp.head.NTxx << ", Dtype = " << theCurrentTemp.head.Dtype
                               << ", Bias voltage " << theCurrentTemp.head.Vbias << ", temperature "
                               << theCurrentTemp.head.temperature << ", fluence " << theCurrentTemp.head.fluence
                               << ", Q-scaling factor " << theCurrentTemp.head.qscale << ", 1/2 multi dcol threshold "
                               << theCurrentTemp.head.s50 << ", 1/2 single dcol threshold " << theCurrentTemp.head.ss50
                               << ", y Lorentz Width " << theCurrentTemp.head.lorywidth << ", y Lorentz Bias "
                               << theCurrentTemp.head.lorybias << ", x Lorentz width " << theCurrentTemp.head.lorxwidth
                               << ", x Lorentz Bias " << theCurrentTemp.head.lorxbias
                               << ", Q/Q_avg fractions for Qbin defs " << theCurrentTemp.head.fbin[0] << ", "
                               << theCurrentTemp.head.fbin[1] << ", " << theCurrentTemp.head.fbin[2]
                               << ", pixel x-size " << theCurrentTemp.head.xsize << ", y-size "
                               << theCurrentTemp.head.ysize << ", zsize " << theCurrentTemp.head.zsize << ENDL;

    if (theCurrentTemp.head.templ_version < code_version) {
      LOGERROR("SiPixelTemplate") << "code expects version " << code_version << " finds "
                                  << theCurrentTemp.head.templ_version << ", no template load" << ENDL;
      return false;
    }

#ifdef SI_PIXEL_TEMPLATE_USE_BOOST

    // next, layout the 1-d/2-d structures needed to store template

    theCurrentTemp.cotbetaY = std::vector<float>(theCurrentTemp.head.NTy);
    theCurrentTemp.cotbetaX = std::vector<float>(theCurrentTemp.head.NTyx);
    theCurrentTemp.cotalphaX = std::vector<float>(theCurrentTemp.head.NTxx);

    theCurrentTemp.enty.resize(boost::extents[theCurrentTemp.head.NTy]);

    theCurrentTemp.entx.resize(boost::extents[theCurrentTemp.head.NTyx][theCurrentTemp.head.NTxx]);

#endif

    // next, loop over all y-angle entries

    for (i = 0; i < theCurrentTemp.head.NTy; ++i) {
      in_file >> theCurrentTemp.enty[i].runnum >> theCurrentTemp.enty[i].costrk[0] >>
          theCurrentTemp.enty[i].costrk[1] >> theCurrentTemp.enty[i].costrk[2];

      if (in_file.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 1, no template load, run # " << theCurrentTemp.enty[i].runnum
                                    << ENDL;
        return false;
      }

      // Calculate the alpha, beta, and cot(beta) for this entry

      theCurrentTemp.enty[i].alpha =
          static_cast<float>(atan2((double)theCurrentTemp.enty[i].costrk[2], (double)theCurrentTemp.enty[i].costrk[0]));

      theCurrentTemp.enty[i].cotalpha = theCurrentTemp.enty[i].costrk[0] / theCurrentTemp.enty[i].costrk[2];

      theCurrentTemp.enty[i].beta =
          static_cast<float>(atan2((double)theCurrentTemp.enty[i].costrk[2], (double)theCurrentTemp.enty[i].costrk[1]));

      theCurrentTemp.enty[i].cotbeta = theCurrentTemp.enty[i].costrk[1] / theCurrentTemp.enty[i].costrk[2];

      in_file >> theCurrentTemp.enty[i].qavg >> theCurrentTemp.enty[i].pixmax >> theCurrentTemp.enty[i].symax >>
          theCurrentTemp.enty[i].dyone >> theCurrentTemp.enty[i].syone >> theCurrentTemp.enty[i].sxmax >>
          theCurrentTemp.enty[i].dxone >> theCurrentTemp.enty[i].sxone;

      if (in_file.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 2, no template load, run # " << theCurrentTemp.enty[i].runnum
                                    << ENDL;
        return false;
      }

      in_file >> theCurrentTemp.enty[i].dytwo >> theCurrentTemp.enty[i].sytwo >> theCurrentTemp.enty[i].dxtwo >>
          theCurrentTemp.enty[i].sxtwo >> theCurrentTemp.enty[i].qmin >> theCurrentTemp.enty[i].clsleny >>
          theCurrentTemp.enty[i].clslenx;

      if (in_file.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 3, no template load, run # " << theCurrentTemp.enty[i].runnum
                                    << ENDL;
        return false;
      }

      if (theCurrentTemp.enty[i].qmin <= 0.) {
        LOGERROR("SiPixelTemplate") << "Error in template ID " << theCurrentTemp.head.ID
                                    << " qmin = " << theCurrentTemp.enty[i].qmin << ", run # "
                                    << theCurrentTemp.enty[i].runnum << ENDL;
        return false;
      }

      for (j = 0; j < 2; ++j) {
        in_file >> theCurrentTemp.enty[i].ypar[j][0] >> theCurrentTemp.enty[i].ypar[j][1] >>
            theCurrentTemp.enty[i].ypar[j][2] >> theCurrentTemp.enty[i].ypar[j][3] >> theCurrentTemp.enty[i].ypar[j][4];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 4, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 9; ++j) {
        for (k = 0; k < TYSIZE; ++k) {
          in_file >> theCurrentTemp.enty[i].ytemp[j][k];
        }

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 5, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 2; ++j) {
        in_file >> theCurrentTemp.enty[i].xpar[j][0] >> theCurrentTemp.enty[i].xpar[j][1] >>
            theCurrentTemp.enty[i].xpar[j][2] >> theCurrentTemp.enty[i].xpar[j][3] >> theCurrentTemp.enty[i].xpar[j][4];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 6, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      qavg_avg = 0.f;
      for (j = 0; j < 9; ++j) {
        for (k = 0; k < TXSIZE; ++k) {
          in_file >> theCurrentTemp.enty[i].xtemp[j][k];
          qavg_avg += theCurrentTemp.enty[i].xtemp[j][k];
        }

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 7, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }
      theCurrentTemp.enty[i].qavg_avg = qavg_avg / 9.;

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].yavg[j] >> theCurrentTemp.enty[i].yrms[j] >> theCurrentTemp.enty[i].ygx0[j] >>
            theCurrentTemp.enty[i].ygsig[j];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 8, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].yflpar[j][0] >> theCurrentTemp.enty[i].yflpar[j][1] >>
            theCurrentTemp.enty[i].yflpar[j][2] >> theCurrentTemp.enty[i].yflpar[j][3] >>
            theCurrentTemp.enty[i].yflpar[j][4] >> theCurrentTemp.enty[i].yflpar[j][5];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 9, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].xavg[j] >> theCurrentTemp.enty[i].xrms[j] >> theCurrentTemp.enty[i].xgx0[j] >>
            theCurrentTemp.enty[i].xgsig[j];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 10, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].xflpar[j][0] >> theCurrentTemp.enty[i].xflpar[j][1] >>
            theCurrentTemp.enty[i].xflpar[j][2] >> theCurrentTemp.enty[i].xflpar[j][3] >>
            theCurrentTemp.enty[i].xflpar[j][4] >> theCurrentTemp.enty[i].xflpar[j][5];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 11, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].chi2yavg[j] >> theCurrentTemp.enty[i].chi2ymin[j] >>
            theCurrentTemp.enty[i].chi2xavg[j] >> theCurrentTemp.enty[i].chi2xmin[j];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 12, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].yavgc2m[j] >> theCurrentTemp.enty[i].yrmsc2m[j] >>
            theCurrentTemp.enty[i].chi2yavgc2m[j] >> theCurrentTemp.enty[i].chi2yminc2m[j];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 13, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].xavgc2m[j] >> theCurrentTemp.enty[i].xrmsc2m[j] >>
            theCurrentTemp.enty[i].chi2xavgc2m[j] >> theCurrentTemp.enty[i].chi2xminc2m[j];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 14, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].yavggen[j] >> theCurrentTemp.enty[i].yrmsgen[j] >>
            theCurrentTemp.enty[i].ygx0gen[j] >> theCurrentTemp.enty[i].ygsiggen[j];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 14a, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        in_file >> theCurrentTemp.enty[i].xavggen[j] >> theCurrentTemp.enty[i].xrmsgen[j] >>
            theCurrentTemp.enty[i].xgx0gen[j] >> theCurrentTemp.enty[i].xgsiggen[j];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 14b, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      in_file >> theCurrentTemp.enty[i].chi2yavgone >> theCurrentTemp.enty[i].chi2yminone >>
          theCurrentTemp.enty[i].chi2xavgone >> theCurrentTemp.enty[i].chi2xminone >> theCurrentTemp.enty[i].qmin2 >>
          theCurrentTemp.enty[i].mpvvav >> theCurrentTemp.enty[i].sigmavav >> theCurrentTemp.enty[i].kappavav >>
          theCurrentTemp.enty[i].r_qMeas_qTrue >> theCurrentTemp.enty[i].spare[0];

      if (in_file.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 15, no template load, run # "
                                    << theCurrentTemp.enty[i].runnum << ENDL;
        return false;
      }

      in_file >> theCurrentTemp.enty[i].mpvvav2 >> theCurrentTemp.enty[i].sigmavav2 >>
          theCurrentTemp.enty[i].kappavav2 >> theCurrentTemp.enty[i].qbfrac[0] >> theCurrentTemp.enty[i].qbfrac[1] >>
          theCurrentTemp.enty[i].qbfrac[2] >> theCurrentTemp.enty[i].fracyone >> theCurrentTemp.enty[i].fracxone >>
          theCurrentTemp.enty[i].fracytwo >> theCurrentTemp.enty[i].fracxtwo;
      //        theCurrentTemp.enty[i].qbfrac[3] = 1. - theCurrentTemp.enty[i].qbfrac[0] - theCurrentTemp.enty[i].qbfrac[1] - theCurrentTemp.enty[i].qbfrac[2];

      if (in_file.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 16, no template load, run # "
                                    << theCurrentTemp.enty[i].runnum << ENDL;
        return false;
      }
    }

    // next, loop over all barrel x-angle entries

    for (k = 0; k < theCurrentTemp.head.NTyx; ++k) {
      for (i = 0; i < theCurrentTemp.head.NTxx; ++i) {
        in_file >> theCurrentTemp.entx[k][i].runnum >> theCurrentTemp.entx[k][i].costrk[0] >>
            theCurrentTemp.entx[k][i].costrk[1] >> theCurrentTemp.entx[k][i].costrk[2];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 17, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }

        // Calculate the alpha, beta, and cot(beta) for this entry

        theCurrentTemp.entx[k][i].alpha = static_cast<float>(
            atan2((double)theCurrentTemp.entx[k][i].costrk[2], (double)theCurrentTemp.entx[k][i].costrk[0]));

        theCurrentTemp.entx[k][i].cotalpha = theCurrentTemp.entx[k][i].costrk[0] / theCurrentTemp.entx[k][i].costrk[2];

        theCurrentTemp.entx[k][i].beta = static_cast<float>(
            atan2((double)theCurrentTemp.entx[k][i].costrk[2], (double)theCurrentTemp.entx[k][i].costrk[1]));

        theCurrentTemp.entx[k][i].cotbeta = theCurrentTemp.entx[k][i].costrk[1] / theCurrentTemp.entx[k][i].costrk[2];

        in_file >> theCurrentTemp.entx[k][i].qavg >> theCurrentTemp.entx[k][i].pixmax >>
            theCurrentTemp.entx[k][i].symax >> theCurrentTemp.entx[k][i].dyone >> theCurrentTemp.entx[k][i].syone >>
            theCurrentTemp.entx[k][i].sxmax >> theCurrentTemp.entx[k][i].dxone >> theCurrentTemp.entx[k][i].sxone;

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 18, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }

        in_file >> theCurrentTemp.entx[k][i].dytwo >> theCurrentTemp.entx[k][i].sytwo >>
            theCurrentTemp.entx[k][i].dxtwo >> theCurrentTemp.entx[k][i].sxtwo >> theCurrentTemp.entx[k][i].qmin >>
            theCurrentTemp.entx[k][i].clsleny >> theCurrentTemp.entx[k][i].clslenx;
        //             >> theCurrentTemp.entx[k][i].mpvvav >> theCurrentTemp.entx[k][i].sigmavav >> theCurrentTemp.entx[k][i].kappavav;

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 19, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }

        for (j = 0; j < 2; ++j) {
          in_file >> theCurrentTemp.entx[k][i].ypar[j][0] >> theCurrentTemp.entx[k][i].ypar[j][1] >>
              theCurrentTemp.entx[k][i].ypar[j][2] >> theCurrentTemp.entx[k][i].ypar[j][3] >>
              theCurrentTemp.entx[k][i].ypar[j][4];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 20, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 9; ++j) {
          for (l = 0; l < TYSIZE; ++l) {
            in_file >> theCurrentTemp.entx[k][i].ytemp[j][l];
          }

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 21, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 2; ++j) {
          in_file >> theCurrentTemp.entx[k][i].xpar[j][0] >> theCurrentTemp.entx[k][i].xpar[j][1] >>
              theCurrentTemp.entx[k][i].xpar[j][2] >> theCurrentTemp.entx[k][i].xpar[j][3] >>
              theCurrentTemp.entx[k][i].xpar[j][4];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 22, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        qavg_avg = 0.f;
        for (j = 0; j < 9; ++j) {
          for (l = 0; l < TXSIZE; ++l) {
            in_file >> theCurrentTemp.entx[k][i].xtemp[j][l];
            qavg_avg += theCurrentTemp.entx[k][i].xtemp[j][l];
          }

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 23, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }
        theCurrentTemp.entx[k][i].qavg_avg = qavg_avg / 9.;

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].yavg[j] >> theCurrentTemp.entx[k][i].yrms[j] >>
              theCurrentTemp.entx[k][i].ygx0[j] >> theCurrentTemp.entx[k][i].ygsig[j];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 24, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].yflpar[j][0] >> theCurrentTemp.entx[k][i].yflpar[j][1] >>
              theCurrentTemp.entx[k][i].yflpar[j][2] >> theCurrentTemp.entx[k][i].yflpar[j][3] >>
              theCurrentTemp.entx[k][i].yflpar[j][4] >> theCurrentTemp.entx[k][i].yflpar[j][5];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 25, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].xavg[j] >> theCurrentTemp.entx[k][i].xrms[j] >>
              theCurrentTemp.entx[k][i].xgx0[j] >> theCurrentTemp.entx[k][i].xgsig[j];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 26, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].xflpar[j][0] >> theCurrentTemp.entx[k][i].xflpar[j][1] >>
              theCurrentTemp.entx[k][i].xflpar[j][2] >> theCurrentTemp.entx[k][i].xflpar[j][3] >>
              theCurrentTemp.entx[k][i].xflpar[j][4] >> theCurrentTemp.entx[k][i].xflpar[j][5];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 27, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].chi2yavg[j] >> theCurrentTemp.entx[k][i].chi2ymin[j] >>
              theCurrentTemp.entx[k][i].chi2xavg[j] >> theCurrentTemp.entx[k][i].chi2xmin[j];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 28, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].yavgc2m[j] >> theCurrentTemp.entx[k][i].yrmsc2m[j] >>
              theCurrentTemp.entx[k][i].chi2yavgc2m[j] >> theCurrentTemp.entx[k][i].chi2yminc2m[j];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 29, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].xavgc2m[j] >> theCurrentTemp.entx[k][i].xrmsc2m[j] >>
              theCurrentTemp.entx[k][i].chi2xavgc2m[j] >> theCurrentTemp.entx[k][i].chi2xminc2m[j];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 30, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].yavggen[j] >> theCurrentTemp.entx[k][i].yrmsgen[j] >>
              theCurrentTemp.entx[k][i].ygx0gen[j] >> theCurrentTemp.entx[k][i].ygsiggen[j];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 30a, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          in_file >> theCurrentTemp.entx[k][i].xavggen[j] >> theCurrentTemp.entx[k][i].xrmsgen[j] >>
              theCurrentTemp.entx[k][i].xgx0gen[j] >> theCurrentTemp.entx[k][i].xgsiggen[j];

          if (in_file.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 30b, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        in_file >> theCurrentTemp.entx[k][i].chi2yavgone >> theCurrentTemp.entx[k][i].chi2yminone >>
            theCurrentTemp.entx[k][i].chi2xavgone >> theCurrentTemp.entx[k][i].chi2xminone >>
            theCurrentTemp.entx[k][i].qmin2 >> theCurrentTemp.entx[k][i].mpvvav >> theCurrentTemp.entx[k][i].sigmavav >>
            theCurrentTemp.entx[k][i].kappavav >> theCurrentTemp.entx[k][i].r_qMeas_qTrue >>
            theCurrentTemp.entx[k][i].spare[0];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 31, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }

        in_file >> theCurrentTemp.entx[k][i].mpvvav2 >> theCurrentTemp.entx[k][i].sigmavav2 >>
            theCurrentTemp.entx[k][i].kappavav2 >> theCurrentTemp.entx[k][i].qbfrac[0] >>
            theCurrentTemp.entx[k][i].qbfrac[1] >> theCurrentTemp.entx[k][i].qbfrac[2] >>
            theCurrentTemp.entx[k][i].fracyone >> theCurrentTemp.entx[k][i].fracxone >>
            theCurrentTemp.entx[k][i].fracytwo >> theCurrentTemp.entx[k][i].fracxtwo;
        //      theCurrentTemp.entx[k][i].qbfrac[3] = 1. - theCurrentTemp.entx[k][i].qbfrac[0] - theCurrentTemp.entx[k][i].qbfrac[1] - theCurrentTemp.entx[k][i].qbfrac[2];

        if (in_file.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 32, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }
      }
    }

    in_file.close();

    // Add this template to the store

    pixelTemp.push_back(theCurrentTemp);

    postInit(pixelTemp);
    return true;

  } else {
    // If file didn't open, report this

    LOGERROR("SiPixelTemplate") << "Error opening File" << tempfile << ENDL;
    return false;
  }

}  // TempInit

bool SiPixelTemplate::pushfile ( const SiPixelTemplateDBObject &  dbobject, std::vector< SiPixelTemplateStore > &  pixelTemp  )

static

This routine initializes the global template structures from an external file template_summary_zpNNNN where NNNN are four digits

Parameters

dbobject

- db storing multiple template calibrations

SiPixelTemplateStore theCurrentTemp; // large, don't allocate it on the stack

Definition at line 724 of file SiPixelTemplate.cc.

References SiPixelTemplateDBObject::char2float::c, EcalCondDB::db, ENDL, SiPixelTemplateDBObject::char2float::f, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, cmsLHEtoEOSManager::l, LOGERROR, LOGINFO, visualization-live-secondInstance_cfg::m, SiPixelTemplateDBObject::reader(), groupFilesInBlocks::temp, TXSIZE, and TYSIZE.

                                                                                                                  {
  // Add template stored in external dbobject to theTemplateStore

  // Local variables
  int i, j, k, l;
  float qavg_avg;
  const int code_version = {17};

  // We must create a new object because dbobject must be a const and our stream must not be
  auto db(dbobject.reader());

  // Create a local template storage entry
  auto tmpPtr = std::make_unique<SiPixelTemplateStore>();  // must be allocated on the heap instead
  auto& theCurrentTemp = *tmpPtr;

  // Fill the template storage for each template calibration stored in the db
  for (int m = 0; m < db.numOfTempl(); ++m) {
    // Read-in a header string first and print it

    SiPixelTemplateDBObject::char2float temp;
    for (i = 0; i < 20; ++i) {
      temp.f = db.sVector()[db.index()];
      theCurrentTemp.head.title[4 * i] = temp.c[0];
      theCurrentTemp.head.title[4 * i + 1] = temp.c[1];
      theCurrentTemp.head.title[4 * i + 2] = temp.c[2];
      theCurrentTemp.head.title[4 * i + 3] = temp.c[3];
      db.incrementIndex(1);
    }
    theCurrentTemp.head.title[79] = '\0';
    LOGINFO("SiPixelTemplate") << "Loading Pixel Template File - " << theCurrentTemp.head.title << ENDL;

    // next, the header information

    db >> theCurrentTemp.head.ID >> theCurrentTemp.head.templ_version >> theCurrentTemp.head.Bfield >>
        theCurrentTemp.head.NTy >> theCurrentTemp.head.NTyx >> theCurrentTemp.head.NTxx >> theCurrentTemp.head.Dtype >>
        theCurrentTemp.head.Vbias >> theCurrentTemp.head.temperature >> theCurrentTemp.head.fluence >>
        theCurrentTemp.head.qscale >> theCurrentTemp.head.s50 >> theCurrentTemp.head.lorywidth >>
        theCurrentTemp.head.lorxwidth >> theCurrentTemp.head.ysize >> theCurrentTemp.head.xsize >>
        theCurrentTemp.head.zsize;

    if (db.fail()) {
      LOGERROR("SiPixelTemplate") << "Error reading file 0A, no template load" << ENDL;
      return false;
    }

    LOGINFO("SiPixelTemplate") << "Loading Pixel Template File - " << theCurrentTemp.head.title
                               << " code version = " << code_version << " object version "
                               << theCurrentTemp.head.templ_version << ENDL;

    if (theCurrentTemp.head.templ_version > 17) {
      db >> theCurrentTemp.head.ss50 >> theCurrentTemp.head.lorybias >> theCurrentTemp.head.lorxbias >>
          theCurrentTemp.head.fbin[0] >> theCurrentTemp.head.fbin[1] >> theCurrentTemp.head.fbin[2];

      if (db.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 0B, no template load" << ENDL;
        return false;
      }
    } else {
      theCurrentTemp.head.ss50 = theCurrentTemp.head.s50;
      theCurrentTemp.head.lorybias = theCurrentTemp.head.lorywidth / 2.f;
      theCurrentTemp.head.lorxbias = theCurrentTemp.head.lorxwidth / 2.f;
      theCurrentTemp.head.fbin[0] = 1.50f;
      theCurrentTemp.head.fbin[1] = 1.00f;
      theCurrentTemp.head.fbin[2] = 0.85f;
      //std::cout<<" set fbin  "<< theCurrentTemp.head.fbin[0]<<" "<<theCurrentTemp.head.fbin[1]<<" "
      //         <<theCurrentTemp.head.fbin[2]<<std::endl;
    }

    LOGINFO("SiPixelTemplate") << "Template ID = " << theCurrentTemp.head.ID << ", Template Version "
                               << theCurrentTemp.head.templ_version << ", Bfield = " << theCurrentTemp.head.Bfield
                               << ", NTy = " << theCurrentTemp.head.NTy << ", NTyx = " << theCurrentTemp.head.NTyx
                               << ", NTxx = " << theCurrentTemp.head.NTxx << ", Dtype = " << theCurrentTemp.head.Dtype
                               << ", Bias voltage " << theCurrentTemp.head.Vbias << ", temperature "
                               << theCurrentTemp.head.temperature << ", fluence " << theCurrentTemp.head.fluence
                               << ", Q-scaling factor " << theCurrentTemp.head.qscale << ", 1/2 multi dcol threshold "
                               << theCurrentTemp.head.s50 << ", 1/2 single dcol threshold " << theCurrentTemp.head.ss50
                               << ", y Lorentz Width " << theCurrentTemp.head.lorywidth << ", y Lorentz Bias "
                               << theCurrentTemp.head.lorybias << ", x Lorentz width " << theCurrentTemp.head.lorxwidth
                               << ", x Lorentz Bias " << theCurrentTemp.head.lorxbias
                               << ", Q/Q_avg fractions for Qbin defs " << theCurrentTemp.head.fbin[0] << ", "
                               << theCurrentTemp.head.fbin[1] << ", " << theCurrentTemp.head.fbin[2]
                               << ", pixel x-size " << theCurrentTemp.head.xsize << ", y-size "
                               << theCurrentTemp.head.ysize << ", zsize " << theCurrentTemp.head.zsize << ENDL;

    if (theCurrentTemp.head.templ_version < code_version) {
      LOGINFO("SiPixelTemplate") << "code expects version " << code_version << " finds "
                                 << theCurrentTemp.head.templ_version << ", load anyway " << ENDL;
      //return false; // dk
    }

#ifdef SI_PIXEL_TEMPLATE_USE_BOOST

    // next, layout the 1-d/2-d structures needed to store template
    theCurrentTemp.cotbetaY = std::vector<float>(theCurrentTemp.head.NTy);
    theCurrentTemp.cotbetaX = std::vector<float>(theCurrentTemp.head.NTyx);
    theCurrentTemp.cotalphaX = std::vector<float>(theCurrentTemp.head.NTxx);
    theCurrentTemp.enty.resize(boost::extents[theCurrentTemp.head.NTy]);
    theCurrentTemp.entx.resize(boost::extents[theCurrentTemp.head.NTyx][theCurrentTemp.head.NTxx]);

#endif

    // next, loop over all barrel y-angle entries

    for (i = 0; i < theCurrentTemp.head.NTy; ++i) {
      db >> theCurrentTemp.enty[i].runnum >> theCurrentTemp.enty[i].costrk[0] >> theCurrentTemp.enty[i].costrk[1] >>
          theCurrentTemp.enty[i].costrk[2];

      if (db.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 1, no template load, run # " << theCurrentTemp.enty[i].runnum
                                    << ENDL;
        return false;
      }

      // Calculate the alpha, beta, and cot(beta) for this entry

      theCurrentTemp.enty[i].alpha =
          static_cast<float>(atan2((double)theCurrentTemp.enty[i].costrk[2], (double)theCurrentTemp.enty[i].costrk[0]));

      theCurrentTemp.enty[i].cotalpha = theCurrentTemp.enty[i].costrk[0] / theCurrentTemp.enty[i].costrk[2];

      theCurrentTemp.enty[i].beta =
          static_cast<float>(atan2((double)theCurrentTemp.enty[i].costrk[2], (double)theCurrentTemp.enty[i].costrk[1]));

      theCurrentTemp.enty[i].cotbeta = theCurrentTemp.enty[i].costrk[1] / theCurrentTemp.enty[i].costrk[2];

      db >> theCurrentTemp.enty[i].qavg >> theCurrentTemp.enty[i].pixmax >> theCurrentTemp.enty[i].symax >>
          theCurrentTemp.enty[i].dyone >> theCurrentTemp.enty[i].syone >> theCurrentTemp.enty[i].sxmax >>
          theCurrentTemp.enty[i].dxone >> theCurrentTemp.enty[i].sxone;

      if (db.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 2, no template load, run # " << theCurrentTemp.enty[i].runnum
                                    << ENDL;
        return false;
      }

      db >> theCurrentTemp.enty[i].dytwo >> theCurrentTemp.enty[i].sytwo >> theCurrentTemp.enty[i].dxtwo >>
          theCurrentTemp.enty[i].sxtwo >> theCurrentTemp.enty[i].qmin >> theCurrentTemp.enty[i].clsleny >>
          theCurrentTemp.enty[i].clslenx;
      //                 >> theCurrentTemp.enty[i].mpvvav >> theCurrentTemp.enty[i].sigmavav >> theCurrentTemp.enty[i].kappavav;

      if (db.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 3, no template load, run # " << theCurrentTemp.enty[i].runnum
                                    << ENDL;
        return false;
      }

      if (theCurrentTemp.enty[i].qmin <= 0.) {
        LOGERROR("SiPixelTemplate") << "Error in template ID " << theCurrentTemp.head.ID
                                    << " qmin = " << theCurrentTemp.enty[i].qmin << ", run # "
                                    << theCurrentTemp.enty[i].runnum << ENDL;
        return false;
      }

      for (j = 0; j < 2; ++j) {
        db >> theCurrentTemp.enty[i].ypar[j][0] >> theCurrentTemp.enty[i].ypar[j][1] >>
            theCurrentTemp.enty[i].ypar[j][2] >> theCurrentTemp.enty[i].ypar[j][3] >> theCurrentTemp.enty[i].ypar[j][4];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 4, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 9; ++j) {
        for (k = 0; k < TYSIZE; ++k) {
          db >> theCurrentTemp.enty[i].ytemp[j][k];
        }

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 5, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 2; ++j) {
        db >> theCurrentTemp.enty[i].xpar[j][0] >> theCurrentTemp.enty[i].xpar[j][1] >>
            theCurrentTemp.enty[i].xpar[j][2] >> theCurrentTemp.enty[i].xpar[j][3] >> theCurrentTemp.enty[i].xpar[j][4];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 6, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      qavg_avg = 0.f;
      for (j = 0; j < 9; ++j) {
        for (k = 0; k < TXSIZE; ++k) {
          db >> theCurrentTemp.enty[i].xtemp[j][k];
          qavg_avg += theCurrentTemp.enty[i].xtemp[j][k];
        }

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 7, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }
      theCurrentTemp.enty[i].qavg_avg = qavg_avg / 9.;

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].yavg[j] >> theCurrentTemp.enty[i].yrms[j] >> theCurrentTemp.enty[i].ygx0[j] >>
            theCurrentTemp.enty[i].ygsig[j];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 8, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].yflpar[j][0] >> theCurrentTemp.enty[i].yflpar[j][1] >>
            theCurrentTemp.enty[i].yflpar[j][2] >> theCurrentTemp.enty[i].yflpar[j][3] >>
            theCurrentTemp.enty[i].yflpar[j][4] >> theCurrentTemp.enty[i].yflpar[j][5];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 9, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].xavg[j] >> theCurrentTemp.enty[i].xrms[j] >> theCurrentTemp.enty[i].xgx0[j] >>
            theCurrentTemp.enty[i].xgsig[j];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 10, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].xflpar[j][0] >> theCurrentTemp.enty[i].xflpar[j][1] >>
            theCurrentTemp.enty[i].xflpar[j][2] >> theCurrentTemp.enty[i].xflpar[j][3] >>
            theCurrentTemp.enty[i].xflpar[j][4] >> theCurrentTemp.enty[i].xflpar[j][5];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 11, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].chi2yavg[j] >> theCurrentTemp.enty[i].chi2ymin[j] >>
            theCurrentTemp.enty[i].chi2xavg[j] >> theCurrentTemp.enty[i].chi2xmin[j];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 12, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].yavgc2m[j] >> theCurrentTemp.enty[i].yrmsc2m[j] >>
            theCurrentTemp.enty[i].chi2yavgc2m[j] >> theCurrentTemp.enty[i].chi2yminc2m[j];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 13, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].xavgc2m[j] >> theCurrentTemp.enty[i].xrmsc2m[j] >>
            theCurrentTemp.enty[i].chi2xavgc2m[j] >> theCurrentTemp.enty[i].chi2xminc2m[j];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 14, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].yavggen[j] >> theCurrentTemp.enty[i].yrmsgen[j] >>
            theCurrentTemp.enty[i].ygx0gen[j] >> theCurrentTemp.enty[i].ygsiggen[j];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 14a, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      for (j = 0; j < 4; ++j) {
        db >> theCurrentTemp.enty[i].xavggen[j] >> theCurrentTemp.enty[i].xrmsgen[j] >>
            theCurrentTemp.enty[i].xgx0gen[j] >> theCurrentTemp.enty[i].xgsiggen[j];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 14b, no template load, run # "
                                      << theCurrentTemp.enty[i].runnum << ENDL;
          return false;
        }
      }

      db >> theCurrentTemp.enty[i].chi2yavgone >> theCurrentTemp.enty[i].chi2yminone >>
          theCurrentTemp.enty[i].chi2xavgone >> theCurrentTemp.enty[i].chi2xminone >> theCurrentTemp.enty[i].qmin2 >>
          theCurrentTemp.enty[i].mpvvav >> theCurrentTemp.enty[i].sigmavav >> theCurrentTemp.enty[i].kappavav >>
          theCurrentTemp.enty[i].r_qMeas_qTrue >> theCurrentTemp.enty[i].spare[0];

      if (db.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 15, no template load, run # "
                                    << theCurrentTemp.enty[i].runnum << ENDL;
        return false;
      }

      db >> theCurrentTemp.enty[i].mpvvav2 >> theCurrentTemp.enty[i].sigmavav2 >> theCurrentTemp.enty[i].kappavav2 >>
          theCurrentTemp.enty[i].qbfrac[0] >> theCurrentTemp.enty[i].qbfrac[1] >> theCurrentTemp.enty[i].qbfrac[2] >>
          theCurrentTemp.enty[i].fracyone >> theCurrentTemp.enty[i].fracxone >> theCurrentTemp.enty[i].fracytwo >>
          theCurrentTemp.enty[i].fracxtwo;
      //            theCurrentTemp.enty[i].qbfrac[3] = 1. - theCurrentTemp.enty[i].qbfrac[0] - theCurrentTemp.enty[i].qbfrac[1] - theCurrentTemp.enty[i].qbfrac[2];

      if (db.fail()) {
        LOGERROR("SiPixelTemplate") << "Error reading file 16, no template load, run # "
                                    << theCurrentTemp.enty[i].runnum << ENDL;
        return false;
      }
    }

    // next, loop over all barrel x-angle entries

    for (k = 0; k < theCurrentTemp.head.NTyx; ++k) {
      for (i = 0; i < theCurrentTemp.head.NTxx; ++i) {
        db >> theCurrentTemp.entx[k][i].runnum >> theCurrentTemp.entx[k][i].costrk[0] >>
            theCurrentTemp.entx[k][i].costrk[1] >> theCurrentTemp.entx[k][i].costrk[2];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 17, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }

        // Calculate the alpha, beta, and cot(beta) for this entry

        theCurrentTemp.entx[k][i].alpha = static_cast<float>(
            atan2((double)theCurrentTemp.entx[k][i].costrk[2], (double)theCurrentTemp.entx[k][i].costrk[0]));

        theCurrentTemp.entx[k][i].cotalpha = theCurrentTemp.entx[k][i].costrk[0] / theCurrentTemp.entx[k][i].costrk[2];

        theCurrentTemp.entx[k][i].beta = static_cast<float>(
            atan2((double)theCurrentTemp.entx[k][i].costrk[2], (double)theCurrentTemp.entx[k][i].costrk[1]));

        theCurrentTemp.entx[k][i].cotbeta = theCurrentTemp.entx[k][i].costrk[1] / theCurrentTemp.entx[k][i].costrk[2];

        db >> theCurrentTemp.entx[k][i].qavg >> theCurrentTemp.entx[k][i].pixmax >> theCurrentTemp.entx[k][i].symax >>
            theCurrentTemp.entx[k][i].dyone >> theCurrentTemp.entx[k][i].syone >> theCurrentTemp.entx[k][i].sxmax >>
            theCurrentTemp.entx[k][i].dxone >> theCurrentTemp.entx[k][i].sxone;

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 18, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }

        db >> theCurrentTemp.entx[k][i].dytwo >> theCurrentTemp.entx[k][i].sytwo >> theCurrentTemp.entx[k][i].dxtwo >>
            theCurrentTemp.entx[k][i].sxtwo >> theCurrentTemp.entx[k][i].qmin >> theCurrentTemp.entx[k][i].clsleny >>
            theCurrentTemp.entx[k][i].clslenx;
        //                     >> theCurrentTemp.entx[k][i].mpvvav >> theCurrentTemp.entx[k][i].sigmavav >> theCurrentTemp.entx[k][i].kappavav;

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 19, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }

        for (j = 0; j < 2; ++j) {
          db >> theCurrentTemp.entx[k][i].ypar[j][0] >> theCurrentTemp.entx[k][i].ypar[j][1] >>
              theCurrentTemp.entx[k][i].ypar[j][2] >> theCurrentTemp.entx[k][i].ypar[j][3] >>
              theCurrentTemp.entx[k][i].ypar[j][4];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 20, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 9; ++j) {
          for (l = 0; l < TYSIZE; ++l) {
            db >> theCurrentTemp.entx[k][i].ytemp[j][l];
          }

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 21, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 2; ++j) {
          db >> theCurrentTemp.entx[k][i].xpar[j][0] >> theCurrentTemp.entx[k][i].xpar[j][1] >>
              theCurrentTemp.entx[k][i].xpar[j][2] >> theCurrentTemp.entx[k][i].xpar[j][3] >>
              theCurrentTemp.entx[k][i].xpar[j][4];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 22, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        qavg_avg = 0.f;
        for (j = 0; j < 9; ++j) {
          for (l = 0; l < TXSIZE; ++l) {
            db >> theCurrentTemp.entx[k][i].xtemp[j][l];
            qavg_avg += theCurrentTemp.entx[k][i].xtemp[j][l];
          }

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 23, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }
        theCurrentTemp.entx[k][i].qavg_avg = qavg_avg / 9.;

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].yavg[j] >> theCurrentTemp.entx[k][i].yrms[j] >>
              theCurrentTemp.entx[k][i].ygx0[j] >> theCurrentTemp.entx[k][i].ygsig[j];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 24, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].yflpar[j][0] >> theCurrentTemp.entx[k][i].yflpar[j][1] >>
              theCurrentTemp.entx[k][i].yflpar[j][2] >> theCurrentTemp.entx[k][i].yflpar[j][3] >>
              theCurrentTemp.entx[k][i].yflpar[j][4] >> theCurrentTemp.entx[k][i].yflpar[j][5];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 25, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].xavg[j] >> theCurrentTemp.entx[k][i].xrms[j] >>
              theCurrentTemp.entx[k][i].xgx0[j] >> theCurrentTemp.entx[k][i].xgsig[j];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 26, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].xflpar[j][0] >> theCurrentTemp.entx[k][i].xflpar[j][1] >>
              theCurrentTemp.entx[k][i].xflpar[j][2] >> theCurrentTemp.entx[k][i].xflpar[j][3] >>
              theCurrentTemp.entx[k][i].xflpar[j][4] >> theCurrentTemp.entx[k][i].xflpar[j][5];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 27, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].chi2yavg[j] >> theCurrentTemp.entx[k][i].chi2ymin[j] >>
              theCurrentTemp.entx[k][i].chi2xavg[j] >> theCurrentTemp.entx[k][i].chi2xmin[j];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 28, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].yavgc2m[j] >> theCurrentTemp.entx[k][i].yrmsc2m[j] >>
              theCurrentTemp.entx[k][i].chi2yavgc2m[j] >> theCurrentTemp.entx[k][i].chi2yminc2m[j];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 29, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].xavgc2m[j] >> theCurrentTemp.entx[k][i].xrmsc2m[j] >>
              theCurrentTemp.entx[k][i].chi2xavgc2m[j] >> theCurrentTemp.entx[k][i].chi2xminc2m[j];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 30, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].yavggen[j] >> theCurrentTemp.entx[k][i].yrmsgen[j] >>
              theCurrentTemp.entx[k][i].ygx0gen[j] >> theCurrentTemp.entx[k][i].ygsiggen[j];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 30a, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        for (j = 0; j < 4; ++j) {
          db >> theCurrentTemp.entx[k][i].xavggen[j] >> theCurrentTemp.entx[k][i].xrmsgen[j] >>
              theCurrentTemp.entx[k][i].xgx0gen[j] >> theCurrentTemp.entx[k][i].xgsiggen[j];

          if (db.fail()) {
            LOGERROR("SiPixelTemplate") << "Error reading file 30b, no template load, run # "
                                        << theCurrentTemp.entx[k][i].runnum << ENDL;
            return false;
          }
        }

        db >> theCurrentTemp.entx[k][i].chi2yavgone >> theCurrentTemp.entx[k][i].chi2yminone >>
            theCurrentTemp.entx[k][i].chi2xavgone >> theCurrentTemp.entx[k][i].chi2xminone >>
            theCurrentTemp.entx[k][i].qmin2 >> theCurrentTemp.entx[k][i].mpvvav >> theCurrentTemp.entx[k][i].sigmavav >>
            theCurrentTemp.entx[k][i].kappavav >> theCurrentTemp.entx[k][i].r_qMeas_qTrue >>
            theCurrentTemp.entx[k][i].spare[0];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 31, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }

        db >> theCurrentTemp.entx[k][i].mpvvav2 >> theCurrentTemp.entx[k][i].sigmavav2 >>
            theCurrentTemp.entx[k][i].kappavav2 >> theCurrentTemp.entx[k][i].qbfrac[0] >>
            theCurrentTemp.entx[k][i].qbfrac[1] >> theCurrentTemp.entx[k][i].qbfrac[2] >>
            theCurrentTemp.entx[k][i].fracyone >> theCurrentTemp.entx[k][i].fracxone >>
            theCurrentTemp.entx[k][i].fracytwo >> theCurrentTemp.entx[k][i].fracxtwo;
        //              theCurrentTemp.entx[k][i].qbfrac[3] = 1. - theCurrentTemp.entx[k][i].qbfrac[0] - theCurrentTemp.entx[k][i].qbfrac[1] - theCurrentTemp.entx[k][i].qbfrac[2];

        if (db.fail()) {
          LOGERROR("SiPixelTemplate") << "Error reading file 32, no template load, run # "
                                      << theCurrentTemp.entx[k][i].runnum << ENDL;
          return false;
        }
      }
    }

    // Add this template to the store

    pixelTemp.push_back(theCurrentTemp);
  }
  postInit(pixelTemp);
  return true;

}  // TempInit

float SiPixelTemplate::qavg ( )

inline

average cluster charge for this set of track angles

Definition at line 407 of file SiPixelTemplate.h.

References qavg_.

Referenced by PixelCPEClusterRepair::checkRecommend2D(), SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

int SiPixelTemplate::qbin	(	int	id,
		float	cotalpha,
		float	cotbeta,
		float	locBz,
		float	locBx,
		float	qclus,
		float &	pixmx,
		float &	sigmay,
		float &	deltay,
		float &	sigmax,
		float &	deltax,
		float &	sy1,
		float &	dy1,
		float &	sy2,
		float &	dy2,
		float &	sx1,
		float &	dx1,
		float &	sx2,
		float &	dx2
	)

Interpolate beta/alpha angles to produce an expected average charge. Return int (0-4) describing the charge of the cluster [0: 1.5<Q/Qavg, 1: 1<Q/Qavg<1.5, 2: 0.85<Q/Qavg<1, 3: 0.95Qmin<Q<0.85Qavg, 4: Q<0.95Qmin].

Parameters

id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014)
locBz	- (input) the sign of this quantity is used to determine whether to flip cot(beta)<0 quantities from cot(beta)>0 (FPix only) for Phase 0 FPix IP-related tracks, locBz < 0 for cot(beta) > 0 and locBz > 0 for cot(beta) < 0 for Phase 1 FPix IP-related tracks, see next comment
locBx	- (input) the sign of this quantity is used to determine whether to flip cot(alpha/beta)<0 quantities from cot(alpha/beta)>0 (FPix only) for Phase 1 FPix IP-related tracks, locBx/locBz > 0 for cot(alpha) > 0 and locBx/locBz < 0 for cot(alpha) < 0 for Phase 1 FPix IP-related tracks, locBx > 0 for cot(beta) > 0 and locBx < 0 for cot(beta) < 0//!
qclus	- (input) the cluster charge in electrons
pixmax	- (output) the maximum pixel charge in electrons (truncation value)
sigmay	- (output) the estimated y-error for CPEGeneric in microns
deltay	- (output) the estimated y-bias for CPEGeneric in microns
sigmax	- (output) the estimated x-error for CPEGeneric in microns
deltax	- (output) the estimated x-bias for CPEGeneric in microns
sy1	- (output) the estimated y-error for 1 single-pixel clusters in microns
dy1	- (output) the estimated y-bias for 1 single-pixel clusters in microns
sy2	- (output) the estimated y-error for 1 double-pixel clusters in microns
dy2	- (output) the estimated y-bias for 1 double-pixel clusters in microns
sx1	- (output) the estimated x-error for 1 single-pixel clusters in microns
dx1	- (output) the estimated x-bias for 1 single-pixel clusters in microns
sx2	- (output) the estimated x-error for 1 double-pixel clusters in microns
dx2	- (output) the estimated x-bias for 1 double-pixel clusters in microns
lorywidth	- (output) the estimated y Lorentz width
lorxwidth	- (output) the estimated x Lorentz width

Definition at line 2991 of file SiPixelTemplate.cc.

References funct::abs(), cms::cuda::assert(), gather_cfg::cout, Exception, validate-o2o-wbm::f, mps_fire::i, if(), dqmiolumiharvest::j, cuda_std::lower_bound(), PixelTestBeamValidation_cfi::Ny, and mathSSE::sqrt().

Referenced by qbin().

{
  // Interpolate for a new set of track angles

  // &&& New approach: use cached pointers.

  // Find the index corresponding to id

  int index = -1;
  for (int i = 0; i < (int)thePixelTemp_.size(); ++i) {
    if (id == thePixelTemp_[i].head.ID) {
      index = i;
      break;
    }
  }

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (index < 0 || index >= (int)thePixelTemp_.size()) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::qbin can't find needed template ID = " << id << std::endl;
  }
#else
  assert(index >= 0 && index < (int)thePixelTemp_.size());
#endif

  //

  auto const& templ = thePixelTemp_[index];

  // Interpolate the absolute value of cot(beta)

  auto acotb = std::abs(cotbeta);

  //    qcorrect corrects the cot(alpha)=0 cluster charge for non-zero cot(alpha)

  auto cotalpha0 = thePixelTemp_[index].enty[0].cotalpha;
  auto qcorrect =
      std::sqrt((1.f + cotbeta * cotbeta + cotalpha * cotalpha) / (1.f + cotbeta * cotbeta + cotalpha0 * cotalpha0));

  // for some cosmics, the ususal gymnastics are incorrect

  float cota = cotalpha;
  bool flip_x = false;
  //y flipping already taken care of by interpolate
  switch (dtype_) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      if (locBx * locBz < 0.f) {
        cota = -cotalpha;
        flip_x = true;
      }
      break;
    default:
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      throw cms::Exception("DataCorrupt")
          << "SiPixelTemplate::illegal subdetector ID = " << thePixelTemp_[index_id_].head.Dtype << std::endl;
#else
      std::cout << "SiPixelTemplate::illegal subdetector ID = " << thePixelTemp_[index_id_].head.Dtype << std::endl;
#endif
  }

  // Copy the charge scaling factor to the private variable

  auto qscale = thePixelTemp_[index].head.qscale;

  /*
    lorywidth = thePixelTemp_[index].head.lorywidth;
    if(locBz > 0.f) {lorywidth = -lorywidth;}
    lorxwidth = thePixelTemp_[index].head.lorxwidth;
    */

  auto Ny = thePixelTemp_[index].head.NTy;
  auto Nyx = thePixelTemp_[index].head.NTyx;
  auto Nxx = thePixelTemp_[index].head.NTxx;

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (Ny < 2 || Nyx < 1 || Nxx < 2) {
    throw cms::Exception("DataCorrupt") << "template ID = " << id_current_ << "has too few entries: Ny/Nyx/Nxx = " << Ny
                                        << "/" << Nyx << "/" << Nxx << std::endl;
  }
#else
  assert(Ny > 1 && Nyx > 0 && Nxx > 1);
#endif

  // Interpolate/store all y-related quantities (flip displacements when flip_y)

  dy1 = (1.f - yratio_) * enty0_->dyone + yratio_ * enty1_->dyone;
  if (flip_y_) {
    dy1 = -dy1;
  }
  sy1 = (1.f - yratio_) * enty0_->syone + yratio_ * enty1_->syone;
  dy2 = (1.f - yratio_) * enty0_->dytwo + yratio_ * enty1_->dytwo;
  if (flip_y_) {
    dy2 = -dy2;
  }
  sy2 = (1.f - yratio_) * enty0_->sytwo + yratio_ * enty1_->sytwo;

  auto qavg = (1.f - yratio_) * enty0_->qavg + yratio_ * enty1_->qavg;
  qavg *= qcorrect;
  auto qmin = (1.f - yratio_) * enty0_->qmin + yratio_ * enty1_->qmin;
  qmin *= qcorrect;
  auto qmin2 = (1.f - yratio_) * enty0_->qmin2 + yratio_ * enty1_->qmin2;
  qmin2 *= qcorrect;

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (qavg <= 0.f || qmin <= 0.f) {
    throw cms::Exception("DataCorrupt")
        << "SiPixelTemplate::qbin, qavg or qmin <= 0,"
        << " Probably someone called the generic pixel reconstruction with an illegal trajectory state" << std::endl;
  }
#else
  assert(qavg > 0.f && qmin > 0.f);
#endif

  //  Scale the input charge to account for differences between pixelav and CMSSW simulation or data

  auto qtotal = qscale * qclus;

  // uncertainty and final corrections depend upon total charge bin
  auto fq = qtotal / qavg;
  int binq;

  if (fq > fbin_[0]) {
    binq = 0;
    //std::cout<<" fq "<<fq<<" "<<qtotal<<" "<<qavg<<" "<<qclus<<" "<<qscale<<" "
    //       <<fbin_[0]<<" "<<fbin_[1]<<" "<<fbin_[2]<<std::endl;
  } else {
    if (fq > fbin_[1]) {
      binq = 1;
    } else {
      if (fq > fbin_[2]) {
        binq = 2;
      } else {
        binq = 3;
      }
    }
  }

  auto yavggen = (1.f - yratio_) * enty0_->yavggen[binq] + yratio_ * enty1_->yavggen[binq];
  if (flip_y_) {
    yavggen = -yavggen;
  }
  auto yrmsgen = (1.f - yratio_) * enty0_->yrmsgen[binq] + yratio_ * enty1_->yrmsgen[binq];

  // next, loop over all x-angle entries, first, find relevant y-slices

  auto iylow = 0;
  auto iyhigh = 0;
  auto yxratio = 0.f;

  {
    auto j = std::lower_bound(templ.cotbetaX.begin(), templ.cotbetaX.begin() + Nyx, acotb);
    if (j == templ.cotbetaX.begin() + Nyx) {
      --j;
      yxratio = 1.f;
    } else if (j == templ.cotbetaX.begin()) {
      ++j;
      yxratio = 0.f;
    } else {
      yxratio = (acotb - (*(j - 1))) / ((*j) - (*(j - 1)));
    }

    iyhigh = j - templ.cotbetaX.begin();
    iylow = iyhigh - 1;
  }

  auto ilow = 0;
  auto ihigh = 0;
  auto xxratio = 0.f;

  {
    auto j = std::lower_bound(templ.cotalphaX.begin(), templ.cotalphaX.begin() + Nxx, cota);
    if (j == templ.cotalphaX.begin() + Nxx) {
      --j;
      xxratio = 1.f;
    } else if (j == templ.cotalphaX.begin()) {
      ++j;
      xxratio = 0.f;
    } else {
      xxratio = (cota - (*(j - 1))) / ((*j) - (*(j - 1)));
    }

    ihigh = j - templ.cotalphaX.begin();
    ilow = ihigh - 1;
  }

  dx1 =
      (1.f - xxratio) * thePixelTemp_[index].entx[0][ilow].dxone + xxratio * thePixelTemp_[index].entx[0][ihigh].dxone;
  if (flip_x) {
    dx1 = -dx1;
  }
  sx1 =
      (1.f - xxratio) * thePixelTemp_[index].entx[0][ilow].sxone + xxratio * thePixelTemp_[index].entx[0][ihigh].sxone;
  dx2 =
      (1.f - xxratio) * thePixelTemp_[index].entx[0][ilow].dxtwo + xxratio * thePixelTemp_[index].entx[0][ihigh].dxtwo;
  if (flip_x) {
    dx2 = -dx2;
  }
  sx2 =
      (1.f - xxratio) * thePixelTemp_[index].entx[0][ilow].sxtwo + xxratio * thePixelTemp_[index].entx[0][ihigh].sxtwo;

  // pixmax is the maximum allowed pixel charge (used for truncation)

  pixmx = (1.f - yxratio) * ((1.f - xxratio) * thePixelTemp_[index].entx[iylow][ilow].pixmax +
                             xxratio * thePixelTemp_[index].entx[iylow][ihigh].pixmax) +
          yxratio * ((1.f - xxratio) * thePixelTemp_[index].entx[iyhigh][ilow].pixmax +
                     xxratio * thePixelTemp_[index].entx[iyhigh][ihigh].pixmax);

  auto xavggen = (1.f - yxratio) * ((1.f - xxratio) * thePixelTemp_[index].entx[iylow][ilow].xavggen[binq] +
                                    xxratio * thePixelTemp_[index].entx[iylow][ihigh].xavggen[binq]) +
                 yxratio * ((1.f - xxratio) * thePixelTemp_[index].entx[iyhigh][ilow].xavggen[binq] +
                            xxratio * thePixelTemp_[index].entx[iyhigh][ihigh].xavggen[binq]);
  if (flip_x) {
    xavggen = -xavggen;
  }

  auto xrmsgen = (1.f - yxratio) * ((1.f - xxratio) * thePixelTemp_[index].entx[iylow][ilow].xrmsgen[binq] +
                                    xxratio * thePixelTemp_[index].entx[iylow][ihigh].xrmsgen[binq]) +
                 yxratio * ((1.f - xxratio) * thePixelTemp_[index].entx[iyhigh][ilow].xrmsgen[binq] +
                            xxratio * thePixelTemp_[index].entx[iyhigh][ihigh].xrmsgen[binq]);

  //  Take the errors and bias from the correct charge bin

  sigmay = yrmsgen;
  deltay = yavggen;

  sigmax = xrmsgen;
  deltax = xavggen;

  // If the charge is too small (then flag it)

  if (qtotal < 0.95f * qmin) {
    binq = 5;
  } else {
    if (qtotal < 0.95f * qmin2) {
      binq = 4;
    }
  }

  return binq;

}  // qbin

int SiPixelTemplate::qbin	(	int	id,
		float	cotalpha,
		float	cotbeta,
		float	locBz,
		float	qclus,
		float &	pixmx,
		float &	sigmay,
		float &	deltay,
		float &	sigmax,
		float &	deltax,
		float &	sy1,
		float &	dy1,
		float &	sy2,
		float &	dy2,
		float &	sx1,
		float &	dx1,
		float &	sx2,
		float &	dx2
	)

Interpolate beta/alpha angles to produce an expected average charge. Return int (0-4) describing the charge of the cluster [0: 1.5<Q/Qavg, 1: 1<Q/Qavg<1.5, 2: 0.85<Q/Qavg<1, 3: 0.95Qmin<Q<0.85Qavg, 4: Q<0.95Qmin].

Parameters

id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014)
locBz	- (input) the sign of this quantity is used to determine whether to flip cot(beta)<0 quantities from cot(beta)>0 (FPix only) for Phase 0 FPix IP-related tracks, locBz < 0 for cot(beta) > 0 and locBz > 0 for cot(beta) < 0 for Phase 1 FPix IP-related tracks, see next comment
locBx	- (input) the sign of this quantity is used to determine whether to flip cot(alpha/beta)<0 quantities from cot(alpha/beta)>0 (FPix only) for Phase 1 FPix IP-related tracks, locBx/locBz > 0 for cot(alpha) > 0 and locBx/locBz < 0 for cot(alpha) < 0 for Phase 1 FPix IP-related tracks, locBx > 0 for cot(beta) > 0 and locBx < 0 for cot(beta) < 0//!
qclus	- (input) the cluster charge in electrons
pixmax	- (output) the maximum pixel charge in electrons (truncation value)
sigmay	- (output) the estimated y-error for CPEGeneric in microns
deltay	- (output) the estimated y-bias for CPEGeneric in microns
sigmax	- (output) the estimated x-error for CPEGeneric in microns
deltax	- (output) the estimated x-bias for CPEGeneric in microns
sy1	- (output) the estimated y-error for 1 single-pixel clusters in microns
dy1	- (output) the estimated y-bias for 1 single-pixel clusters in microns
sy2	- (output) the estimated y-error for 1 double-pixel clusters in microns
dy2	- (output) the estimated y-bias for 1 double-pixel clusters in microns
sx1	- (output) the estimated x-error for 1 single-pixel clusters in microns
dx1	- (output) the estimated x-bias for 1 single-pixel clusters in microns
sx2	- (output) the estimated x-error for 1 double-pixel clusters in microns
dx2	- (output) the estimated x-bias for 1 double-pixel clusters in microns
lorywidth	- (output) the estimated y Lorentz width
lorxwidth	- (output) the estimated x Lorentz width

Definition at line 3284 of file SiPixelTemplate.cc.

References qbin().

{
  // Interpolate for a new set of track angles

  // Local variables
  float locBx = 1.f;  //  lorywidth, lorxwidth;

  return SiPixelTemplate::qbin(id,
                               cotalpha,
                               cotbeta,
                               locBz,
                               locBx,
                               qclus,
                               pixmx,
                               sigmay,
                               deltay,
                               sigmax,
                               deltax,
                               sy1,
                               dy1,
                               sy2,
                               dy2,
                               sx1,
                               dx1,
                               sx2,
                               dx2);  // , lorywidth, lorxwidth);

}  // qbin

int SiPixelTemplate::qbin	(	int	id,
		float	cotalpha,
		float	cotbeta,
		float	qclus
	)

Interpolate beta/alpha angles to produce an expected average charge. Return int (0-4) describing the charge of the cluster [0: 1.5<Q/Qavg, 1: 1<Q/Qavg<1.5, 2: 0.85<Q/Qavg<1, 3: 0.95Qmin<Q<0.85Qavg, 4: Q<0.95Qmin].

Parameters

id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014)
locBz	- (input) the sign of this quantity is used to determine whether to flip cot(beta)<0 quantities from cot(beta)>0 (FPix only) for FPix IP-related tracks, locBz < 0 for cot(beta) > 0 and locBz > 0 for cot(beta) < 0
qclus	- (input) the cluster charge in electrons
pixmax	- (output) the maximum pixel charge in electrons (truncation value)
sigmay	- (output) the estimated y-error for CPEGeneric in microns
deltay	- (output) the estimated y-bias for CPEGeneric in microns
sigmax	- (output) the estimated x-error for CPEGeneric in microns
deltax	- (output) the estimated x-bias for CPEGeneric in microns
sy1	- (output) the estimated y-error for 1 single-pixel clusters in microns
dy1	- (output) the estimated y-bias for 1 single-pixel clusters in microns
sy2	- (output) the estimated y-error for 1 double-pixel clusters in microns
dy2	- (output) the estimated y-bias for 1 double-pixel clusters in microns
sx1	- (output) the estimated x-error for 1 single-pixel clusters in microns
dx1	- (output) the estimated x-bias for 1 single-pixel clusters in microns
sx2	- (output) the estimated x-error for 1 double-pixel clusters in microns
dx2	- (output) the estimated x-bias for 1 double-pixel clusters in microns Interpolate beta/alpha angles to produce an expected average charge. Return int (0-4) describing the charge of the cluster [0: 1.5<Q/Qavg, 1: 1<Q/Qavg<1.5, 2: 0.85<Q/Qavg<1, 3: 0.95Qmin<Q<0.85Qavg, 4: Q<0.95Qmin].
id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014)
qclus	- (input) the cluster charge in electrons

Definition at line 3373 of file SiPixelTemplate.cc.

References validate-o2o-wbm::f, and qbin().

                                                                            {
  // Interpolate for a new set of track angles

  // Local variables
  float pixmx, sigmay, deltay, sigmax, deltax, sy1, dy1, sy2, dy2, sx1, dx1, sx2, dx2, locBz;  //  lorywidth, lorxwidth;
  // Local variables
  float locBx = 1.f;
  if (cotbeta < 0.f) {
    locBx = -1.f;
  }
  locBz = locBx;
  if (cotalpha < 0.f) {
    locBz = -locBx;
  }

  return SiPixelTemplate::qbin(id,
                               cotalpha,
                               cotbeta,
                               locBz,
                               locBx,
                               qclus,
                               pixmx,
                               sigmay,
                               deltay,
                               sigmax,
                               deltax,
                               sy1,
                               dy1,
                               sy2,
                               dy2,
                               sx1,
                               dx1,
                               sx2,
                               dx2);  // , lorywidth, lorxwidth);

}  // qbin

int SiPixelTemplate::qbin	(	int	id,
		float	cotbeta,
		float	qclus
	)

Interpolate beta/alpha angles to produce an expected average charge. Return int (0-4) describing the charge of the cluster [0: 1.5<Q/Qavg, 1: 1<Q/Qavg<1.5, 2: 0.85<Q/Qavg<1, 3: 0.95Qmin<Q<0.85Qavg, 4: Q<0.95Qmin].

Parameters

id	- (input) index of the template to use
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014)
qclus	- (input) the cluster charge in electrons

Definition at line 3417 of file SiPixelTemplate.cc.

References validate-o2o-wbm::f, and qbin().

                                                            {
  // Interpolate for a new set of track angles

  // Local variables
  float pixmx, sigmay, deltay, sigmax, deltax, sy1, dy1, sy2, dy2, sx1, dx1, sx2, dx2, locBz,
      locBx;  //, lorywidth, lorxwidth;
  const float cotalpha = 0.f;
  locBx = 1.f;
  if (cotbeta < 0.f) {
    locBx = -1.f;
  }
  locBz = locBx;
  if (cotalpha < 0.f) {
    locBz = -locBx;
  }
  return SiPixelTemplate::qbin(id,
                               cotalpha,
                               cotbeta,
                               locBz,
                               locBx,
                               qclus,
                               pixmx,
                               sigmay,
                               deltay,
                               sigmax,
                               deltax,
                               sy1,
                               dy1,
                               sy2,
                               dy2,
                               sx1,
                               dx1,
                               sx2,
                               dx2);  // , lorywidth, lorxwidth);

}  // qbin

void SiPixelTemplate::qbin_dist	(	int	id,
		float	cotalpha,
		float	cotbeta,
		float	qbin_frac[4],
		float &	ny1_frac,
		float &	ny2_frac,
		float &	nx1_frac,
		float &	nx2_frac
	)

Interpolate beta/alpha angles to produce estimated errors for fastsim

Parameters

id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014)
qbin_frac[4]	- (output) the integrated probability for qbin=0, 0+1, 0+1+2, 0+1+2+3 (1.)
ny1_frac	- (output) the probability for ysize = 1 for a single-size pixel
ny2_frac	- (output) the probability for ysize = 1 for a double-size pixel
nx1_frac	- (output) the probability for xsize = 1 for a single-size pixel
nx2_frac	- (output) the probability for xsize = 1 for a double-size pixel

Definition at line 3627 of file SiPixelTemplate.cc.

References cms::cuda::assert(), enty0_, enty1_, Exception, validate-o2o-wbm::f, SiPixelTemplateEntry::fracyone, SiPixelTemplateEntry::fracytwo, mps_fire::i, id_current_, PixelTestBeamValidation_cfi::Ny, thePixelTemp_, xxratio(), yratio_, and yxratio().

Referenced by PixelTemplateSmearerBase::smearHit(), and PixelTemplateSmearerBase::smearMergeGroup().

{
  // Interpolate for a new set of track angles

  // Local variables
  int i;
  int ilow, ihigh, iylow, iyhigh, Ny, Nxx, Nyx, index;
  float yxratio, xxratio;
  float acotb;
  float qfrac[4];
  //bool flip_y;

  // Find the index corresponding to id

  index = -1;
  for (i = 0; i < (int)thePixelTemp_.size(); ++i) {
    if (id == thePixelTemp_[i].head.ID) {
      index = i;
      //                id_current_ = id;
      break;
    }
  }

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (index < 0 || index >= (int)thePixelTemp_.size()) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::temperrors can't find needed template ID = " << id
                                        << std::endl;
  }
#else
  assert(index >= 0 && index < (int)thePixelTemp_.size());
#endif

  //

  // Interpolate the absolute value of cot(beta)

  acotb = fabs((double)cotbeta);

  // Copy the charge scaling factor to the private variable

  Ny = thePixelTemp_[index].head.NTy;
  Nyx = thePixelTemp_[index].head.NTyx;
  Nxx = thePixelTemp_[index].head.NTxx;

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (Ny < 2 || Nyx < 1 || Nxx < 2) {
    throw cms::Exception("DataCorrupt") << "template ID = " << id_current_ << "has too few entries: Ny/Nyx/Nxx = " << Ny
                                        << "/" << Nyx << "/" << Nxx << std::endl;
  }
#else
  assert(Ny > 1 && Nyx > 0 && Nxx > 1);
#endif

  // Interpolate/store all y-related quantities (flip displacements when flip_y)
  ny1_frac = (1.f - yratio_) * enty0_->fracyone + yratio_ * enty1_->fracyone;
  ny2_frac = (1.f - yratio_) * enty0_->fracytwo + yratio_ * enty1_->fracytwo;

  // next, loop over all x-angle entries, first, find relevant y-slices

  iylow = 0;
  yxratio = 0.f;

  if (acotb >= thePixelTemp_[index].entx[Nyx - 1][0].cotbeta) {
    iylow = Nyx - 2;
    yxratio = 1.f;

  } else if (acotb >= thePixelTemp_[index].entx[0][0].cotbeta) {
    for (i = 0; i < Nyx - 1; ++i) {
      if (thePixelTemp_[index].entx[i][0].cotbeta <= acotb && acotb < thePixelTemp_[index].entx[i + 1][0].cotbeta) {
        iylow = i;
        yxratio = (acotb - thePixelTemp_[index].entx[i][0].cotbeta) /
                  (thePixelTemp_[index].entx[i + 1][0].cotbeta - thePixelTemp_[index].entx[i][0].cotbeta);
        break;
      }
    }
  }

  iyhigh = iylow + 1;

  ilow = 0;
  xxratio = 0.f;

  if (cotalpha >= thePixelTemp_[index].entx[0][Nxx - 1].cotalpha) {
    ilow = Nxx - 2;
    xxratio = 1.f;

  } else {
    if (cotalpha >= thePixelTemp_[index].entx[0][0].cotalpha) {
      for (i = 0; i < Nxx - 1; ++i) {
        if (thePixelTemp_[index].entx[0][i].cotalpha <= cotalpha &&
            cotalpha < thePixelTemp_[index].entx[0][i + 1].cotalpha) {
          ilow = i;
          xxratio = (cotalpha - thePixelTemp_[index].entx[0][i].cotalpha) /
                    (thePixelTemp_[index].entx[0][i + 1].cotalpha - thePixelTemp_[index].entx[0][i].cotalpha);
          break;
        }
      }
    }
  }

  ihigh = ilow + 1;

  for (i = 0; i < 3; ++i) {
    qfrac[i] = (1.f - yxratio) * ((1.f - xxratio) * thePixelTemp_[index].entx[iylow][ilow].qbfrac[i] +
                                  xxratio * thePixelTemp_[index].entx[iylow][ihigh].qbfrac[i]) +
               yxratio * ((1.f - xxratio) * thePixelTemp_[index].entx[iyhigh][ilow].qbfrac[i] +
                          xxratio * thePixelTemp_[index].entx[iyhigh][ihigh].qbfrac[i]);
  }
  nx1_frac = (1.f - yxratio) * ((1.f - xxratio) * thePixelTemp_[index].entx[iylow][ilow].fracxone +
                                xxratio * thePixelTemp_[index].entx[iylow][ihigh].fracxone) +
             yxratio * ((1.f - xxratio) * thePixelTemp_[index].entx[iyhigh][ilow].fracxone +
                        xxratio * thePixelTemp_[index].entx[iyhigh][ihigh].fracxone);
  nx2_frac = (1.f - yxratio) * ((1.f - xxratio) * thePixelTemp_[index].entx[iylow][ilow].fracxtwo +
                                xxratio * thePixelTemp_[index].entx[iylow][ihigh].fracxtwo) +
             yxratio * ((1.f - xxratio) * thePixelTemp_[index].entx[iyhigh][ilow].fracxtwo +
                        xxratio * thePixelTemp_[index].entx[iyhigh][ihigh].fracxtwo);

  qbin_frac[0] = qfrac[0];
  qbin_frac[1] = qbin_frac[0] + qfrac[1];
  qbin_frac[2] = qbin_frac[1] + qfrac[2];
  qbin_frac[3] = 1.f;
  return;

}  // qbin_dist

float SiPixelTemplate::qmin ( )

inline

minimum cluster charge for valid hit (keeps 99.9% of simulated hits)

Definition at line 422 of file SiPixelTemplate.h.

References qmin_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::qmin ( int  i )

inline

minimum cluster charge for valid hit (keeps 99.9% or 99.8% of simulated hits)

Definition at line 423 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, qmin2_, and qmin_.

float SiPixelTemplate::qscale ( )

inline

charge scaling factor

Definition at line 409 of file SiPixelTemplate.h.

References qscale_.

Referenced by SiPixelLorentzAnglePCLWorker::analyze(), SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::r_qMeas_qTrue ( )

inline

ratio of measured to true cluster charge

Definition at line 678 of file SiPixelTemplate.h.

References r_qMeas_qTrue_.

Referenced by SiPixelLorentzAnglePCLWorker::analyze().

float SiPixelTemplate::s50 ( )

inline

1/2 of the pixel threshold signal in electrons

Definition at line 410 of file SiPixelTemplate.h.

References s50_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), SiPixelTemplateSplit::PixelTempSplit(), and PixelTemplateSmearerBase::smearHit().

float SiPixelTemplate::sigmavav ( )

inline

"sigma" scale fctor for Vavilov distribution

Definition at line 668 of file SiPixelTemplate.h.

References sigmavav_.

Referenced by vavilov_pars().

float SiPixelTemplate::sigmavav2 ( )

inline

"sigma" scale fctor for 2-cluster Vavilov distribution

Definition at line 673 of file SiPixelTemplate.h.

References sigmavav2_.

Referenced by vavilov2_pars().

bool SiPixelTemplate::simpletemplate2D	(	float	xhit,
		float	yhit,
		std::vector< bool > &	ydouble,
		std::vector< bool > &	xdouble,
		float	template2d[13+2][21+2]
	)

Make simple 2-D templates from track angles set in interpolate and hit position.

Parameters

xhit	- (input) x-position of hit relative to the lower left corner of pixel[1][1] (to allow for the "padding" of the two-d clusters in the splitter)
yhit	- (input) y-position of hit relative to the lower left corner of pixel[1][1]
ydouble	- (input) STL vector of 21 element array to flag a double-pixel starting at cluster[1][1]
xdouble	- (input) STL vector of 11 element array to flag a double-pixel starting at cluster[1][1]
template2d	- (output) 2d template of size matched to the cluster. Input must be zeroed since charge is added only.

Definition at line 3770 of file SiPixelTemplate.cc.

References funct::abs(), any(), SimplePixel::btype, BXM3, BYM3, cota_current_, cotb_current_, validate-o2o-wbm::f, SimplePixel::i, mps_fire::i, SimplePixel::j, dqmiolumiharvest::j, lorxwidth_, lorywidth_, SiStripPI::max, qavg_avg_, SimplePixel::s, mathSSE::sqrt(), SimplePixel::x, xsize_, SimplePixel::y, ysize_, and zsize_.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

                                                                                                              {
  // Local variables

  float x0, y0, xf, yf, xi, yi, sf, si, s0, qpix, slopey, slopex, ds;
  int i, j, jpix0, ipix0, jpixf, ipixf, jpix, ipix, nx, ny, anx, any, jmax, imax;
  float qtotal;
  //    double path;
  std::list<SimplePixel> list;
  std::list<SimplePixel>::iterator listIter, listEnd;

  // Calculate the entry and exit points for the line charge from the track

  x0 = xhit - 0.5 * zsize_ * cota_current_;
  y0 = yhit - 0.5 * zsize_ * cotb_current_;

  jpix0 = floor(x0 / xsize_) + 1;
  ipix0 = floor(y0 / ysize_) + 1;

  if (jpix0 < 0 || jpix0 > BXM3) {
    return false;
  }
  if (ipix0 < 0 || ipix0 > BYM3) {
    return false;
  }

  xf = xhit + 0.5 * zsize_ * cota_current_ + lorxwidth_;
  yf = yhit + 0.5 * zsize_ * cotb_current_ + lorywidth_;

  jpixf = floor(xf / xsize_) + 1;
  ipixf = floor(yf / ysize_) + 1;

  if (jpixf < 0 || jpixf > BXM3) {
    return false;
  }
  if (ipixf < 0 || ipixf > BYM3) {
    return false;
  }

  // total charge length

  sf = std::sqrt((xf - x0) * (xf - x0) + (yf - y0) * (yf - y0));
  if ((xf - x0) != 0.f) {
    slopey = (yf - y0) / (xf - x0);
  } else {
    slopey = 1.e10;
  }
  if ((yf - y0) != 0.f) {
    slopex = (xf - x0) / (yf - y0);
  } else {
    slopex = 1.e10;
  }

  // use average charge in this direction

  qtotal = qavg_avg_;

  SimplePixel element;
  element.s = sf;
  element.x = xf;
  element.y = yf;
  element.i = ipixf;
  element.j = jpixf;
  element.btype = 0;
  list.push_back(element);

  //  nx is the number of x interfaces crossed by the line charge

  nx = jpixf - jpix0;
  anx = abs(nx);
  if (anx > 0) {
    if (nx > 0) {
      for (j = jpix0; j < jpixf; ++j) {
        xi = xsize_ * j;
        yi = slopey * (xi - x0) + y0;
        ipix = (int)(yi / ysize_) + 1;
        si = std::sqrt((xi - x0) * (xi - x0) + (yi - y0) * (yi - y0));
        element.s = si;
        element.x = xi;
        element.y = yi;
        element.i = ipix;
        element.j = j;
        element.btype = 1;
        list.push_back(element);
      }
    } else {
      for (j = jpix0; j > jpixf; --j) {
        xi = xsize_ * (j - 1);
        yi = slopey * (xi - x0) + y0;
        ipix = (int)(yi / ysize_) + 1;
        si = std::sqrt((xi - x0) * (xi - x0) + (yi - y0) * (yi - y0));
        element.s = si;
        element.x = xi;
        element.y = yi;
        element.i = ipix;
        element.j = j;
        element.btype = 1;
        list.push_back(element);
      }
    }
  }

  ny = ipixf - ipix0;
  any = abs(ny);
  if (any > 0) {
    if (ny > 0) {
      for (i = ipix0; i < ipixf; ++i) {
        yi = ysize_ * i;
        xi = slopex * (yi - y0) + x0;
        jpix = (int)(xi / xsize_) + 1;
        si = std::sqrt((xi - x0) * (xi - x0) + (yi - y0) * (yi - y0));
        element.s = si;
        element.x = xi;
        element.y = yi;
        element.i = i;
        element.j = jpix;
        element.btype = 2;
        list.push_back(element);
      }
    } else {
      for (i = ipix0; i > ipixf; --i) {
        yi = ysize_ * (i - 1);
        xi = slopex * (yi - y0) + x0;
        jpix = (int)(xi / xsize_) + 1;
        si = std::sqrt((xi - x0) * (xi - x0) + (yi - y0) * (yi - y0));
        element.s = si;
        element.x = xi;
        element.y = yi;
        element.i = i;
        element.j = jpix;
        element.btype = 2;
        list.push_back(element);
      }
    }
  }

  imax = std::max(ipix0, ipixf);
  jmax = std::max(jpix0, jpixf);

  // Sort the list according to the distance from the initial point

  list.sort();

  // Look for double pixels and adjust the list appropriately

  for (i = 1; i < imax; ++i) {
    if (ydouble[i - 1]) {
      listIter = list.begin();
      if (ny > 0) {
        while (listIter != list.end()) {
          if (listIter->i == i && listIter->btype == 2) {
            listIter = list.erase(listIter);
            continue;
          }
          if (listIter->i > i) {
            --(listIter->i);
          }
          ++listIter;
        }
      } else {
        while (listIter != list.end()) {
          if (listIter->i == i + 1 && listIter->btype == 2) {
            listIter = list.erase(listIter);
            continue;
          }
          if (listIter->i > i + 1) {
            --(listIter->i);
          }
          ++listIter;
        }
      }
    }
  }

  for (j = 1; j < jmax; ++j) {
    if (xdouble[j - 1]) {
      listIter = list.begin();
      if (nx > 0) {
        while (listIter != list.end()) {
          if (listIter->j == j && listIter->btype == 1) {
            listIter = list.erase(listIter);
            continue;
          }
          if (listIter->j > j) {
            --(listIter->j);
          }
          ++listIter;
        }
      } else {
        while (listIter != list.end()) {
          if (listIter->j == j + 1 && listIter->btype == 1) {
            listIter = list.erase(listIter);
            continue;
          }
          if (listIter->j > j + 1) {
            --(listIter->j);
          }
          ++listIter;
        }
      }
    }
  }

  // The list now contains the path lengths of the line charge in each pixel from (x0,y0).  Cacluate the lengths of the segments and the charge.

  s0 = 0.f;
  listIter = list.begin();
  listEnd = list.end();
  for (; listIter != listEnd; ++listIter) {
    si = listIter->s;
    ds = si - s0;
    s0 = si;
    j = listIter->j;
    i = listIter->i;
    if (sf > 0.f) {
      qpix = qtotal * ds / sf;
    } else {
      qpix = qtotal;
    }
    template2d[j][i] += qpix;
  }

  return true;

}  // simpletemplate2D

float SiPixelTemplate::ss50 ( )

inline

1/2 of the single pixel per double column threshold in electrons

Definition at line 411 of file SiPixelTemplate.h.

References ss50_.

float SiPixelTemplate::sxmax ( )

inline

average pixel signal for x-projection of cluster

Definition at line 417 of file SiPixelTemplate.h.

References sxmax_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::sxone ( )

inline

rms for one pixel x-clusters

Definition at line 419 of file SiPixelTemplate.h.

References sxone_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), SiPixelTemplateSplit::PixelTempSplit(), and temperrors().

float SiPixelTemplate::sxtwo ( )

inline

rms for one double-pixel x-clusters

Definition at line 421 of file SiPixelTemplate.h.

References sxtwo_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), SiPixelTemplateSplit::PixelTempSplit(), and temperrors().

float SiPixelTemplate::symax ( )

inline

average pixel signal for y-projection of cluster

Definition at line 412 of file SiPixelTemplate.h.

References symax_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::syone ( )

inline

rms for one pixel y-clusters

Definition at line 414 of file SiPixelTemplate.h.

References syone_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::sytwo ( )

inline

rms for one double-pixel y-clusters

Definition at line 416 of file SiPixelTemplate.h.

References sytwo_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

void SiPixelTemplate::temperrors	(	int	id,
		float	cotalpha,
		float	cotbeta,
		int	qBin,
		float &	sigmay,
		float &	sigmax,
		float &	sy1,
		float &	sy2,
		float &	sx1,
		float &	sx2
	)

Interpolate beta/alpha angles to produce estimated errors for fastsim

Parameters

id	- (input) index of the template to use
cotalpha	- (input) the cotangent of the alpha track angle (see CMS IN 2004/014)
cotbeta	- (input) the cotangent of the beta track angle (see CMS IN 2004/014)
qBin	- (input) charge bin from 0-3
sigmay	- (output) the estimated y-error for CPETemplate in microns
sigmax	- (output) the estimated x-error for CPETemplate in microns
sy1	- (output) the estimated y-error for 1 single-pixel clusters in microns
sy2	- (output) the estimated y-error for 1 double-pixel clusters in microns
sx1	- (output) the estimated x-error for 1 single-pixel clusters in microns
sx2	- (output) the estimated x-error for 1 double-pixel clusters in microns

Definition at line 3467 of file SiPixelTemplate.cc.

References funct::abs(), cms::cuda::assert(), enty0_, enty1_, Exception, validate-o2o-wbm::f, mps_fire::i, id_current_, if(), PixelTestBeamValidation_cfi::Ny, sxone(), sxtwo(), SiPixelTemplateEntry::syone, SiPixelTemplateEntry::sytwo, thePixelTemp_, xrms(), xxratio(), yratio_, SiPixelTemplateEntry::yrms, yrms(), and yxratio().

Referenced by PixelTemplateSmearerBase::smearHit(), and PixelTemplateSmearerBase::smearMergeGroup().

{
  // Interpolate for a new set of track angles

  // Local variables
  int i;
  int ilow, ihigh, iylow, iyhigh, Ny, Nxx, Nyx, index;
  float yxratio, xxratio;
  float acotb;
  float yrms, xrms;
  //bool flip_y;

  // Find the index corresponding to id

  index = -1;
  for (i = 0; i < (int)thePixelTemp_.size(); ++i) {
    if (id == thePixelTemp_[i].head.ID) {
      index = i;
      break;
    }
  }

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (index < 0 || index >= (int)thePixelTemp_.size()) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::temperrors can't find needed template ID = " << id
                                        << std::endl;
  }
#else
  assert(index >= 0 && index < (int)thePixelTemp_.size());
#endif

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (qBin < 0 || qBin > 5) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::temperrors called with illegal qBin = " << qBin
                                        << std::endl;
  }
#else
  assert(qBin >= 0 && qBin < 6);
#endif

  // The error information for qBin > 3 is taken to be the same as qBin=3

  if (qBin > 3) {
    qBin = 3;
  }
  //

  // Interpolate the absolute value of cot(beta)

  acotb = std::abs(cotbeta);

  // Copy the charge scaling factor to the private variable

  Ny = thePixelTemp_[index].head.NTy;
  Nyx = thePixelTemp_[index].head.NTyx;
  Nxx = thePixelTemp_[index].head.NTxx;

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (Ny < 2 || Nyx < 1 || Nxx < 2) {
    throw cms::Exception("DataCorrupt") << "template ID = " << id_current_ << "has too few entries: Ny/Nyx/Nxx = " << Ny
                                        << "/" << Nyx << "/" << Nxx << std::endl;
  }
#else
  assert(Ny > 1 && Nyx > 0 && Nxx > 1);
#endif

  // next, loop over all y-angle entries

  // Interpolate/store all y-related quantities (flip displacements when flip_y)

  sy1 = (1.f - yratio_) * enty0_->syone + yratio_ * enty1_->syone;
  sy2 = (1.f - yratio_) * enty0_->sytwo + yratio_ * enty1_->sytwo;
  yrms = (1.f - yratio_) * enty0_->yrms[qBin] + yratio_ * enty1_->yrms[qBin];

  // next, loop over all x-angle entries, first, find relevant y-slices

  iylow = 0;
  yxratio = 0.f;

  if (acotb >= thePixelTemp_[index].entx[Nyx - 1][0].cotbeta) {
    iylow = Nyx - 2;
    yxratio = 1.f;

  } else if (acotb >= thePixelTemp_[index].entx[0][0].cotbeta) {
    for (i = 0; i < Nyx - 1; ++i) {
      if (thePixelTemp_[index].entx[i][0].cotbeta <= acotb && acotb < thePixelTemp_[index].entx[i + 1][0].cotbeta) {
        iylow = i;
        yxratio = (acotb - thePixelTemp_[index].entx[i][0].cotbeta) /
                  (thePixelTemp_[index].entx[i + 1][0].cotbeta - thePixelTemp_[index].entx[i][0].cotbeta);
        break;
      }
    }
  }

  iyhigh = iylow + 1;

  ilow = 0;
  xxratio = 0.f;

  if (cotalpha >= thePixelTemp_[index].entx[0][Nxx - 1].cotalpha) {
    ilow = Nxx - 2;
    xxratio = 1.f;

  } else {
    if (cotalpha >= thePixelTemp_[index].entx[0][0].cotalpha) {
      for (i = 0; i < Nxx - 1; ++i) {
        if (thePixelTemp_[index].entx[0][i].cotalpha <= cotalpha &&
            cotalpha < thePixelTemp_[index].entx[0][i + 1].cotalpha) {
          ilow = i;
          xxratio = (cotalpha - thePixelTemp_[index].entx[0][i].cotalpha) /
                    (thePixelTemp_[index].entx[0][i + 1].cotalpha - thePixelTemp_[index].entx[0][i].cotalpha);
          break;
        }
      }
    }
  }

  ihigh = ilow + 1;

  sx1 =
      (1.f - xxratio) * thePixelTemp_[index].entx[0][ilow].sxone + xxratio * thePixelTemp_[index].entx[0][ihigh].sxone;
  sx2 =
      (1.f - xxratio) * thePixelTemp_[index].entx[0][ilow].sxtwo + xxratio * thePixelTemp_[index].entx[0][ihigh].sxtwo;

  xrms = (1.f - yxratio) * ((1.f - xxratio) * thePixelTemp_[index].entx[iylow][ilow].xrms[qBin] +
                            xxratio * thePixelTemp_[index].entx[iylow][ihigh].xrms[qBin]) +
         yxratio * ((1.f - xxratio) * thePixelTemp_[index].entx[iyhigh][ilow].xrms[qBin] +
                    xxratio * thePixelTemp_[index].entx[iyhigh][ihigh].xrms[qBin]);

  //  Take the errors and bias from the correct charge bin

  sigmay = yrms;

  sigmax = xrms;

  return;

}  // temperrors

void SiPixelTemplate::vavilov2_pars	(	double &	mpv,
		double &	sigma,
		double &	kappa
	)

Interpolate beta/alpha angles to produce Vavilov parameters for the 2-cluster charge distribution

Parameters

mpv	- (output) the Vavilov most probable charge (well, not really the most probable esp at large kappa)
sigma	- (output) the Vavilov sigma parameter
kappa	- (output) the Vavilov kappa parameter [0.01 (Landau-like) < kappa < 10 (Gaussian-like)

Definition at line 4086 of file SiPixelTemplate.cc.

References cms::cuda::assert(), cota_current_, cotb_current_, Exception, validate-o2o-wbm::f, mps_fire::i, id_current_, index_id_, kappavav2(), kappavav2_, mpvvav2(), mpvvav2_, PixelTestBeamValidation_cfi::Ny, sigmavav2(), sigmavav2_, mathSSE::sqrt(), thePixelTemp_, and yratio().

Referenced by SiPixelTemplateSplit::PixelTempSplit().

{
  // Local variables
  int i;
  int ilow, ihigh, Ny;
  float yratio, cotb, cotalpha0, arg;

  // Interpolate in cotbeta only for the correct total path length (converts cotalpha, cotbeta into an effective cotbeta)

  cotalpha0 = thePixelTemp_[index_id_].enty[0].cotalpha;
  arg = cotb_current_ * cotb_current_ + cota_current_ * cota_current_ - cotalpha0 * cotalpha0;
  if (arg < 0.f)
    arg = 0.f;
  cotb = std::sqrt(arg);

  // Copy the charge scaling factor to the private variable

  Ny = thePixelTemp_[index_id_].head.NTy;

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (Ny < 2) {
    throw cms::Exception("DataCorrupt") << "template ID = " << id_current_ << "has too few entries: Ny = " << Ny
                                        << std::endl;
  }
#else
  assert(Ny > 1);
#endif

  // next, loop over all y-angle entries

  ilow = 0;
  yratio = 0.f;

  if (cotb >= thePixelTemp_[index_id_].enty[Ny - 1].cotbeta) {
    ilow = Ny - 2;
    yratio = 1.f;

  } else {
    if (cotb >= thePixelTemp_[index_id_].enty[0].cotbeta) {
      for (i = 0; i < Ny - 1; ++i) {
        if (thePixelTemp_[index_id_].enty[i].cotbeta <= cotb && cotb < thePixelTemp_[index_id_].enty[i + 1].cotbeta) {
          ilow = i;
          yratio = (cotb - thePixelTemp_[index_id_].enty[i].cotbeta) /
                   (thePixelTemp_[index_id_].enty[i + 1].cotbeta - thePixelTemp_[index_id_].enty[i].cotbeta);
          break;
        }
      }
    }
  }

  ihigh = ilow + 1;

  // Interpolate Vavilov parameters

  mpvvav2_ = (1.f - yratio) * thePixelTemp_[index_id_].enty[ilow].mpvvav2 +
             yratio * thePixelTemp_[index_id_].enty[ihigh].mpvvav2;
  sigmavav2_ = (1.f - yratio) * thePixelTemp_[index_id_].enty[ilow].sigmavav2 +
               yratio * thePixelTemp_[index_id_].enty[ihigh].sigmavav2;
  kappavav2_ = (1.f - yratio) * thePixelTemp_[index_id_].enty[ilow].kappavav2 +
               yratio * thePixelTemp_[index_id_].enty[ihigh].kappavav2;

  // Copy to parameter list

  mpv = (double)mpvvav2_;
  sigma = (double)sigmavav2_;
  kappa = (double)kappavav2_;

  return;

}  // vavilov2_pars

void SiPixelTemplate::vavilov_pars	(	double &	mpv,
		double &	sigma,
		double &	kappa
	)

Interpolate beta/alpha angles to produce Vavilov parameters for the charge distribution

Parameters

mpv	- (output) the Vavilov most probable charge (well, not really the most probable esp at large kappa)
sigma	- (output) the Vavilov sigma parameter
kappa	- (output) the Vavilov kappa parameter [0.01 (Landau-like) < kappa < 10 (Gaussian-like)

Definition at line 4002 of file SiPixelTemplate.cc.

References cms::cuda::assert(), cota_current_, cotb_current_, ENDL, Exception, validate-o2o-wbm::f, mps_fire::i, id_current_, index_id_, kappavav(), kappavav_, LOGERROR, mpvvav(), mpvvav_, PixelTestBeamValidation_cfi::Ny, sigmavav(), sigmavav_, mathSSE::sqrt(), thePixelTemp_, and yratio().

Referenced by SiPixelTemplateReco::PixelTempReco1D().

{
  // Local variables
  int i;
  int ilow, ihigh, Ny;
  float yratio, cotb, cotalpha0, arg;

  // Interpolate in cotbeta only for the correct total path length (converts cotalpha, cotbeta into an effective cotbeta)

  cotalpha0 = thePixelTemp_[index_id_].enty[0].cotalpha;
  arg = cotb_current_ * cotb_current_ + cota_current_ * cota_current_ - cotalpha0 * cotalpha0;
  if (arg < 0.f)
    arg = 0.f;
  cotb = std::sqrt(arg);

  // Copy the charge scaling factor to the private variable

  Ny = thePixelTemp_[index_id_].head.NTy;

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (Ny < 2) {
    throw cms::Exception("DataCorrupt") << "template ID = " << id_current_ << "has too few entries: Ny = " << Ny
                                        << std::endl;
  }
#else
  assert(Ny > 1);
#endif

  // next, loop over all y-angle entries

  ilow = 0;
  yratio = 0.f;

  if (cotb >= thePixelTemp_[index_id_].enty[Ny - 1].cotbeta) {
    ilow = Ny - 2;
    yratio = 1.f;

  } else {
    if (cotb >= thePixelTemp_[index_id_].enty[0].cotbeta) {
      for (i = 0; i < Ny - 1; ++i) {
        if (thePixelTemp_[index_id_].enty[i].cotbeta <= cotb && cotb < thePixelTemp_[index_id_].enty[i + 1].cotbeta) {
          ilow = i;
          yratio = (cotb - thePixelTemp_[index_id_].enty[i].cotbeta) /
                   (thePixelTemp_[index_id_].enty[i + 1].cotbeta - thePixelTemp_[index_id_].enty[i].cotbeta);
          break;
        }
      }
    }
  }

  ihigh = ilow + 1;

  // Interpolate Vavilov parameters

  mpvvav_ = (1.f - yratio) * thePixelTemp_[index_id_].enty[ilow].mpvvav +
            yratio * thePixelTemp_[index_id_].enty[ihigh].mpvvav;
  sigmavav_ = (1.f - yratio) * thePixelTemp_[index_id_].enty[ilow].sigmavav +
              yratio * thePixelTemp_[index_id_].enty[ihigh].sigmavav;
  kappavav_ = (1.f - yratio) * thePixelTemp_[index_id_].enty[ilow].kappavav +
              yratio * thePixelTemp_[index_id_].enty[ihigh].kappavav;

  // Copy to parameter list

  //Avoid rounding difference between floats and doubles causing issues later
  if (kappavav_ <= 0.01f) {
    LOGERROR("SiPixelTemplate") << "Vavilov kappa value is " << kappavav_ << " changing it to be above 0.01" << ENDL;
    kappavav_ = 0.01f + 0.0000001f;
  }

  mpv = (double)mpvvav_;
  sigma = (double)sigmavav_;
  kappa = (double)kappavav_;

  return;

}  // vavilov_pars

float SiPixelTemplate::xavg ( int  i )

inline

average x-bias of reconstruction binned in 4 charge bins

Definition at line 482 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and xavg_.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

float SiPixelTemplate::xavgc2m ( int  i )

inline

1st pass chi2 min search: average x-bias of reconstruction binned in 4 charge bins

Definition at line 604 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and xavgc2m_.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::xflcorr	(	int	binq,
		float	qflx
	)

Return interpolated x-correction for input charge bin and qflx

Parameters

binq	- (input) charge bin [0-3]
qflx	- (input) (Q_f-Q_l)/(Q_f+Q_l) for this cluster

Definition at line 2448 of file SiPixelTemplate.cc.

References cms::cuda::assert(), PVValHelper::dx, Exception, and validate-o2o-wbm::f.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

{
  // Interpolate using quantities already stored in the private variables

  // Local variables
  float qfl, qfl2, qfl3, qfl4, qfl5, dx;

  // Make sure that input is OK

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (binq < 0 || binq > 3) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xflcorr called with binq = " << binq << std::endl;
  }
#else
  assert(binq >= 0 && binq < 4);
#endif
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (fabs((double)qflx) > 1.) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xflcorr called with qflx = " << qflx << std::endl;
  }
#else
  assert(fabs((double)qflx) <= 1.);
#endif

  // Define the maximum signal to allow before de-weighting a pixel

  qfl = qflx;

  if (qfl < -0.9f) {
    qfl = -0.9f;
  }
  if (qfl > 0.9f) {
    qfl = 0.9f;
  }

  // Interpolate between the two polynomials

  qfl2 = qfl * qfl;
  qfl3 = qfl2 * qfl;
  qfl4 = qfl3 * qfl;
  qfl5 = qfl4 * qfl;
  dx = (1.f - yxratio_) *
           ((1.f - xxratio_) * (xflparll_[binq][0] + xflparll_[binq][1] * qfl + xflparll_[binq][2] * qfl2 +
                                xflparll_[binq][3] * qfl3 + xflparll_[binq][4] * qfl4 + xflparll_[binq][5] * qfl5) +
            xxratio_ * (xflparlh_[binq][0] + xflparlh_[binq][1] * qfl + xflparlh_[binq][2] * qfl2 +
                        xflparlh_[binq][3] * qfl3 + xflparlh_[binq][4] * qfl4 + xflparlh_[binq][5] * qfl5)) +
       yxratio_ *
           ((1.f - xxratio_) * (xflparhl_[binq][0] + xflparhl_[binq][1] * qfl + xflparhl_[binq][2] * qfl2 +
                                xflparhl_[binq][3] * qfl3 + xflparhl_[binq][4] * qfl4 + xflparhl_[binq][5] * qfl5) +
            xxratio_ * (xflparhh_[binq][0] + xflparhh_[binq][1] * qfl + xflparhh_[binq][2] * qfl2 +
                        xflparhh_[binq][3] * qfl3 + xflparhh_[binq][4] * qfl4 + xflparhh_[binq][5] * qfl5));

  return dx;

}  // End xflcorr

float SiPixelTemplate::xgsig ( int  i )

inline

average sigma_x from Gaussian fit binned in 4 charge bins

Definition at line 512 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and xgsig_.

float SiPixelTemplate::xgx0 ( int  i )

inline

average x0 from Gaussian fit binned in 4 charge bins

Definition at line 502 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and xgx0_.

float SiPixelTemplate::xrms ( int  i )

inline

average x-rms of reconstruction binned in 4 charge bins

Definition at line 492 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and xrms_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and temperrors().

float SiPixelTemplate::xrmsc2m ( int  i )

inline

1st pass chi2 min search: average x-rms of reconstruction binned in 4 charge bins

Definition at line 614 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and xrmsc2m_.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

void SiPixelTemplate::xsigma2	(	int	fxpix,
		int	lxpix,
		float	sxthr,
		float	xsum[13+4],
		float	xsig2[13+4]
	)

Return vector of x errors (squared) for an input vector of projected signals Add large Q scaling for use in cluster splitting.

Parameters

fxpix	- (input) index of the first real pixel in the projected cluster (doesn't include pseudopixels)
lxpix	- (input) index of the last real pixel in the projected cluster (doesn't include pseudopixels)
sxthr	- (input) maximum signal before de-weighting
xsum	- (input) 11-element vector of pixel signals
xsig2	- (output) 11-element vector of x errors (squared)

Definition at line 2274 of file SiPixelTemplate.cc.

References cms::cuda::assert(), BHX, BXM2, ENDL, Exception, validate-o2o-wbm::f, mps_fire::i, and LOGERROR.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

{
  // Interpolate using quantities already stored in the private variables

  // Local variables
  int i;
  float sigi, sigi2, sigi3, sigi4, yint, sxmax, x0, qscale, s25;

  // Make sure that input is OK

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (fxpix < 2 || fxpix >= BXM2) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xsigma2 called with fxpix = " << fxpix << std::endl;
  }
#else
  assert(fxpix > 1 && fxpix < BXM2);
#endif
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (lxpix < fxpix || lxpix >= BXM2) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xsigma2 called with lxpix/fxpix = " << lxpix << "/"
                                        << fxpix << std::endl;
  }
#else
  assert(lxpix >= fxpix && lxpix < BXM2);
#endif

  // Define the maximum signal to use in the parameterization

  sxmax = sxmax_;
  s25 = 0.5f * s50_;
  if (sxmax_ > sxparmax_) {
    sxmax = sxparmax_;
  }

  // Evaluate pixel-by-pixel uncertainties (weights) for the templ analysis

  for (i = fxpix - 2; i <= lxpix + 2; ++i) {
    if (i < fxpix || i > lxpix) {
      // Nearest pseudopixels have uncertainties of 50% of threshold, next-nearest have 10% of threshold

      xsig2[i] = s50_ * s50_;
    } else {
      if (xsum[i] < sxmax) {
        sigi = xsum[i];
        qscale = 1.f;
        if (sigi < s25)
          sigi = s25;
      } else {
        sigi = sxmax;
        qscale = xsum[i] / sxmax;
      }
      sigi2 = sigi * sigi;
      sigi3 = sigi2 * sigi;
      sigi4 = sigi3 * sigi;

      // First, do the cotbeta interpolation

      if (i <= BHX) {
        yint = (1.f - yratio_) * (xparly0_[0][0] + xparly0_[0][1] * sigi + xparly0_[0][2] * sigi2 +
                                  xparly0_[0][3] * sigi3 + xparly0_[0][4] * sigi4) +
               yratio_ * (xparhy0_[0][0] + xparhy0_[0][1] * sigi + xparhy0_[0][2] * sigi2 + xparhy0_[0][3] * sigi3 +
                          xparhy0_[0][4] * sigi4);
      } else {
        yint = (1.f - yratio_) * (xparly0_[1][0] + xparly0_[1][1] * sigi + xparly0_[1][2] * sigi2 +
                                  xparly0_[1][3] * sigi3 + xparly0_[1][4] * sigi4) +
               yratio_ * (xparhy0_[1][0] + xparhy0_[1][1] * sigi + xparhy0_[1][2] * sigi2 + xparhy0_[1][3] * sigi3 +
                          xparhy0_[1][4] * sigi4);
      }

      // Next, do the cotalpha interpolation

      if (i <= BHX) {
        xsig2[i] = (1.f - xxratio_) * (xparl_[0][0] + xparl_[0][1] * sigi + xparl_[0][2] * sigi2 +
                                       xparl_[0][3] * sigi3 + xparl_[0][4] * sigi4) +
                   xxratio_ * (xparh_[0][0] + xparh_[0][1] * sigi + xparh_[0][2] * sigi2 + xparh_[0][3] * sigi3 +
                               xparh_[0][4] * sigi4);
      } else {
        xsig2[i] = (1.f - xxratio_) * (xparl_[1][0] + xparl_[1][1] * sigi + xparl_[1][2] * sigi2 +
                                       xparl_[1][3] * sigi3 + xparl_[1][4] * sigi4) +
                   xxratio_ * (xparh_[1][0] + xparh_[1][1] * sigi + xparh_[1][2] * sigi2 + xparh_[1][3] * sigi3 +
                               xparh_[1][4] * sigi4);
      }

      // Finally, get the mid-point value of the cotalpha function

      if (i <= BHX) {
        x0 = xpar0_[0][0] + xpar0_[0][1] * sigi + xpar0_[0][2] * sigi2 + xpar0_[0][3] * sigi3 + xpar0_[0][4] * sigi4;
      } else {
        x0 = xpar0_[1][0] + xpar0_[1][1] * sigi + xpar0_[1][2] * sigi2 + xpar0_[1][3] * sigi3 + xpar0_[1][4] * sigi4;
      }

      // Finally, rescale the yint value for cotalpha variation

      if (x0 != 0.f) {
        xsig2[i] = xsig2[i] / x0 * yint;
      }
      xsig2[i] *= qscale;
      if (xsum[i] > sxthr) {
        xsig2[i] = 1.e8;
      }
      if (xsig2[i] <= 0.f) {
        LOGERROR("SiPixelTemplate") << "neg x-error-squared, id = " << id_current_ << ", index = " << index_id_
                                    << ", cot(alpha) = " << cota_current_ << ", cot(beta) = " << cotb_current_
                                    << ", sigi = " << sigi << ENDL;
      }
    }
  }

  return;

}  // End xsigma2

float SiPixelTemplate::xsize ( )

inline

pixel x-size (microns)

Definition at line 675 of file SiPixelTemplate.h.

References xsize_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

void SiPixelTemplate::xtemp	(	int	fxbin,
		int	lxbin,
		float	xtemplate[41][13+4]
	)

Return interpolated y-template in single call

Parameters

fxbin	- (input) index of first bin (0-40) to fill
fxbin	- (input) index of last bin (0-40) to fill
xtemplate	- (output) a 41x11 output buffer

Definition at line 2587 of file SiPixelTemplate.cc.

References cms::cuda::assert(), BXM1, BXM2, BXSIZE, Exception, mps_fire::i, and dqmiolumiharvest::j.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), PixelTemplateSmearerBase::smearHit(), and PixelTemplateSmearerBase::smearMergeGroup().

                                                                             {
  // Retrieve already interpolated quantities

  // Local variables
  int i, j;

  // Verify that input parameters are in valid range

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (fxbin < 0 || fxbin > 40) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xtemp called with fxbin = " << fxbin << std::endl;
  }
#else
  assert(fxbin >= 0 && fxbin < 41);
#endif
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (lxbin < 0 || lxbin > 40) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xtemp called with lxbin = " << lxbin << std::endl;
  }
#else
  assert(lxbin >= 0 && lxbin < 41);
#endif

  // Build the x-template, the central 25 bins are here in all cases

  for (i = 0; i < 9; ++i) {
    for (j = 0; j < BXSIZE; ++j) {
      xtemplate[i + 16][j] = xtemp_[i][j];
    }
  }
  for (i = 0; i < 8; ++i) {
    xtemplate[i + 8][BXM1] = 0.f;
    for (j = 0; j < BXM1; ++j) {
      xtemplate[i + 8][j] = xtemp_[i][j + 1];
    }
  }
  for (i = 1; i < 9; ++i) {
    xtemplate[i + 24][0] = 0.f;
    for (j = 0; j < BXM1; ++j) {
      xtemplate[i + 24][j + 1] = xtemp_[i][j];
    }
  }
  //  Add more bins if needed
  if (fxbin < 8) {
    for (i = 0; i < 8; ++i) {
      xtemplate[i][BXM2] = 0.f;
      xtemplate[i][BXM1] = 0.f;
      for (j = 0; j < BXM2; ++j) {
        xtemplate[i][j] = xtemp_[i][j + 2];
      }
    }
  }
  if (lxbin > 32) {
    for (i = 1; i < 9; ++i) {
      xtemplate[i + 32][0] = 0.f;
      xtemplate[i + 32][1] = 0.f;
      for (j = 0; j < BXM2; ++j) {
        xtemplate[i + 32][j + 2] = xtemp_[i][j];
      }
    }
  }

  return;

}  // End xtemp

void SiPixelTemplate::xtemp3d	(	int	i,
		int	j,
		std::vector< float > &	xtemplate
	)

Return interpolated 3d x-template in single call

Parameters

i,j	- (input) template indices
xtemplate	- (output) a boost 3d array containing two sets of temlate indices and the combined pixel signals

Definition at line 2944 of file SiPixelTemplate.cc.

References BXSIZE, mps_fire::i, dqmiolumiharvest::j, and isotrackApplyRegressor::k.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

{
  // Sum two 2-d templates to make the 3-d template
  if (i >= 0 && i < nxbins_ && j <= i) {
    for (int k = 0; k < BXSIZE; ++k) {
      xtemplate[k] = temp2dx_[i][k] + temp2dx_[j][k];
    }
  } else {
    for (int k = 0; k < BXSIZE; ++k) {
      xtemplate[k] = 0.;
    }
  }

  return;

}  // End xtemp3d

void SiPixelTemplate::xtemp3d_int	(	int	nxpix,
		int &	nxbins
	)

Make interpolated 3d x-template (stored as class variables)

Parameters

nxpix	- (input) number of pixels in cluster (needed to size template)
nxbins	- (output) number of bins needed for each template projection

Definition at line 2865 of file SiPixelTemplate.cc.

References cms::cuda::assert(), BXM1, BXM3, BXSIZE, change_name::diff, Exception, mps_fire::i, dqmiolumiharvest::j, and isotrackApplyRegressor::k.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

{
  // Retrieve already interpolated quantities

  // Local variables
  int i, j, k;
  int ioff0, ioffp, ioffm;

  // Verify that input parameters are in valid range

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (nxpix < 1 || nxpix >= BXM3) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xtemp3d called with nxpix = " << nxpix << std::endl;
  }
#else
  assert(nxpix > 0 && nxpix < BXM3);
#endif

  // Calculate the size of the shift in pixels needed to span the entire cluster

  float diff = fabsf(nxpix - clslenx_) / 2.f + 1.f;
  int nshift = (int)diff;
  if ((diff - nshift) > 0.5f) {
    ++nshift;
  }

  // Calculate the number of bins needed to specify each hit range

  nxbins_ = 9 + 16 * nshift;

  // Create a 2-d working template with the correct size

  temp2dx_.resize(boost::extents[nxbins_][BXSIZE]);

  //  The 9 central bins are copied from the interpolated private store

  ioff0 = 8 * nshift;

  for (i = 0; i < 9; ++i) {
    for (j = 0; j < BXSIZE; ++j) {
      temp2dx_[i + ioff0][j] = xtemp_[i][j];
    }
  }

  // Add the +- shifted templates

  for (k = 1; k <= nshift; ++k) {
    ioffm = ioff0 - k * 8;
    for (i = 0; i < 8; ++i) {
      for (j = 0; j < k; ++j) {
        temp2dx_[i + ioffm][BXM1 - j] = 0.f;
      }
      for (j = 0; j < BXSIZE - k; ++j) {
        temp2dx_[i + ioffm][j] = xtemp_[i][j + k];
      }
    }
    ioffp = ioff0 + k * 8;
    for (i = 1; i < 9; ++i) {
      for (j = 0; j < k; ++j) {
        temp2dx_[i + ioffp][j] = 0.f;
      }
      for (j = 0; j < BXSIZE - k; ++j) {
        temp2dx_[i + ioffp][j + k] = xtemp_[i][j];
      }
    }
  }

  nxbins = nxbins_;

  return;

}  // End xtemp3d_int

float SiPixelTemplate::xxratio ( )

inline

fractional distance in x between cotalpha templates

Definition at line 441 of file SiPixelTemplate.h.

References xxratio_.

Referenced by qbin_dist(), and temperrors().

float SiPixelTemplate::yavg ( int  i )

inline

average y-bias of reconstruction binned in 4 charge bins

Definition at line 442 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and yavg_.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

float SiPixelTemplate::yavgc2m ( int  i )

inline

1st pass chi2 min search: average y-bias of reconstruction binned in 4 charge bins

Definition at line 562 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and yavgc2m_.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

float SiPixelTemplate::yflcorr	(	int	binq,
		float	qfly
	)

Return interpolated y-correction for input charge bin and qfly

Parameters

binq	- (input) charge bin [0-3]
qfly	- (input) (Q_f-Q_l)/(Q_f+Q_l) for this cluster

Definition at line 2392 of file SiPixelTemplate.cc.

References cms::cuda::assert(), PVValHelper::dy, Exception, and validate-o2o-wbm::f.

Referenced by SiPixelTemplateReco::PixelTempReco1D().

{
  // Interpolate using quantities already stored in the private variables

  // Local variables
  float qfl, qfl2, qfl3, qfl4, qfl5, dy;

  // Make sure that input is OK

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (binq < 0 || binq > 3) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yflcorr called with binq = " << binq << std::endl;
  }
#else
  assert(binq >= 0 && binq < 4);
#endif
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (fabs((double)qfly) > 1.) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yflcorr called with qfly = " << qfly << std::endl;
  }
#else
  assert(fabs((double)qfly) <= 1.);
#endif

  // Define the maximum signal to allow before de-weighting a pixel

  qfl = qfly;

  if (qfl < -0.9f) {
    qfl = -0.9f;
  }
  if (qfl > 0.9f) {
    qfl = 0.9f;
  }

  // Interpolate between the two polynomials

  qfl2 = qfl * qfl;
  qfl3 = qfl2 * qfl;
  qfl4 = qfl3 * qfl;
  qfl5 = qfl4 * qfl;
  dy = (1.f - yratio_) * (yflparl_[binq][0] + yflparl_[binq][1] * qfl + yflparl_[binq][2] * qfl2 +
                          yflparl_[binq][3] * qfl3 + yflparl_[binq][4] * qfl4 + yflparl_[binq][5] * qfl5) +
       yratio_ * (yflparh_[binq][0] + yflparh_[binq][1] * qfl + yflparh_[binq][2] * qfl2 + yflparh_[binq][3] * qfl3 +
                  yflparh_[binq][4] * qfl4 + yflparh_[binq][5] * qfl5);

  return dy;

}  // End yflcorr

float SiPixelTemplate::ygsig ( int  i )

inline

average sigma_y from Gaussian fit binned in 4 charge bins

Definition at line 472 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and ygsig_.

float SiPixelTemplate::ygx0 ( int  i )

inline

average y0 from Gaussian fit binned in 4 charge bins

Definition at line 462 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and ygx0_.

float SiPixelTemplate::yratio ( )

inline

fractional distance in y between cotbeta templates

Definition at line 439 of file SiPixelTemplate.h.

References yratio_.

Referenced by vavilov2_pars(), and vavilov_pars().

float SiPixelTemplate::yrms ( int  i )

inline

average y-rms of reconstruction binned in 4 charge bins

Definition at line 452 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and yrms_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and temperrors().

float SiPixelTemplate::yrmsc2m ( int  i )

inline

1st pass chi2 min search: average y-rms of reconstruction binned in 4 charge bins

Definition at line 572 of file SiPixelTemplate.h.

References cms::cuda::assert(), Exception, mps_fire::i, and yrmsc2m_.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

void SiPixelTemplate::ysigma2	(	int	fypix,
		int	lypix,
		float	sythr,
		float	ysum[21+4],
		float	ysig2[21+4]
	)

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

void SiPixelTemplate::ysigma2	(	float	qpixel,
		int	index,
		float &	ysig2
	)

Return y error (squared) for an input signal and yindex Add large Q scaling for use in cluster splitting.

Parameters

qpixel	- (input) pixel charge
index	- (input) y-index index of pixel
ysig2	- (output) square error

Definition at line 2201 of file SiPixelTemplate.cc.

References cms::cuda::assert(), BHY, BYM2, ENDL, Exception, validate-o2o-wbm::f, and LOGERROR.

{
  // Interpolate using quantities already stored in the private variables

  // Local variables
  float sigi, sigi2, sigi3, sigi4, symax, qscale, err2, s25;

  // Make sure that input is OK

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (index < 2 || index >= BYM2) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::ysigma2 called with index = " << index << std::endl;
  }
#else
  assert(index > 1 && index < BYM2);
#endif

  // Define the maximum signal to use in the parameterization

  symax = symax_;
  s25 = 0.5f * s50_;
  if (symax_ > syparmax_) {
    symax = syparmax_;
  }

  // Evaluate pixel-by-pixel uncertainties (weights) for the templ analysis

  if (qpixel < symax) {
    sigi = qpixel;
    qscale = 1.f;
    if (sigi < s25)
      sigi = s25;
  } else {
    sigi = symax;
    qscale = qpixel / symax;
  }
  sigi2 = sigi * sigi;
  sigi3 = sigi2 * sigi;
  sigi4 = sigi3 * sigi;
  if (index <= BHY) {
    err2 =
        (1.f - yratio_) *
            (yparl_[0][0] + yparl_[0][1] * sigi + yparl_[0][2] * sigi2 + yparl_[0][3] * sigi3 + yparl_[0][4] * sigi4) +
        yratio_ *
            (yparh_[0][0] + yparh_[0][1] * sigi + yparh_[0][2] * sigi2 + yparh_[0][3] * sigi3 + yparh_[0][4] * sigi4);
  } else {
    err2 =
        (1.f - yratio_) *
            (yparl_[1][0] + yparl_[1][1] * sigi + yparl_[1][2] * sigi2 + yparl_[1][3] * sigi3 + yparl_[1][4] * sigi4) +
        yratio_ *
            (yparh_[1][0] + yparh_[1][1] * sigi + yparh_[1][2] * sigi2 + yparh_[1][3] * sigi3 + yparh_[1][4] * sigi4);
  }
  ysig2 = qscale * err2;
  if (ysig2 <= 0.f) {
    LOGERROR("SiPixelTemplate") << "neg y-error-squared, id = " << id_current_ << ", index = " << index_id_
                                << ", cot(alpha) = " << cota_current_ << ", cot(beta) = " << cotb_current_
                                << ", sigi = " << sigi << ENDL;
  }

  return;

}  // End ysigma2

float SiPixelTemplate::ysize ( )

inline

pixel y-size (microns)

Definition at line 676 of file SiPixelTemplate.h.

References ysize_.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), and SiPixelTemplateSplit::PixelTempSplit().

void SiPixelTemplate::ytemp	(	int	fybin,
		int	lybin,
		float	ytemplate[41][21+4]
	)

Return interpolated y-template in single call

Parameters

fybin	- (input) index of first bin (0-40) to fill
fybin	- (input) index of last bin (0-40) to fill
ytemplate	- (output) a 41x25 output buffer

Definition at line 2511 of file SiPixelTemplate.cc.

References cms::cuda::assert(), BYM1, BYM2, BYSIZE, Exception, mps_fire::i, and dqmiolumiharvest::j.

Referenced by SiPixelTemplateReco::PixelTempReco1D(), PixelTemplateSmearerBase::smearHit(), and PixelTemplateSmearerBase::smearMergeGroup().

{
  // Retrieve already interpolated quantities

  // Local variables
  int i, j;

  // Verify that input parameters are in valid range

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (fybin < 0 || fybin > 40) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::ytemp called with fybin = " << fybin << std::endl;
  }
#else
  assert(fybin >= 0 && fybin < 41);
#endif
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (lybin < 0 || lybin > 40) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::ytemp called with lybin = " << lybin << std::endl;
  }
#else
  assert(lybin >= 0 && lybin < 41);
#endif

  // Build the y-template, the central 25 bins are here in all cases

  for (i = 0; i < 9; ++i) {
    for (j = 0; j < BYSIZE; ++j) {
      ytemplate[i + 16][j] = ytemp_[i][j];
    }
  }
  for (i = 0; i < 8; ++i) {
    ytemplate[i + 8][BYM1] = 0.f;
    for (j = 0; j < BYM1; ++j) {
      ytemplate[i + 8][j] = ytemp_[i][j + 1];
    }
  }
  for (i = 1; i < 9; ++i) {
    ytemplate[i + 24][0] = 0.f;
    for (j = 0; j < BYM1; ++j) {
      ytemplate[i + 24][j + 1] = ytemp_[i][j];
    }
  }

  //  Add   more bins if needed

  if (fybin < 8) {
    for (i = 0; i < 8; ++i) {
      ytemplate[i][BYM2] = 0.f;
      ytemplate[i][BYM1] = 0.f;
      for (j = 0; j < BYM2; ++j) {
        ytemplate[i][j] = ytemp_[i][j + 2];
      }
    }
  }
  if (lybin > 32) {
    for (i = 1; i < 9; ++i) {
      ytemplate[i + 32][0] = 0.f;
      ytemplate[i + 32][1] = 0.f;
      for (j = 0; j < BYM2; ++j) {
        ytemplate[i + 32][j + 2] = ytemp_[i][j];
      }
    }
  }

  return;

}  // End ytemp

void SiPixelTemplate::ytemp3d	(	int	i,
		int	j,
		std::vector< float > &	ytemplate
	)

Return interpolated 3d y-template in single call

Parameters

i,j	- (input) template indices
ytemplate	- (output) a boost 3d array containing two sets of temlate indices and the combined pixel signals

Definition at line 2842 of file SiPixelTemplate.cc.

References BYSIZE, mps_fire::i, dqmiolumiharvest::j, and isotrackApplyRegressor::k.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

{
  // Sum two 2-d templates to make the 3-d template
  if (i >= 0 && i < nybins_ && j <= i) {
    for (int k = 0; k < BYSIZE; ++k) {
      ytemplate[k] = temp2dy_[i][k] + temp2dy_[j][k];
    }
  } else {
    for (int k = 0; k < BYSIZE; ++k) {
      ytemplate[k] = 0.;
    }
  }

  return;

}  // End ytemp3d

void SiPixelTemplate::ytemp3d_int	(	int	nypix,
		int &	nybins
	)

Make interpolated 3d y-template (stored as class variables)

Parameters

nypix	- (input) number of pixels in cluster (needed to size template)
nybins	- (output) number of bins needed for each template projection

Definition at line 2764 of file SiPixelTemplate.cc.

References cms::cuda::assert(), BYM1, BYM3, BYSIZE, change_name::diff, Exception, mps_fire::i, dqmiolumiharvest::j, and isotrackApplyRegressor::k.

Referenced by SiPixelTemplateSplit::PixelTempSplit().

{
  // Retrieve already interpolated quantities

  // Local variables
  int i, j, k;
  int ioff0, ioffp, ioffm;

  // Verify that input parameters are in valid range

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  if (nypix < 1 || nypix >= BYM3) {
    throw cms::Exception("DataCorrupt") << "SiPixelTemplate::ytemp3d called with nypix = " << nypix << std::endl;
  }
#else
  assert(nypix > 0 && nypix < BYM3);
#endif

  // Calculate the size of the shift in pixels needed to span the entire cluster

  float diff = fabsf(nypix - clsleny_) / 2. + 1.f;
  int nshift = (int)diff;
  if ((diff - nshift) > 0.5f) {
    ++nshift;
  }

  // Calculate the number of bins needed to specify each hit range

  nybins_ = 9 + 16 * nshift;

  // Create a 2-d working template with the correct size

  temp2dy_.resize(boost::extents[nybins_][BYSIZE]);

  //  The 9 central bins are copied from the interpolated private store

  ioff0 = 8 * nshift;

  for (i = 0; i < 9; ++i) {
    for (j = 0; j < BYSIZE; ++j) {
      temp2dy_[i + ioff0][j] = ytemp_[i][j];
    }
  }

  // Add the +- shifted templates

  for (k = 1; k <= nshift; ++k) {
    ioffm = ioff0 - k * 8;
    for (i = 0; i < 8; ++i) {
      for (j = 0; j < k; ++j) {
        temp2dy_[i + ioffm][BYM1 - j] = 0.f;
      }
      for (j = 0; j < BYSIZE - k; ++j) {
        temp2dy_[i + ioffm][j] = ytemp_[i][j + k];
      }
    }
    ioffp = ioff0 + k * 8;
    for (i = 1; i < 9; ++i) {
      for (j = 0; j < k; ++j) {
        temp2dy_[i + ioffp][j] = 0.f;
      }
      for (j = 0; j < BYSIZE - k; ++j) {
        temp2dy_[i + ioffp][j + k] = ytemp_[i][j];
      }
    }
  }

  nybins = nybins_;
  return;

}  // End ytemp3d_int

float SiPixelTemplate::yxratio ( )

inline

fractional distance in y between cotalpha templates slices

Definition at line 440 of file SiPixelTemplate.h.

References yxratio_.

Referenced by qbin_dist(), and temperrors().

float SiPixelTemplate::zsize ( )

inline

pixel z-size or thickness (microns)

Definition at line 677 of file SiPixelTemplate.h.

References zsize_.

Member Data Documentation

float SiPixelTemplate::abs_cotb_

private

absolute value of cot beta

Definition at line 693 of file SiPixelTemplate.h.

float SiPixelTemplate::chi2xavg_[4]

private

average x chi^2 in 4 charge bins

Definition at line 758 of file SiPixelTemplate.h.

Referenced by chi2xavg().

float SiPixelTemplate::chi2xavgc2m_[4]

private

1st pass chi2 min search: average x-chisq for merged clusters

Definition at line 766 of file SiPixelTemplate.h.

Referenced by chi2xavgc2m().

float SiPixelTemplate::chi2xavgone_

private

average x chi^2 for 1 pixel clusters

Definition at line 770 of file SiPixelTemplate.h.

Referenced by chi2xavgone().

float SiPixelTemplate::chi2xmin_[4]

private

minimum of x chi^2 in 4 charge bins

Definition at line 759 of file SiPixelTemplate.h.

Referenced by chi2xmin().

float SiPixelTemplate::chi2xminc2m_[4]

private

1st pass chi2 min search: minimum x-chisq for merged clusters

Definition at line 767 of file SiPixelTemplate.h.

Referenced by chi2xminc2m().

float SiPixelTemplate::chi2xminone_

private

minimum of x chi^2 for 1 pixel clusters

Definition at line 771 of file SiPixelTemplate.h.

Referenced by chi2xminone().

float SiPixelTemplate::chi2yavg_[4]

private

average y chi^2 in 4 charge bins

Definition at line 756 of file SiPixelTemplate.h.

Referenced by chi2yavg().

float SiPixelTemplate::chi2yavgc2m_[4]

private

1st pass chi2 min search: average y-chisq for merged clusters

Definition at line 762 of file SiPixelTemplate.h.

Referenced by chi2yavgc2m().

float SiPixelTemplate::chi2yavgone_

private

average y chi^2 for 1 pixel clusters

Definition at line 768 of file SiPixelTemplate.h.

Referenced by chi2yavgone().

float SiPixelTemplate::chi2ymin_[4]

private

minimum of y chi^2 in 4 charge bins

Definition at line 757 of file SiPixelTemplate.h.

Referenced by chi2ymin().

float SiPixelTemplate::chi2yminc2m_[4]

private

1st pass chi2 min search: minimum y-chisq for merged clusters

Definition at line 763 of file SiPixelTemplate.h.

Referenced by chi2yminc2m().

float SiPixelTemplate::chi2yminone_

private

minimum of y chi^2 for 1 pixel clusters

Definition at line 769 of file SiPixelTemplate.h.

Referenced by chi2yminone().

float SiPixelTemplate::clslenx_

private

x-cluster length of smaller interpolated template in pixels

Definition at line 720 of file SiPixelTemplate.h.

Referenced by clslenx().

float SiPixelTemplate::clsleny_

private

y-cluster length of smaller interpolated template in pixels

Definition at line 719 of file SiPixelTemplate.h.

Referenced by clsleny().

float SiPixelTemplate::cota_current_

private

current cot alpha

Definition at line 691 of file SiPixelTemplate.h.

Referenced by simpletemplate2D(), SiPixelTemplate(), vavilov2_pars(), and vavilov_pars().

float SiPixelTemplate::cotb_current_

private

current cot beta

Definition at line 692 of file SiPixelTemplate.h.

Referenced by simpletemplate2D(), SiPixelTemplate(), vavilov2_pars(), and vavilov_pars().

float SiPixelTemplate::delyavg_

private

average difference between clsleny_ and cluster length [with threshold effects]

Definition at line 723 of file SiPixelTemplate.h.

float SiPixelTemplate::delysig_

private

rms of difference between clsleny_ and cluster length [with threshold effects]

Definition at line 724 of file SiPixelTemplate.h.

int SiPixelTemplate::dtype_

private

flags BPix (=0) or FPix (=1)

Definition at line 694 of file SiPixelTemplate.h.

float SiPixelTemplate::dxone_

private

mean offset/correction for one pixel x-clusters

Definition at line 714 of file SiPixelTemplate.h.

Referenced by dxone().

float SiPixelTemplate::dxtwo_

private

mean offset/correction for one double-pixel x-clusters

Definition at line 716 of file SiPixelTemplate.h.

Referenced by dxtwo().

float SiPixelTemplate::dyone_

private

mean offset/correction for one pixel y-clusters

Definition at line 708 of file SiPixelTemplate.h.

Referenced by dyone().

float SiPixelTemplate::dytwo_

private

mean offset/correction for one double-pixel y-clusters

Definition at line 710 of file SiPixelTemplate.h.

Referenced by dytwo().

const SiPixelTemplateEntry* SiPixelTemplate::entry_sideloaded_

private

Definition at line 809 of file SiPixelTemplate.h.

Referenced by SiPixelTemplate().

const SiPixelTemplateEntry* SiPixelTemplate::entx00_

private

Definition at line 802 of file SiPixelTemplate.h.

const SiPixelTemplateEntry* SiPixelTemplate::entx02_

private

Definition at line 803 of file SiPixelTemplate.h.

const SiPixelTemplateEntry* SiPixelTemplate::entx20_

private

Definition at line 804 of file SiPixelTemplate.h.

const SiPixelTemplateEntry* SiPixelTemplate::entx21_

private

Definition at line 806 of file SiPixelTemplate.h.

const SiPixelTemplateEntry* SiPixelTemplate::entx22_

private

Definition at line 805 of file SiPixelTemplate.h.

const SiPixelTemplateEntry* SiPixelTemplate::enty0_

private

Definition at line 799 of file SiPixelTemplate.h.

Referenced by qbin_dist(), and temperrors().

const SiPixelTemplateEntry* SiPixelTemplate::enty1_

private

Definition at line 800 of file SiPixelTemplate.h.

Referenced by qbin_dist(), and temperrors().

float SiPixelTemplate::fbin_[3]

private

The QBin definitions in Q_clus/Q_avg.

Definition at line 790 of file SiPixelTemplate.h.

Referenced by fbin().

bool SiPixelTemplate::flip_x_

private

flip x sign-sensitive quantities

Definition at line 696 of file SiPixelTemplate.h.

bool SiPixelTemplate::flip_y_

private

flip y sign-sensitive quantities

Definition at line 695 of file SiPixelTemplate.h.

float SiPixelTemplate::fracxone_

private

The simulated fraction of single pixel x-clusters.

Definition at line 792 of file SiPixelTemplate.h.

Referenced by fracxone().

float SiPixelTemplate::fracxtwo_

private

The simulated fraction of single double-size pixel x-clusters.

Definition at line 794 of file SiPixelTemplate.h.

Referenced by fracxtwo().

float SiPixelTemplate::fracyone_

private

The simulated fraction of single pixel y-clusters.

Definition at line 791 of file SiPixelTemplate.h.

Referenced by fracyone().

float SiPixelTemplate::fracytwo_

private

The simulated fraction of single double-size pixel y-clusters.

Definition at line 793 of file SiPixelTemplate.h.

Referenced by fracytwo().

int SiPixelTemplate::id_current_

private

current id

Definition at line 689 of file SiPixelTemplate.h.

Referenced by qbin_dist(), SiPixelTemplate(), temperrors(), vavilov2_pars(), and vavilov_pars().

int SiPixelTemplate::index_id_

private

current index

Definition at line 690 of file SiPixelTemplate.h.

Referenced by SiPixelTemplate(), vavilov2_pars(), and vavilov_pars().

float SiPixelTemplate::kappavav2_

private

kappa parameter for 2-cluster Vavilov distribution

Definition at line 778 of file SiPixelTemplate.h.

Referenced by kappavav2(), and vavilov2_pars().

float SiPixelTemplate::kappavav_

private

kappa parameter for Vavilov distribution

Definition at line 775 of file SiPixelTemplate.h.

Referenced by kappavav(), and vavilov_pars().

float SiPixelTemplate::lorxbias_

private

Lorentz x-bias.

Definition at line 782 of file SiPixelTemplate.h.

Referenced by lorxbias().

float SiPixelTemplate::lorxwidth_

private

Lorentz x-width.

Definition at line 780 of file SiPixelTemplate.h.

Referenced by lorxwidth(), and simpletemplate2D().

float SiPixelTemplate::lorybias_

private

Lorentz y-bias.

Definition at line 781 of file SiPixelTemplate.h.

Referenced by lorybias().

float SiPixelTemplate::lorywidth_

private

Lorentz y-width (sign corrected for fpix frame)

Definition at line 779 of file SiPixelTemplate.h.

Referenced by lorywidth(), and simpletemplate2D().

float SiPixelTemplate::mpvvav2_

private

most probable charge in 2-cluster Vavilov distribution (not actually for larger kappa)

Definition at line 776 of file SiPixelTemplate.h.

Referenced by mpvvav2(), and vavilov2_pars().

float SiPixelTemplate::mpvvav_

private

most probable charge in Vavilov distribution (not actually for larger kappa)

Definition at line 773 of file SiPixelTemplate.h.

Referenced by mpvvav(), and vavilov_pars().

float SiPixelTemplate::nxbins_

private

number of bins in each dimension of the x-splitting template

Definition at line 788 of file SiPixelTemplate.h.

float SiPixelTemplate::nybins_

private

number of bins in each dimension of the y-splitting template

Definition at line 787 of file SiPixelTemplate.h.

float SiPixelTemplate::offsetx_[4]

private

x-offset in charge bins

Definition at line 727 of file SiPixelTemplate.h.

float SiPixelTemplate::offsety_[4]

private

y-offset in charge bins

Definition at line 728 of file SiPixelTemplate.h.

float SiPixelTemplate::pixmax_

private

maximum pixel charge

Definition at line 702 of file SiPixelTemplate.h.

Referenced by pixmax().

float SiPixelTemplate::qavg_

private

average cluster charge for this set of track angles

Definition at line 701 of file SiPixelTemplate.h.

Referenced by qavg().

float SiPixelTemplate::qavg_avg_

private

average of cluster charge less than qavg

Definition at line 786 of file SiPixelTemplate.h.

Referenced by simpletemplate2D().

float SiPixelTemplate::qmin2_

private

tighter minimum cluster charge for valid hit (keeps 99.8% of simulated hits)

Definition at line 772 of file SiPixelTemplate.h.

Referenced by qmin().

float SiPixelTemplate::qmin_

private

minimum cluster charge for valid hit (keeps 99.9% of simulated hits)

Definition at line 718 of file SiPixelTemplate.h.

Referenced by qmin().

float SiPixelTemplate::qscale_

private

charge scaling factor

Definition at line 703 of file SiPixelTemplate.h.

Referenced by qscale().

float SiPixelTemplate::r_qMeas_qTrue_

private

ratio of measured to true cluster charges

Definition at line 789 of file SiPixelTemplate.h.

Referenced by r_qMeas_qTrue().

float SiPixelTemplate::s50_

private

1/2 of the pixel single col threshold signal in electrons

Definition at line 704 of file SiPixelTemplate.h.

Referenced by s50().

float SiPixelTemplate::scalex_[4]

private

x-error scale factor in charge bins

Definition at line 725 of file SiPixelTemplate.h.

float SiPixelTemplate::scalexavg_

private

average x-error scale factor

Definition at line 721 of file SiPixelTemplate.h.

float SiPixelTemplate::scaley_[4]

private

y-error scale factor in charge bins

Definition at line 726 of file SiPixelTemplate.h.

float SiPixelTemplate::scaleyavg_

private

average y-error scale factor

Definition at line 722 of file SiPixelTemplate.h.

float SiPixelTemplate::sigmavav2_

private

"sigma" scale fctor for 2-cluster Vavilov distribution

Definition at line 777 of file SiPixelTemplate.h.

Referenced by sigmavav2(), and vavilov2_pars().

float SiPixelTemplate::sigmavav_

private

"sigma" scale fctor for Vavilov distribution

Definition at line 774 of file SiPixelTemplate.h.

Referenced by sigmavav(), and vavilov_pars().

float SiPixelTemplate::ss50_

private

1/2 of the pixel double col threshold signal in electrons

Definition at line 705 of file SiPixelTemplate.h.

Referenced by ss50().

bool SiPixelTemplate::success_

private

true if cotalpha, cotbeta are inside of the acceptance (dynamically loaded)

Definition at line 697 of file SiPixelTemplate.h.

float SiPixelTemplate::sxmax_

private

average pixel signal for x-projection of cluster

Definition at line 712 of file SiPixelTemplate.h.

Referenced by sxmax().

float SiPixelTemplate::sxone_

private

rms for one pixel x-clusters

Definition at line 715 of file SiPixelTemplate.h.

Referenced by sxone().

float SiPixelTemplate::sxparmax_

private

maximum pixel signal for parameterization of x uncertainties

Definition at line 713 of file SiPixelTemplate.h.

float SiPixelTemplate::sxtwo_

private

rms for one double-pixel x-clusters

Definition at line 717 of file SiPixelTemplate.h.

Referenced by sxtwo().

float SiPixelTemplate::symax_

private

average pixel signal for y-projection of cluster

Definition at line 706 of file SiPixelTemplate.h.

Referenced by symax().

float SiPixelTemplate::syone_

private

rms for one pixel y-clusters

Definition at line 709 of file SiPixelTemplate.h.

Referenced by syone().

float SiPixelTemplate::syparmax_

private

maximum pixel signal for parameterization of y uncertainties

Definition at line 707 of file SiPixelTemplate.h.

float SiPixelTemplate::sytwo_

private

rms for one double-pixel y-clusters

Definition at line 711 of file SiPixelTemplate.h.

Referenced by sytwo().

boost::multi_array<float, 2> SiPixelTemplate::temp2dx_

private

2d-primitive for spltting 3-d template

Definition at line 796 of file SiPixelTemplate.h.

boost::multi_array<float, 2> SiPixelTemplate::temp2dy_

private

2d-primitive for spltting 3-d template

Definition at line 795 of file SiPixelTemplate.h.

const std::vector<SiPixelTemplateStore>& SiPixelTemplate::thePixelTemp_

private

Definition at line 812 of file SiPixelTemplate.h.

Referenced by qbin_dist(), temperrors(), vavilov2_pars(), and vavilov_pars().

float SiPixelTemplate::xavg_[4]

private

average x-bias of reconstruction binned in 4 charge bins

Definition at line 748 of file SiPixelTemplate.h.

Referenced by xavg().

float SiPixelTemplate::xavgc2m_[4]

private

1st pass chi2 min search: average x-bias of reconstruction binned in 4 charge bins

Definition at line 764 of file SiPixelTemplate.h.

Referenced by xavgc2m().

float SiPixelTemplate::xflparhh_[4][6]

private

Aqfl-parameterized x-correction in 4 charge bins for larger cotbeta, cotalpha.

Definition at line 755 of file SiPixelTemplate.h.

float SiPixelTemplate::xflparhl_[4][6]

private

Aqfl-parameterized x-correction in 4 charge bins for larger cotbeta, smaller cotalpha.

Definition at line 754 of file SiPixelTemplate.h.

float SiPixelTemplate::xflparlh_[4][6]

private

Aqfl-parameterized x-correction in 4 charge bins for smaller cotbeta, larger cotalpha.

Definition at line 753 of file SiPixelTemplate.h.

float SiPixelTemplate::xflparll_[4][6]

private

Aqfl-parameterized x-correction in 4 charge bins for smaller cotbeta, cotalpha.

Definition at line 752 of file SiPixelTemplate.h.

float SiPixelTemplate::xgsig_[4]

private

sigma from Gaussian fit binned in 4 charge bins

Definition at line 751 of file SiPixelTemplate.h.

Referenced by xgsig().

float SiPixelTemplate::xgx0_[4]

private

average x0 from Gaussian fit binned in 4 charge bins

Definition at line 750 of file SiPixelTemplate.h.

Referenced by xgx0().

float SiPixelTemplate::xpar0_[2][5]

private

projected x-pixel uncertainty parameterization for central cotalpha

Definition at line 738 of file SiPixelTemplate.h.

float SiPixelTemplate::xparh_[2][5]

private

projected x-pixel uncertainty parameterization for larger cotalpha

Definition at line 740 of file SiPixelTemplate.h.

float SiPixelTemplate::xparhy0_[2][5]

private

projected x-pixel uncertainty parameterization for larger cotbeta (central alpha)

Definition at line 734 of file SiPixelTemplate.h.

float SiPixelTemplate::xparl_[2][5]

private

projected x-pixel uncertainty parameterization for smaller cotalpha

Definition at line 739 of file SiPixelTemplate.h.

float SiPixelTemplate::xparly0_[2][5]

private

projected x-pixel uncertainty parameterization for smaller cotbeta (central alpha)

Definition at line 733 of file SiPixelTemplate.h.

float SiPixelTemplate::xrms_[4]

private

average x-rms of reconstruction binned in 4 charge bins

Definition at line 749 of file SiPixelTemplate.h.

Referenced by xrms().

float SiPixelTemplate::xrmsc2m_[4]

private

1st pass chi2 min search: average x-rms of reconstruction binned in 4 charge bins

Definition at line 765 of file SiPixelTemplate.h.

Referenced by xrmsc2m().

float SiPixelTemplate::xsize_

private

Pixel x-size.

Definition at line 783 of file SiPixelTemplate.h.

Referenced by simpletemplate2D(), and xsize().

float SiPixelTemplate::xtemp_[9][13+4]

private

templates for x-reconstruction (binned over 5 central pixels)

Definition at line 741 of file SiPixelTemplate.h.

float SiPixelTemplate::xxratio_

private

fractional distance in x between cotalpha templates

Definition at line 737 of file SiPixelTemplate.h.

Referenced by xxratio().

float SiPixelTemplate::yavg_[4]

private

average y-bias of reconstruction binned in 4 charge bins

Definition at line 742 of file SiPixelTemplate.h.

Referenced by yavg().

float SiPixelTemplate::yavgc2m_[4]

private

1st pass chi2 min search: average y-bias of reconstruction binned in 4 charge bins

Definition at line 760 of file SiPixelTemplate.h.

Referenced by yavgc2m().

float SiPixelTemplate::yflparh_[4][6]

private

Aqfl-parameterized y-correction in 4 charge bins for larger cotbeta.

Definition at line 747 of file SiPixelTemplate.h.

float SiPixelTemplate::yflparl_[4][6]

private

Aqfl-parameterized y-correction in 4 charge bins for smaller cotbeta.

Definition at line 746 of file SiPixelTemplate.h.

float SiPixelTemplate::ygsig_[4]

private

average sigma_y from Gaussian fit binned in 4 charge bins

Definition at line 745 of file SiPixelTemplate.h.

Referenced by ygsig().

float SiPixelTemplate::ygx0_[4]

private

average y0 from Gaussian fit binned in 4 charge bins

Definition at line 744 of file SiPixelTemplate.h.

Referenced by ygx0().

float SiPixelTemplate::yparh_[2][5]

private

projected y-pixel uncertainty parameterization for larger cotbeta

Definition at line 732 of file SiPixelTemplate.h.

float SiPixelTemplate::yparl_[2][5]

private

projected y-pixel uncertainty parameterization for smaller cotbeta

Definition at line 731 of file SiPixelTemplate.h.

float SiPixelTemplate::yratio_

private

fractional distance in y between cotbeta templates

Definition at line 730 of file SiPixelTemplate.h.

Referenced by qbin_dist(), temperrors(), and yratio().

float SiPixelTemplate::yrms_[4]

private

average y-rms of reconstruction binned in 4 charge bins

Definition at line 743 of file SiPixelTemplate.h.

Referenced by yrms().

float SiPixelTemplate::yrmsc2m_[4]

private

1st pass chi2 min search: average y-rms of reconstruction binned in 4 charge bins

Definition at line 761 of file SiPixelTemplate.h.

Referenced by yrmsc2m().

float SiPixelTemplate::ysize_

private

Pixel y-size.

Definition at line 784 of file SiPixelTemplate.h.

Referenced by simpletemplate2D(), and ysize().

float SiPixelTemplate::ytemp_[9][21+4]

private

templates for y-reconstruction (binned over 5 central pixels)

Definition at line 735 of file SiPixelTemplate.h.

float SiPixelTemplate::yxratio_

private

fractional distance in y between x-slices of cotalpha templates

Definition at line 736 of file SiPixelTemplate.h.

Referenced by yxratio().

float SiPixelTemplate::zsize_

private

Pixel z-size (thickness)

Definition at line 785 of file SiPixelTemplate.h.

Referenced by simpletemplate2D(), and zsize().