Mdc/MdcTables/include/MdcTables/MdcTables.h

Go to the documentation of this file.

/* modified the Class MdcRec_wirhit for KalFit & Calib use
 *
 **********************************************************/
 
#ifndef _MdcTables_h_
#define _MdcTables_h_
 
#include <iostream>
#include <string>
#include <vector>
 
#include "MdcRecEvent/RecMdcHit.h"
#include "MdcTables/HepevtTables.h"
 
using namespace std;
 
//
//*** raw data info. of MDC wire hits ***
//
class MdcRaw_wirhit {
public:
  MdcRaw_wirhit() {};
 
public:
  int               id;
  int               crt;
  int               slt;
  int               chn;
  int               pre;
  int               sqt;
  int               edges;
  int               tdc1;
  int               tdc2;
  int               tdc3;
  int               tdc4;
  int               tdc5;
  int               tdc6;
  int               tdc7;
  int               tdc8;
  int               tdc9;
  int               tdc10;
  int               tdc11;
  int               tdc12;
  int               tdc13;
  int               tdc14;
  int               tdc15;
  int               tdc16;
  int               stat;
  int               layer;
  int               local;
  const MdcGeoWire* geo;
};
 
class MdcRawWirhitCol {
public:
  static vector<MdcRaw_wirhit>* getMdcRawWirhitCol( void );
 
private:
  static vector<MdcRaw_wirhit>* s_col;
};
 
//
//*** digitized info. of MDC wire hits ***
//
class MdcRec_wirhit;
class MdcDat_wirhit {
public:
  MdcDat_wirhit() {};
 
public:
  int               id;
  float             adc;
  float             tdc;
  int               stat;
  const MdcGeoWire* geo;
  MdcRec_wirhit*    rec;
};
 
class MdcDatWirhitCol {
public:
  static vector<MdcDat_wirhit>* getMdcDatWirhitCol( void );
 
private:
  static vector<MdcDat_wirhit>* s_col;
};
 
//
//*** digitized info. of MDC wire hits ***
//
class MdcDat_olhit {
public:
  MdcDat_olhit() {};
 
public:
  int               id;
  float             adc;
  float             tdc;
  int               stat;
  const MdcGeoWire* geo;
};
 
class MdcDatOlhitCol {
public:
  static vector<MdcDat_olhit>* getMdcDatOlhitCol( void );
 
private:
  static vector<MdcDat_olhit>* s_col;
};
 
//
//*** const. param. to calculate drift distance ***
//
class MdcCal_tzero {
public:
  MdcCal_tzero() {};
 
public:
  int   id;
  float tzero;
};
 
class MdcCalTzeroCol {
public:
  static vector<MdcCal_tzero>* getMdcCalTzeroCol( void );
 
private:
  static vector<MdcCal_tzero>* s_col;
};
 
//
//*** run by run t0 ***
//
class MdcCal_tzero2 {
public:
  MdcCal_tzero2() {};
 
public:
  int   id;
  float t0;
};
 
class MdcCalTzero2Col {
public:
  static vector<MdcCal_tzero2>* getMdcCalTzero2Col( void );
 
private:
  static vector<MdcCal_tzero2>* s_col;
};
 
//
//*** Defifinition of bad wires  ***
//
class MdcCal_badwire {
public:
  MdcCal_badwire() {};
 
public:
  int id;
  int bad[3];
};
 
class MdcCalBadwireCol {
public:
  static vector<MdcCal_badwire>* getMdcCalBadwireCol( void );
 
private:
  static vector<MdcCal_badwire>* s_col;
};
 
//
//**** nition of tables for const. param. to calculate drift distance ***
//
class MdcCal_const {
public:
  MdcCal_const() {};
 
public:
  int   id;
  float xtl[8][18];
  float xtr[8][18];
  float bndl[4][18];
  float bndr[4][18];
};
 
class MdcCalConstCol {
public:
  static vector<MdcCal_const>* getMdcCalConstCol( void );
 
private:
  static vector<MdcCal_const>* s_col;
};
 
