PreT0MdcCalib Class Reference

#include <PreT0MdcCalib.h>

Inheritance diagram for PreT0MdcCalib:

List of all members.

Public Member Functions
	PreT0MdcCalib ()
	~PreT0MdcCalib ()
void	initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc, IMdcUtilitySvc *mdcUtilitySvc)
void	setParam (MdcCalParams &param)
int	fillHist (MdcCalEvent *event)
int	updateConst (MdcCalibConst *calconst)
void	clear ()
Static Private Member Functions
static Double_t	funTmin (Double_t *x, Double_t *par)
static Double_t	funTmax (Double_t *x, Double_t *par)
static Double_t	xtfun (Double_t *x, Double_t *par)
Private Attributes
MdcCalParams	m_param
TObjArray *	m_hlist
IMdcGeomSvc *	m_mdcGeomSvc
IMdcCalibFunSvc *	m_mdcFunSvc
IMdcUtilitySvc *	m_mdcUtilitySvc
int	m_nzbin
double	m_zwid [MdcCalNLayer]
double	m_zst [MdcCalNLayer]
double	m_vp [MdcCalNLayer]
TFolder *	m_fdTrec
TFolder *	m_fdTrecZ
TH1F *	m_hTrec [MdcCalNLayer][MdcCalLR]
TH1F *	m_hTrecCosm [MdcCalNLayer][2]
TH1F *	m_hTrecZ [MdcCalNLayer][MdcCalLR][11]

---

Detailed Description

Definition at line 14 of file PreT0MdcCalib.h.

---

Constructor & Destructor Documentation

PreT0MdcCalib::PreT0MdcCalib

(

)

Definition at line 31 of file PreT0MdcCalib.cxx.

References m_nzbin.

                            {
     m_nzbin = 11;
}

PreT0MdcCalib::~PreT0MdcCalib

(

)

Definition at line 35 of file PreT0MdcCalib.cxx.

                             {
}

---

Member Function Documentation

void PreT0MdcCalib::clear

(

)

[virtual]

Implements MdcCalib.

Definition at line 38 of file PreT0MdcCalib.cxx.

References bin, MdcCalib::clear(), m_fdTrec, m_fdTrecZ, m_hTrec, m_hTrecCosm, m_hTrecZ, m_nzbin, MdcCalLR, and MdcCalNLayer.

                         {
     int lay;
     int lr;
     int bin;
     for(lay=0; lay<MdcCalNLayer; lay++){
          for(lr=0; lr<MdcCalLR; lr++){
               delete m_hTrec[lay][lr];
               for(bin=0; bin<m_nzbin; bin++){
                    delete m_hTrecZ[lay][lr][bin];
               }
          }
     }
     for(lay=0; lay<MdcCalNLayer; lay++){
          for(bin=0; bin<2; bin++) delete m_hTrecCosm[lay][bin];
     }
     delete m_fdTrec;
     delete m_fdTrecZ;

     MdcCalib::clear();
}

int PreT0MdcCalib::fillHist

(

MdcCalEvent *

event

)

[virtual]

Implements MdcCalib.

Definition at line 138 of file PreT0MdcCalib.cxx.

