SiPixelTemplate.h

Go to the documentation of this file.

//
//  SiPixelTemplate.h (v10.00)
//
//  Add goodness-of-fit info and spare entries to templates, version number in template header, more error checking
//  Add correction for (Q_F-Q_L)/(Q_F+Q_L) bias
//  Add cot(beta) reflection to reduce y-entries and more sophisticated x-interpolation
//  Fix small index searching bug in interpolate method
//  Change interpolation indexing to avoid complier complaining about possible un-initialized variables
//  Replace containers with static arrays in calls to ysigma2 and xsigma2
//  Add external threshold to calls to ysigma2 and xsigma2, fix parameter signal max for xsigma2
//  Return to 5 pixel spanning but adjust boundaries to use only when needed
//  Implement improved (faster) chi2min search that depends on pixel types
//  Fill template arrays in single calls to this object
//  Add qmin to the template
//  Add qscale to match charge scales
//  Small improvement to x-chisquare interpolation
//  Enlarge SiPixelTemplateStore to accommodate larger templates and increased alpha acceptance (reduce PT threshold to ~200 MeV)
//  Store x and y cluster sizes in fractional pixels to facilitate cluster splitting
//  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
//  Store error and bias information for the simple chi^2 min position analysis (no interpolation or Q_{FB} corrections) to use in cluster splitting
//  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.
//  Add a new method to calculate qbin for input cotbeta and cluster charge.  To be used for error estimation of merged clusters in PixelCPEGeneric.
//  Add bias info for Barrel and FPix separately in the header
//  Improve the charge estimation for larger cot(alpha) tracks
//  Change interpolate method to return false boolean if track angles are outside of range
//  Add template info and method for truncation information
//  Change to allow template sizes to be changed at compile time
//  Fix bug in track angle checking
//  Accommodate Dave's new DB pushfile which overloads the old method (file input)
//  Add CPEGeneric error information and expand qbin method to access useful info for PixelCPEGeneric
//  Fix large cot(alpha) bug in qmin interpolation
//  Add second qmin to allow a qbin=5 state
//  Use interpolated chi^2 info for one-pixel clusters
//  Separate BPix and FPix charge scales and thresholds
//  Fix DB pushfile version number checking bug.
//  Remove assert from qbin method
//  Replace asserts with exceptions in CMSSW
//  Change calling sequence to interpolate method to handle cot(beta)<0 for FPix cosmics
//  Add getter for pixelav Lorentz width estimates to qbin method
//  Add check on template size to interpolate and qbin methods
//  Add qbin population information, charge distribution information
//
//  V7.00 - Decouple BPix and FPix information into separate templates
//  Add methods to facilitate improved cluster splitting
//  Fix small charge scaling bug (affects FPix only)
//  Change y-slice used for the x-template to be closer to the actual cotalpha-cotbeta point
//  (there is some weak breakdown of x-y factorization in the FPix after irradiation)
//
//  V8.00 - Add method to calculate a simple 2D template
//  Reorganize the interpolate method to extract header info only once per ID
//  V8.01 - Improve simple template normalization
//  V8.05 - Change qbin normalization to work better after irradiation
//  V8.10 - Add Vavilov distribution interpolation
//  V8.11 - Renormalize the x-templates for Guofan's cluster size calculation
//  V8.12 - Technical fix to qavg issue.
//  V8.13 - Fix qbin and fastsim interpolaters to avoid changing class variables
//  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)
//          Rename class variables from pxxxx (private xxxx) to xxxx_ to follow standard convention.
//          Add compiler option to store the template entries in BOOST multiarrays of structs instead of simple c arrays
//          (allows dynamic resizing template storage and has bounds checking but costs ~10% in execution time).
//  V8.21 - Add new qbin method to use in cluster splitting
//  V8.23 - Replace chi-min position errors with merged cluster chi2 probability info
//  V8.25 - Incorporate VI's speed changes into the current version
//  V8.26 - Modify the Vavilov lookups to work better with the FPix (offset y-templates)
//  V8.30 - Change the splitting template generation and access to improve speed and eliminate triple index boost::multiarray
//  V8.31 - Add correction factor: measured/true charge
//  V8.31 - Fix version number bug in db object I/O (pushfile)
//  V8.32 - Check for illegal qmin during loading
//  V8.33 - Fix small type conversion warnings
//  V8.40 - Incorporate V.I. optimizations
//  V9.00 - Expand header to include multi and single dcol thresholds, LA biases, and (variable) Qbin definitions
//  V9.01 - Protect against negative error squared
//  V10.00 - Update to work with Phase 1 FPix.  Fix some code problems introduced by other maintainers.


// Created by Morris Swartz on 10/27/06.
//
//

