Mdc/MdcTables/include/MdcTables/MdstTables.h

Go to the documentation of this file.

#ifndef _MdstTables_h_
#define _MdstTables_h_
 
#include <iostream>
#include <string>
#include <vector>
 
#include "MdcTables/HepevtTables.h"
 
using namespace std;
 
//
//*** MDST v.2.30. Run header
//
class Mdst_run_head {
public:
  Mdst_run_head(){};
 
public:
  int id;
  int version;
  int data_type;
  int exp_no;
  int run_no;
};
 
class MdstRunHeadCol {
public:
  static vector<Mdst_run_head>* getMdstRunHeadCol( void );
 
private:
  static vector<Mdst_run_head>* s_col;
};
 
//
//*** Run trailer
//
class Mdst_run_end {
public:
  Mdst_run_end(){};
 
public:
  int id;
  int exp_no;
  int run_no;
};
 
class MdstRunEndCol {
public:
  static vector<Mdst_run_end>* getMdstRunEndCol( void );
 
private:
  static vector<Mdst_run_end>* s_col;
};
 
//
//*** Event header
//
class Mdst_event {
public:
  Mdst_event(){};
 
public:
  int id;
  int exp_no;
  int run_no;
  int event_no;
  int trigger;
  int date;
  int time;
};
 
class MdstEventCol {
public:
  static vector<Mdst_event>* getMdstEventCol( void );
 
private:
  static vector<Mdst_event>* s_col;
};
 
//
//***Additional event header
//
class Mdst_event_add {
public:
  Mdst_event_add(){};
 
public:
  int   id;
  float scale;
  int   flag[5];
};
 
class MdstEventAddCol {
public:
  static vector<Mdst_event_add>* getMdstEventAddCol( void );
 
private:
  static vector<Mdst_event_add>* s_col;
};
 
//
//*** Data quality in the current event
//
class Mdst_quality {
public:
  Mdst_quality(){};
 
public:
  int  id;
  char name[4];
  int  quality;
};
 
class MdstQualityCol {
public:
  static vector<Mdst_quality>* getMdstQualityCol( void );
 
private:
  static vector<Mdst_quality>* s_col;
};
 
//
//*** Reconstructed charged tracks.
//
class Mdst_trk;
class Mdst_acc;
class Mdst_tof;
class Mdst_muid;
class Mdst_charged {
public:
  Mdst_charged(){};
 
public:
  int   id;
  float charge;
  float px;
  float py;
  float pz;
  float mass;
  int   used_pid;
  float pid_e;
  float pid_mu;
  float pid_pi;
  float pid_K;
  float pid_p;
  //  int elid;
  Mdst_trk* trk;
  Mdst_acc* acc;
  Mdst_tof* tof;
  //  Mdst_klm *  klm;
  Mdst_muid* muid;
};
 
class MdstChargedCol {
public:
  static vector<Mdst_charged>* getMdstChargedCol( void );
 
private:
  static vector<Mdst_charged>* s_col;
};
 
//
//*** Reconstructed V0-particles, i.e. Ks, Lambda,
//*** Lambda-bar, converted-gamma.
//
class Mdst_vee_daughters;
class Mdst_vee2 {
public:
  Mdst_vee2(){};
 
public:
  int                 id;
  int                 kind;
  Mdst_charged*       chgd[2];
  float               p[4];
  float               v[3];
  float               z_dist;
  float               chisq;
  int                 type;
  Mdst_vee_daughters* daut;
};
 
class MdstVee2Col {
public:
  static vector<Mdst_vee2>* getMdstVee2Col( void );
 
private:
  static vector<Mdst_vee2>* s_col;
};
 
//
//*** Track params. and error matrix of V0 daughters
//*** before the vtx-constraint fit.
//
class Mdst_vee_daughters {
public:
  Mdst_vee_daughters(){};
 
public:
  int   id;
  float helix_p[5];
  float helix_m[5];
  float error_p[15];
  float error_m[15];
};
 
class MdstVeeDaughtersCol {
public:
  static vector<Mdst_vee_daughters>* getMdstVeeDaughtersCol( void );
 
private:
  static vector<Mdst_vee_daughters>* s_col;
};
 
//
//*** Reconstructed gamma's.
//
class Mdst_ecl;
class Mdst_efc;
class Mdst_gamma {
public:
  Mdst_gamma(){};
 
public:
  int       id;
  float     px;
  float     py;
  float     pz;
  Mdst_ecl* ecl;
  Mdst_efc* efc;
};
 
class MdstGammaCol {
public:
  static vector<Mdst_gamma>* getMdstGammaCol( void );
 
private:
  static vector<Mdst_gamma>* s_col;
};
 
//
//*** Reconstructed pi0's.
//
class Mdst_pi0 {
public:
  Mdst_pi0(){};
 
public:
  int         id;
  Mdst_gamma* gamma[2];
  float       px;
  float       py;
  float       pz;
  float       energy;
  float       mass;
  float       chisq;
};
 
class MdstPi0Col {
public:
  static vector<Mdst_pi0>* getMdstPi0Col( void );
 
private:
  static vector<Mdst_pi0>* s_col;
};
 