References bin, Bes_Common::DEBUG, MdcCalEvent::getEsCutFlag(), MdcCalEvent::getRecTrk(), MdcCalEvent::getTes(), IMdcCalibFunSvc::getTimeWalk(), genRecEmupikp::i, m_hTrec, m_hTrecCosm, m_hTrecZ, m_mdcFunSvc, m_mdcGeomSvc, m_nzbin, m_param, m_vp, m_zst, m_zwid, MdcCalTdcCnv, msgSvc(), and MdcCalParams::timeShift.

                                             {
     IMessageSvc* msgSvc;
     Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
     MsgStream log(msgSvc, "PreT0MdcCalib");
     log << MSG::DEBUG << "PreT0MdcCalib::fillHist()" << endreq;

//      MdcCalib::fillHist(event);

     int i;
     int k;
     int lay;
     int cel;
     int lr;
     int bin;

     double tdc;
     double traw;
     double trec;
     double tdr;
     double t0;
     double tp = 0.0;
     double tof = 0.0;
     double zhit;
     double zprop;

     MdcCalRecTrk* rectrk;
     MdcCalRecHit* rechit;

     IDataProviderSvc* eventSvc = NULL;
     Gaudi::svcLocator()->service("EventDataSvc", eventSvc);

     // get EsTimeCol
     double tes = event->getTes();
  //    cout << "tes " << tes << endl;
     bool esCutFg = event->getEsCutFlag();
     if( ! esCutFg ) return -1;

     int nhit;
     int ntrk = event -> getNTrk();
     for(i=0; i<ntrk; i++){
          rectrk = event->getRecTrk(i);
          nhit = rectrk -> getNHits();
          for(k=0; k<nhit; k++){
               rechit = rectrk -> getRecHit(k);
               lay = rechit -> getLayid();
               cel = rechit -> getCellid();
               lr = rechit -> getLR();
               zhit = rechit -> getZhit();
               tdc = rechit -> getTdc();
               tdr = rechit -> getTdrift();

               traw = tdc * MdcCalTdcCnv;
//             traw = tdc;      // ns

               zprop = fabs(zhit - m_zst[lay]);
               bin = (int)(zprop / m_zwid[lay]);
               tp = zprop / m_vp[lay];
               t0 = m_mdcFunSvc -> getT0(lay, cel);
               tof = rechit -> getTof();

               double adc = rechit -> getQhit();
               double tw = m_mdcFunSvc->getTimeWalk(lay, adc);
//             cout << setw(15) << adc << setw(15) << tw << endl;

               const MdcGeoWire* pWire = m_mdcGeomSvc -> Wire(lay, cel);
               double y1 = pWire -> Backward().y();
               double y2 = pWire -> Forward().y();
               double ymid = (y1+y2)*0.5;
//             if(5==m_param.particle){ // cosmic-ray
//                  if(ymid > 0) trec = traw - tp + tof - tes + m_param.timeShift - tw;
//                  else trec = traw - tp - tof - tes + m_param.timeShift - tw;
//             } else{
//                  trec = traw - tp - tof - tes + m_param.timeShift - tw;
//             }
               trec = traw - tp - tof - tes + m_param.timeShift - tw;

               m_hTrec[lay][lr] -> Fill(trec);
               m_hTrec[lay][2] -> Fill(trec); // l-r in common
               if(ymid > 0) m_hTrecCosm[lay][0] -> Fill(trec);
               else m_hTrecCosm[lay][1] -> Fill(trec);

               if(bin < m_nzbin){
                    m_hTrecZ[lay][lr][bin] -> Fill(trec);
                    m_hTrecZ[lay][2][bin] -> Fill(trec);
               }
          }
     }
     return 1;
}

Double_t PreT0MdcCalib::funTmax	(	Double_t *	x,
		Double_t *	par
	)			[static, private]

Definition at line 445 of file PreT0MdcCalib.cxx.

References exp().

Referenced by updateConst().

                                                         {
     Double_t fitval;
     fitval = par[0] + par[1] / (1 + exp((x[0]-par[2])/par[3]));
     return fitval;
}

Double_t PreT0MdcCalib::funTmin	(	Double_t *	x,
		Double_t *	par
	)			[static, private]

Definition at line 438 of file PreT0MdcCalib.cxx.

References exp().

Referenced by updateConst().

                                                         {
     Double_t fitval;
     fitval = par[0] + par[1]*exp( -par[2]*(x[0]-par[3]) ) /
          ( 1 + exp( -(x[0]-par[4])/par[5] ));
     return fitval;
}

void PreT0MdcCalib::initialize	(	TObjArray *	hlist,
		IMdcGeomSvc *	mdcGeomSvc,
		IMdcCalibFunSvc *	mdcFunSvc,
		IMdcUtilitySvc *	mdcUtilitySvc
	)			[virtual]

Implements MdcCalib.

Definition at line 59 of file PreT0MdcCalib.cxx.

