/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_13_patch3/src/RecoLocalTracker/SiPixelRecHits/interface/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.
// Copyright 2009 __TheJohnsHopkinsUniversity__. All rights reserved.
// 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() {id_current_ = -1; index_id_ = -1; cota_current_ = 0.; cotb_current_ = 0.;} 
  bool pushfile(int filenum);     // load the private store with info from the 
                                  // file with the index (int) filenum
                                                                  
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  bool pushfile(const SiPixelTemplateDBObject& dbobject);     // 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

  std::vector< SiPixelTemplateStore2D > thePixelTemp_;
} ;


#endif