//
//*** const. param. for error of drift distance ***
//
class MdcCal_const2 {
public:
  MdcCal_const2() {};
 
public:
  int   id;
  float sgm[5];
};
 
class MdcCalConst2Col {
public:
  static vector<MdcCal_const2>* getMdcCalConst2Col( void );
 
private:
  static vector<MdcCal_const2>* s_col;
};
 
//
//*** const. param. for time walk ***
//
class MdcCal_const3 {
public:
  MdcCal_const3() {};
 
public:
  int   id;
  float tw[2];
};
 
class MdcCalConst3Col {
public:
  static vector<MdcCal_const3>* getMdcCalConst3Col( void );
 
private:
  static vector<MdcCal_const3>* s_col;
};
 
//
//*** fudge factor and tanL dep. ***
//
class MdcCal_const4 {
public:
  MdcCal_const4() {};
 
public:
  int   id;
  float fudge;
  int   npoint;
  float tanl[20];
  float ftanl[20];
  float a[20];
  float b[20];
};
 
class MdcCalConst4Col {
public:
  static vector<MdcCal_const4>* getMdcCalConst4Col( void );
 
private:
  static vector<MdcCal_const4>* s_col;
};
 
//
//*** miscellaneous ***
//
class MdcCal_misc {
public:
  MdcCal_misc() {};
 
public:
  int   id;
  int   level;
  float inv_speed;
};
 
class MdcCalMiscCol {
public:
  static vector<MdcCal_misc>* getMdcCalMiscCol( void );
 
private:
  static vector<MdcCal_misc>* s_col;
};
 
//
//*** const. param. to calculate charge  ***
//
class MdcCal_ped {
public:
  MdcCal_ped() {};
 
public:
  int   id;
  float pmean;
  float psigma;
};
 
class MdcCalPedCol {
public:
  static vector<MdcCal_ped>* getMdcCalPedCol( void );
 
private:
  static vector<MdcCal_ped>* s_col;
};
 
//
//*** wire-hits of MDC ***
//
class MdcRec_trk;
class MdcRec_wirhit {
public:
  MdcRec_wirhit() : geo( 0 ), dat( 0 ), trk( 0 ), rechitptr( 0 ) {};
  ~MdcRec_wirhit();
  MdcRec_wirhit( const MdcRec_wirhit& rhs )
      : geo( rhs.geo ), dat( rhs.dat ), trk( rhs.trk ), rechitptr( rhs.rechitptr ) {
    id          = rhs.id;
    ddl         = rhs.ddl;
    ddr         = rhs.ddr;
    erddl       = rhs.erddl;
    erddr       = rhs.erddr;
    pChiSq      = rhs.pChiSq;
    lr          = rhs.lr;
    stat        = rhs.stat;
    tdc         = rhs.tdc;
    adc         = rhs.adc;
    timechannel = rhs.timechannel;
  }
 
  MdcRec_wirhit& operator=( const MdcRec_wirhit& rhs ) {
 
    if ( this == &rhs ) return *this;
    id          = rhs.id;
    ddl         = rhs.ddl;
    ddr         = rhs.ddr;
    erddl       = rhs.erddl;
    erddr       = rhs.erddr;
    pChiSq      = rhs.pChiSq;
    lr          = rhs.lr;
    stat        = rhs.stat;
    geo         = rhs.geo;
    trk         = rhs.trk;
    dat         = rhs.dat;
    tdc         = rhs.tdc;
    adc         = rhs.adc;
    timechannel = rhs.timechannel;
    rechitptr   = rhs.rechitptr;
    return *this;
  }
 
public:
  int               id{ 0 };
  float             ddl{ 0.0 };
  float             ddr{ 0.0 };
  float             erddl{ 0.0 };
  float             erddr{ 0.0 };
  float             pChiSq{ 0.0 };
  int               lr{ 0 };
  int               stat{ 0 };
  const MdcGeoWire* geo{ nullptr };
  MdcDat_wirhit*    dat{ nullptr };
  MdcRec_trk*       trk{ nullptr };
  RecMdcHit*        rechitptr{ nullptr };
  float             tdc{ 0.0 };
  float             adc{ 0.0 };
  unsigned          timechannel{ 0 }; // liucy for tsf
};
 