References MdcGeoWire::Backward(), bin, MdcGeoWire::Forward(), Bes_Common::INFO, m_fdTrec, m_fdTrecZ, m_hlist, m_hTrec, m_hTrecCosm, m_hTrecZ, m_mdcFunSvc, m_mdcGeomSvc, m_mdcUtilitySvc, m_nzbin, m_vp, m_zst, m_zwid, MdcCalLR, MdcCalNLayer, msgSvc(), and IMdcGeomSvc::Wire().

                                                                                          {
     IMessageSvc* msgSvc;
     Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
     MsgStream log(msgSvc, "PreT0MdcCalib");
     log << MSG::INFO << "PreT0MdcCalib::initialize()" << endreq;

     m_hlist = hlist;
     m_mdcGeomSvc = mdcGeomSvc;
     m_mdcFunSvc = mdcFunSvc;
     m_mdcUtilitySvc = mdcUtilitySvc;

//      MdcCalib::initialize(m_hlist, m_mdcGeomSvc, m_mdcFunSvc, m_mdcUtilitySvc);

     int lay;
     int lr;
     int bin;
     char hname[200];

     m_fdTrec = new TFolder("Trec", "Trec");
     m_hlist->Add(m_fdTrec);

     m_fdTrecZ = new TFolder("TrecZ", "TrecZ");
     m_hlist->Add(m_fdTrecZ);

     for(lay=0; lay<MdcCalNLayer; lay++){
          for(lr=0; lr<MdcCalLR; lr++){
               if(0 == lr) sprintf(hname, "Trec%02d_L", lay);
               else if(1 == lr) sprintf(hname, "Trec%02d_R", lay);
               else sprintf(hname, "Trec%02d_C", lay);

               if(lay < 8) m_hTrec[lay][lr] = new TH1F(hname, "", 100, 0, 400);
               else m_hTrec[lay][lr] = new TH1F(hname, "", 125, 0, 500);
               m_fdTrec -> Add(m_hTrec[lay][lr]);
          }
     }

     for(lay=0; lay<MdcCalNLayer; lay++){
          for(int iud=0; iud<2; iud++){
               if(0 == iud) sprintf(hname, "TrecCosm%02d_Up", lay);
               else sprintf(hname, "TrecCosm%02d_Dw", lay);
               if(lay < 8) m_hTrecCosm[lay][iud] = new TH1F(hname, "", 100, 0, 400);
               else m_hTrecCosm[lay][iud] = new TH1F(hname, "", 125, 0, 500);
               m_fdTrec -> Add(m_hTrecCosm[lay][iud]);
          }
     }

     for(lay=0; lay<MdcCalNLayer; lay++){
          for(lr=0; lr<MdcCalLR; lr++){
               for(bin=0; bin<m_nzbin; bin++){
                    if(0 == lr) sprintf(hname, "Trec%02d_z%02d_L", lay, bin);
                    else if(1 == lr) sprintf(hname, "Trec%02d_z%02d_R", lay, bin);
                    else sprintf(hname, "Trec%02d_z%02d_C", lay, bin);

                    if(lay < 8) m_hTrecZ[lay][lr][bin] = new TH1F(hname, "", 100, 0, 400);
                    else m_hTrecZ[lay][lr][bin] = new TH1F(hname, "", 125, 0, 500);
                    m_fdTrecZ -> Add(m_hTrecZ[lay][lr][bin]);
               }
          }
     }

     double zeast;
     double zwest;
     for(lay=0; lay<MdcCalNLayer; lay++){
          zwest = m_mdcGeomSvc->Wire(lay, 0)->Forward().z();
          zeast = m_mdcGeomSvc->Wire(lay, 0)->Backward().z();
          m_zwid[lay] = (zeast - zwest) / (double)m_nzbin;

          if(lay < 8) m_vp[lay] = 220.0; // *10^9 mm/s
          else m_vp[lay] = 240.0; // *10^9 mm/s

          if( 0 == (lay % 2) ){ // west end
               m_zst[lay] = zwest;
          } else{               // east end
               m_zst[lay] = zeast;
          }
     }
}

void PreT0MdcCalib::setParam

(

MdcCalParams &

param

)

[inline, virtual]

Implements MdcCalib.

Definition at line 51 of file PreT0MdcCalib.h.

References m_param, and MdcCalib::setParam().

                                                      {
     MdcCalib::setParam(param);
     m_param = param;
}

int PreT0MdcCalib::updateConst

(

MdcCalibConst *

calconst

)

[virtual]

Implements MdcCalib.

Definition at line 228 of file PreT0MdcCalib.cxx.

