Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

MdcDedxTrk Class Reference

#include <MdcDedxTrk.h>

List of all members.

Public Member Functions

double cal_dedx (float)
double cal_dedx (float)
double cal_dedx_bitrunc (float, int, int &)
double cal_dedx_bitrunc (float, int, int &)
double cal_dedx_geometric (float)
double cal_dedx_geometric (float)
double cal_dedx_geometric_trunc (float)
double cal_dedx_geometric_trunc (float)
double cal_dedx_harmonic (float)
double cal_dedx_harmonic (float)
double cal_dedx_harmonic_trunc (float)
double cal_dedx_harmonic_trunc (float)
double cal_dedx_log (float, int)
double cal_dedx_log (float, int)
double cal_dedx_median (float)
double cal_dedx_median (float)
double cal_dedx_transform (int)
double cal_dedx_transform (int)
int charge () const
int charge () const
double chi_dedx (int) const
double chi_dedx (int) const
double dedx () const
double dedx () const
 --------------------------------------------------------------------
double dedx_r () const
double dedx_r () const
int end_lyr () const
int end_lyr () const
double exp_sigma (int) const
double exp_sigma (int) const
double expect (int) const
double expect (int) const
vector< double > get_phlist (void)
vector< double > get_phlist (void)
float get_pl (int layer) const
float get_pl (int layer) const
 MdcDedxTrk ()
 MdcDedxTrk (RecMdcKalTrack &trk_kal)
 MdcDedxTrk (RecMdcTrack &trk)
 MdcDedxTrk ()
 MdcDedxTrk (RecMdcKalTrack &trk_kal)
 MdcDedxTrk (RecMdcTrack &trk)
int nlyr () const
int nlyr () const
int nsample () const
int nsample () const
int nslyr () const
int nslyr () const
double P () const
double P () const
double * pchi_dedx (void)
double * pchi_dedx (void)
double * pexp_sigma (void)
double * pexp_sigma (void)
double * pexpect (void)
double * pexpect (void)
double phi () const
double phi () const
double * pprob (void)
double * pprob (void)
double prob (int) const
double prob (int) const
double Pt () const
double Pt () const
int quality () const
int quality () const
void set_dEdx (int l, float dEdx_meas, int trkalg, int runflag, int vflag[3], double t0, vector< double > &DedxCurve_Parameter, vector< double > &DedxSigma_Parameter)
void set_dEdx (int l, float dEdx_meas, int trkalg, int runflag, int vflag[3], double t0, vector< double > &DedxCurve_Parameter, vector< double > &DedxSigma_Parameter)
void set_ExTrk (RecMdcTrack &trk)
void set_ExTrk (RecMdcTrack &trk)
void set_ExTrk_Kal (RecMdcKalTrack &trk_kal)
void set_ExTrk_Kal (RecMdcKalTrack &trk_kal)
void set_phlist (vector< double >)
void set_phlist (vector< double >)
double SpaceChargeCorrec (double, double, int, double)
double SpaceChargeCorrec (double, double, int, double)
int st_lyr () const
int st_lyr () const
int stat (int)
int stat () const
int stat (int)
int stat () const
double theta () const
double theta () const
int trk_id (RecMdcKalTrack *)
int trk_id (RecMdcTrack *)
int trk_id () const
int trk_id (RecMdcKalTrack *)
int trk_id (RecMdcTrack *)
int trk_id () const
RecMdcTrack * trk_ptr () const
RecMdcTrack * trk_ptr () const
RecMdcKalTrack * trk_ptr_kal () const
RecMdcKalTrack * trk_ptr_kal () const
 ~MdcDedxTrk ()
 ~MdcDedxTrk ()

Private Member Functions

int get_exlist (int, int, int)
int get_exlist (int, int, int)

Private Attributes

double chi_ex [5]
double dedx_exp [5]
const MdcDedxCorrection * ex_calib
const MdcDedxCorrection * ex_calib
double ex_sigma [5]
int m_charge
int m_dbFlag
double m_dEdx
double m_dEdx_r
int m_end_l
int m_nlyr
int m_nsample
int m_nslyr
float m_P
double m_phi
vector< double > m_phlist
vector< double > m_phlist
double m_pl_rp
int m_quality
int m_smpl_max
int m_smpl_min
int m_st_l
int m_stat
double m_theta
RecMdcTrack * m_trk
RecMdcTrack * m_trk
int m_trk_id
RecMdcKalTrack * m_trk_kal
RecMdcKalTrack * m_trk_kal
float m_truncate
int m_x_rej
double pid_prob [5]

