Analysis/ParticleID/include/ParticleID/DedxPID.h

Go to the documentation of this file.

#ifndef ParticleID_DedxPID_H
#define ParticleID_DedxPID_H
//
// DedxPID package:  particle identification with dE/dx
// read original chi from DstDedx,
// make beta*gamma = p/m  and dip angle cos(theta) dependent correction
//
// In 1st version, only the momentum dependent is taken into account
// The corrections are made by: M.Yang, M.S. Chen, L.L. Wang, J.Y. Zhang and Y.Z. Sun
// Author: K.L. He     date: 11/12/2005, created
//
 
#include "ParticleID/ParticleIDBase.h"
 
class DedxPID : public ParticleIDBase {
 
public:
  static DedxPID* instance();
  // constructor & desconstructor
  ~DedxPID() { ; }
 
  void   init();
  void   calculate();
  bool   IsPidInfoValid() const { return ( m_ndof > 0 ); }
  double chi( int n ) const { return m_chi[n]; }
  double prob( int n ) const { return m_prob[n]; }
  double offset( int n ) const { return m_offset[n]; }
  double sigma( int n ) const { return m_sigma[n]; }
  int    ndof() const { return m_ndof; }
  double normPH() const { return m_normPH; }
  double goodHits() const { return m_goodHits; }
  int    neuronPID() const { return -1; }
  int    getNhitCutDx() const { return m_nhitcutdx; }
  void   setNhitCutDx( const int nhitcuthdx = 5 ) { m_nhitcutdx = nhitcuthdx; }
 
protected:
  int    particleIDCalculation();
  int    neuronPIDCalculation() { return -1; }
  double offsetDedx( int n, double ptrk, double cost );
  double sigmaDedx( int n, double ptrk, double cost );
  int    LikelihoodCalculation() { return -1; }
  double mypol3( double x, double par0, double par1, double par2, double par3 );
  double mypol5( double x, double par0, double par1, double par2, double par3, double par4,
                 double par5 );
  void   inputpar();
  double CorrDedx( int n, double ptrk, double cost, double chi, int charge );
  double iterate( double ptrk, double* mean, double* p );
  double cal_par( int index1, double* m_jpsi_pip_ptrk_offset, double ptrk, double begin,
                  double bin );
  double offsetCorr( int n, int charge, double ptrk, double cost );
  double sigmaCorr( int n, int charge, double ptrk, double cost );
  double interpolation( double cost, double* costheta, double* par );
 
private:
  double m_chi[5];
  double m_prob[5];
  double m_offset[5];
  double m_sigma[5];
  double m_chimin;
  double m_pdfmin;
  int    m_ndof;
  int    m_nhitcutdx;
  int    m_readstate;
  double m_normPH;
  double m_probPH;
  double m_goodHits;
  // lixr add
  int m_runxx;
 
  double m_jpsi_kap_ptrk_offset[12];
  double m_jpsi_kap_ptrk_sigma[12];
  double m_jpsi_kam_ptrk_offset[12];
  double m_jpsi_kam_ptrk_sigma[12];
  double m_jpsi_kap_theta_offset[18];
  double m_jpsi_kap_theta_sigma[18];
  double m_jpsi_kam_theta_offset[18];
  double m_jpsi_kam_theta_sigma[18];
 
  double m_jpsi_mc_kap_ptrk_offset[12];
  double m_jpsi_mc_kap_ptrk_sigma[12];
  double m_jpsi_mc_kam_ptrk_offset[12];
  double m_jpsi_mc_kam_ptrk_sigma[12];
  double m_jpsi_mc_kap_theta_offset[18];
  double m_jpsi_mc_kap_theta_sigma[18];
  double m_jpsi_mc_kam_theta_offset[18];
  double m_jpsi_mc_kam_theta_sigma[18];
 
  double m_jpsi_protonp_ptrk_offset[8];
  double m_jpsi_protonp_ptrk_sigma[8];
  double m_jpsi_protonm_ptrk_offset[8];
  double m_jpsi_protonm_ptrk_sigma[8];
  double m_jpsi_protonp_theta_offset[18];
  double m_jpsi_protonp_theta_sigma[18];
  double m_jpsi_protonm_theta_offset[18];
  double m_jpsi_protonm_theta_sigma[18];
 
  double m_jpsi_mc_protonp_ptrk_offset[8];
  double m_jpsi_mc_protonp_ptrk_sigma[8];
  double m_jpsi_mc_protonm_ptrk_offset[8];
  double m_jpsi_mc_protonm_ptrk_sigma[8];
  double m_jpsi_mc_protonp_theta_offset[18];
  double m_jpsi_mc_protonp_theta_sigma[18];
  double m_jpsi_mc_protonm_theta_offset[18];
  double m_jpsi_mc_protonm_theta_sigma[18];
 
  // psip
  double m_psip_kap_ptrk_offset[9];
  double m_psip_kap_ptrk_sigma[9];
  double m_psip_kam_ptrk_offset[9];
  double m_psip_kam_ptrk_sigma[9];
 
  double m_psip_mc_kap_ptrk_offset[9];
  double m_psip_mc_kap_ptrk_sigma[9];
  double m_psip_mc_kam_ptrk_offset[9];
  double m_psip_mc_kam_ptrk_sigma[9];
 
  double m_psip_protonp_ptrk_offset[9];
  double m_psip_protonp_ptrk_sigma[9];
  double m_psip_protonm_ptrk_offset[9];
  double m_psip_protonm_ptrk_sigma[9];
 
  double m_psip_mc_protonp_ptrk_offset[9];
  double m_psip_mc_protonp_ptrk_sigma[9];
  double m_psip_mc_protonm_ptrk_offset[9];
  double m_psip_mc_protonm_ptrk_sigma[9];
 
  // psipp
 
  double m_psipp_pi_ptrk_offset[18];
  double m_psipp_pi_ptrk_sigma[18];
  double m_psipp_pi_theta_offset[16];
  double m_psipp_pi_theta_sigma[16];
 
  double m_psipp_mc_pi_ptrk_offset[18];
  double m_psipp_mc_pi_ptrk_sigma[18];
  double m_psipp_mc_pi_theta_offset[16];
  double m_psipp_mc_pi_theta_sigma[16];
 
  double m_psipp_ka_ptrk_offset[17];
  double m_psipp_ka_ptrk_sigma[17];
  double m_psipp_ka_theta_offset[16];
  double m_psipp_ka_theta_sigma[16];
 
  double m_psipp_mc_ka_ptrk_offset[17];
  double m_psipp_mc_ka_ptrk_sigma[17];
  double m_psipp_mc_ka_theta_offset[16];
  double m_psipp_mc_ka_theta_sigma[16];
 
  double m_psipp_proton_ptrk_offset[18];
  double m_psipp_proton_ptrk_sigma[18];
  double m_psipp_proton_theta_offset[18];
  double m_psipp_proton_theta_sigma[18];
 
  double m_psipp_mc_proton_ptrk_offset[9];
  double m_psipp_mc_proton_ptrk_sigma[9];
  double m_psipp_mc_proton_theta_offset[18];
  double m_psipp_mc_proton_theta_sigma[18];
 
  double m_offsetCorr[5];
  double m_sigmaCorr[5];
 
private:
  DedxPID();
  static DedxPID* m_pointer;
};
 
#endif