SiStripTemplate.h

Go to the documentation of this file.

//
//  SiStripTemplate.h (v2.10)  [v1.0 based on SiPixelTemplate v8.20]
//
//  V1.05 - add VI optimizations from pixel template object
//  V1.06 - increase angular acceptance (and structure size)
//  V2.00 - add barycenter interpolation and getters, fix calculation for charge deposition to accommodate cota-offsets in the central cotb entries.
//  V2.01 - fix problem with number of spare entries
//  V2.10 - modify methods for cluster splitting to improve speed
//
// Created by Morris Swartz on 10/11/10.
//
//
 
// Build the template storage structure from several pieces 

#ifndef SiStripTemplate_h
#define SiStripTemplate_h 1

#include "SiStripTemplateDefs.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 SiStripTemplateEntry { 
  int runnum;              
  float alpha;             
  float cotalpha;          
  float beta;              
  float cotbeta;           
  float costrk[3];            
  float qavg;              
  float sxmax;             
  float dxone;             
  float sxone;             
  float qmin;              
  float qmin2;             
  float clslenx;           
  float mpvvav;            
  float sigmavav;          
  float kappavav;          
  float mpvvav2;           
  float sigmavav2;         
  float kappavav2;         
  float xpar[2][5];        
  float xtemp[9][TSXSIZE];  
  float xavg[4];           
  float xrms[4];           
  float xgx0[4];           
  float xgsig[4];          
  float xflpar[4][6];      
  float chi2xavg[4];       
  float chi2xmin[4];       
  float chi2xavgone;       
  float chi2xminone;       
  float xavgc2m[4];        
  float xrmsc2m[4];        
  float xgx0c2m[4];        
  float xgsigc2m[4];       
  float chi2xavgc2m[4];    
  float chi2xminc2m[4];    
  float xavggen[4];        
  float xrmsgen[4];        
  float xgx0gen[4];        
  float xgsiggen[4];       
  float xavgbcn[4];        
  float xrmsbcn[4];        
  float xgx0bcn[4];        
  float xgsigbcn[4];       
  float qbfrac[3];         
  float fracxone;          
  float qavg_avg;          
  float qavg_spare;        
  float spare[7];
} ;




