SiPixelTemplate2D.h

Go to the documentation of this file.

//
//  SiPixelTemplate2D.h (v1.03)
//
//  Full 2-D templates for cluster splitting, simulated cluster reweighting, and improved cluster probability
//
// Created by Morris Swartz on 12/01/09.
// V1.01 - fix qavg_ filling
// V1.02 - Add locBz to test if FPix use is out of range
// V1.03 - Fix edge checking on final template to increase template size and to properly truncate cluster
//
//

// Build the template storage structure from several pieces

#ifndef SiPixelTemplate2D_h
#define SiPixelTemplate2D_h 1

#include "RecoLocalTracker/SiPixelRecHits/interface/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 SiPixelTemplateEntry2D { 
   int runnum;              
   float cotalpha;          
   float cotbeta;           
   float costrk[3];         
   float qavg;              
   float pixmax;            
   float sxymax;            
   int iymin;               
   int iymax;               
   int jxmin;               
   int jxmax;               
   float xypar[2][5];       
   float lanpar[2][5];      
   float xytemp[7][7][T2YSIZE][T2XSIZE];  
   float chi2avg[4];        
   float chi2min[4];        
   float chi2avgone;        
   float chi2minone;        
   float spare[20];
} ;




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



struct SiPixelTemplateStore2D { 
   SiPixelTemplateHeader2D head;
   boost::multi_array<SiPixelTemplateEntry2D,2> entry;     
} ;





// ******************************************************************************************
// ******************************************************************************************
class SiPixelTemplate2D {
public:
   SiPixelTemplate2D(const std::vector< SiPixelTemplateStore2D > & thePixelTemp) : thePixelTemp_(thePixelTemp) {id_current_ = -1; index_id_ = -1; cota_current_ = 0.; cotb_current_ = 0.;} 
   static bool pushfile(int filenum, std::vector< SiPixelTemplateStore2D > & 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< SiPixelTemplateStore2D > & thePixelTemp_);     // load the private store with info from db
#endif
   
   
   // Interpolate input alpha and beta angles to produce a working template for each individual hit.
   
   bool xytemp(int id, float cotalpha, float cotbeta, float locBz, float xhit, float yhit, std::vector<bool>& ydouble, std::vector<bool>& xdouble, float template2d[BXM2][BYM2]);
   
   // Overload to allow user to avoid the locBz information
   
   bool xytemp(int id, float cotalpha, float cotbeta, float xhit, float yhit, std::vector<bool>& ydouble, std::vector<bool>& xdouble, float template2d[BXM2][BYM2]);
   
   // Get pixel signal uncertainties
   
   void xysigma2(float qpixel, int index, float& xysig2);
   
   // Get the interpolated Landau distribution parameters
   
   void landau_par(float lanpar[2][5]);
   
   float qavg() {return qavg_;}        
   float pixmax() {return pixmax_;}    
   float qscale() {return qscale_;}    
   float s50() {return s50_;}          
   float sxymax() {return sxymax_;}    
   float xytemp(int j, int i) {        
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(j < 0 || j > BXM3 || i < 0 || i > BYM3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate2D::xytemp called with illegal indices = " << j << "," << i << std::endl;}
#else
      assert((j>=0 && j<BYM2) && (i>=0 && i<BYM2));
#endif
      return xytemp_[j][i];} 
   float chi2avg(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate2D::chi2yavg called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2avg_[i];} 
   float chi2min(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiPixelTemplate2D::chi2ymin called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<4);
#endif
      return chi2min_[i];} 
   float chi2avgone() {return chi2avgone_;}                        
   float chi2minone() {return chi2minone_;}                        
   float lorywidth() {return lorywidth_;}                            
   float lorxwidth() {return lorxwidth_;}                            
   float xsize() {return xsize_;}                                    
   float ysize() {return ysize_;}                                    
   float zsize() {return zsize_;}                                    
   int storesize() {return (int)thePixelTemp_.size();}                    
   
private:
   
   // Keep current template interpolaion parameters
   
   int id_current_;           
   int index_id_;             
   float cota_current_;       
   float cotb_current_;       
   int Nyx_;                  
   int Nxx_;                  
   int Dtype_;                
   float cotbeta0_;           
   float cotbeta1_;           
   float deltacotb_;          
   float cotalpha0_;          
   float cotalpha1_;          
   float deltacota_;          
   int iy0_;                  
   int iy1_;                  
   float adcotb_;             
   int jx0_;                  
   int jx1_;                  
   float adcota_;             
   bool success_;             
   
   
   // Keep results of last interpolation to return through member functions
   
   float qavg_;              
   float pixmax_;            
   float qscale_;            
   float s50_;               
   float sxymax_;            
   float xytemp_[BXM2][BYM2];
   float xypary0x0_[2][5];   
   float xypary1x0_[2][5];   
   float xypary0x1_[2][5];   
   float lanpar_[2][5];      
   float chi2avg_[4];       
   float chi2min_[4];       
   float chi2avgone_;       
   float chi2minone_;       
   float lorywidth_;         
   float lorxwidth_;         
   float xsize_;             
   float ysize_;             
   float zsize_;             
   
   // The actual template store is a std::vector container
   
   const std::vector< SiPixelTemplateStore2D > & thePixelTemp_;
} ;


#endif