class MdcRecWirhitCol {
public:
  static vector<MdcRec_wirhit>* getMdcRecWirhitCol( void );
 
private:
  static vector<MdcRec_wirhit>* s_col;
};
 
//
//*** track of MDC ***
//
class MdcRec_trk_add;
class MdcRec_trk {
public:
  MdcRec_trk() : add( 0 ) {};
  ~MdcRec_trk();
 
  MdcRec_trk( const MdcRec_trk& rhs ) : add( rhs.add ) {
    id     = rhs.id;
    chiSq  = rhs.chiSq;
    ndf    = rhs.ndf;
    fiTerm = rhs.fiTerm;
    nhits  = rhs.nhits;
    nster  = rhs.nster;
    nclus  = rhs.nclus;
    stat   = rhs.stat;
    mass   = rhs.mass;
    hitcol = rhs.hitcol;
    for ( int i = 0; i < 15; i++ )
    {
      if ( i < 3 ) pivot[i] = rhs.pivot[i];
      if ( i < 5 ) helix[i] = rhs.helix[i];
      error[i] = rhs.error[i];
    }
  }
 
  MdcRec_trk& operator=( const MdcRec_trk& rhs ) {
 
    if ( this == &rhs ) return *this;
    id     = rhs.id;
    chiSq  = rhs.chiSq;
    ndf    = rhs.ndf;
    fiTerm = rhs.fiTerm;
    nhits  = rhs.nhits;
    nster  = rhs.nster;
    nclus  = rhs.nclus;
    stat   = rhs.stat;
    add    = rhs.add;
    mass   = rhs.mass;
    hitcol = rhs.hitcol;
    for ( int i = 0; i < 15; i++ )
    {
      if ( i < 3 ) pivot[i] = rhs.pivot[i];
      if ( i < 5 ) helix[i] = rhs.helix[i];
      error[i] = rhs.error[i];
    }
    return *this;
  }
 
public:
  int                    id;
  float                  helix[5];
  float                  pivot[3];
  float                  error[15];
  float                  chiSq;
  float                  ndf;
  float                  fiTerm;
  int                    nhits;
  int                    nster;
  int                    nclus;
  int                    stat;
  float                  mass;
  vector<MdcRec_wirhit*> hitcol;
  MdcRec_trk_add*        add;
 
public:
  const float fi0( void ) const { return helix[1]; }
  const float cpa( void ) const { return helix[2]; }
  const float dz( void ) const { return helix[3]; }
  const float tanl( void ) const { return helix[4]; }
};
 
class MdcRecTrkCol {
public:
  static vector<MdcRec_trk>* getMdcRecTrkCol( void );
 
private:
  static vector<MdcRec_trk>* s_col;
};
 
//
//*** dEdx of MDC ***
//
class MdcRec_dedx {
public:
  MdcRec_dedx() {};
 
public:
  int         id;
  float       dEdx;
  float       dEdx_exp[5];
  float       sigma_dEdx[5];
  float       pid_prob[5];
  MdcRec_trk* trk;
  int         stat;
};
 
class MdcRecDedxCol {
public:
  static vector<MdcRec_dedx>* getMdcRecDedxCol( void );
 
private:
  static vector<MdcRec_dedx>* s_col;
};
 
//
//*** MDC timing ***
//
class MdcRec_timing {
public:
  MdcRec_timing() {};
 
public:
  int   id;
  float time;
  int   quality;
};
 
class MdcRecTimingCol {
public:
  static vector<MdcRec_timing>* getMdcRecTimingCol( void );
 
private:
  static vector<MdcRec_timing>* s_col;
};
 
//
//*** const. param. for dE/dx caliburation  ***
//
class MdcRec_excalib {
public:
  MdcRec_excalib() {};
 
public:
  int   id;
  float gain[8208];
  float ggs_f[10];
  float ggs_b[10];
  float erggs_f[10];
  float erggs_b[10];
  float localg[15][47];
  float ddg[10][47];
  float mdcgain;
};
 
