RecCgemDedx.h

Go to the documentation of this file.

/*
 * @class : CgemDedx
 *
 *  this class models "dE/dx" used in Cgem Reconstruction
 * 
 * @author: wangdy
 * 
 * ********************************************************/
 
#ifndef RECCGEMDEDX_H
#define RECCGEMDEDX_H
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/SmartRef.h"
#include "GaudiKernel/SmartRefVector.h"
#include "GaudiKernel/ObjectVector.h"
#include "EventModel/EventModel.h" 
#include "RecCgemTrack.h"
#include "RecCgemDedxHit.h"
 
 
//#include "Identifier/Identifier.h"
//#include "ExtEvent/ExtTrack.h"
#include "DstEvent/DstCgemDedx.h" 
 
extern const CLID& CLID_RecCgemDedx;     
typedef SmartRefVector<RecCgemDedxHit>  RecCgemDedxHitRefVec;
//class CgemDedx : virtual public ContainedObject {
class RecCgemDedx : virtual public DstCgemDedx {
  
 public:
   virtual const CLID& clID() const   { 
      return RecCgemDedx::classID();
   }                                                                           
                                                                                  
   static const CLID& classID()       { 
      return CLID_RecCgemDedx;
   }                                                                           
                                                                     
   
   //ctor and dector
   RecCgemDedx();
   RecCgemDedx(const RecCgemDedx& dedxtrk);
   RecCgemDedx(const DstCgemDedx& dedxtrk);
   RecCgemDedx& operator=(const RecCgemDedx&);
   RecCgemDedx& operator=(const DstCgemDedx&);
   
   ~RecCgemDedx();
    //extractors
    // int getId(void) const { return m_id;  }
    // int getPid(void) const { return m_pid;  }
    // int getStat(void) const { return m_stat;   }
    // int getNHits(void) const { return m_nhits;   }
    // float getDedx(void) const { return m_dedx;  }
    // float getDedxStd(void) const { return m_dedx_std;  }
    // int getBitrunc(void) const { return m_bitrunc;  }
 
    double getDedxHit(void)     {return m_dedx_hit;     }
    double getDedxEsat(void)    {return m_dedx_esat;    }
    double getDedxNoRun(void)   {return m_dedx_norun;   }
    double getDedxMoment(void)      {return m_dedx_momentum;     }      
                                                   
    double getDedxExpect(int pid) const { return m_dedx_exp[pid-1];   }
    double getSigmaDedx(int pid) const { return m_sigma_dedx[pid-1];   }
    double getPidProb(int pid) const { return m_pid_prob[pid-1];   }
    // double getChi(int pid) const { return m_chi[pid-1];   }
    SmartRef<RecCgemTrack> getTrack(void)  { return m_trk; }
   
    //modifiers
    void setDedxHit(double dedx_hit)     { m_dedx_hit = dedx_hit;     }
    void setDedxEsat(double dedx_esat)   { m_dedx_esat = dedx_esat;   }
    void setDedxNoRun(double dedx_norun) { m_dedx_norun = dedx_norun; }
    void setDedxMoment(double dedx_momentum){ m_dedx_momentum = dedx_momentum;     } 
    // void setId(int id) { m_id = id;   }
    // void setPid(int pid) { m_pid = pid;   }
    // void setStat(int stat) { m_stat = stat;    }
    // void setNHits(int nhits) { m_nhits = nhits;    }
    // void setDedx(float dedx) { m_dedx = dedx; }
    // void setDedxStd(float dedx_std) { m_dedx_std = dedx_std; }
    // void setBitrunc(int bitrunc) { m_bitrunc = bitrunc;   }
   
    void setDedxExpect(double* dedx_exp) {
      for(int i = 0; i < 5; i++)
       m_dedx_exp[i] = dedx_exp[i]  ;
    }
    void setSigmaDedx(double* sigma_dedx) {
      for(int i = 0; i < 5; i++)
       m_sigma_dedx[i] = sigma_dedx[i] ;
    }
    void setPidProb(double* pid_prob) {
      for(int i = 0; i < 5; i++)
       m_pid_prob[i] = pid_prob[i] ;
    }
    /* void setChi(double* chi) {
      for(int i = 0; i < 5; i++)
       m_chi[i] = chi[i] ;
       }
     */
    void setTrack(SmartRef<RecCgemTrack> trk) {  m_trk = trk;    }
             
private:
    double  m_dedx_hit;   //double trucation mean of hit-level calib
    double  m_dedx_esat;  //double trucation mean of hit-level+electron saturation calib
    double  m_dedx_norun; //double trucation mean of no run gain calib  
    double  m_dedx_momentum;   //dE/dx calib used momentum
    //   int m_bitrunc;   //bitrunction rate
    //   int m_id;
    //   int m_pid;      // partile id results
    //   int m_stat;      // status flag                 
    //   int m_nhits;      // number of hits used in dE/dx recon
    //   float m_dedx;        // measured value of dE/dx
    //   float m_dedx_std;     // normalized dE/dx;
    double m_dedx_exp[5];    // expected value of dE/dx for 5 particle hypotheses
    double m_sigma_dedx[5]; // sigma value of dE/dx for 5 particle hypotheses
    double m_pid_prob[5]; // probability for each of  the 5 particle hypotheses
    //  double m_chi[5];     // chi of dE/dx for  each of  5 particle hypotheses
    SmartRef<RecCgemTrack> m_trk;    // reference to the   track 
   
};
 
typedef ObjectVector<RecCgemDedx> RecCgemDedxCol; 
 
#endif