SiPixelGenError.h

Go to the documentation of this file.

//
//  SiPixelGenError.h (v2.20)
//
//  Object to contain Lorentz drift and error information for the Generic Algorithm
//
// Created by Morris Swartz on 1/10/2014.
//
// Update for Phase 1 FPix, M.S. 1/15/17
//  V2.01 - Allow subdetector ID=5 for FPix R2P2, Fix error message
//  V2.10 - Update the variable size [SI_PIXEL_TEMPLATE_USE_BOOST] option so that it works with VI's enhancements
//  V2.20 - Add directory path selection to the ascii pushfile method
//  V2.21 - Move templateStore to the heap, fix variable name in pushfile()
//  V2.30 - Fix interpolation of IrradiationBias corrections

// Build the template storage structure from several pieces

#ifndef SiPixelGenError_h
#define SiPixelGenError_h 1

#include "SiPixelTemplateDefs.h"

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

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

struct SiPixelGenErrorEntry {  
  int runnum;                  
  float cotalpha;              
  float cotbeta;               
  float qavg;                  
  float pixmax;                
  float dyone;                 
  float syone;                 
  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];  
};

struct SiPixelGenErrorHeader {  
  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 SiPixelGenErrorStore {  
  SiPixelGenErrorHeader head;
#ifndef SI_PIXEL_TEMPLATE_USE_BOOST
  float cotbetaY[TEMP_ENTRY_SIZEY];
  float cotbetaX[TEMP_ENTRY_SIZEX_B];
  float cotalphaX[TEMP_ENTRY_SIZEX_A];
  SiPixelGenErrorEntry enty[TEMP_ENTRY_SIZEY];
  SiPixelGenErrorEntry entx[TEMP_ENTRY_SIZEX_B][TEMP_ENTRY_SIZEX_A];
#else
  float* cotbetaY;
  float* cotbetaX;
  float* cotalphaX;
  boost::multi_array<SiPixelGenErrorEntry, 1> enty;  
  boost::multi_array<SiPixelGenErrorEntry, 2> entx;
#endif
};

// ******************************************************************************************
// ******************************************************************************************
class SiPixelGenError {
public:
  SiPixelGenError(const std::vector<SiPixelGenErrorStore>& thePixelTemp)
      : id_current_(-1),
        index_id_(-1),
        lorxwidth_(0),
        lorywidth_(0),
        lorxbias_(0),
        lorybias_(0),
        fbin_{0, 0, 0},
        xsize_(0),
        ysize_(0),
        zsize_(0),
        thePixelTemp_(thePixelTemp) {}  

  // Load the private store with info from the file with the index (int) filenum from directory dir:
  //   ${dir}generror_summary_zp${filenum}.out
  static bool pushfile(int filenum, std::vector<SiPixelGenErrorStore>& pixelTemp, std::string dir = "");

#ifndef SI_PIXEL_TEMPLATE_STANDALONE
  // load the private store with info from db
  static bool pushfile(const SiPixelGenErrorDBObject& dbobject, std::vector<SiPixelGenErrorStore>& pixelTemp);
#endif

  // initialize the binary search information;
  static void postInit(std::vector<SiPixelGenErrorStore>& thePixelTemp_);

  // Interpolate input beta angle to estimate the average charge. return qbin flag for input cluster charge, and estimate y/x errors and biases for the Generic Algorithm.
  int qbin(int id,
           float cotalpha,
           float cotbeta,
           float locBz,
           float locBx,
           float qclus,
           bool irradiationCorrections,
           int& 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 provide backward compatibility

  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);
  // Overloaded method to provide only the LA parameters
  int qbin(int id);

  float lorywidth() { return lorywidth_; }  
  float lorxwidth() { return lorxwidth_; }  
  float lorybias() { return lorybias_; }    
  float lorxbias() { return lorxbias_; }    

  float fbin(int i) {
#ifndef SI_PIXEL_TEMPLATE_STANDALONE
    if (i < 0 || i > 2) {
      throw cms::Exception("DataCorrupt")
          << "SiPixelTemplate::chi2xminc2m called with illegal index = " << i << std::endl;
    }
#else
    assert(i >= 0 && i < 3);
#endif
    return fbin_[i];
  }                                 
  float xsize() { return xsize_; }  
  float ysize() { return ysize_; }  
  float zsize() { return zsize_; }  

private:
  // Keep current template interpolaion parameters

  int id_current_;  
  int index_id_;    

  // Keep results of last interpolation to return through member functions

  float lorxwidth_;  
  float lorywidth_;  
  float lorxbias_;   
  float lorybias_;   
  float fbin_[3];    
  float xsize_;      
  float ysize_;      
  float zsize_;      

  // The actual template store is a std::vector container

  const std::vector<SiPixelGenErrorStore>& thePixelTemp_;
};

#endif