class MdcRecExcalibCol {
public:
  static vector<MdcRec_excalib>* getMdcRecExcalibCol( void );
 
private:
  static vector<MdcRec_excalib>* s_col;
};
 
//
//*** const. param. to caliburate global gain ***
//
class MdcRec_exglobal {
public:
  MdcRec_exglobal() {};
 
public:
  int   id;
  float mdcgain;
  float mdcresol;
};
 
class MdcRecExglobalCol {
public:
  static vector<MdcRec_exglobal>* getMdcRecExglobalCol( void );
 
private:
  static vector<MdcRec_exglobal>* s_col;
};
 
//
//*** const. param. to caliburate dE/dx curve ***
//
class MdcRec_excurve {
public:
  MdcRec_excurve() {};
 
public:
  int   id;
  float f_bg[10];
  float f_erbg[12];
  float f_erbg2[12];
};
 
class MdcRecExcurveCol {
public:
  static vector<MdcRec_excurve>* getMdcRecExcurveCol( void );
 
private:
  static vector<MdcRec_excurve>* s_col;
};
 
//
//*** const. to calib. dE/dx curve for 5 particles ***
//
class MdcRec_excurve_add {
public:
  MdcRec_excurve_add() {};
 
public:
  int   id;
  int   flag;
  float f_e[12];
  float f_mu[12];
  float f_pi[12];
  float f_k[12];
  float f_p[12];
};
 
class MdcRecExcurveAddCol {
public:
  static vector<MdcRec_excurve_add>* getMdcRecExcurveAddCol( void );
 
private:
  static vector<MdcRec_excurve_add>* s_col;
};
 
//
//*** re-reconst. dE/dx ( global calib )"
//
class MdcRec_exnoggs {
public:
  MdcRec_exnoggs() {};
 
public:
  int          id;
  float        dEdx_r;
  float        mdcR_old;
  MdcRec_trk*  trk;
  MdcRec_dedx* rex;
};
 
class MdcRecExnoggsCol {
public:
  static vector<MdcRec_exnoggs>* getMdcRecExnoggsCol( void );
 
private:
  static vector<MdcRec_exnoggs>* s_col;
};
 
//
//*** Definition of current calib. function parameter (2nd POLY.)"
//
class MdcRec_excurrentfit {
public:
  MdcRec_excurrentfit() {};
 
public:
  int   id;
  float curr_slope;
  float curr_const;
  float f_slope[50];
  float f_const[50];
};
 
class MdcRecExcurrentfitCol {
public:
  static vector<MdcRec_excurrentfit>* getMdcRecExcurrentfitCol( void );
 
private:
  static vector<MdcRec_excurrentfit>* s_col;
};
 
//
//*** wire current from daqom"
//
class MdcRec_daqom {
public:
  MdcRec_daqom() {};
 
public:
  int   id;
  int   Time;
  float MC[56];
  float GasPress;
  float MDCTemp[5];
  int   RunState;
  float BeamCurrent[2];
  float LUMEFC;
  float LUMCSI;
  float VLT40;
  float TOFRATES;
};
 
class MdcRecDaqomCol {
public:
  static vector<MdcRec_daqom>* getMdcRecDaqomCol( void );
 
private:
  static vector<MdcRec_daqom>* s_col;
};
 
//
//*** digitized info. of MDC wire hits ***
//
class MdcDat_mcwirhit {
public:
  MdcDat_mcwirhit() {};
 
public:
  int               id;
  float             xw;
  float             yw;
  float             zw;
  float             dist;
  float             chrg;
  float             xin;
  float             yin;
  float             zin;
  float             xout;
  float             yout;
  float             zout;
  int               lr;
  int               stat;
  const MdcGeoWire* geo;
  MdcDat_wirhit*    dat;
  const Gen_hepevt* hep;
  MdcRec_trk*       trk;
  float             px;
  float             py;
  float             pz;
  float             pid;
  float             tof;
  float             tdc;
};
 