Constructor & Destructor Documentation

MdcDedxTrk::MdcDedxTrk (  RecMdcTrack &  trk  ) 
  

00054                                           :
00055 ex_calib( 0 )
00056 {
00057      m_stat = -1;
00058      m_st_l = -1;
00059      m_end_l = -1;
00060      m_trk_id = 0;
00061      m_nlyr = 0;
00062      m_nslyr = 0;
00063      m_dbFlag = 0;
00064      m_truncate = 0.8;
00065      m_x_rej = 1;
00066      m_dEdx = 0;
00067      m_pl_rp = 0;
00068      m_nsample = 0;
00069      m_quality = -99;
00070      m_smpl_min = 0;
00071      m_smpl_max = 0;
00072 
00073      set_ExTrk( trk );
00074 #ifdef DEBUG
00075       std::cout<<"MdcDedxTrk(2) constructed!"<<std::endl;
00076 #endif   
00077 }

MdcDedxTrk::MdcDedxTrk (  RecMdcKalTrack &  trk_kal  ) 
  

00079                                                  : 
00080 ex_calib( 0 ) 
00081 { 
00082      m_stat = -1;
00083      m_st_l = -1;
00084      m_end_l = -1;
00085      m_trk_id = 0;
00086      m_nlyr = 0;
00087      m_nslyr = 0; 
00088      m_dbFlag = 0; 
00089      m_truncate = 0.8;   
00090      m_x_rej = 1;
00091      m_dEdx = 0;
00092      m_pl_rp = 0; 
00093      m_nsample = 0;
00094      m_quality = -99;
00095      m_smpl_min = 0; 
00096      m_smpl_max = 0;
00097 
00098      set_ExTrk_Kal( trk_kal ); 
00099 #ifdef DEBUG 
00100      std::cout<<"MdcDedxTrk(2) kal constructed!"<<std::endl;
00101 #endif 
00102 }

MdcDedxTrk::MdcDedxTrk (   ) 
 

MdcDedxTrk class

>>>>>>>>> 

00020                         :
00021 ex_calib( 0 )
00022 {
00023      m_stat = -1;
00024      m_st_l = -1;
00025      m_end_l = -1;
00026      m_trk_id = 0;
00027      m_nlyr = 0;
00028      m_nslyr = 0;
00029      m_dbFlag = 0;
00030      m_trk = 0;
00031      m_truncate = 0.8;
00032      m_x_rej = 1;
00033      m_P = 0;
00034      m_theta = 0;
00035      m_dEdx = 0;
00036      m_pl_rp = 0;
00037      m_nsample = 0;
00038      m_quality = -99;
00039      m_smpl_min = 0;
00040      m_smpl_max = 0;
00041    for( unsigned a = 0; a < 5 ; a++ ){
00042           dedx_exp[a]=0.0;
00043           ex_sigma[a]=0.0;
00044           pid_prob[a]=0.0;
00045           chi_ex[a]=999.0;
00046    }
00047    
00048 #ifdef DEBUG   
00049    std::cout<<"MdcDedxTrk(1) constructed!"<<std::endl;
00050 #endif   
00051    
00052 }

MdcDedxTrk::~MdcDedxTrk (   ) 
  

00104                        {
00105 #ifdef DEBUG   
00106     std::cout<<"MdcDedxTrk destructed!!!"<<std::endl;
00107 #endif   
00108 }

MdcDedxTrk::MdcDedxTrk (  RecMdcTrack &  trk  ) 
 

MdcDedxTrk::MdcDedxTrk (  RecMdcKalTrack &  trk_kal  ) 
 

MdcDedxTrk::MdcDedxTrk (   ) 
 

MdcDedxTrk::~MdcDedxTrk (   ) 
 

Member Function Documentation

double MdcDedxTrk::cal_dedx (  float   ) 
 

double MdcDedxTrk::cal_dedx (  float   ) 
  

00337                                     {
00338      sort(m_phlist.begin(),m_phlist.end());
00339 
00340      int nsampl = (int)( m_phlist.size()*truncate );
00341      double qSum = 0;
00342      unsigned i = 0;
00343     for(vector<double>::iterator ql= m_phlist.begin();ql!=m_phlist.end();ql++){
00344       i++;
00345       if(  i<= nsampl )
00346         qSum += (*ql);
00347     }
00348 
00349      float trunc=qSum/nsampl;
00350   return trunc;
00351   std::cout<<"MdcDedxTrk::cal_dedx()!!!"<<std::endl;
00352 }

double MdcDedxTrk::cal_dedx_bitrunc (  float  ,
int  ,
int & 
) 
 