// Build the template storage structure from several pieces

#ifndef SiPixelTemplate_h
#define SiPixelTemplate_h 1

#include "SiPixelTemplateDefs.h"

#include<vector>
#include<cassert>
#include "boost/multi_array.hpp"

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
#include "CondFormats/SiPixelObjects/interface/SiPixelTemplateDBObject.h"
#include "FWCore/Utilities/interface/Exception.h"
#endif

struct SiPixelTemplateEntry { 
   int runnum;              
   float alpha;             
   float cotalpha;          
   float beta;              
   float cotbeta;           
   float costrk[3];            
   float qavg;              
   float pixmax;            
   float symax;             
   float dyone;             
   float syone;             
   float sxmax;             
   float dxone;             
   float sxone;             
   float dytwo;             
   float sytwo;             
   float dxtwo;             
   float sxtwo;             
   float qmin;              
   float qmin2;             
   float yavggen[4];        
   float yrmsgen[4];        
   float xavggen[4];        
   float xrmsgen[4];        
   
   float clsleny;           
   float clslenx;           
   float mpvvav;            
   float sigmavav;          
   float kappavav;          
   float mpvvav2;           
   float sigmavav2;         
   float kappavav2;         
   float ypar[2][5];        
   float ytemp[9][TYSIZE];  
   float xpar[2][5];        
   float xtemp[9][TXSIZE];  
   float yavg[4];           
   float yrms[4];           
   float ygx0[4];           
   float ygsig[4];          
   float yflpar[4][6];      
   float xavg[4];           
   float xrms[4];           
   float xgx0[4];           
   float xgsig[4];          
   float xflpar[4][6];      
   float chi2yavg[4];       
   float chi2ymin[4];       
   float chi2xavg[4];       
   float chi2xmin[4];       
   float chi2yavgone;       
   float chi2yminone;       
   float chi2xavgone;       
   float chi2xminone;       
   float yavgc2m[4];        
   float yrmsc2m[4];        
   float chi2yavgc2m[4];    
   float chi2yminc2m[4];    
   float xavgc2m[4];        
   float xrmsc2m[4];        
   float chi2xavgc2m[4];    
   float chi2xminc2m[4];    
   float ygx0gen[4];        
   float ygsiggen[4];       
   float xgx0gen[4];        
   float xgsiggen[4];       
   float qbfrac[3];         
   float fracyone;          
   float fracxone;          
   float fracytwo;          
   float fracxtwo;          
   float qavg_avg;          
   float r_qMeas_qTrue;     
   float spare[1];
} ;




struct SiPixelTemplateHeader {           
   int ID;                 
   int NTy;                
   int NTyx;               
   int NTxx;               
   int Dtype;              
   float qscale;           
   float lorywidth;        
   float lorxwidth;        
   float lorybias;         
   float lorxbias;         
   float Vbias;            
   float temperature;      
   float fluence;          
   float s50;              
   float ss50;             
   char title[80];         
   int templ_version;      
   float Bfield;           
   float fbin[3];          
   float xsize;            
   float ysize;            
   float zsize;            
} ;



struct SiPixelTemplateStore { 
   SiPixelTemplateHeader head;
   float cotbetaY[60];
   float cotbetaX[5];
   float cotalphaX[29];
#ifndef SI_PIXEL_TEMPLATE_USE_BOOST
   SiPixelTemplateEntry enty[60];     
   SiPixelTemplateEntry entx[5][29];  
#else
   boost::multi_array<SiPixelTemplateEntry,1> enty;     
   boost::multi_array<SiPixelTemplateEntry,2> entx;     
#endif
} ;


// ******************************************************************************************
// ******************************************************************************************
class SiPixelTemplate {
public:
   SiPixelTemplate(const std::vector< SiPixelTemplateStore > & thePixelTemp) : thePixelTemp_(thePixelTemp) { id_current_ = -1; index_id_ = -1; cota_current_ = 0.; cotb_current_ = 0.; } 
   
   static bool pushfile(int filenum, std::vector< SiPixelTemplateStore > & thePixelTemp_);     // load the private store with info from the
   // file with the index (int) filenum
   
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
   static bool pushfile(const SiPixelTemplateDBObject& dbobject, std::vector< SiPixelTemplateStore > & thePixelTemp_);     // load the private store with info from db
#endif
   
   // initialize the rest;
   static void postInit(std::vector< SiPixelTemplateStore > & thePixelTemp_);
   
   // Interpolate input alpha and beta angles to produce a working template for each individual hit.
   bool 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.
   bool interpolate(int id, float cotalpha, float cotbeta, float locBz);
   
   // overload for compatibility.
   bool interpolate(int id, float cotalpha, float cotbeta);
   