struct SiStripTemplateHeader {           
  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 SiStripTemplateStore { 
  SiStripTemplateHeader head;
#ifndef SI_STRIP_TEMPLATE_USE_BOOST 
  SiStripTemplateEntry enty[31];     
  SiStripTemplateEntry entx[5][73];  
#else
  boost::multi_array<SiStripTemplateEntry,1> enty;     
  boost::multi_array<SiStripTemplateEntry,2> entx;     
#endif
} ;


// ******************************************************************************************
// ******************************************************************************************
class SiStripTemplate {
 public:
  SiStripTemplate() {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 interpolate(int id, float cotalpha, float cotbeta, float locBy);
    
// overload for compatibility. 
  bool interpolate(int id, float cotalpha, float cotbeta);
  
// retreive interpolated templates. 
  void xtemp(int fxbin, int lxbin, float xtemplate[41][BSXSIZE]);
    
// interpolate a scaled cluster shape. 
  void sxtemp(float xhit, std::vector<float>& cluster);
    
//Method to estimate the central strip of the interpolated x-template
  int cxtemp();
    
// new methods to build templates from two interpolated clusters (for splitting) 
  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 xsigma2(int fxstrp, int lxstrp, float sxthr, float xsum[BSXSIZE], float xsig2[BSXSIZE]);
  
// Interpolate qfl correction in x. 
  float xflcorr(int binq, float qflx);
  
// Interpolate input beta angle to estimate the average charge. return qbin flag for input cluster charge. 
  int qbin(int id, float cotalpha, float cotbeta, float qclus);
    
//Method to interpolate Vavilov distribution parameters
  void vavilov_pars(double& mpv, double& sigma, double& kappa);
    
//Method to interpolate Vavilov distribution parameters for merged clusters
    void vavilov2_pars(double& mpv, double& sigma, double& kappa);
    
   
  float qavg() {return qavg_;}        
  float qscale() {return qscale_;}         
  float s50() {return s50_;}               
  float sxmax() {return sxmax_;}            
  float dxone() {return dxone_;}             
  float sxone() {return sxone_;}             
  float qmin() {return qmin_;}               
  float qmin(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 1) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::qmin called with illegal index = " << i << std::endl;}
#else
      assert(i>=0 && i<2); 
#endif
     if(i==0){return qmin_;}else{return qmin2_;}} 
  float clslenx() {return clslenx_;}         
  float yratio() {return yratio_;}            
  float yxratio() {return yxratio_;}           
  float xxratio() {return xxratio_;}           
  float xavg(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::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") << "SiStripTemplate::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") << "SiStripTemplate::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") << "SiStripTemplate::xgsig called with illegal index = " << i << std::endl;}
#else     
      assert(i>=0 && i<4); 
#endif
     return xgsig_[i];}       
  float chi2xavg(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::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") << "SiStripTemplate::chi2xmin called with illegal index = " << i << std::endl;}
#else     
      assert(i>=0 && i<4);
#endif
     return chi2xmin_[i];} 
  float xavgc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::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") << "SiStripTemplate::xrmsc2m called with illegal index = " << i << std::endl;}
#else     
      assert(i>=0 && i<4); 
#endif
     return xrmsc2m_[i];}   
  float xgx0c2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::xgx0cm2 called with illegal index = " << i << std::endl;}
#else     
      assert(i>=0 && i<4); 
#endif
     return xgx0c2m_[i];}   
  float xgsigc2m(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
      if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::xgsigc2m called with illegal index = " << i << std::endl;}
#else     
      assert(i>=0 && i<4); 
#endif
     return xgsigc2m_[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 xavgbcn(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
        if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::xavgbcn called with illegal index = " << i << std::endl;}
#else     
        assert(i>=0 && i<4); 
#endif
        return xavgbcn_[i];}   
    float xrmsbcn(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
        if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::xrmsbcn called with illegal index = " << i << std::endl;}
#else     
        assert(i>=0 && i<4); 
#endif
        return xrmsbcn_[i];}   
    float xgx0bcn(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
        if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::xgx0cm2 called with illegal index = " << i << std::endl;}
#else     
        assert(i>=0 && i<4); 
#endif
        return xgx0bcn_[i];}   
    float xgsigbcn(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
        if(i < 0 || i > 3) {throw cms::Exception("DataCorrupt") << "SiStripTemplate::xgsigbcn called with illegal index = " << i << std::endl;}
#else     
        assert(i>=0 && i<4); 
#endif
        return xgsigbcn_[i];} 
  float chi2xavgone() {return chi2xavgone_;}                        
  float chi2xminone() {return chi2xminone_;}                        
  float lorxwidth() {return lorxwidth_;}                            
  float mpvvav() {return mpvvav_;}                                  
  float sigmavav() {return sigmavav_;}                              
  float kappavav() {return kappavav_;}                              
  float xsize() {return xsize_;}                                    
  float ysize() {return ysize_;}                                    
  float zsize() {return zsize_;}                                    
//  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 sxmax_;             
    float sxparmax_;          
    float syparmax_;          
    float dxone_;             
    float sxone_;             
    float dxtwo_;             
    float sxtwo_;             
    float qmin_;              
    float clslenx_;           
    float xparly0_[2][5];     
    float xparhy0_[2][5];     
    float yratio_;            
    float yxratio_;           
    float xxratio_;           
    float xpar0_[2][5];       
    float xparl_[2][5];       
    float xparh_[2][5];       
    float xtemp_[9][BSXSIZE];  
    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 xavgc2m_[4];        
    float xrmsc2m_[4];        
    float xgx0c2m_[4];        
    float xgsigc2m_[4];       
    float chi2xavg_[4];       
    float chi2xmin_[4];       
    float chi2xavgc2m_[4];    
    float chi2xminc2m_[4];    
    float xavgbcn_[4];        
    float xrmsbcn_[4];        
    float xgx0bcn_[4];        
    float xgsigbcn_[4];       
    float chi2xavgone_;       
    float chi2xminone_;       
    float qmin2_;             
    float mpvvav_;            
    float sigmavav_;          
    float kappavav_;          
    float mpvvav2_;           
    float sigmavav2_;         
    float kappavav2_;         
    float lorxwidth_;         
    float xsize_;             
    float ysize_;             
    float zsize_;             
    float qavg_avg_;          
    float nxbins_;            
    boost::multi_array<float,2> temp2dx_; 
    
    
    // The actual template store is a std::vector container
    
    std::vector< SiStripTemplateStore > theStripTemp_;
} ;


#endif