double MdcDedxTrk::cal_dedx_bitrunc (  float  ,
int  ,
int & 
) 
  

00355                                                                    {
00356  sort(m_phlist.begin(),m_phlist.end());
00357  int nsampl = (int)( m_phlist.size()*truncate );
00358  int smpl = (int)(m_phlist.size()*(truncate+0.05));
00359  int min_cut = (int)( m_phlist.size()*0.05 + 0.5 );
00360  double qSum = 0;
00361  unsigned i = 0;
00362  for(vector<double>::iterator ql= m_phlist.begin();ql!=m_phlist.end();ql++){
00363     i++;
00364     if(i<= smpl && i>=min_cut ) qSum += (*ql);
00365  }
00366  double trunc=-99;
00367  usedhit = smpl-min_cut+1;
00368  if(usedhit>0)
00369    trunc=qSum/usedhit;
00370  
00371  //float trunc_cal = SpaceChargeCorrec(theta, mom, ParticleFlag, trunc);  
00372  //if(alg) m_dEdx = trunc_cal; 
00373  
00374  return trunc;
00375  std::cout<<"MdcDedxTrk::cal_dedx()!!!"<<std::endl;
00376 }

double MdcDedxTrk::cal_dedx_geometric (  float   ) 
 

double MdcDedxTrk::cal_dedx_geometric (  float   ) 
  

00452                                               {
00453      sort(m_phlist.begin(),m_phlist.end());
00454 
00455      int nsampl = m_phlist.size();
00456      double qSum = 1.0;
00457     for(vector<double>::iterator ql= m_phlist.begin();ql!=m_phlist.end();ql++){
00458       qSum *= (*ql);
00459     }
00460 
00461      double trunc = pow(qSum,1/double(nsampl));
00462   return trunc;
00463   std::cout<<"MdcDedxTrk::cal_dedx()!!!"<<std::endl;
00464 }

double MdcDedxTrk::cal_dedx_geometric_trunc (  float   ) 
 

double MdcDedxTrk::cal_dedx_geometric_trunc (  float   ) 
  

00467                                                     {
00468      sort(m_phlist.begin(),m_phlist.end());
00469 
00470      int nsampl = (int)( m_phlist.size()*truncate );
00471      double qSum = 1.0;
00472      unsigned i = 0;
00473     for(vector<double>::iterator ql= m_phlist.begin();ql!=m_phlist.end();ql++){
00474       i++;
00475       if(  i<= nsampl )
00476         qSum *= (*ql);
00477     }
00478 
00479      double trunc = pow(qSum,1/double(nsampl));
00480   return trunc;
00481 
00482   std::cout<<"MdcDedxTrk::cal_dedx()!!!"<<std::endl;
00483 }

double MdcDedxTrk::cal_dedx_harmonic (  float   ) 
 

double MdcDedxTrk::cal_dedx_harmonic (  float   ) 
  

00486                                              {
00487      sort(m_phlist.begin(),m_phlist.end());
00488 
00489      int nsampl = m_phlist.size();
00490      double qSum = 0;
00491     for(vector<double>::iterator ql= m_phlist.begin();ql!=m_phlist.end();ql++){
00492       qSum += 1/(*ql);
00493     }
00494 
00495      float trunc=nsampl/qSum;
00496   return trunc;
00497   std::cout<<"MdcDedxTrk::cal_dedx()!!!"<<std::endl;
00498 }

double MdcDedxTrk::cal_dedx_harmonic_trunc (  float   ) 
 

double MdcDedxTrk::cal_dedx_harmonic_trunc (  float   ) 
  

00501                                                    {
00502      sort(m_phlist.begin(),m_phlist.end());
00503 
00504      int nsampl = (int)( m_phlist.size()*truncate );
00505      double qSum = 0;
00506      unsigned i = 0;
00507     for(vector<double>::iterator ql= m_phlist.begin();ql!=m_phlist.end();ql++){
00508       i++;
00509       if(  i<= nsampl )
00510         qSum += 1/(*ql);
00511     }
00512 
00513      float trunc= nsampl/qSum;
00514   return trunc;
00515   std::cout<<"MdcDedxTrk::cal_dedx()!!!"<<std::endl;
00516 }

double MdcDedxTrk::cal_dedx_log (  float  ,
int 
) 
 

double MdcDedxTrk::cal_dedx_log (  float  ,
int 
) 
  