//
//*** Reconstructed K-long's.
//
class Mdst_ecl;
class Mdst_klm_cluster;
class Mdst_klong {
public:
  Mdst_klong(){};
 
public:
  int       id;
  float     cos_x;
  float     cos_y;
  float     cos_z;
  Mdst_ecl* ecl;
  //  Mdst_klm * klm;
  Mdst_klm_cluster* klmc;
};
 
class MdstKlongCol {
public:
  static vector<Mdst_klong>* getMdstKlongCol( void );
 
private:
  static vector<Mdst_klong>* s_col;
};
 
//
//*** Muon ID information.
//
class Mdst_klm_mu;
class Mdst_muid {
public:
  Mdst_muid(){};
 
public:
  int          id;
  int          quality;
  int          muon;
  Mdst_klm_mu* klm;
};
 
class MdstMuidCol {
public:
  static vector<Mdst_muid>* getMdstMuidCol( void );
 
private:
  static vector<Mdst_muid>* s_col;
};
 
//
//*** TRK(=CDC plus SVD) information.
//
class Mdst_trk_fit;
class Mdst_trk {
public:
  Mdst_trk(){};
 
public:
  int           id;
  Mdst_trk_fit* mhyp[5];
  int           quality;
  int           quality_dedx;
  float         dEdx;
  float         dEdx_exp[5];
  float         sigma_dEdx[5];
  float         pid_e;
  float         pid_mu;
  float         pid_pi;
  float         pid_K;
  float         pid_p;
};
 
class MdstTrkCol {
public:
  static vector<Mdst_trk>* getMdstTrkCol( void );
 
private:
  static vector<Mdst_trk>* s_col;
};
 
//
//***
//
class Mdst_trk_add {
public:
  Mdst_trk_add(){};
 
public:
  int   id;
  int   stat[10];
  float buff[10];
};
 
class MdstTrkAddCol {
public:
  static vector<Mdst_trk_add>* getMdstTrkAddCol( void );
 
private:
  static vector<Mdst_trk_add>* s_col;
};
 
//
//*** Track fit results with multiple mass hypotheses.
//
class Mdst_trk_fit {
public:
  Mdst_trk_fit(){};
 
public:
  int   id;
  int   quality;
  int   hit_cdc[2];
  int   hit_svd;
  int   nhits[5];
  float mass;
  float pivot_x;
  float pivot_y;
  float pivot_z;
  float helix[5];
  float error[15];
  float chisq;
  int   ndf;
  float first_x;
  float first_y;
  float first_z;
  float last_x;
  float last_y;
  float last_z;
};
 
class MdstTrkFitCol {
public:
  static vector<Mdst_trk_fit>* getMdstTrkFitCol( void );
 
private:
  static vector<Mdst_trk_fit>* s_col;
};
 
//
//*** ACC (Aerogel Cherenkov Counter) information.
//
class Mdst_acc {
public:
  Mdst_acc(){};
 
public:
  int   id;
  int   quality;
  int   fire;
  float photo_electron;
  float pid_e;
  float pid_mu;
  float pid_pi;
  float pid_K;
  float pid_p;
};
 
class MdstAccCol {
public:
  static vector<Mdst_acc>* getMdstAccCol( void );
 
private:
  static vector<Mdst_acc>* s_col;
};
 
//
//*** TOF (Time Of Flight counter) information.
//
class Mdst_tof {
public:
  Mdst_tof(){};
 
public:
  int   id;
  int   quality;
  float path_length;
  float tof;
  float tof_exp[5];
  float sigma_tof;
  float ndf[5];
  float pid_e;
  float pid_mu;
  float pid_pi;
  float pid_K;
  float pid_p;
  float cl_e;
  float cl_mu;
  float cl_pi;
  float cl_K;
  float cl_p;
};
 
class MdstTofCol {
public:
  static vector<Mdst_tof>* getMdstTofCol( void );
 
private:
  static vector<Mdst_tof>* s_col;
};
 
//
//*** ECL (Electromagnetic CaLorimeter) information.
//
class Mdst_ecl {
public:
  Mdst_ecl(){};
 
public:
  int   id;
  int   match;
  int   quality;
  float energy;
  float phi;
  float theta;
  float r;
  float error[6];
  int   electron;
};
 
class MdstEclCol {
public:
  static vector<Mdst_ecl>* getMdstEclCol( void );
 
private:
  static vector<Mdst_ecl>* s_col;
};
 
//
//*** ECL (Electromagnetic Calorimeter) information add on.
//
class Mdst_ecl_cr;
class Mdst_ecl_aux {
public:
  Mdst_ecl_aux(){};
 
public:
  int          id;
  float        mass;
  float        width;
  float        e9oe25;
  float        e9oe25unf;
  float        seed;
  int          cId;
  float        property[10];
  int          nhits;
  Mdst_ecl_cr* cr;
  Mdst_trk*    trk;
};
 
class MdstEclAuxCol {
public:
  static vector<Mdst_ecl_aux>* getMdstEclAuxCol( void );
 
private:
  static vector<Mdst_ecl_aux>* s_col;
};
 