   // retreive interpolated templates.
   void ytemp(int fybin, int lybin, float ytemplate[41][BYSIZE]);
   
   void xtemp(int fxbin, int lxbin, float xtemplate[41][BXSIZE]);
   
   //Method to estimate the central pixel of the interpolated y-template
   int cytemp();
   
   //Method to estimate the central pixel of the interpolated x-template
   int cxtemp();
   
   // new methods to build templates from two interpolated clusters (for splitting)
   void ytemp3d_int(int nypix, int& nybins);
   
   void ytemp3d(int j, int k, std::vector<float>& ytemplate);
   
   void xtemp3d_int(int nxpix, int& nxbins);
   
   void xtemp3d(int j, int k, std::vector<float>& xtemplate);
   
   // Convert vector of projected signals into uncertainties for fitting.
   void ysigma2(int fypix, int lypix, float sythr, float ysum[BYSIZE], float ysig2[BYSIZE]);
   
   void ysigma2(float qpixel, int index, float& ysig2);
   
   void xsigma2(int fxpix, int lxpix, float sxthr, float xsum[BXSIZE], float xsig2[BXSIZE]);
   
   // Interpolate qfl correction in y.
   float yflcorr(int binq, float qfly);
   
   // Interpolate qfl correction in x.
   float xflcorr(int binq, float qflx);
   
   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);
   
   // Overload to use for cluster splitting
   int qbin(int id, float cotalpha, float cotbeta, float qclus);
   
   // Overload to keep legacy interface
   int qbin(int id, float cotbeta, float qclus);
   
   // Method to return template errors for fastsim
   void temperrors(int id, float cotalpha, float cotbeta, int qBin, float& sigmay, float& sigmax, float& sy1, float& sy2, float& sx1, float& sx2);
   
   //Method to return qbin and size probabilities for fastsim
   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);
   
   //Method to calculate simple 2D templates
   bool simpletemplate2D(float xhitp, float yhitp, std::vector<bool>& ydouble, std::vector<bool>& xdouble, float template2d[BXM2][BYM2]);
   
   //Method to interpolate Vavilov distribution parameters
   void vavilov_pars(double& mpv, double& sigma, double& kappa);
   
   //Method to interpolate 2-cluster Vavilov distribution parameters
   void vavilov2_pars(double& mpv, double& sigma, double& kappa);
   
   
   float qavg() {return qavg_;}        
   float pixmax() {return pixmax_;}         
   float qscale() {return qscale_;}         
   float s50() {return s50_;}               
   float ss50() {return ss50_;}               
   float symax() {return symax_;}             
   float dyone() {return dyone_;}             
   float syone() {return syone_;}             
   float dytwo() {return dytwo_;}             
   float sytwo() {return sytwo_;}            
   float sxmax() {return sxmax_;}            
   float dxone() {return dxone_;}             
   float sxone() {return sxone_;}             
   float dxtwo() {return dxtwo_;}             
   float sxtwo() {return sxtwo_;}             
   float qmin() {return qmin_;}               
   float qmin(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 1) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::qmin called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<2);
#endif
      if(i==0){return qmin_;}else{return qmin2_;}} 
   float clsleny() {return clsleny_;}         
   float clslenx() {return clslenx_;}         
   float yratio() {return yratio_;}            
   float yxratio() {return yxratio_;}           
   float xxratio() {return xxratio_;}           
   float yavg(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yavg called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return yavg_[i];}         
   float yrms(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yrms called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return yrms_[i];}         
   float ygx0(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::ygx0 called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return ygx0_[i];}         
   float ygsig(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::ygsig called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return ygsig_[i];}       
   float xavg(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xavg called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return xavg_[i];}         
   float xrms(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xrms called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return xrms_[i];}         
   float xgx0(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xgx0 called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return xgx0_[i];}         
   float xgsig(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xgsig called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return xgsig_[i];}       
   float chi2yavg(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2yavg called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2yavg_[i];} 
   float chi2ymin(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2ymin called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2ymin_[i];} 
   float chi2xavg(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2xavg called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2xavg_[i];} 
   float chi2xmin(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2xmin called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2xmin_[i];} 
   float yavgc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yavgc2m called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return yavgc2m_[i];}   
   float yrmsc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::yrmsc2m called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return yrmsc2m_[i];}   
   float chi2yavgc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2yavgc2m called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2yavgc2m_[i];}   
   float chi2yminc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2yminc2m called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2yminc2m_[i];} 
   float xavgc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xavgc2m called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return xavgc2m_[i];}   
   float xrmsc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::xrmsc2m called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return xrmsc2m_[i];}   
   float chi2xavgc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2xavgc2m called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2xavgc2m_[i];}   
   float chi2xminc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::chi2xminc2m called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2xminc2m_[i];} 
   float fbin(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 2) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate::fbin called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<3);