class MdcDatMcwirhitCol {
public:
  static vector<MdcDat_mcwirhit>* getMdcDatMcwirhitCol( void );
 
private:
  static vector<MdcDat_mcwirhit>* s_col;
};
 
//
//*** MC information of MDC track ***
//
class MdcRec_mctrk {
public:
  MdcRec_mctrk() {};
 
public:
  int               id;
  const Gen_hepevt* hep;
  float             wirFrac;
  float             wirFracHep;
  int               charge;
  float             ptFrac;
  float             pzFrac;
  int               quality;
};
 
class MdcRecMctrkCol {
public:
  static vector<MdcRec_mctrk>* getMdcRecMctrkCol( void );
 
private:
  static vector<MdcRec_mctrk>* s_col;
};
 
//
//*** MDC track and generated track matching ***
//
class MdcRec_mctrk2hep {
public:
  MdcRec_mctrk2hep() {};
 
public:
  int            id;
  MdcRec_wirhit* wir;
  //  MdcRec_clust * clust;
  MdcRec_trk*       trk;
  const Gen_hepevt* hep;
};
 
class MdcRecMctrk2hepCol {
public:
  static vector<MdcRec_mctrk2hep>* getMdcRecMctrk2hepCol( void );
 
private:
  static vector<MdcRec_mctrk2hep>* s_col;
};
 
//
//*** additional tables for track of MDC ***
//
class MdcTrk;
class MdcRec_trk_add {
public:
  MdcRec_trk_add() : body( 0 ), mother( 0 ), daughter( 0 ), rectrk( 0 ) {};
  ~MdcRec_trk_add();
  MdcRec_trk_add( const MdcRec_trk_add& rhs )
      : mother( rhs.mother )
      , body( rhs.body )
      , daughter( rhs.daughter )
      , rectrk( rhs.rectrk ) {
    id       = rhs.id;
    quality  = rhs.quality;
    kind     = rhs.kind;
    decision = rhs.decision;
    stat     = rhs.stat;
    for ( int i = 0; i < 3; i++ ) { likelihood[i] = rhs.likelihood[i]; }
  }
 
  MdcRec_trk_add& operator=( const MdcRec_trk_add& rhs ) {
 
    if ( this == &rhs ) return *this;
    id       = rhs.id;
    quality  = rhs.quality;
    kind     = rhs.kind;
    decision = rhs.decision;
    stat     = rhs.stat;
    rectrk   = rhs.rectrk;
    body     = rhs.body;
    mother   = rhs.mother;
    daughter = rhs.daughter;
    for ( int i = 0; i < 3; i++ ) { likelihood[i] = rhs.likelihood[i]; }
    return *this;
  }
 
public:
  int         id;
  int         quality;
  int         kind;
  MdcRec_trk* body;
  MdcRec_trk* mother;
  MdcRec_trk* daughter;
  int         decision;
  float       likelihood[3];
  int         stat;
  MdcTrk*     rectrk;
};
 
class MdcRecTrkAddCol {
public:
  static vector<MdcRec_trk_add>* getMdcRecTrkAddCol( void );
 
private:
  static vector<MdcRec_trk_add>* s_col;
};
 
//
//*** mdctime run-dependent offset  ***
//
class MdcRec_timeofs {
public:
  MdcRec_timeofs() {};
 
public:
  int   id;
  float offset;
};
 
class MdcRecTimeofsCol {
public:
  static vector<MdcRec_timeofs>* getMdcRecTimeofsCol( void );
 
private:
  static vector<MdcRec_timeofs>* s_col;
};
 
//
//*** Tof_xtime2 information with tighter cuts ***
//*** from Tof_mdctime                         ***
//
class Mdc_xtime2 {
public:
  Mdc_xtime2() {};
 
public:
  int   id;
  float xtime;
  float tofhit;
  float trig32;
  float evtime;
  float tdcstop;
};
 
class MdcXtime2Col {
public:
  static vector<Mdc_xtime2>* getMdcXtime2Col( void );
 
private:
  static vector<Mdc_xtime2>* s_col;
};
 
#endif // _MdcTables_h_