00536                                                 {
00537  //sort(m_phlist.begin(),m_phlist.end());
00538 // int nsampl = (int)( m_phlist.size()*truncate );
00539  //int smpl = (int)(m_phlist.size()*(truncate+0.05));
00540  //int min_cut = (int)(  m_phlist.size()*0.05 + 0.5 );
00541  double qSum = 0;
00542  unsigned i = 0;
00543  for(vector<double>::iterator ql= m_phlist.begin();ql!=m_phlist.end();ql++){
00544     i++;
00545    // if(i<= smpl && i>=min_cut )     qSum += log(*ql);
00546    qSum += log(*ql);
00547  }
00548 
00549 // float trunc=qSum/(smpl-min_cut+1);
00550  float trunc=qSum/m_phlist.size();
00551 // cout<<"logtrunc....." <<  nsampl <<" " << smpl << " " << min_cut <<endl;
00552  //if(alg) m_dEdx = trunc;
00553  return trunc;
00554   std::cout<<"MdcDedxTrk::cal_dedx_log()!!!"<<std::endl;
00555 }

double MdcDedxTrk::cal_dedx_median (  float   ) 
 

double MdcDedxTrk::cal_dedx_median (  float   ) 
  

00438                                            {
00439      sort(m_phlist.begin(),m_phlist.end());
00440 
00441    int nsample = m_phlist.size();
00442    double median;   
00443    if( fmod(double(nsample),2.0) ) {   
00444       median = m_phlist[(nsample-1)/2];
00445    } else {
00446       median= 0.5*( m_phlist[nsample/2] + m_phlist[nsample/2-1] );
00447    }
00448   return median;
00449 }

double MdcDedxTrk::cal_dedx_transform (  int   ) 
 

double MdcDedxTrk::cal_dedx_transform (  int   ) 
  

00519                                        {
00520      sort(m_phlist.begin(),m_phlist.end());
00521 
00522      int nsampl = m_phlist.size();
00523      double qSum = 0;
00524     for(vector<double>::iterator ql= m_phlist.begin();ql!=m_phlist.end();ql++){
00525       qSum += 1/sqrt(*ql);
00526     }
00527 
00528      float trunc=1/qSum;
00529    //if(alg) m_dEdx = trunc;
00530   return trunc;
00531   std::cout<<"MdcDedxTrk::cal_dedx()!!!"<<std::endl;
00532 }

int MdcDedxTrk::charge (   )  const
 

int MdcDedxTrk::charge (   )  const [inline]
  

00262 { return m_charge; }

double MdcDedxTrk::chi_dedx (  int   )  const
 

double MdcDedxTrk::chi_dedx (  int   )  const [inline]
  

00228                                           {
00229      if( pid >= 0 && pid < 5 ) return chi_ex[pid];
00230      else return -1;
00231  }

double MdcDedxTrk::dedx (   )  const
 

double MdcDedxTrk::dedx (   )  const [inline]
 

-------------------------------------------------------------------- 

00125                               { return m_dEdx; 
00126    std::cout<<"MdcDedxTrk::dedx!!!"<<std::endl;  }

double MdcDedxTrk::dedx_r (   )  const
 

double MdcDedxTrk::dedx_r (   )  const [inline]
  

00132                                 { return m_dEdx_r; 
00133    std::cout<<"MdcDedxTrk::dedx_r()!!!"<<m_dEdx_r<<std::endl;  }

int MdcDedxTrk::end_lyr (   )  const
 

int MdcDedxTrk::end_lyr (   )  const [inline]
  

00275 { return m_end_l; }

double MdcDedxTrk::exp_sigma (  int   )  const
 

double MdcDedxTrk::exp_sigma (  int   )  const [inline]
  

00210                                            {
00211 
00212 
00213        if( pid >= 0 && pid < 5 ) return ex_sigma[pid];
00214        else return -1;
00215    std::cout<<"MdcDedxTrk::exp_sigma!!!"<<std::endl;   
00216  }

double MdcDedxTrk::expect (  int   )  const
 

double MdcDedxTrk::expect (  int   )  const [inline]
  

00202                                         {
00203       
00204  
00205        if( pid >= 0 && pid < 5 ) return dedx_exp[pid];
00206        else return -1;
00207    std::cout<<"MdcDedxTrk::expect!!!"<<std::endl;    
00208  }

int MdcDedxTrk::get_exlist (  int  ,
int  ,
int 
)  [private]
 

int MdcDedxTrk::get_exlist (  int  ,
int  ,
int 
)  [private]
  

00593                                                          {
00594 
00595    return 1;
00596   
00597 }

vector<double> MdcDedxTrk::get_phlist (  void   ) 
 

vector< double > MdcDedxTrk::get_phlist (  void   )  [inline]
  