References Bes_Common::DEBUG, MdcCalParams::fgCalib, funTmax(), funTmin(), MdcCalibConst::getT0(), MdcCalibConst::getXtpar(), genRecEmupikp::i, MdcGeoWire::Id(), MdcCalParams::initT0, MdcCalParams::initTm, m_hTrec, m_hTrecCosm, m_mdcGeomSvc, m_param, MdcCalLR, MdcCalNLayer, msgSvc(), SetOptFit(), MdcCalParams::t0Shift, MdcCalParams::timeShift, MdcCalParams::tmaxFitChindf, MdcCalParams::tmaxFitRange, MdcCalParams::tminFitChindf, MdcCalParams::tminFitRange, and IMdcGeomSvc::Wire().

                                                     {
     IMessageSvc* msgSvc;
     Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
     MsgStream log(msgSvc, "PreT0MdcCalib");
     log << MSG::DEBUG << "PreT0MdcCalib::updateConst()" << endreq;

//      MdcCalib::updateConst(calconst);

     // fit Tmin
     int lay;
     int wir;
     int lr;
     double t0Fit[MdcCalNLayer][MdcCalLR];
     double t0Cal[MdcCalNLayer][MdcCalLR];
     double tmax[MdcCalNLayer][MdcCalLR];
     double initT0 = m_param.initT0;

     int fitTminFg[MdcCalNLayer][MdcCalLR];
     int fitTmaxFg[MdcCalNLayer][MdcCalLR];
     double chisq;
     double ndf;
     double chindfTmin[MdcCalNLayer][MdcCalLR];
     double chindfTmax[MdcCalNLayer][MdcCalLR];
     char funname[200];

     // add for cosmic-ray
     TF1* ftminCosm[MdcCalNLayer][2];
     double t0FitCosm[MdcCalNLayer][2];

     TF1* ftmin[MdcCalNLayer][MdcCalLR];
//      sprintf(funname, "ftmin");
//      TF1* ftmin = new TF1(funname, funTmin, 0, 150, 6);
     for(lay=0; lay<MdcCalNLayer; lay++){
          for(lr=0; lr<MdcCalLR; lr++){
               fitTminFg[lay][lr] = 0;
               chindfTmin[lay][lr] = -1;
               sprintf(funname, "ftmin%02d_%d", lay, lr);
               ftmin[lay][lr] = new TF1(funname, funTmin, 0, 150, 6);

               if(1 == m_param.fgCalib[lay]){
                    Stat_t nEntryTot = 0;
                    for(int ibin=1; ibin<=25; ibin++){
                         Stat_t entry = m_hTrec[lay][lr]->GetBinContent(ibin);
                         nEntryTot += entry;
                    }
                    double c0Ini = (double)nEntryTot / 25.0;
                    double c1Ini = (m_hTrec[lay][lr]->GetMaximum()) - c0Ini;

                    ftmin[lay][lr] -> SetParameter(0, c0Ini);
                    ftmin[lay][lr] -> SetParameter(1, c1Ini);
                    ftmin[lay][lr] -> SetParameter(2, 0);
                    ftmin[lay][lr] -> SetParameter(4, initT0);
                    ftmin[lay][lr] -> SetParameter(5, 2);

                    m_hTrec[lay][lr] -> Fit(funname, "Q", "",
                                            m_param.tminFitRange[lay][0],
                                            m_param.tminFitRange[lay][1]);
                    gStyle -> SetOptFit(11);
//                  chisq = ftmin[lay][lr]->GetChisquare();
//                  ndf = ftmin[lay][lr]->GetNDF();
                    chisq = ftmin[lay][lr]->GetChisquare();
                    ndf = ftmin[lay][lr]->GetNDF();
                    chindfTmin[lay][lr] = chisq / ndf;

                    if(chindfTmin[lay][lr] < m_param.tminFitChindf){
                         fitTminFg[lay][lr] = 1;
                         t0Fit[lay][lr] = ftmin[lay][lr]->GetParameter(4);
//                       t0Fit[lay][lr] = ftmin->GetParameter(4);
                         t0Fit[lay][lr] += m_param.t0Shift;
                         t0Cal[lay][lr] = t0Fit[lay][lr] - m_param.timeShift;
                    }
               }

               if(0 == fitTminFg[lay][lr]){
                    wir = m_mdcGeomSvc->Wire(lay, 0)->Id();
                    t0Cal[lay][lr] = calconst->getT0(wir);
                    t0Fit[lay][lr] = t0Cal[lay][lr] + m_param.timeShift;
               }
          }

          for(int iud=0; iud<2; iud++){
               sprintf(funname, "ftminCosm_%02d_%d", lay, iud);
               ftminCosm[lay][iud] = new TF1(funname, funTmin, 0, 150, 6);
               ftminCosm[lay][iud] -> SetParameter(0, 0);
               ftminCosm[lay][iud] -> SetParameter(4, initT0);
               ftminCosm[lay][iud] -> SetParameter(5, 1);
               m_hTrecCosm[lay][iud] -> Fit(funname, "Q", "",
                                            m_param.tminFitRange[lay][0],
                                            m_param.tminFitRange[lay][1]);
               gStyle -> SetOptFit(11);
               t0FitCosm[lay][iud] += m_param.t0Shift;
               t0FitCosm[lay][iud] = ftminCosm[lay][iud]->GetParameter(4);
          }
     }

     // fit Tmax
     TF1* ftmax[MdcCalNLayer][MdcCalLR];
     for(lay=0; lay<MdcCalNLayer; lay++){
          for(lr=0; lr<MdcCalLR; lr++){
               fitTmaxFg[lay][lr] = 0;
               chindfTmax[lay][lr] = -1;
               sprintf(funname, "ftmax%02d_%d", lay, lr);
               ftmax[lay][lr] = new TF1(funname, funTmax, 250, 500, 4);

               if(1 == m_param.fgCalib[lay]){
                    ftmax[lay][lr] -> SetParameter(2, m_param.initTm[lay]);
                    ftmax[lay][lr] -> SetParameter(3, 10);
                    m_hTrec[lay][lr] -> Fit(funname, "Q+", "",
                                            m_param.tmaxFitRange[lay][0],
                                            m_param.tmaxFitRange[lay][1]);
                    gStyle -> SetOptFit(11);
                    chisq = ftmax[lay][lr]->GetChisquare();
                    ndf = ftmax[lay][lr]->GetNDF();
                    chindfTmax[lay][lr] = chisq / ndf;
                    if(chindfTmax[lay][lr] < m_param.tmaxFitChindf){
                         fitTmaxFg[lay][lr] = 1;
                         tmax[lay][lr] = ftmax[lay][lr]->GetParameter(2);
                    }
               }

               if(0 == fitTmaxFg[lay][lr]){
                    tmax[lay][lr] = (calconst->getXtpar(lay, 0, lr, 6)) + t0Fit[lay][2];
               }
          }
     }

     // output for check
     ofstream ft0("preT0.dat");
     for(lay=0; lay<MdcCalNLayer; lay++){
          ft0 << setw(5) << lay << setw(3) << fitTminFg[lay][2]
              << setw(15) << t0Cal[lay][2] << setw(15) << t0Fit[lay][2]
              << setw(15) << chindfTmin[lay][2] << endl;
     }
     ft0 << endl;
     for(lay=0; lay<MdcCalNLayer; lay++){
          ft0 << setw(5) << lay
              << setw(3) << fitTmaxFg[lay][0] << setw(10) << tmax[lay][0]
              << setw(10) << chindfTmax[lay][0]
              << setw(3) << fitTmaxFg[lay][1] << setw(10) << tmax[lay][1]
              << setw(10) << chindfTmax[lay][1]
              << setw(3) << fitTmaxFg[lay][2] << setw(10) << tmax[lay][2]
              << setw(10) << chindfTmax[lay][2]
              << setw(10) << tmax[lay][0] - t0Fit[lay][2]
              << setw(10) << tmax[lay][1] - t0Fit[lay][2]
              << setw(10) << tmax[lay][2] - t0Fit[lay][2]
              << endl;
     }
     ft0.close();
     cout << "preT0.dat was written." << endl;

     // output for cosmic T0
     ofstream ft0cosm("cosmicT0.dat");
     for(lay=0; lay<MdcCalNLayer; lay++){
          ft0cosm << setw(5) << lay << setw(15) << t0Fit[lay][2]
                  << setw(15) << t0FitCosm[lay][0] << setw(15) << t0FitCosm[lay][1] << endl;
     }
     ft0cosm.close();

     // set T0
     int i;
     int nwire = m_mdcGeomSvc -> getWireSize();
     for(i=0; i<nwire; i++){
          lay = m_mdcGeomSvc -> Wire(i) -> Layer();
          if(1 == m_param.fgCalib[lay]){
               calconst -> resetT0(i, t0Cal[lay][2]);
               calconst -> resetDelT0(i, 0.0);
          }
     }

     // set tm of X-T
     if(m_param.preT0SetTm){
          int iEntr;
          double tm;
          for(lay=0; lay<MdcCalNLayer; lay++){
               if(1 != m_param.fgCalib[lay]) continue;

               for(iEntr=0; iEntr<MdcCalNENTRXT; iEntr++){
                    for(lr=0; lr<MdcCalLR; lr++){
                         tm = tmax[lay][lr] - t0Fit[lay][2];
                         if( (tmax[lay][lr] > m_param.tmaxFitRange[lay][0]) &&
                             (tmax[lay][lr] < m_param.tmaxFitRange[lay][1]) ){
                              calconst -> resetXtpar(lay, iEntr, lr, 6, tm);
                         }
                    }
               }
          }
     }

     // set sigma
     int bin;
     double sdpar = m_param.initSigma;  // mm
     for(lay=0; lay<MdcCalNLayer; lay++){
          for(int iEntr=0; iEntr<MdcCalNENTRSD; iEntr++){
               for(lr=0; lr<2; lr++){
                    for(bin=0; bin<MdcCalSdNBIN; bin++){
                         calconst -> resetSdpar(lay, iEntr, lr, bin, sdpar);
                    }
               }
          }
     }

//      delete ftmin;
     for(lay=0; lay<MdcCalNLayer; lay++){
          for(lr=0; lr<MdcCalLR; lr++){     
               delete ftmin[lay][lr];
               delete ftmax[lay][lr];
          }
     }
     return 1;
}

