big.h

Go to the documentation of this file.

#ifndef big_h
#define big_h 1
#include "CondFormats/Serialization/interface/Serializable.h"
 
#include <vector>
#include <string>
#include "CondFormats/Calibration/interface/TensorIndex.h"
class big {
public:
  big() : id_current(-1), index_id(-1), cota_current(0.), cotb_current(0.), fpix_current(false) {
    //constructor
    tVector_.reserve(1000);
    thVector_.reserve(1000);
    sVector_.reserve(1000);
  }
  void fill(size_t tVectorSize, size_t thVectorSize, size_t sVectorSize, const std::string& atitle);
 
  class bigEntry {
  public:
    //constructor
    bigEntry() {
      par.reserve(parIDX::SIZE);
      ytemp.reserve(ytempIDX::SIZE);
      xtemp.reserve(xtempIDX::SIZE);
      avg.reserve(avgIDX::SIZE);
      aqfl.reserve(aqflIDX::SIZE);
      chi2.reserve(chi2IDX::SIZE);
      spare.reserve(spareIDX::SIZE);
    }
    void fill(int runnum, float seed);
 
  public:
    int runnum;
    float alpha;
    float cotalpha;
    float beta;
    float cotbeta;
    float costrk[3];
    float qavg;
    float symax;
    float dyone;
    float syone;
    float sxmax;
    float dxone;
    float sxone;
    float dytwo;
    float sytwo;
    float dxtwo;
    float sxtwo;
    float qmin;
    //projected pixel uncertainty parameterization, first dimension x,y;
    typedef TensorIndex<2, 2, 5> parIDX;
    std::vector<float> par;
    //templates for y-reconstruction (binned over 1 central pixel)
    typedef TensorIndex<9, 21> ytempIDX;
    std::vector<float> ytemp;
    //templates for x-reconstruction (binned over 1 central pixel)
    typedef TensorIndex<9, 7> xtempIDX;
    std::vector<float> xtemp;
    //average parameters (binned in 4 charge bins ), first dimention x,y; second dimention bias,rms,g0,sigma;
    typedef TensorIndex<2, 4, 4> avgIDX;
    std::vector<float> avg;
    //Aqfl-parameterized x,y-correction (in 4 charge bins), first dimension x,y
    typedef TensorIndex<2, 4, 6> aqflIDX;
    std::vector<float> aqfl;
    //chi^2 (in 4 charge bins), first dimension x,y; second dimension average, minimum;
    typedef TensorIndex<2, 2, 4> chi2IDX;
    std::vector<float> chi2;
    //spare entries, first dimension x,y
    typedef TensorIndex<2, 10> spareIDX;
    std::vector<float> spare;
 
    COND_SERIALIZABLE;
  };  //inline class bigEntry
 
  //inline class bigHeader
  class bigHeader {
  public:
    bigHeader() : title("") {}
    void fill(const std::string& atitle);
    std::string title;  
    int ID;             
    int NBy;            
    int NByx;           
    int NBxx;           
    int NFy;            
    int NFyx;           
    int NFxx;           
    float vbias;        
    float temperature;  
    float fluence;      
    float qscale;       
    float s50;          
    int templ_version;  
 
    COND_SERIALIZABLE;
  };  //end inline class bigHeader
 
  //inline class bigStore
  class bigStore {
  public:
    //constructor
    bigStore() {
      entby.reserve(entbyIDX::SIZE);
      entbx.reserve(entbxIDX::SIZE);
      entfy.reserve(entfyIDX::SIZE);
      entfx.reserve(entfxIDX::SIZE);
    }
    //dummy filler
    void fill(const std::string& atitle);
    //data members
    bigHeader head;
    typedef TensorIndex<60> entbyIDX;
    std::vector<bigEntry> entby;
    typedef TensorIndex<5, 9> entbxIDX;
    std::vector<bigEntry> entbx;
    typedef TensorIndex<5> entfyIDX;
    std::vector<bigEntry> entfy;
    typedef TensorIndex<2, 9> entfxIDX;
    std::vector<bigEntry> entfx;
 
    COND_SERIALIZABLE;
  };  //end inline class bigStore
 
  typedef std::vector<bigEntry> entryVector;
  typedef std::vector<bigHeader> headVector;
  typedef std::vector<bigStore> storeVector;
 
private:
  entryVector tVector_;
  headVector thVector_;
  storeVector sVector_;
  int id_current;      
  int index_id;        
  float cota_current;  
  float cotb_current;  
  float abs_cotb;      
  bool fpix_current;   
 
  COND_SERIALIZABLE;
};  //end big
#endif