Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 12:51:34

0001 //
0002 //  SiPixelTemplate.h (v10.24)
0003 //
0004 //  Add goodness-of-fit info and spare entries to templates, version number in template header, more error checking
0005 //  Add correction for (Q_F-Q_L)/(Q_F+Q_L) bias
0006 //  Add cot(beta) reflection to reduce y-entries and more sophisticated x-interpolation
0007 //  Fix small index searching bug in interpolate method
0008 //  Change interpolation indexing to avoid complier complaining about possible un-initialized variables
0009 //  Replace containers with static arrays in calls to ysigma2 and xsigma2
0010 //  Add external threshold to calls to ysigma2 and xsigma2, fix parameter signal max for xsigma2
0011 //  Return to 5 pixel spanning but adjust boundaries to use only when needed
0012 //  Implement improved (faster) chi2min search that depends on pixel types
0013 //  Fill template arrays in single calls to this object
0014 //  Add qmin to the template
0015 //  Add qscale to match charge scales
0016 //  Small improvement to x-chisquare interpolation
0017 //  Enlarge SiPixelTemplateStore to accommodate larger templates and increased alpha acceptance (reduce PT threshold to ~200 MeV)
0018 //  Store x and y cluster sizes in fractional pixels to facilitate cluster splitting
0019 //  Keep interpolated central 9 template bins in private storage and expand/shift in the getter functions (faster for speed=2/3) and easier to build 3d templates
0020 //  Store error and bias information for the simple chi^2 min position analysis (no interpolation or Q_{FB} corrections) to use in cluster splitting
0021 //  To save time, the gaussian centers and sigma are not interpolated right now (they aren't currently used).  They can be restored by un-commenting lines in the interpolate method.
0022 //  Add a new method to calculate qbin for input cotbeta and cluster charge.  To be used for error estimation of merged clusters in PixelCPEGeneric.
0023 //  Add bias info for Barrel and FPix separately in the header
0024 //  Improve the charge estimation for larger cot(alpha) tracks
0025 //  Change interpolate method to return false boolean if track angles are outside of range
0026 //  Add template info and method for truncation information
0027 //  Change to allow template sizes to be changed at compile time
0028 //  Fix bug in track angle checking
0029 //  Accommodate Dave's new DB pushfile which overloads the old method (file input)
0030 //  Add CPEGeneric error information and expand qbin method to access useful info for PixelCPEGeneric
0031 //  Fix large cot(alpha) bug in qmin interpolation
0032 //  Add second qmin to allow a qbin=5 state
0033 //  Use interpolated chi^2 info for one-pixel clusters
0034 //  Separate BPix and FPix charge scales and thresholds
0035 //  Fix DB pushfile version number checking bug.
0036 //  Remove assert from qbin method
0037 //  Replace asserts with exceptions in CMSSW
0038 //  Change calling sequence to interpolate method to handle cot(beta)<0 for FPix cosmics
0039 //  Add getter for pixelav Lorentz width estimates to qbin method
0040 //  Add check on template size to interpolate and qbin methods
0041 //  Add qbin population information, charge distribution information
0042 //
0043 //  V7.00 - Decouple BPix and FPix information into separate templates
0044 //  Add methods to facilitate improved cluster splitting
0045 //  Fix small charge scaling bug (affects FPix only)
0046 //  Change y-slice used for the x-template to be closer to the actual cotalpha-cotbeta point
0047 //  (there is some weak breakdown of x-y factorization in the FPix after irradiation)
0048 //
0049 //  V8.00 - Add method to calculate a simple 2D template
0050 //  Reorganize the interpolate method to extract header info only once per ID
0051 //  V8.01 - Improve simple template normalization
0052 //  V8.05 - Change qbin normalization to work better after irradiation
0053 //  V8.10 - Add Vavilov distribution interpolation
0054 //  V8.11 - Renormalize the x-templates for Guofan's cluster size calculation
0055 //  V8.12 - Technical fix to qavg issue.
0056 //  V8.13 - Fix qbin and fastsim interpolaters to avoid changing class variables
0057 //  V8.20 - Add methods to identify the central pixels in the x- and y-templates (to help align templates with clusters in radiation damaged detectors)
0058 //          Rename class variables from pxxxx (private xxxx) to xxxx_ to follow standard convention.
0059 //          Add compiler option to store the template entries in BOOST multiarrays of structs instead of simple c arrays
0060 //          (allows dynamic resizing template storage and has bounds checking but costs ~10% in execution time).
0061 //  V8.21 - Add new qbin method to use in cluster splitting
0062 //  V8.23 - Replace chi-min position errors with merged cluster chi2 probability info
0063 //  V8.25 - Incorporate VI's speed changes into the current version
0064 //  V8.26 - Modify the Vavilov lookups to work better with the FPix (offset y-templates)
0065 //  V8.30 - Change the splitting template generation and access to improve speed and eliminate triple index boost::multiarray
0066 //  V8.31 - Add correction factor: measured/true charge
0067 //  V8.31 - Fix version number bug in db object I/O (pushfile)
0068 //  V8.32 - Check for illegal qmin during loading
0069 //  V8.33 - Fix small type conversion warnings
0070 //  V8.40 - Incorporate V.I. optimizations
0071 //  V9.00 - Expand header to include multi and single dcol thresholds, LA biases, and (variable) Qbin definitions
0072 //  V9.01 - Protect against negative error squared
0073 //  V10.00 - Update to work with Phase 1 FPix.  Fix some code problems introduced by other maintainers.
0074 //  V10.01 - Fix initialization style as suggested by S. Krutelyov
0075 //  V10.10 - Add class variables and methods to correctly calculate the probabilities of single pixel clusters
0076 //  V10.11 - Allow subdetector ID=5 for FPix R2P2 [allows better internal labeling of templates]
0077 //  V10.12 - Enforce minimum signal size in pixel charge uncertainty calculation
0078 //  V10.13 - Update the variable size [SI_PIXEL_TEMPLATE_USE_BOOST] option so that it works with VI's enhancements
0079 //  V10.20 - Add directory path selection to the ascii pushfile method
0080 //  V10.21 - Address runtime issues in pushfile() for gcc 7.X due to using tempfile as char string + misc. cleanup [Petar]
0081 //  V10.22 - Move templateStore to the heap, fix variable name in pushfile() [Petar]
0082 //  V10.24 - Add sideload() + associated gymnastics [Petar and Oz]
0083 
0084 // Created by Morris Swartz on 10/27/06.
0085 //
0086 //
0087 
0088 // Build the template storage structure from several pieces
0089 
0090 #ifndef SiPixelTemplate_h
0091 #define SiPixelTemplate_h 1
0092 
0093 #include "SiPixelTemplateDefs.h"
0094 
0095 #include <vector>
0096 #include <cassert>
0097 #include "boost/multi_array.hpp"
0098 
0099 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0100 #include "CondFormats/SiPixelObjects/interface/SiPixelTemplateDBObject.h"
0101 #include "FWCore/Utilities/interface/Exception.h"
0102 #endif
0103 
0104 struct SiPixelTemplateEntry {  //!< Basic template entry corresponding to a single set of track angles
0105   int runnum;                  //!< number of pixelav run used to generate this entry
0106   float alpha;                 //!< alpha track angle (defined in CMS CMS IN 2004/014)
0107   float cotalpha;              //!< cot(alpha) is proportional to cluster length in x and is basis of interpolation
0108   float beta;                  //!< beta track angle (defined in CMS CMS IN 2004/014)
0109   float cotbeta;               //!< cot(beta) is proportional to cluster length in y and is basis of interpolation
0110   float costrk[3];             //!< direction cosines of tracks used to generate this entry
0111   float qavg;                  //!< average cluster charge for this set of track angles (now includes threshold effects)
0112   float pixmax;                //!< maximum charge for individual pixels in cluster
0113   float symax;                 //!< average pixel signal for y-projection of cluster
0114   float dyone;                 //!< mean offset/correction for one pixel y-clusters
0115   float syone;                 //!< rms for one pixel y-clusters
0116   float sxmax;                 //!< average pixel signal for x-projection of cluster
0117   float dxone;                 //!< mean offset/correction for one pixel x-clusters
0118   float sxone;                 //!< rms for one pixel x-clusters
0119   float dytwo;                 //!< mean offset/correction for one double-pixel y-clusters
0120   float sytwo;                 //!< rms for one double-pixel y-clusters
0121   float dxtwo;                 //!< mean offset/correction for one double-pixel x-clusters
0122   float sxtwo;                 //!< rms for one double-pixel x-clusters
0123   float qmin;                  //!< minimum cluster charge for valid hit (keeps 99.9% of simulated hits)
0124   float qmin2;                 //!< tighter minimum cluster charge for valid hit (keeps 99.8% of simulated hits)
0125   float yavggen[4];            //!< generic algorithm: average y-bias of reconstruction binned in 4 charge bins
0126   float yrmsgen[4];            //!< generic algorithm: average y-rms of reconstruction binned in 4 charge bins
0127   float xavggen[4];            //!< generic algorithm: average x-bias of reconstruction binned in 4 charge bins
0128   float xrmsgen[4];            //!< generic algorithm: average x-rms of reconstruction binned in 4 charge bins
0129 
0130   float clsleny;   //!< cluster y-length in pixels at signal height symax/2
0131   float clslenx;   //!< cluster x-length in pixels at signal height sxmax/2
0132   float mpvvav;    //!< most probable charge in Vavilov distribution (not actually for larger kappa)
0133   float sigmavav;  //!< "sigma" scale fctor for Vavilov distribution
0134   float kappavav;  //!< kappa parameter for Vavilov distribution
0135   float mpvvav2;  //!< most probable charge in Vavilov distribution for 2 merged clusters (not actually for larger kappa)
0136   float sigmavav2;         //!< "sigma" scale fctor for Vavilov distribution for 2 merged clusters
0137   float kappavav2;         //!< kappa parameter for Vavilov distribution for 2 merged clusters
0138   float ypar[2][5];        //!< projected y-pixel uncertainty parameterization
0139   float ytemp[9][TYSIZE];  //!< templates for y-reconstruction (binned over 1 central pixel)
0140   float xpar[2][5];        //!< projected x-pixel uncertainty parameterization
0141   float xtemp[9][TXSIZE];  //!< templates for x-reconstruction (binned over 1 central pixel)
0142   float yavg[4];           //!< average y-bias of reconstruction binned in 4 charge bins
0143   float yrms[4];           //!< average y-rms of reconstruction binned in 4 charge bins
0144   float ygx0[4];           //!< average y0 from Gaussian fit binned in 4 charge bins
0145   float ygsig[4];          //!< average sigma_y from Gaussian fit binned in 4 charge bins
0146   float yflpar[4][6];      //!< Aqfl-parameterized y-correction in 4 charge bins
0147   float xavg[4];           //!< average x-bias of reconstruction binned in 4 charge bins
0148   float xrms[4];           //!< average x-rms of reconstruction binned in 4 charge bins
0149   float xgx0[4];           //!< average x0 from Gaussian fit binned in 4 charge bins
0150   float xgsig[4];          //!< average sigma_x from Gaussian fit binned in 4 charge bins
0151   float xflpar[4][6];      //!< Aqfl-parameterized x-correction in 4 charge bins
0152   float chi2yavg[4];       //!< average y chi^2 in 4 charge bins
0153   float chi2ymin[4];       //!< minimum of y chi^2 in 4 charge bins
0154   float chi2xavg[4];       //!< average x chi^2 in 4 charge bins
0155   float chi2xmin[4];       //!< minimum of x chi^2 in 4 charge bins
0156   float chi2yavgone;       //!< average y chi^2 for 1 pixel clusters
0157   float chi2yminone;       //!< minimum of y chi^2 for 1 pixel clusters
0158   float chi2xavgone;       //!< average x chi^2 for 1 pixel clusters
0159   float chi2xminone;       //!< minimum of x chi^2 for 1 pixel clusters
0160   float yavgc2m[4];        //!< 1st pass chi2 min search: average y-bias of reconstruction binned in 4 charge bins
0161   float yrmsc2m[4];        //!< 1st pass chi2 min search: average y-rms of reconstruction binned in 4 charge bins
0162   float chi2yavgc2m[4];    //!< 1st pass chi2 min search: average y chi^2 in 4 charge bins (merged clusters)
0163   float chi2yminc2m[4];    //!< 1st pass chi2 min search: minimum of y chi^2 in 4 charge bins (merged clusters)
0164   float xavgc2m[4];        //!< 1st pass chi2 min search: average x-bias of reconstruction binned in 4 charge bins
0165   float xrmsc2m[4];        //!< 1st pass chi2 min search: average x-rms of reconstruction binned in 4 charge bins
0166   float chi2xavgc2m[4];    //!< 1st pass chi2 min search: average x chi^2 in 4 charge bins (merged clusters)
0167   float chi2xminc2m[4];    //!< 1st pass chi2 min search: minimum of x chi^2 in 4 charge bins (merged clusters)
0168   float ygx0gen[4];        //!< generic algorithm: average y0 from Gaussian fit binned in 4 charge bins
0169   float ygsiggen[4];       //!< generic algorithm: average sigma_y from Gaussian fit binned in 4 charge bins
0170   float xgx0gen[4];        //!< generic algorithm: average x0 from Gaussian fit binned in 4 charge bins
0171   float xgsiggen[4];       //!< generic algorithm: average sigma_x from Gaussian fit binned in 4 charge bins
0172   float qbfrac[3];         //!< fraction of sample in qbin = 0-2 (>=3 is the complement)
0173   float fracyone;          //!< fraction of sample with ysize = 1
0174   float fracxone;          //!< fraction of sample with xsize = 1
0175   float fracytwo;          //!< fraction of double pixel sample with ysize = 1
0176   float fracxtwo;          //!< fraction of double pixel sample with xsize = 1
0177   float qavg_avg;       //!< average cluster charge of clusters that are less than qavg (normalize 2-D simple templates)
0178   float r_qMeas_qTrue;  //!< ratio of measured to true cluster charge
0179   float spare[1];
0180 };
0181 
0182 struct SiPixelTemplateHeader {  //!< template header structure
0183   int ID;                       //!< template ID number
0184   int NTy;                      //!< number of Template y entries
0185   int NTyx;                     //!< number of Template y-slices of x entries
0186   int NTxx;                     //!< number of Template x-entries in each slice
0187   int Dtype;                    //!< detector type (0=BPix, 1=FPix)
0188   float qscale;                 //!< Charge scaling to match cmssw and pixelav
0189   float lorywidth;              //!< estimate of y-lorentz width for optimal resolution
0190   float lorxwidth;              //!< estimate of x-lorentz width for optimal resolution
0191   float lorybias;               //!< estimate of y-lorentz bias
0192   float lorxbias;               //!< estimate of x-lorentz bias
0193   float Vbias;                  //!< detector bias potential in Volts
0194   float temperature;            //!< detector temperature in deg K
0195   float fluence;                //!< radiation fluence in n_eq/cm^2
0196   float s50;                    //!< 1/2 of the multihit dcol threshold in electrons
0197   float ss50;                   //!< 1/2 of the single hit dcol threshold in electrons
0198   char title[80];               //!< template title
0199   int templ_version;            //!< Version number of the template to ensure code compatibility
0200   float Bfield;                 //!< Bfield in Tesla
0201   float fbin[3];                //!< The QBin definitions in Q_clus/Q_avg
0202   float xsize;                  //!< pixel size (for future use in upgraded geometry)
0203   float ysize;                  //!< pixel size (for future use in upgraded geometry)
0204   float zsize;                  //!< pixel size (for future use in upgraded geometry)
0205 };
0206 
0207 struct SiPixelTemplateStore {  //!< template storage structure
0208   SiPixelTemplateHeader head;
0209 #ifndef SI_PIXEL_TEMPLATE_USE_BOOST
0210   std::array<float, TEMP_ENTRY_SIZEY> cotbetaY;
0211   std::array<float, TEMP_ENTRY_SIZEX_B> cotbetaX;
0212   std::array<float, TEMP_ENTRY_SIZEX_A> cotalphaX;
0213   //!< 60 y templates spanning cluster lengths from 0px to +18px
0214   SiPixelTemplateEntry enty[TEMP_ENTRY_SIZEY];
0215   //!< 60 Barrel x templates spanning cluster lengths from -6px (-1.125Rad) to +6px (+1.125Rad) in each of 60 slices
0216   SiPixelTemplateEntry entx[TEMP_ENTRY_SIZEX_B][TEMP_ENTRY_SIZEX_A];
0217 #else
0218   std::vector<float> cotbetaY;
0219   std::vector<float> cotbetaX;
0220   std::vector<float> cotalphaX;
0221   boost::multi_array<SiPixelTemplateEntry, 1> enty;  //!< use 1d entry to store [60] entries
0222   //!< use 2d entry to store [60][60] entries
0223   boost::multi_array<SiPixelTemplateEntry, 2> entx;
0224 #endif
0225 };
0226 
0227 // ******************************************************************************************
0228 //! \class SiPixelTemplate
0229 //!
0230 //!  A template management class.  SiPixelTemplate contains thePixelTemp
0231 //!  (a std::vector  of SiPixelTemplateStore, each of which is a collection of many
0232 //!  SiPixelTemplateEntries).  Each SiPixelTemplateStore corresponds to a given detector
0233 //!  condition, and is valid for a range of runs.  We allow more than one Store since the
0234 //!  may change over time.
0235 //!
0236 //!  This class reads templates from files via pushfile() method.
0237 //!
0238 //!  The main functionality of SiPixelTemplate is interpolate(), which produces a template
0239 //!  on the fly, given a specific track's alpha and beta.  The results are kept in data
0240 //!  members and accessed via inline getters.
0241 //!
0242 //!  The resulting template is then used by PixelTempReco2D() (a global function) which
0243 //!  get the reference for SiPixelTemplate & templ and uses the current template to
0244 //!  reconstruct the SiPixelRecHit.
0245 // ******************************************************************************************
0246 class SiPixelTemplate {
0247 public:
0248   SiPixelTemplate(const std::vector<SiPixelTemplateStore>& thePixelTemp) : thePixelTemp_(thePixelTemp) {
0249     id_current_ = -1;
0250     index_id_ = -1;
0251     cota_current_ = 0.;
0252     cotb_current_ = 0.;
0253     entry_sideloaded_ = nullptr;
0254   }  //!< Constructor for cases in which template store already exists
0255 
0256 // Load the private store with info from the file with the index (int) filenum from directory dir:
0257 //   ${dir}template_summary_zp${filenum}.out
0258 #ifdef SI_PIXEL_TEMPLATE_STANDALONE
0259   static bool pushfile(int filenum, std::vector<SiPixelTemplateStore>& pixelTemp, std::string dir = "");
0260 
0261   // For calibrations only: load precalculated values -- no interpolation.
0262   void sideload(SiPixelTemplateEntry* entry,
0263                 int iDtype,
0264                 float locBx,
0265                 float locBz,
0266                 float lorwdy,
0267                 float lorwdx,
0268                 float q50,
0269                 float fbin[3],
0270                 float xsize,
0271                 float ysize,
0272                 float zsize);
0273 
0274 #else
0275   static bool pushfile(int filenum,
0276                        std::vector<SiPixelTemplateStore>& pixelTemp,
0277                        // *&^%$#@!  Different default dir -- remove once FastSim is updated.
0278                        std::string dir = "CalibTracker/SiPixelESProducers/data/");
0279 
0280   //load from DB (default in CMSSW)
0281   static bool pushfile(const SiPixelTemplateDBObject& dbobject,
0282                        std::vector<SiPixelTemplateStore>& pixelTemp);  // load the private store with info from db
0283 #endif
0284 
0285   // initialize the rest;
0286   static void postInit(std::vector<SiPixelTemplateStore>& thePixelTemp_);
0287 
0288   // Interpolate input alpha and beta angles to produce a working template for each individual hit.
0289   bool interpolate(int id, float cotalpha, float cotbeta, float locBz, float locBx);
0290 
0291   // Interpolate input alpha and beta angles to produce a working template for each individual hit.
0292   bool interpolate(int id, float cotalpha, float cotbeta, float locBz);
0293 
0294   // overload for compatibility.
0295   bool interpolate(int id, float cotalpha, float cotbeta);
0296 
0297   // retreive interpolated templates.
0298   void ytemp(int fybin, int lybin, float ytemplate[41][BYSIZE]);
0299 
0300   void xtemp(int fxbin, int lxbin, float xtemplate[41][BXSIZE]);
0301 
0302   //Method to estimate the central pixel of the interpolated y-template
0303   int cytemp();
0304 
0305   //Method to estimate the central pixel of the interpolated x-template
0306   int cxtemp();
0307 
0308   //Methods to build templates from two interpolated clusters (for splitting)
0309   void ytemp3d_int(int nypix, int& nybins);
0310 
0311   void ytemp3d(int j, int k, std::vector<float>& ytemplate);
0312 
0313   void xtemp3d_int(int nxpix, int& nxbins);
0314 
0315   void xtemp3d(int j, int k, std::vector<float>& xtemplate);
0316 
0317   // Convert vector of projected signals into uncertainties for fitting.
0318   void ysigma2(int fypix, int lypix, float sythr, float ysum[BYSIZE], float ysig2[BYSIZE]);
0319 
0320   void ysigma2(float qpixel, int index, float& ysig2);
0321 
0322   void xsigma2(int fxpix, int lxpix, float sxthr, float xsum[BXSIZE], float xsig2[BXSIZE]);
0323 
0324   // Interpolate qfl correction in y.
0325   float yflcorr(int binq, float qfly);
0326 
0327   // Interpolate qfl correction in x.
0328   float xflcorr(int binq, float qflx);
0329 
0330   int qbin(int id,
0331            float cotalpha,
0332            float cotbeta,
0333            float locBz,
0334            float locBx,
0335            float qclus,
0336            float& pixmx,
0337            float& sigmay,
0338            float& deltay,
0339            float& sigmax,
0340            float& deltax,
0341            float& sy1,
0342            float& dy1,
0343            float& sy2,
0344            float& dy2,
0345            float& sx1,
0346            float& dx1,
0347            float& sx2,
0348            float& dx2);
0349 
0350   int qbin(int id,
0351            float cotalpha,
0352            float cotbeta,
0353            float locBz,
0354            float qclus,
0355            float& pixmx,
0356            float& sigmay,
0357            float& deltay,
0358            float& sigmax,
0359            float& deltax,
0360            float& sy1,
0361            float& dy1,
0362            float& sy2,
0363            float& dy2,
0364            float& sx1,
0365            float& dx1,
0366            float& sx2,
0367            float& dx2);
0368 
0369   // Overload to use for cluster splitting
0370   int qbin(int id, float cotalpha, float cotbeta, float qclus);
0371 
0372   // Overload to keep legacy interface
0373   int qbin(int id, float cotbeta, float qclus);
0374 
0375   // Method to return template errors for fastsim
0376   void temperrors(int id,
0377                   float cotalpha,
0378                   float cotbeta,
0379                   int qBin,
0380                   float& sigmay,
0381                   float& sigmax,
0382                   float& sy1,
0383                   float& sy2,
0384                   float& sx1,
0385                   float& sx2);
0386 
0387   //Method to return qbin and size probabilities for fastsim
0388   void qbin_dist(int id,
0389                  float cotalpha,
0390                  float cotbeta,
0391                  float qbin_frac[4],
0392                  float& ny1_frac,
0393                  float& ny2_frac,
0394                  float& nx1_frac,
0395                  float& nx2_frac);
0396 
0397   //Method to calculate simple 2D templates
0398   bool simpletemplate2D(
0399       float xhitp, float yhitp, std::vector<bool>& ydouble, std::vector<bool>& xdouble, float template2d[BXM2][BYM2]);
0400 
0401   //Method to interpolate Vavilov distribution parameters
0402   void vavilov_pars(double& mpv, double& sigma, double& kappa);
0403 
0404   //Method to interpolate 2-cluster Vavilov distribution parameters
0405   void vavilov2_pars(double& mpv, double& sigma, double& kappa);
0406 
0407   float qavg() { return qavg_; }      //!< average cluster charge for this set of track angles
0408   float pixmax() { return pixmax_; }  //!< maximum pixel charge
0409   float qscale() { return qscale_; }  //!< charge scaling factor
0410   float s50() { return s50_; }        //!< 1/2 of the pixel threshold signal in electrons
0411   float ss50() { return ss50_; }      //!< 1/2 of the single pixel per double column threshold in electrons
0412   float symax() { return symax_; }    //!< average pixel signal for y-projection of cluster
0413   float dyone() { return dyone_; }    //!< mean offset/correction for one pixel y-clusters
0414   float syone() { return syone_; }    //!< rms for one pixel y-clusters
0415   float dytwo() { return dytwo_; }    //!< mean offset/correction for one double-pixel y-clusters
0416   float sytwo() { return sytwo_; }    //!< rms for one double-pixel y-clusters
0417   float sxmax() { return sxmax_; }    //!< average pixel signal for x-projection of cluster
0418   float dxone() { return dxone_; }    //!< mean offset/correction for one pixel x-clusters
0419   float sxone() { return sxone_; }    //!< rms for one pixel x-clusters
0420   float dxtwo() { return dxtwo_; }    //!< mean offset/correction for one double-pixel x-clusters
0421   float sxtwo() { return sxtwo_; }    //!< rms for one double-pixel x-clusters
0422   float qmin() { return qmin_; }      //!< minimum cluster charge for valid hit (keeps 99.9% of simulated hits)
0423   float qmin(int i) {
0424 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0425     if (i < 0 || i > 1) {
0426       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::qmin called with illegal index = " << i << std::endl;
0427     }
0428 #else
0429     assert(i >= 0 && i < 2);
0430 #endif
0431     if (i == 0) {
0432       return qmin_;
0433     } else {
0434       return qmin2_;
0435     }
0436   }  //!< minimum cluster charge for valid hit (keeps 99.9% or 99.8% of simulated hits)
0437   float clsleny() { return clsleny_; }  //!< y-size of smaller interpolated template in pixels
0438   float clslenx() { return clslenx_; }  //!< x-size of smaller interpolated template in pixels
0439   float yratio() { return yratio_; }    //!< fractional distance in y between cotbeta templates
0440   float yxratio() { return yxratio_; }  //!< fractional distance in y between cotalpha templates slices
0441   float xxratio() { return xxratio_; }  //!< fractional distance in x between cotalpha templates
0442   float yavg(int i) {
0443 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0444     if (i < 0 || i > 3) {
0445       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yavg called with illegal index = " << i << std::endl;
0446     }
0447 #else
0448     assert(i >= 0 && i < 4);
0449 #endif
0450     return yavg_[i];
0451   }  //!< average y-bias of reconstruction binned in 4 charge bins
0452   float yrms(int i) {
0453 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0454     if (i < 0 || i > 3) {
0455       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yrms called with illegal index = " << i << std::endl;
0456     }
0457 #else
0458     assert(i >= 0 && i < 4);
0459 #endif
0460     return yrms_[i];
0461   }  //!< average y-rms of reconstruction binned in 4 charge bins
0462   float ygx0(int i) {
0463 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0464     if (i < 0 || i > 3) {
0465       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::ygx0 called with illegal index = " << i << std::endl;
0466     }
0467 #else
0468     assert(i >= 0 && i < 4);
0469 #endif
0470     return ygx0_[i];
0471   }  //!< average y0 from Gaussian fit binned in 4 charge bins
0472   float ygsig(int i) {
0473 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0474     if (i < 0 || i > 3) {
0475       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::ygsig called with illegal index = " << i << std::endl;
0476     }
0477 #else
0478     assert(i >= 0 && i < 4);
0479 #endif
0480     return ygsig_[i];
0481   }  //!< average sigma_y from Gaussian fit binned in 4 charge bins
0482   float xavg(int i) {
0483 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0484     if (i < 0 || i > 3) {
0485       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xavg called with illegal index = " << i << std::endl;
0486     }
0487 #else
0488     assert(i >= 0 && i < 4);
0489 #endif
0490     return xavg_[i];
0491   }  //!< average x-bias of reconstruction binned in 4 charge bins
0492   float xrms(int i) {
0493 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0494     if (i < 0 || i > 3) {
0495       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xrms called with illegal index = " << i << std::endl;
0496     }
0497 #else
0498     assert(i >= 0 && i < 4);
0499 #endif
0500     return xrms_[i];
0501   }  //!< average x-rms of reconstruction binned in 4 charge bins
0502   float xgx0(int i) {
0503 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0504     if (i < 0 || i > 3) {
0505       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xgx0 called with illegal index = " << i << std::endl;
0506     }
0507 #else
0508     assert(i >= 0 && i < 4);
0509 #endif
0510     return xgx0_[i];
0511   }  //!< average x0 from Gaussian fit binned in 4 charge bins
0512   float xgsig(int i) {
0513 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0514     if (i < 0 || i > 3) {
0515       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xgsig called with illegal index = " << i << std::endl;
0516     }
0517 #else
0518     assert(i >= 0 && i < 4);
0519 #endif
0520     return xgsig_[i];
0521   }  //!< average sigma_x from Gaussian fit binned in 4 charge bins
0522   float chi2yavg(int i) {
0523 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0524     if (i < 0 || i > 3) {
0525       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2yavg called with illegal index = " << i << std::endl;
0526     }
0527 #else
0528     assert(i >= 0 && i < 4);
0529 #endif
0530     return chi2yavg_[i];
0531   }  //!< average y chi^2 in 4 charge bins
0532   float chi2ymin(int i) {
0533 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0534     if (i < 0 || i > 3) {
0535       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2ymin called with illegal index = " << i << std::endl;
0536     }
0537 #else
0538     assert(i >= 0 && i < 4);
0539 #endif
0540     return chi2ymin_[i];
0541   }  //!< minimum y chi^2 in 4 charge bins
0542   float chi2xavg(int i) {
0543 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0544     if (i < 0 || i > 3) {
0545       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2xavg called with illegal index = " << i << std::endl;
0546     }
0547 #else
0548     assert(i >= 0 && i < 4);
0549 #endif
0550     return chi2xavg_[i];
0551   }  //!< averaage x chi^2 in 4 charge bins
0552   float chi2xmin(int i) {
0553 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0554     if (i < 0 || i > 3) {
0555       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2xmin called with illegal index = " << i << std::endl;
0556     }
0557 #else
0558     assert(i >= 0 && i < 4);
0559 #endif
0560     return chi2xmin_[i];
0561   }  //!< minimum y chi^2 in 4 charge bins
0562   float yavgc2m(int i) {
0563 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0564     if (i < 0 || i > 3) {
0565       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yavgc2m called with illegal index = " << i << std::endl;
0566     }
0567 #else
0568     assert(i >= 0 && i < 4);
0569 #endif
0570     return yavgc2m_[i];
0571   }  //!< 1st pass chi2 min search: average y-bias of reconstruction binned in 4 charge bins
0572   float yrmsc2m(int i) {
0573 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0574     if (i < 0 || i > 3) {
0575       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yrmsc2m called with illegal index = " << i << std::endl;
0576     }
0577 #else
0578     assert(i >= 0 && i < 4);
0579 #endif
0580     return yrmsc2m_[i];
0581   }  //!< 1st pass chi2 min search: average y-rms of reconstruction binned in 4 charge bins
0582   float chi2yavgc2m(int i) {
0583 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0584     if (i < 0 || i > 3) {
0585       throw cms::Exception("DataCorrupt")
0586           << "SiPixelTemplate::chi2yavgc2m called with illegal index = " << i << std::endl;
0587     }
0588 #else
0589     assert(i >= 0 && i < 4);
0590 #endif
0591     return chi2yavgc2m_[i];
0592   }  //!< 1st pass chi2 min search: average y-chisq for merged clusters
0593   float chi2yminc2m(int i) {
0594 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0595     if (i < 0 || i > 3) {
0596       throw cms::Exception("DataCorrupt")
0597           << "SiPixelTemplate::chi2yminc2m called with illegal index = " << i << std::endl;
0598     }
0599 #else
0600     assert(i >= 0 && i < 4);
0601 #endif
0602     return chi2yminc2m_[i];
0603   }  //!< 1st pass chi2 min search: minimum y-chisq for merged clusters
0604   float xavgc2m(int i) {
0605 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0606     if (i < 0 || i > 3) {
0607       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xavgc2m called with illegal index = " << i << std::endl;
0608     }
0609 #else
0610     assert(i >= 0 && i < 4);
0611 #endif
0612     return xavgc2m_[i];
0613   }  //!< 1st pass chi2 min search: average x-bias of reconstruction binned in 4 charge bins
0614   float xrmsc2m(int i) {
0615 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0616     if (i < 0 || i > 3) {
0617       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xrmsc2m called with illegal index = " << i << std::endl;
0618     }
0619 #else
0620     assert(i >= 0 && i < 4);
0621 #endif
0622     return xrmsc2m_[i];
0623   }  //!< 1st pass chi2 min search: average x-rms of reconstruction binned in 4 charge bins
0624   float chi2xavgc2m(int i) {
0625 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0626     if (i < 0 || i > 3) {
0627       throw cms::Exception("DataCorrupt")
0628           << "SiPixelTemplate::chi2xavgc2m called with illegal index = " << i << std::endl;
0629     }
0630 #else
0631     assert(i >= 0 && i < 4);
0632 #endif
0633     return chi2xavgc2m_[i];
0634   }  //!< 1st pass chi2 min search: average x-chisq for merged clusters
0635   float chi2xminc2m(int i) {
0636 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0637     if (i < 0 || i > 3) {
0638       throw cms::Exception("DataCorrupt")
0639           << "SiPixelTemplate::chi2xminc2m called with illegal index = " << i << std::endl;
0640     }
0641 #else
0642     assert(i >= 0 && i < 4);
0643 #endif
0644     return chi2xminc2m_[i];
0645   }  //!< 1st pass chi2 min search: minimum x-chisq for merged clusters
0646   float fbin(int i) {
0647 #ifndef SI_PIXEL_TEMPLATE_STANDALONE
0648     if (i < 0 || i > 2) {
0649       throw cms::Exception("DataCorrupt") << "SiPixelTemplate::fbin called with illegal index = " << i << std::endl;
0650     }
0651 #else
0652     assert(i >= 0 && i < 3);
0653 #endif
0654     return fbin_[i];
0655   }  //!< Return lower bound of Qbin definition
0656 
0657   float chi2yavgone() { return chi2yavgone_; }  //!< //!< average y chi^2 for 1 pixel clusters
0658   float chi2yminone() { return chi2yminone_; }  //!< //!< minimum of y chi^2 for 1 pixel clusters
0659   float chi2xavgone() { return chi2xavgone_; }  //!< //!< average x chi^2 for 1 pixel clusters
0660   float chi2xminone() { return chi2xminone_; }  //!< //!< minimum of x chi^2 for 1 pixel clusters
0661   float lorywidth() { return lorywidth_; }      //!< signed lorentz y-width (microns)
0662   float lorxwidth() { return lorxwidth_; }      //!< signed lorentz x-width (microns)
0663   //float lorybias() {return lorywidth_;}                            //!< signed lorentz y-width (microns)
0664   //float lorxbias() {return lorxwidth_;}                            //!< signed lorentz x-width (microns)
0665   float lorybias() { return lorybias_; }  //!< signed lorentz y-width (microns)
0666   float lorxbias() { return lorxbias_; }  //!< signed lorentz x-width (microns)
0667   float mpvvav() { return mpvvav_; }  //!< most probable charge in Vavilov distribution (not actually for larger kappa)
0668   float sigmavav() { return sigmavav_; }  //!< "sigma" scale fctor for Vavilov distribution
0669   float kappavav() { return kappavav_; }  //!< kappa parameter for Vavilov distribution
0670   float mpvvav2() {
0671     return mpvvav2_;
0672   }  //!< most probable charge in 2-cluster Vavilov distribution (not actually for larger kappa)
0673   float sigmavav2() { return sigmavav2_; }          //!< "sigma" scale fctor for 2-cluster Vavilov distribution
0674   float kappavav2() { return kappavav2_; }          //!< kappa parameter for 2-cluster Vavilov distribution
0675   float xsize() { return xsize_; }                  //!< pixel x-size (microns)
0676   float ysize() { return ysize_; }                  //!< pixel y-size (microns)
0677   float zsize() { return zsize_; }                  //!< pixel z-size or thickness (microns)
0678   float r_qMeas_qTrue() { return r_qMeas_qTrue_; }  //!< ratio of measured to true cluster charge
0679   float fracyone() { return fracyone_; }            //!< The simulated fraction of single pixel y-clusters
0680   float fracxone() { return fracxone_; }            //!< The simulated fraction of single pixel x-clusters
0681   float fracytwo() { return fracytwo_; }            //!< The simulated fraction of single double-size pixel y-clusters
0682   float fracxtwo() { return fracxtwo_; }            //!< The simulated fraction of single double-size pixel x-clusters
0683   //  float yspare(int i) {assert(i>=0 && i<5); return pyspare[i];}    //!< vector of 5 spares interpolated in beta only
0684   //  float xspare(int i) {assert(i>=0 && i<10); return pxspare[i];}    //!< vector of 10 spares interpolated in alpha and beta
0685 
0686 private:
0687   // Keep current template interpolaion parameters
0688 
0689   int id_current_;      //!< current id
0690   int index_id_;        //!< current index
0691   float cota_current_;  //!< current cot alpha
0692   float cotb_current_;  //!< current cot beta
0693   float abs_cotb_;      //!< absolute value of cot beta
0694   int dtype_;           //!< flags BPix (=0) or FPix (=1)
0695   bool flip_y_;         //!< flip y sign-sensitive quantities
0696   bool flip_x_;         //!< flip x sign-sensitive quantities
0697   bool success_;        //!< true if cotalpha, cotbeta are inside of the acceptance (dynamically loaded)
0698 
0699   // Keep results of last interpolation to return through member functions
0700 
0701   float qavg_;        //!< average cluster charge for this set of track angles
0702   float pixmax_;      //!< maximum pixel charge
0703   float qscale_;      //!< charge scaling factor
0704   float s50_;         //!< 1/2 of the pixel single col threshold signal in electrons
0705   float ss50_;        //!< 1/2 of the pixel double col threshold signal in electrons
0706   float symax_;       //!< average pixel signal for y-projection of cluster
0707   float syparmax_;    //!< maximum pixel signal for parameterization of y uncertainties
0708   float dyone_;       //!< mean offset/correction for one pixel y-clusters
0709   float syone_;       //!< rms for one pixel y-clusters
0710   float dytwo_;       //!< mean offset/correction for one double-pixel y-clusters
0711   float sytwo_;       //!< rms for one double-pixel y-clusters
0712   float sxmax_;       //!< average pixel signal for x-projection of cluster
0713   float sxparmax_;    //!< maximum pixel signal for parameterization of x uncertainties
0714   float dxone_;       //!< mean offset/correction for one pixel x-clusters
0715   float sxone_;       //!< rms for one pixel x-clusters
0716   float dxtwo_;       //!< mean offset/correction for one double-pixel x-clusters
0717   float sxtwo_;       //!< rms for one double-pixel x-clusters
0718   float qmin_;        //!< minimum cluster charge for valid hit (keeps 99.9% of simulated hits)
0719   float clsleny_;     //!< y-cluster length of smaller interpolated template in pixels
0720   float clslenx_;     //!< x-cluster length of smaller interpolated template in pixels
0721   float scalexavg_;   //!< average x-error scale factor
0722   float scaleyavg_;   //!< average y-error scale factor
0723   float delyavg_;     //!< average difference between clsleny_ and cluster length [with threshold effects]
0724   float delysig_;     //!< rms of difference between clsleny_ and cluster length [with threshold effects]
0725   float scalex_[4];   //!< x-error scale factor in charge bins
0726   float scaley_[4];   //!< y-error scale factor in charge bins
0727   float offsetx_[4];  //!< x-offset in charge bins
0728   float offsety_[4];  //!< y-offset in charge bins
0729 
0730   float yratio_;            //!< fractional distance in y between cotbeta templates
0731   float yparl_[2][5];       //!< projected y-pixel uncertainty parameterization for smaller cotbeta
0732   float yparh_[2][5];       //!< projected y-pixel uncertainty parameterization for larger cotbeta
0733   float xparly0_[2][5];     //!< projected x-pixel uncertainty parameterization for smaller cotbeta (central alpha)
0734   float xparhy0_[2][5];     //!< projected x-pixel uncertainty parameterization for larger cotbeta (central alpha)
0735   float ytemp_[9][BYSIZE];  //!< templates for y-reconstruction (binned over 5 central pixels)
0736   float yxratio_;           //!< fractional distance in y between x-slices of cotalpha templates
0737   float xxratio_;           //!< fractional distance in x between cotalpha templates
0738   float xpar0_[2][5];       //!< projected x-pixel uncertainty parameterization for central cotalpha
0739   float xparl_[2][5];       //!< projected x-pixel uncertainty parameterization for smaller cotalpha
0740   float xparh_[2][5];       //!< projected x-pixel uncertainty parameterization for larger cotalpha
0741   float xtemp_[9][BXSIZE];  //!< templates for x-reconstruction (binned over 5 central pixels)
0742   float yavg_[4];           //!< average y-bias of reconstruction binned in 4 charge bins
0743   float yrms_[4];           //!< average y-rms of reconstruction binned in 4 charge bins
0744   float ygx0_[4];           //!< average y0 from Gaussian fit binned in 4 charge bins
0745   float ygsig_[4];          //!< average sigma_y from Gaussian fit binned in 4 charge bins
0746   float yflparl_[4][6];     //!< Aqfl-parameterized y-correction in 4 charge bins for smaller cotbeta
0747   float yflparh_[4][6];     //!< Aqfl-parameterized y-correction in 4 charge bins for larger cotbeta
0748   float xavg_[4];           //!< average x-bias of reconstruction binned in 4 charge bins
0749   float xrms_[4];           //!< average x-rms of reconstruction binned in 4 charge bins
0750   float xgx0_[4];           //!< average x0 from Gaussian fit binned in 4 charge bins
0751   float xgsig_[4];          //!< sigma from Gaussian fit binned in 4 charge bins
0752   float xflparll_[4][6];    //!< Aqfl-parameterized x-correction in 4 charge bins for smaller cotbeta, cotalpha
0753   float xflparlh_[4][6];    //!< Aqfl-parameterized x-correction in 4 charge bins for smaller cotbeta, larger cotalpha
0754   float xflparhl_[4][6];    //!< Aqfl-parameterized x-correction in 4 charge bins for larger cotbeta, smaller cotalpha
0755   float xflparhh_[4][6];    //!< Aqfl-parameterized x-correction in 4 charge bins for larger cotbeta, cotalpha
0756   float chi2yavg_[4];       //!< average y chi^2 in 4 charge bins
0757   float chi2ymin_[4];       //!< minimum of y chi^2 in 4 charge bins
0758   float chi2xavg_[4];       //!< average x chi^2 in 4 charge bins
0759   float chi2xmin_[4];       //!< minimum of x chi^2 in 4 charge bins
0760   float yavgc2m_[4];        //!< 1st pass chi2 min search: average y-bias of reconstruction binned in 4 charge bins
0761   float yrmsc2m_[4];        //!< 1st pass chi2 min search: average y-rms of reconstruction binned in 4 charge bins
0762   float chi2yavgc2m_[4];    //!< 1st pass chi2 min search: average y-chisq for merged clusters
0763   float chi2yminc2m_[4];    //!< 1st pass chi2 min search: minimum y-chisq for merged clusters
0764   float xavgc2m_[4];        //!< 1st pass chi2 min search: average x-bias of reconstruction binned in 4 charge bins
0765   float xrmsc2m_[4];        //!< 1st pass chi2 min search: average x-rms of reconstruction binned in 4 charge bins
0766   float chi2xavgc2m_[4];    //!< 1st pass chi2 min search: average x-chisq for merged clusters
0767   float chi2xminc2m_[4];    //!< 1st pass chi2 min search: minimum x-chisq for merged clusters
0768   float chi2yavgone_;       //!< average y chi^2 for 1 pixel clusters
0769   float chi2yminone_;       //!< minimum of y chi^2 for 1 pixel clusters
0770   float chi2xavgone_;       //!< average x chi^2 for 1 pixel clusters
0771   float chi2xminone_;       //!< minimum of x chi^2 for 1 pixel clusters
0772   float qmin2_;             //!< tighter minimum cluster charge for valid hit (keeps 99.8% of simulated hits)
0773   float mpvvav_;            //!< most probable charge in Vavilov distribution (not actually for larger kappa)
0774   float sigmavav_;          //!< "sigma" scale fctor for Vavilov distribution
0775   float kappavav_;          //!< kappa parameter for Vavilov distribution
0776   float mpvvav2_;           //!< most probable charge in 2-cluster Vavilov distribution (not actually for larger kappa)
0777   float sigmavav2_;         //!< "sigma" scale fctor for 2-cluster Vavilov distribution
0778   float kappavav2_;         //!< kappa parameter for 2-cluster Vavilov distribution
0779   float lorywidth_;         //!< Lorentz y-width (sign corrected for fpix frame)
0780   float lorxwidth_;         //!< Lorentz x-width
0781   float lorybias_;          //!< Lorentz y-bias
0782   float lorxbias_;          //!< Lorentz x-bias
0783   float xsize_;             //!< Pixel x-size
0784   float ysize_;             //!< Pixel y-size
0785   float zsize_;             //!< Pixel z-size (thickness)
0786   float qavg_avg_;          //!< average of cluster charge less than qavg
0787   float nybins_;            //!< number of bins in each dimension of the y-splitting template
0788   float nxbins_;            //!< number of bins in each dimension of the x-splitting template
0789   float r_qMeas_qTrue_;     //!< ratio of measured to true cluster charges
0790   float fbin_[3];           //!< The QBin definitions in Q_clus/Q_avg
0791   float fracyone_;          //!< The simulated fraction of single pixel y-clusters
0792   float fracxone_;          //!< The simulated fraction of single pixel x-clusters
0793   float fracytwo_;          //!< The simulated fraction of single double-size pixel y-clusters
0794   float fracxtwo_;          //!< The simulated fraction of single double-size pixel x-clusters
0795   boost::multi_array<float, 2> temp2dy_;  //!< 2d-primitive for spltting 3-d template
0796   boost::multi_array<float, 2> temp2dx_;  //!< 2d-primitive for spltting 3-d template
0797 
0798   // Pointers to presently interpolated point:
0799   const SiPixelTemplateEntry* enty0_;  // enty[ilow]
0800   const SiPixelTemplateEntry* enty1_;  // enty[iylow][ilow]
0801 
0802   const SiPixelTemplateEntry* entx00_;  // entx[iylow][ilow]
0803   const SiPixelTemplateEntry* entx02_;
0804   const SiPixelTemplateEntry* entx20_;
0805   const SiPixelTemplateEntry* entx22_;
0806   const SiPixelTemplateEntry* entx21_;
0807 
0808   // Pointer to the sideloaded Entry: use this one if set.
0809   const SiPixelTemplateEntry* entry_sideloaded_;
0810 
0811   // The actual template store is a std::vector container
0812   const std::vector<SiPixelTemplateStore>& thePixelTemp_;
0813 };
0814 
0815 #endif