#endif
      return fbin_[i];} 
   
   float chi2yavgone() {return chi2yavgone_;}                        
   float chi2yminone() {return chi2yminone_;}                        
   float chi2xavgone() {return chi2xavgone_;}                        
   float chi2xminone() {return chi2xminone_;}                        
   float lorywidth() {return lorywidth_;}                            
   float lorxwidth() {return lorxwidth_;}                            
   //float lorybias() {return lorywidth_;}                            //!< signed lorentz y-width (microns)
   //float lorxbias() {return lorxwidth_;}                            //!< signed lorentz x-width (microns)
   float lorybias() {return lorybias_;}                            
   float lorxbias() {return lorxbias_;}                            
   float mpvvav() {return mpvvav_;}                                  
   float sigmavav() {return sigmavav_;}                              
   float kappavav() {return kappavav_;}                              
   float mpvvav2() {return mpvvav2_;}                                
   float sigmavav2() {return sigmavav2_;}                            
   float kappavav2() {return kappavav2_;}                            
   float xsize() {return xsize_;}                                    
   float ysize() {return ysize_;}                                    
   float zsize() {return zsize_;}                                    
   float r_qMeas_qTrue() {return r_qMeas_qTrue_;}                    
   //  float yspare(int i) {assert(i>=0 && i<5); return pyspare[i];}    //!< vector of 5 spares interpolated in beta only
   //  float xspare(int i) {assert(i>=0 && i<10); return pxspare[i];}    //!< vector of 10 spares interpolated in alpha and beta
   
   
private:
   
   // Keep current template interpolaion parameters
   
   int id_current_;           
   int index_id_;             
   float cota_current_;       
   float cotb_current_;       
   float abs_cotb_;           
   bool success_;             
   
   
   // Keep results of last interpolation to return through member functions
   
   float qavg_;              
   float pixmax_;            
   float qscale_;            
   float s50_;               
   float ss50_;              
   float symax_;             
   float syparmax_;          
   float dyone_;             
   float syone_;             
   float dytwo_;             
   float sytwo_;             
   float sxmax_;             
   float sxparmax_;          
   float dxone_;             
   float sxone_;             
   float dxtwo_;             
   float sxtwo_;             
   float qmin_;              
   float clsleny_;           
   float clslenx_;           
   float yratio_;            
   float yparl_[2][5];       
   float yparh_[2][5];       
   float xparly0_[2][5];     
   float xparhy0_[2][5];     
   float ytemp_[9][BYSIZE];  
   float yxratio_;           
   float xxratio_;           
   float xpar0_[2][5];       
   float xparl_[2][5];       
   float xparh_[2][5];       
   float xtemp_[9][BXSIZE];  
   float yavg_[4];           
   float yrms_[4];           
   float ygx0_[4];           
   float ygsig_[4];          
   float yflparl_[4][6];     
   float yflparh_[4][6];     
   float xavg_[4];           
   float xrms_[4];           
   float xgx0_[4];           
   float xgsig_[4];           
   float xflparll_[4][6];    
   float xflparlh_[4][6];    
   float xflparhl_[4][6];    
   float xflparhh_[4][6];    
   float chi2yavg_[4];       
   float chi2ymin_[4];       
   float chi2xavg_[4];       
   float chi2xmin_[4];       
   float yavgc2m_[4];        
   float yrmsc2m_[4];        
   float chi2yavgc2m_[4];    
   float chi2yminc2m_[4];    
   float xavgc2m_[4];        
   float xrmsc2m_[4];        
   float chi2xavgc2m_[4];    
   float chi2xminc2m_[4];    
   float chi2yavgone_;       
   float chi2yminone_;       
   float chi2xavgone_;       
   float chi2xminone_;       
   float qmin2_;             
   float mpvvav_;            
   float sigmavav_;          
   float kappavav_;          
   float mpvvav2_;           
   float sigmavav2_;         
   float kappavav2_;         
   float lorywidth_;         
   float lorxwidth_;         
   float lorybias_;          
   float lorxbias_;          
   float xsize_;             
   float ysize_;             
   float zsize_;             
   float qavg_avg_;          
   float nybins_;            
   float nxbins_;            
   float r_qMeas_qTrue_;     
   float fbin_[3];           
   boost::multi_array<float,2> temp2dy_; 
   boost::multi_array<float,2> temp2dx_; 
   
   
   // The actual template store is a std::vector container
   
   const std::vector< SiPixelTemplateStore > & thePixelTemp_;
} ;


#endif