00283                                           {
00284   return m_phlist;
00285 }

float MdcDedxTrk::get_pl (  int  layer  )  const
 

float MdcDedxTrk::get_pl (  int  layer  )  const
  

00600                                     {
00601 return 1.0;
00602 
00603   }

int MdcDedxTrk::nlyr (   )  const
 

int MdcDedxTrk::nlyr (   )  const [inline]
  

00265 { return m_nlyr; }

int MdcDedxTrk::nsample (   )  const
 

int MdcDedxTrk::nsample (   )  const [inline]
  

00271 { return m_nsample; }

int MdcDedxTrk::nslyr (   )  const
 

int MdcDedxTrk::nslyr (   )  const [inline]
  

00268 { return m_nslyr; }

double MdcDedxTrk::P (   )  const
 

double MdcDedxTrk::P (   )  const [inline]
  

00135                            { return m_P; 
00136   }

double* MdcDedxTrk::pchi_dedx (  void   ) 
 

double * MdcDedxTrk::pchi_dedx (  void   )  [inline]
  

00257                                    {
00258   return chi_ex;
00259  }

double* MdcDedxTrk::pexp_sigma (  void   ) 
 

double * MdcDedxTrk::pexp_sigma (  void   )  [inline]
  

00241                                     {
00242 
00243 
00244    return ex_sigma;
00245    std::cout<<"MdcDedxTrk::pexp_sigma!!!"<<std::endl;   
00246  }

double* MdcDedxTrk::pexpect (  void   ) 
 

double * MdcDedxTrk::pexpect (  void   )  [inline]
  

00234                                   {
00235 
00236 
00237    return dedx_exp;
00238    std::cout<<"MdcDedxTrk::pexpect!!!"<<std::endl;   
00239  }

double MdcDedxTrk::phi (   )  const
 

double MdcDedxTrk::phi (   )  const [inline]
  

00144                              { return m_phi; 
00145   }

double* MdcDedxTrk::pprob (  void   ) 
 

double * MdcDedxTrk::pprob (  void   )  [inline]
  

00249                                {
00250    
00251 
00252   return pid_prob;
00253   std::cout<<"MdcDedxTrk::pprob()!!!"<<std::endl;    
00254  }

double MdcDedxTrk::prob (  int   )  const
 

double MdcDedxTrk::prob (  int   )  const [inline]
  

00219                                       {
00220 
00221 
00222        if( pid >= 0 && pid < 5 ) return pid_prob[pid];
00223        else return -1;
00224   std::cout<<"MdcDedxTrk::prob()!!!"<<std::endl;    
00225  }

double MdcDedxTrk::Pt (   )  const
 

double MdcDedxTrk::Pt (   )  const [inline]
  

00138                             { return m_P*std::sin( m_theta ); 
00139   }

int MdcDedxTrk::quality (   )  const
 

int MdcDedxTrk::quality (   )  const [inline]
  

00128                               { return m_quality; 
00129    std::cout<<"MdcDedxTrk::quality!!!"<<std::endl;   }

void MdcDedxTrk::set_dEdx (  int  l,
float  dEdx_meas,
int  trkalg,
int  runflag,
int  vflag[3],
double  t0,
vector< double > &  DedxCurve_Parameter,
vector< double > &  DedxSigma_Parameter
) 
 

void MdcDedxTrk::set_dEdx (  int  l,
float  dEdx_meas,
int  trkalg,
int  runflag,
int  vflag[3],
double  t0,
vector< double > &  DedxCurve_Parameter,
vector< double > &  DedxSigma_Parameter
) 
  

00560                                                                                                                                                                             {
00561    
00562 #ifdef DEBUG
00563    cout<<"ttttttlandau: "<<landau<<"       dedx:  "<<m_dEdx<<"       nsample:  "
00564      <<m_nsample<<"        nsmpl : "<<nsample()<<"       m_P: "<<m_P<<"       theta: "<<m_theta<<"      pl-rp: "
00565      <<m_pl_rp<<"       ph size:  "<<m_phlist.size() <<endl;
00566 #endif   
00567   
00568   
00569    //ex_calib->dedx_pid_exp( landau, alg, typflag, (float)m_dEdx, (int)m_nsample,
00570                        //(float)m_P, (float)m_theta,(float)m_pl_rp,
00571                        // dedx_exp, ex_sigma, pid_prob, chi_ex);  
00572   int alg =0;
00573   int dedxhit_use = (int)(m_phlist.size()*0.7);  
00574 
00575   //some old data with od methods
00576   if(runflag ==1 || runflag ==2 )
00577     ex_calib->dedx_pid_exp_old( landau, alg, runflag, (float)m_dEdx, (int)dedxhit_use,
00578                                 (float)m_P, (float)m_theta, (float)t0,(float)m_pl_rp,
00579                                 dedx_exp, ex_sigma, pid_prob, chi_ex);
00580   //for 2009 psip data and after
00581   else
00582     ex_calib->dedx_pid_exp( vflag, (float)m_dEdx, trkalg,(int)dedxhit_use,
00583                             (float)m_P, (float)m_theta, (float)t0,(float)m_pl_rp,
00584                             dedx_exp, ex_sigma, pid_prob, chi_ex, DedxCurve_Parameter, DedxSigma_Parameter); 
00585   
00586 #ifdef DEBUG
00587    std::cout<<"MdcDedxTrk::set_dEdx()!!!"<<std::endl;
00588 #endif   
00589 }