static Double_t PreT0MdcCalib::xtfun	(	Double_t *	x,
		Double_t *	par
	)			[static, private]

---

Member Data Documentation

TFolder* PreT0MdcCalib::m_fdTrec [private]

Definition at line 44 of file PreT0MdcCalib.h.

Referenced by clear(), and initialize().

TFolder* PreT0MdcCalib::m_fdTrecZ [private]

Definition at line 45 of file PreT0MdcCalib.h.

Referenced by clear(), and initialize().

TObjArray* PreT0MdcCalib::m_hlist [private]

Reimplemented from MdcCalib.

Definition at line 34 of file PreT0MdcCalib.h.

Referenced by initialize().

TH1F* PreT0MdcCalib::m_hTrec[MdcCalNLayer][MdcCalLR] [private]

Definition at line 46 of file PreT0MdcCalib.h.

Referenced by clear(), fillHist(), initialize(), and updateConst().

TH1F* PreT0MdcCalib::m_hTrecCosm[MdcCalNLayer][2] [private]

Definition at line 47 of file PreT0MdcCalib.h.

Referenced by clear(), fillHist(), initialize(), and updateConst().

TH1F* PreT0MdcCalib::m_hTrecZ[MdcCalNLayer][MdcCalLR][11] [private]

Definition at line 48 of file PreT0MdcCalib.h.

