d8/dc3/SiPixelGenError_8h_source.html

//

//  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