void MdcDedxTrk::set_ExTrk (  RecMdcTrack &  trk  ) 
 

void MdcDedxTrk::set_ExTrk (  RecMdcTrack &  trk  ) 
  

00111                                         {
00112    for( unsigned a = 0; a < 5 ; a++ ){
00113           dedx_exp[a]=0.0;
00114           ex_sigma[a]=0.0;
00115           pid_prob[a]=0.0;
00116           chi_ex[a]=0.0;
00117    }
00118    m_stat = 1;
00119    m_trk = &trk;
00120    m_trk_id = trk.trackId();
00121    m_quality = trk.stat();
00122    if( !ex_calib ) ex_calib = MdcDedxCorrection::getMdcDedxCorrection();
00123 
00124      m_charge = ( trk.helix(2) > 0 )? 1 : -1;
00125      float m_Pt = 1.0/fabs( trk.helix(2) );
00126      m_P = m_Pt*sqrt(1 + trk.helix(4)*trk.helix(4));
00127      m_theta = M_PI_2 - atan( trk.helix(4) );
00128      m_phi = ( trk.helix(1) < 3*M_PI_2 )? trk.helix(1)+M_PI_2 : trk.helix(1)-3*M_PI_2;
00129      m_nsample = trk.getNhits();
00130      m_pl_rp = 1.5;
00131 
00132 #ifdef DEBUG     
00133     std::cout<<"MdcDedxTrk::set_ExTrk(&trk)!!!"<<std::endl;
00134 #endif
00135 }

void MdcDedxTrk::set_ExTrk_Kal (  RecMdcKalTrack &  trk_kal  ) 
 

void MdcDedxTrk::set_ExTrk_Kal (  RecMdcKalTrack &  trk_kal  ) 
  

00138                                                    {
00139    for( unsigned a = 0; a < 5 ; a++ ){
00140           dedx_exp[a]=0.0;
00141           ex_sigma[a]=0.0;
00142           pid_prob[a]=0.0;
00143           chi_ex[a]=0.0;
00144    }      
00145    m_stat = 1;
00146    m_trk_kal = &trk_kal;
00147    m_trk_id = trk_kal.trackId();
00148    m_quality = trk_kal.stat();
00149 
00150    HepVector kal_helix = m_trk_kal->getFHelix();
00151    
00152    if( !ex_calib ) ex_calib = MdcDedxCorrection::getMdcDedxCorrection();
00153      
00154      m_charge = ( kal_helix(3) > 0 )? 1 : -1;
00155      float m_Pt = 1.0/fabs( kal_helix(3) );
00156      m_P = m_Pt*sqrt(1 + kal_helix(5)*kal_helix(5));
00157      m_theta = M_PI_2 - atan( kal_helix(5) );
00158      m_phi = ( kal_helix(2) < 3*M_PI_2 )? kal_helix(2)+M_PI_2 : kal_helix(2)-3*M_PI_2;
00159      m_nsample = trk_kal.getNhits(2);
00160      m_pl_rp = 1.5;
00161 #ifdef DEBUG     
00162     std::cout<<"MdcDedxTrk::set_ExTrk(&trk_kal)!!!"<<std::endl;
00163 #endif
00164 }

void MdcDedxTrk::set_phlist (  vector< double >   ) 
 

void MdcDedxTrk::set_phlist (  vector< double >   )  [inline]
  

00278                                                   {
00279    m_phlist = phlist; 
00280 }

double MdcDedxTrk::SpaceChargeCorrec (  double  ,
double  ,
int  ,
double 
) 
 

double MdcDedxTrk::SpaceChargeCorrec (  double  ,
double  ,
int  ,
double 
) 
  