//
//*** ECL (Electromagnetic Calorimeter) information- Connected
//*** Region(super-cluster): not calibrated yet.
//
class Mdst_ecl_cr {
public:
  Mdst_ecl_cr(){};
 
public:
  int   id;
  int   match;
  int   quality;
  float energy;
  float phi;
  float theta;
  float r;
  float mass;
  float width;
  float property[10];
  int   nhits;
  int   nshowers;
};
 
class MdstEclCrCol {
public:
  static vector<Mdst_ecl_cr>* getMdstEclCrCol( void );
 
private:
  static vector<Mdst_ecl_cr>* s_col;
};
 
//
//*** TRK to ECL match information.
//
class Mdst_ecl_trk {
public:
  Mdst_ecl_trk(){};
 
public:
  int       id;
  Mdst_ecl* ecl;
  Mdst_trk* trk;
  int       type;
  int       cId;
  float     x[3];
  float     p[3];
  float     error[21];
};
 
class MdstEclTrkCol {
public:
  static vector<Mdst_ecl_trk>* getMdstEclTrkCol( void );
 
private:
  static vector<Mdst_ecl_trk>* s_col;
};
 
//
//*** Cluster information of KLM.
//
class Mdst_klm_cluster {
public:
  Mdst_klm_cluster(){};
 
public:
  int       id;
  Mdst_trk* trk;
  Mdst_ecl* ecl;
  int       quality;
  int       layers;
  int       first_layer;
  float     phi;
  float     theta;
  float     error[3];
};
 
class MdstKlmClusterCol {
public:
  static vector<Mdst_klm_cluster>* getMdstKlmClusterCol( void );
 
private:
  static vector<Mdst_klm_cluster>* s_col;
};
 
//
//*** Extended muon ID information related to KLM.
//
class Mdst_klm_mu {
public:
  Mdst_klm_mu(){};
 
public:
  int   id;
  float absp_len_pas;
  float absp_len_hit;
  int   layer_pas;
  int   layer_hit;
};
 
class MdstKlmMuCol {
public:
  static vector<Mdst_klm_mu>* getMdstKlmMuCol( void );
 
private:
  static vector<Mdst_klm_mu>* s_col;
};
 
//
//*** Muon ID Extended Information.
//
class Mdst_klm_mu_ex {
public:
  Mdst_klm_mu_ex(){};
 
public:
  int           id;
  Mdst_charged* pMDST_Charged;
  float         Muon_likelihood;
  float         Pion_likelihood;
  float         Kaon_likelihood;
  float         Miss_likelihood;
  float         Junk_likelihood;
  int           Outcome;
  float         Chi_2;
  int           N_hits;
  int           N_strips;
  int           Layer_trk_brl;
  int           Layer_trk_end;
  int           Layer_hit_brl;
  int           Layer_hit_end;
  int           N_layer_trk_brl;
  int           N_layer_trk_end;
  int           N_layer_hit_brl;
  int           N_layer_hit_end;
  int           Trk_pattern;
  int           Hit_pattern;
};
 
class MdstKlmMuExCol {
public:
  static vector<Mdst_klm_mu_ex>* getMdstKlmMuExCol( void );
 
private:
  static vector<Mdst_klm_mu_ex>* s_col;
};
 
//
//*** EFC (Extreme Forward Calorimeter) information.
//
class Mdst_efc {
public:
  Mdst_efc(){};
 
public:
  int   id;
  int   quality[2];
  float energy;
  float phi;
  float theta;
  float error[6];
};
 
class MdstEfcCol {
public:
  static vector<Mdst_efc>* getMdstEfcCol( void );
 
private:
  static vector<Mdst_efc>* s_col;
};
 
//
//*** Cross reference between track and hepevt
//
class Mdst_sim_trk {
public:
  Mdst_sim_trk(){};
 
public:
  int         id;
  Mdst_trk*   trk;
  Gen_hepevt* hepevt;
  float       relation[3];
};
 
class MdstSimTrkCol {
public:
  static vector<Mdst_sim_trk>* getMdstSimTrkCol( void );
 
private:
  static vector<Mdst_sim_trk>* s_col;
};
 
//
//*** Cross reference between shower and hepevt
//
class Mdst_sim_ecl {
public:
  Mdst_sim_ecl(){};
 
public:
  int         id;
  Mdst_ecl*   ecl;
  Gen_hepevt* hepevt;
  float       relation[3];
};
 
class MdstSimEclCol {
public:
  static vector<Mdst_sim_ecl>* getMdstSimEclCol( void );
 
private:
  static vector<Mdst_sim_ecl>* s_col;
};
 
//
//*** Random seeds
//
class Mdst_sim_rand {
public:
  Mdst_sim_rand(){};
 
public:
  int id;
  int seed1;
  int seed2;
  int iseq;
};
 
class MdstSimRandCol {
public:
  static vector<Mdst_sim_rand>* getMdstSimRandCol( void );
 
private:
  static vector<Mdst_sim_rand>* s_col;
};
 
#endif // _MdstTables_h_