Referenced by clear(), fillHist(), and initialize().

IMdcCalibFunSvc* PreT0MdcCalib::m_mdcFunSvc [private]

Reimplemented from MdcCalib.

Definition at line 36 of file PreT0MdcCalib.h.

Referenced by fillHist(), and initialize().

IMdcGeomSvc* PreT0MdcCalib::m_mdcGeomSvc [private]

Reimplemented from MdcCalib.

Definition at line 35 of file PreT0MdcCalib.h.

Referenced by fillHist(), initialize(), and updateConst().

IMdcUtilitySvc* PreT0MdcCalib::m_mdcUtilitySvc [private]

Reimplemented from MdcCalib.

Definition at line 37 of file PreT0MdcCalib.h.

Referenced by initialize().

int PreT0MdcCalib::m_nzbin [private]

Definition at line 39 of file PreT0MdcCalib.h.

Referenced by clear(), fillHist(), initialize(), and PreT0MdcCalib().

MdcCalParams PreT0MdcCalib::m_param [private]

Reimplemented from MdcCalib.

Definition at line 32 of file PreT0MdcCalib.h.

Referenced by fillHist(), setParam(), and updateConst().

double PreT0MdcCalib::m_vp[MdcCalNLayer] [private]

Definition at line 42 of file PreT0MdcCalib.h.

Referenced by fillHist(), and initialize().

double PreT0MdcCalib::m_zst[MdcCalNLayer] [private]

Definition at line 41 of file PreT0MdcCalib.h.

Referenced by fillHist(), and initialize().

double PreT0MdcCalib::m_zwid[MdcCalNLayer] [private]

Definition at line 40 of file PreT0MdcCalib.h.

Referenced by fillHist(), and initialize().

---