00379                                                                                           {
00380    if(Particle ==0) return dEdx;
00381    const int    par_cand( 6 );
00382    const float  Charge_Mass[par_cand] =
00383    {0, 0.00051100, 0.10566, 0.13957, 0.4937, 0.93827 };        
00384    const float  mass_e( 0.511 );
00385    double       beta_G, beta;
00386    float        betterm, bethe_B; 
00387    double e_Par[5] = {143.349, 1.7315, 0.192616, 2.90437, 1.08248};  
00388    double Beta_Gamma[22] ={0.373026, 0.479605, 0.586184, 0.692763, 0.799342, 782.779, 1565.56,
00389                            2348.34,  17.2727,  18.1245,  1.43297,  2.14946,  12.1803, 13.6132,
00390                            6.62515,  10.4109,  14.1967,  17.9825,  21.7683,  26.0274, 30.7596,
00391                            35.4919 }; 
00392    double K_par[22] ={4.64411e-05, 5.86544e-05, 8.05289e-05, 8.46981e-05, 8.92014e-05, 4.74517e-05, 4.51684e-05,      
00393                       5.32732e-05, 6.12803e-05, 6.14592e-05, 8.08608e-05, 6.73184e-05, 5.46448e-05, 6.1377e-05,       
00394                       6.57385e-05, 7.03053e-05, 6.61171e-05, 6.86824e-05, 6.246e-05,   7.25988e-05, 7.11034e-05,       
00395                       6.24924e-05 };
00396    double D_par[22] ={0.0871504, 0.0956379, 0.117193,  0.118647,  0.127203, 0.0566449, 0.0529198,
00397                       0.0642525, 0.0764562, 0.081341, 0.0952263, 0.0987536, 0.0639901, 0.0845994,
00398                       0.0777062, 0.0823206, 0.0783874, 0.079537, 0.0815792, 0.0849875, 0.0824751,
00399                       0.0776296 };
00400    double DSqr_par[22] = {0.00759519,  0.0091466,  0.0137341,  0.0140772,  0.0161807, 0.00320864, 0.00280051,
00401                           0.00412839, 0.00584555, 0.00661636, 0.00906805, 0.00975227, 0.00409473, 0.00715706,
00402                           0.00603826, 0.00677668, 0.00614458, 0.00632613, 0.00665516, 0.00722288, 0.00680214,
00403                           0.00602635};  
00404  
00405    beta_G = mom/Charge_Mass[Particle];
00406    if(beta_G <0.3) beta_G =0.3;
00407    double bet=beta_G/TMath::Sqrt(beta_G*beta_G+1);
00408    double fterm=TMath::Log(e_Par[2]+1/pow(beta_G,e_Par[4]));
00409    double fitval=e_Par[0]/pow(bet,e_Par[3])*(e_Par[1]-pow(bet,e_Par[3])-fterm);
00410    TGraphErrors *gr1 = new TGraphErrors(22,Beta_Gamma, K_par,0,0);
00411    TGraphErrors *gr2 = new TGraphErrors(22,Beta_Gamma, DSqr_par,0,0);
00412 
00413    double par[3];
00414    par[0] = fitval; 
00415    par[1] = gr1->Eval(m_theta);
00416    par[2] = gr2->Eval(m_theta);
00417    Double_t y = fabs(cos(m_theta));
00418    double electron_par[3] ={334.032, 6.20658e-05, 0.00525673};
00419    double arg= TMath::Sqrt(y*y+ par[2]);
00420    //double cal_factor =par[0]*TMath::Exp(-(par[1]* par[0])/arg);
00421    double cal_factor =TMath::Exp(-(par[1]* par[0])/arg);
00422    double arg_electron = TMath::Sqrt(y*y + electron_par[2]);
00423    //double electron_factor = electron_par[0]*TMath::Exp(-(electron_par[1]* electron_par[0])/arg);
00424    double electron_factor = TMath::Exp(-(electron_par[1]* electron_par[0])/arg_electron);
00425    //cout<<"cal_factor = "<<cal_factor<<"         electron_factor = "<<electron_factor<<endl;
00426    double dedx_cal = dEdx/(cal_factor/electron_factor);
00427    //double dedx_cal = dEdx/cal_factor;
00428    //cout<<"m_theta= "<<m_theta<<"      y ="<<y<<"      beta_G  = "<<beta_G <<"     dEdx = "<<dEdx<<"     cal dedx = "<<dedx_cal<<endl;
00429    delete gr1;
00430    delete gr2;
00431    return dedx_cal;
00432 }

int MdcDedxTrk::st_lyr (   )  const
 

int MdcDedxTrk::st_lyr (   )  const [inline]
  

00273 { return m_st_l; }

int MdcDedxTrk::stat (  int   ) 
 

int MdcDedxTrk::stat (   )  const
 

int MdcDedxTrk::stat (  int   )  [inline]
  

00147                                  { return m_stat = status; 
00148   std::cout<<m_stat<<"MdcDedxTrk::stat(int)!"<<std::endl;}

int MdcDedxTrk::stat (   )  const [inline]
  

00150                            { return m_stat; 
00151   std::cout<<m_stat<<"MdcDedxTrk::stat()!"<<std::endl;}

double MdcDedxTrk::theta (   )  const
 

double MdcDedxTrk::theta (   )  const [inline]
  

00141                                { return m_theta; 
00142   }

int MdcDedxTrk::trk_id (  RecMdcKalTrack *   ) 
 

int MdcDedxTrk::trk_id (  RecMdcTrack *   ) 
 

int MdcDedxTrk::trk_id (   )  const
 

int MdcDedxTrk::trk_id (  RecMdcKalTrack *   )  [inline]
  

00174                                                  {
00175   m_trk_kal = trk_kal;
00176   m_trk_id = (int)trk_kal->trackId();;
00177   return m_trk_id;
00178 }

int MdcDedxTrk::trk_id (  RecMdcTrack *   )  [inline]
  

00154                                           {
00155   m_trk = trk;
00156   m_trk_id = (int)trk->trackId();;
00157   return m_trk_id;
00158 }

int MdcDedxTrk::trk_id (   )  const [inline]
  

00188                              { 
00189 
00190    return m_trk_id;
00191    std::cout<<m_trk_id<<"MdcDedxTrk::trk_id()!"<<std::endl;   
00192  }

RecMdcTrack* MdcDedxTrk::trk_ptr (   )  const
 

RecMdcTrack * MdcDedxTrk::trk_ptr (   )  const [inline]
  

00161                                         { 
00162 
00163    return m_trk;  
00164    std::cout<<m_trk<<"MdcDedxTrk::trk_ptr()!"<<std::endl;
00165 }

RecMdcKalTrack* MdcDedxTrk::trk_ptr_kal (   )  const
 

RecMdcKalTrack * MdcDedxTrk::trk_ptr_kal (   )  const [inline]
  

00181                                                {
00182  
00183    return m_trk_kal;
00184    std::cout<<m_trk_kal<<"MdcDedxTrk::trk_ptr_kal()!"<<std::endl;
00185 }

Member Data Documentation

double MdcDedxTrk::chi_ex [private]
 

double MdcDedxTrk::dedx_exp [private]
 

const MdcDedxCorrection* MdcDedxTrk::ex_calib [private]
 

const MdcDedxCorrection* MdcDedxTrk::ex_calib [private]
 

double MdcDedxTrk::ex_sigma [private]
 

int MdcDedxTrk::m_charge [private]
 

int MdcDedxTrk::m_dbFlag [private]
 

double MdcDedxTrk::m_dEdx [private]
 

double MdcDedxTrk::m_dEdx_r [private]
 

int MdcDedxTrk::m_end_l [private]
 

int MdcDedxTrk::m_nlyr [private]
 

int MdcDedxTrk::m_nsample [private]
 

int MdcDedxTrk::m_nslyr [private]
 

float MdcDedxTrk::m_P [private]
 

double MdcDedxTrk::m_phi [private]
 

vector<double> MdcDedxTrk::m_phlist [private]
 

vector<double> MdcDedxTrk::m_phlist [private]
 

double MdcDedxTrk::m_pl_rp [private]
 

int MdcDedxTrk::m_quality [private]
 

int MdcDedxTrk::m_smpl_max [private]
 

int MdcDedxTrk::m_smpl_min [private]
 

int MdcDedxTrk::m_st_l [private]
 

int MdcDedxTrk::m_stat [private]
 

double MdcDedxTrk::m_theta [private]
 

RecMdcTrack* MdcDedxTrk::m_trk [private]
 

RecMdcTrack* MdcDedxTrk::m_trk [private]
 

int MdcDedxTrk::m_trk_id [private]
 

RecMdcKalTrack* MdcDedxTrk::m_trk_kal [private]
 

RecMdcKalTrack* MdcDedxTrk::m_trk_kal [private]
 

float MdcDedxTrk::m_truncate [private]
 

int MdcDedxTrk::m_x_rej [private]
 

double MdcDedxTrk::pid_prob [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:25:02 2011 for BOSS6.5.5 by  doxygen 1.3.9.1