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

PreT0MdcCalib Class Reference

#include <PreT0MdcCalib.h>

Inheritance diagram for PreT0MdcCalib:

MdcCalib MdcCalib List of all members.

Public Member Functions

void clear ()
void clear ()
int fillHist (MdcCalEvent *event)
int fillHist (MdcCalEvent *event)
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)
 PreT0MdcCalib ()
 PreT0MdcCalib ()
virtual void read_file (std::vector< std::string > path)
virtual void read_file (std::vector< std::string > path)
void setParam (MdcCalParams &param)
void setParam (MdcCalParams &param)
virtual void settuple (std::string path)
virtual void settuple (std::string path)
int updateConst (MdcCalibConst *calconst)
int updateConst (MdcCalibConst *calconst)
 ~PreT0MdcCalib ()
 ~PreT0MdcCalib ()

Static Private Member Functions

Double_t funTmax (Double_t *x, Double_t *par)
Double_t funTmax (Double_t *x, Double_t *par)
Double_t funTmin (Double_t *x, Double_t *par)
Double_t funTmin (Double_t *x, Double_t *par)
Double_t xtfun (Double_t *x, Double_t *par)
Double_t xtfun (Double_t *x, Double_t *par)

Private Attributes

TFolder * m_fdTrec
TFolder * m_fdTrec
TFolder * m_fdTrecZ
TFolder * m_fdTrecZ
TObjArray * m_hlist
TObjArray * m_hlist
TH1F * m_hTrec [MdcCalNLayer][MdcCalLR]
TH1F * m_hTrec [MdcCalNLayer][MdcCalLR]
TH1F * m_hTrecCosm [MdcCalNLayer][2]
TH1F * m_hTrecCosm [MdcCalNLayer][2]
TH1F * m_hTrecZ [MdcCalNLayer][MdcCalLR][11]
TH1F * m_hTrecZ [MdcCalNLayer][MdcCalLR][11]
IMdcCalibFunSvcm_mdcFunSvc
IMdcCalibFunSvcm_mdcFunSvc
IMdcGeomSvcm_mdcGeomSvc
IMdcGeomSvcm_mdcGeomSvc
int m_nzbin
MdcCalParams m_param
double m_vp [MdcCalNLayer]
double m_zst [MdcCalNLayer]
double m_zwid [MdcCalNLayer]

Constructor & Destructor Documentation

PreT0MdcCalib::PreT0MdcCalib  ) 
 

00031                             {
00032      m_nzbin = 11;
00033 }

PreT0MdcCalib::~PreT0MdcCalib  ) 
 

00035                              {
00036 }

PreT0MdcCalib::PreT0MdcCalib  ) 
 

PreT0MdcCalib::~PreT0MdcCalib  ) 
 


Member Function Documentation

void PreT0MdcCalib::clear  )  [virtual]
 

Implements MdcCalib.

void PreT0MdcCalib::clear  )  [virtual]
 

Implements MdcCalib.

00038                          {
00039      int lay;
00040      int lr;
00041      int bin;
00042      for(lay=0; lay<MdcCalNLayer; lay++){
00043           for(lr=0; lr<MdcCalLR; lr++){
00044                delete m_hTrec[lay][lr];
00045                for(bin=0; bin<m_nzbin; bin++){
00046                     delete m_hTrecZ[lay][lr][bin];
00047                }
00048           }
00049      }
00050      for(lay=0; lay<MdcCalNLayer; lay++){
00051           for(bin=0; bin<2; bin++) delete m_hTrecCosm[lay][bin];
00052      }
00053      delete m_fdTrec;
00054      delete m_fdTrecZ;
00055 
00056      MdcCalib::clear();
00057 }

int PreT0MdcCalib::fillHist MdcCalEvent event  )  [virtual]
 

Implements MdcCalib.

int PreT0MdcCalib::fillHist MdcCalEvent event  )  [virtual]
 

Implements MdcCalib.

00137                                              {
00138      IMessageSvc* msgSvc;
00139      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00140      MsgStream log(msgSvc, "PreT0MdcCalib");
00141      log << MSG::DEBUG << "PreT0MdcCalib::fillHist()" << endreq;
00142 
00143 //      MdcCalib::fillHist(event);
00144 
00145      int i;
00146      int k;
00147      int lay;
00148      int cel;
00149      int lr;
00150      int bin;
00151 
00152      double tdc;
00153      double traw;
00154      double trec;
00155      double tdr;
00156      double t0;
00157      double tp = 0.0;
00158      double tof = 0.0;
00159      double zhit;
00160      double zprop;
00161 
00162      MdcCalRecTrk* rectrk;
00163      MdcCalRecHit* rechit;
00164 
00165      IDataProviderSvc* eventSvc = NULL;
00166      Gaudi::svcLocator()->service("EventDataSvc", eventSvc);
00167 
00168      // get EsTimeCol
00169      double tes = event->getTes();
00170      bool esCutFg = event->getEsCutFlag();
00171      if( ! esCutFg ) return -1;
00172 
00173      int nhit;
00174      int ntrk = event -> getNTrk();
00175      for(i=0; i<ntrk; i++){
00176           rectrk = event->getRecTrk(i);
00177           nhit = rectrk -> getNHits();
00178           for(k=0; k<nhit; k++){
00179                rechit = rectrk -> getRecHit(k);
00180                lay = rechit -> getLayid();
00181                cel = rechit -> getCellid();
00182                lr = rechit -> getLR();
00183                zhit = rechit -> getZhit();
00184                tdc = rechit -> getTdc();
00185                tdr = rechit -> getTdrift();
00186 
00187                traw = tdc * MdcCalTdcCnv;
00188 //             traw = tdc;      // ns
00189 
00190                zprop = fabs(zhit - m_zst[lay]);
00191                bin = (int)(zprop / m_zwid[lay]);
00192                tp = zprop / m_vp[lay];
00193                t0 = m_mdcFunSvc -> getT0(lay, cel);
00194                tof = rechit -> getTof();
00195 
00196                const MdcGeoWire* pWire = m_mdcGeomSvc -> Wire(lay, cel);
00197                double y1 = pWire -> Backward().y();
00198                double y2 = pWire -> Forward().y();
00199                double ymid = (y1+y2)*0.5;
00200                if(5==m_param.particle){ // cosmic-ray
00201                     if(ymid > 0) trec = traw - tp + tof - tes + m_param.timeShift;
00202                     else trec = traw - tp - tof - tes + m_param.timeShift;
00203                } else{
00204                     trec = traw - tp - tof - tes + m_param.timeShift;
00205                }
00206 
00207                m_hTrec[lay][lr] -> Fill(trec);
00208                m_hTrec[lay][2] -> Fill(trec); // l-r in common
00209                if(ymid > 0) m_hTrecCosm[lay][0] -> Fill(trec);
00210                else m_hTrecCosm[lay][1] -> Fill(trec);
00211 
00212                if(bin < m_nzbin){
00213                     m_hTrecZ[lay][lr][bin] -> Fill(trec);
00214                     m_hTrecZ[lay][2][bin] -> Fill(trec);
00215                }
00216           }
00217      }
00218      return 1;
00219 }

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

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

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

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

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

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

void PreT0MdcCalib::initialize TObjArray *  hlist,
IMdcGeomSvc mdcGeomSvc,
IMdcCalibFunSvc mdcFunSvc
[virtual]
 

Implements MdcCalib.

void PreT0MdcCalib::initialize TObjArray *  hlist,
IMdcGeomSvc mdcGeomSvc,
IMdcCalibFunSvc mdcFunSvc
[virtual]
 

Implements MdcCalib.

00060                                                            {
00061      IMessageSvc* msgSvc;
00062      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00063      MsgStream log(msgSvc, "PreT0MdcCalib");
00064      log << MSG::INFO << "PreT0MdcCalib::initialize()" << endreq;
00065 
00066      m_hlist = hlist;
00067      m_mdcGeomSvc = mdcGeomSvc;
00068      m_mdcFunSvc = mdcFunSvc;
00069 
00070 //      MdcCalib::initialize(m_hlist, m_mdcGeomSvc, m_mdcFunSvc);
00071 
00072      int lay;
00073      int lr;
00074      int bin;
00075      char hname[200];
00076 
00077      m_fdTrec = new TFolder("Trec", "Trec");
00078      m_hlist->Add(m_fdTrec);
00079 
00080      m_fdTrecZ = new TFolder("TrecZ", "TrecZ");
00081      m_hlist->Add(m_fdTrecZ);
00082 
00083      for(lay=0; lay<MdcCalNLayer; lay++){
00084           for(lr=0; lr<MdcCalLR; lr++){
00085                if(0 == lr) sprintf(hname, "Trec%02d_L", lay);
00086                else if(1 == lr) sprintf(hname, "Trec%02d_R", lay);
00087                else sprintf(hname, "Trec%02d_C", lay);
00088 
00089                if(lay < 8) m_hTrec[lay][lr] = new TH1F(hname, "", 100, 0, 400);
00090                else m_hTrec[lay][lr] = new TH1F(hname, "", 125, 0, 500);
00091                m_fdTrec -> Add(m_hTrec[lay][lr]);
00092           }
00093      }
00094 
00095      for(lay=0; lay<MdcCalNLayer; lay++){
00096           for(int iud=0; iud<2; iud++){
00097                if(0 == iud) sprintf(hname, "TrecCosm%02d_Up", lay);
00098                else sprintf(hname, "TrecCosm%02d_Dw", lay);
00099                if(lay < 8) m_hTrecCosm[lay][iud] = new TH1F(hname, "", 100, 0, 400);
00100                else m_hTrecCosm[lay][iud] = new TH1F(hname, "", 125, 0, 500);
00101                m_fdTrec -> Add(m_hTrecCosm[lay][iud]);
00102           }
00103      }
00104 
00105      for(lay=0; lay<MdcCalNLayer; lay++){
00106           for(lr=0; lr<MdcCalLR; lr++){
00107                for(bin=0; bin<m_nzbin; bin++){
00108                     if(0 == lr) sprintf(hname, "Trec%02d_z%02d_L", lay, bin);
00109                     else if(1 == lr) sprintf(hname, "Trec%02d_z%02d_R", lay, bin);
00110                     else sprintf(hname, "Trec%02d_z%02d_C", lay, bin);
00111 
00112                     if(lay < 8) m_hTrecZ[lay][lr][bin] = new TH1F(hname, "", 100, 0, 400);
00113                     else m_hTrecZ[lay][lr][bin] = new TH1F(hname, "", 125, 0, 500);
00114                     m_fdTrecZ -> Add(m_hTrecZ[lay][lr][bin]);
00115                }
00116           }
00117      }
00118 
00119      double zeast;
00120      double zwest;
00121      for(lay=0; lay<MdcCalNLayer; lay++){
00122           zwest = m_mdcGeomSvc->Wire(lay, 0)->Forward().z();
00123           zeast = m_mdcGeomSvc->Wire(lay, 0)->Backward().z();
00124           m_zwid[lay] = (zeast - zwest) / (double)m_nzbin;
00125 
00126           if(lay < 8) m_vp[lay] = 220.0; // *10^9 mm/s
00127           else m_vp[lay] = 240.0; // *10^9 mm/s
00128 
00129           if( 0 == (lay % 2) ){ // west end
00130                m_zst[lay] = zwest;
00131           } else{               // east end
00132                m_zst[lay] = zeast;
00133           }
00134      }
00135 }

virtual void PreT0MdcCalib::read_file std::vector< std::string >  path  )  [virtual]
 

Reimplemented from MdcCalib.

void PreT0MdcCalib::read_file std::vector< std::string >  path  )  [virtual]
 

Reimplemented from MdcCalib.

00477                                                        {
00478      MdcCalib::read_file(path);
00479 }

void PreT0MdcCalib::setParam MdcCalParams param  )  [virtual]
 

Implements MdcCalib.

void PreT0MdcCalib::setParam MdcCalParams param  )  [inline, virtual]
 

Implements MdcCalib.

00054                                                       {
00055      MdcCalib::setParam(param);
00056      m_param = param;
00057 }

virtual void PreT0MdcCalib::settuple std::string  path  )  [virtual]
 

Reimplemented from MdcCalib.

void PreT0MdcCalib::settuple std::string  path  )  [virtual]
 

Reimplemented from MdcCalib.

00415                                           {  
00416      MdcCalib::settuple(path);
00417      TFile *f1 = new TFile(path.c_str());
00418      std::cout<<path<<std::endl;
00419      //
00420      //  m_mdcGeomSvc = mdcGeomSvc;
00421      //m_mdcFunSvc = mdcFunSvc;
00422 
00423 //      MdcCalib::initialize(m_hlist, m_mdcGeomSvc, m_mdcFunSvc);
00424 
00425      int lay;
00426      int lr;
00427      int bin;
00428      char hname[200];
00429      
00430      m_fdTrec=(TFolder *)f1->Get("Trec;1");
00431      m_fdTrecZ=(TFolder *)f1->Get("TrecZ;1");
00432      for(lay=0; lay<MdcCalNLayer; lay++){
00433           for(lr=0; lr<MdcCalLR; lr++){
00434                if(0 == lr) sprintf(hname, "Trec%02d_L", lay);
00435                else if(1 == lr) sprintf(hname, "Trec%02d_R", lay);
00436                else sprintf(hname, "Trec%02d_C", lay);
00437                if(lay < 8) m_hTrec[lay][lr]=(TH1F *)m_fdTrec ->FindObject(hname);   
00438                else m_hTrec[lay][lr]=(TH1F *)m_fdTrec ->FindObject(hname);                    
00439           }
00440      }
00441     
00442      for(lay=0; lay<MdcCalNLayer; lay++){
00443           for(lr=0; lr<MdcCalLR; lr++){
00444                for(bin=0; bin<m_nzbin; bin++){
00445                     if(0 == lr) sprintf(hname, "Trec%02d_z%02d_L", lay, bin);
00446                     else if(1 == lr) sprintf(hname, "Trec%02d_z%02d_R", lay, bin);
00447                     else sprintf(hname, "Trec%02d_z%02d_C", lay, bin);
00448           
00449                     if(lay < 8) m_hTrecZ[lay][lr][bin]=(TH1F *)m_fdTrecZ ->FindObject(hname);
00450                     else  m_hTrecZ[lay][lr][bin]=(TH1F *)m_fdTrecZ ->FindObject(hname);  
00451                }
00452           }
00453      }
00454 
00455    
00456      double zeast;
00457      double zwest;
00458      for(lay=0; lay<MdcCalNLayer; lay++){
00459           zwest = m_mdcGeomSvc->Wire(lay, 0)->Forward().z();
00460           zeast = m_mdcGeomSvc->Wire(lay, 0)->Backward().z();
00461           m_zwid[lay] = (zeast - zwest) / (double)m_nzbin;
00462 
00463           if(lay < 8) m_vp[lay] = 220.0; // *10^9 mm/s
00464           else m_vp[lay] = 240.0; // *10^9 mm/s
00465 
00466           if( 0 == (lay % 2) ){ // west end
00467                m_zst[lay] = zwest;
00468           } else{               // east end
00469                m_zst[lay] = zeast;
00470           }
00471      }
00472 
00473 }

int PreT0MdcCalib::updateConst MdcCalibConst calconst  )  [virtual]
 

Implements MdcCalib.

int PreT0MdcCalib::updateConst MdcCalibConst calconst  )  [virtual]
 

Implements MdcCalib.

00221                                                      {
00222      IMessageSvc* msgSvc;
00223      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00224      MsgStream log(msgSvc, "PreT0MdcCalib");
00225      log << MSG::DEBUG << "PreT0MdcCalib::updateConst()" << endreq;
00226 
00227 //      MdcCalib::updateConst(calconst);
00228 
00229      // fit Tmin
00230      int lay;
00231      int wir;
00232      int lr;
00233      double t0Fit[MdcCalNLayer][MdcCalLR];
00234      double t0Cal[MdcCalNLayer][MdcCalLR];
00235      double tmax[MdcCalNLayer][MdcCalLR];
00236      double initT0 = m_param.initT0;
00237 
00238      int fitTminFg[MdcCalNLayer][MdcCalLR];
00239      int fitTmaxFg[MdcCalNLayer][MdcCalLR];
00240      double chisq;
00241      double ndf;
00242      double chindfTmin[MdcCalNLayer][MdcCalLR];
00243      double chindfTmax[MdcCalNLayer][MdcCalLR];
00244      char funname[200];
00245 
00246      // add for cosmic-ray
00247      TF1* ftminCosm[MdcCalNLayer][2];
00248      double t0FitCosm[MdcCalNLayer][2];
00249 
00250      TF1* ftmin[MdcCalNLayer][MdcCalLR];
00251      for(lay=0; lay<MdcCalNLayer; lay++){
00252           for(lr=0; lr<MdcCalLR; lr++){
00253                fitTminFg[lay][lr] = 0;
00254                chindfTmin[lay][lr] = -1;
00255                sprintf(funname, "ftmin%02d_%d", lay, lr);
00256                ftmin[lay][lr] = new TF1(funname, funTmin, 0, 150, 6);
00257 
00258                if(1 == m_param.fgCalib[lay]){
00259                     ftmin[lay][lr] -> SetParameter(0, 0);
00260                     ftmin[lay][lr] -> SetParameter(4, initT0);
00261                     ftmin[lay][lr] -> SetParameter(5, 1);
00262 
00263                     m_hTrec[lay][lr] -> Fit(funname, "Q", "",
00264                                             m_param.tminFitRange[lay][0],
00265                                             m_param.tminFitRange[lay][1]);
00266                     gStyle -> SetOptFit(11);
00267                     chisq = ftmin[lay][lr]->GetChisquare();
00268                     ndf = ftmin[lay][lr]->GetNDF();
00269                     chindfTmin[lay][lr] = chisq / ndf;
00270 
00271                     if(chindfTmin[lay][lr] < m_param.tminFitChindf){
00272                          fitTminFg[lay][lr] = 1;
00273                          t0Fit[lay][lr] = ftmin[lay][lr]->GetParameter(4);
00274                          t0Fit[lay][lr] += m_param.t0Shift;
00275                          t0Cal[lay][lr] = t0Fit[lay][lr] - m_param.timeShift;
00276                     }
00277                }
00278 
00279                if(0 == fitTminFg[lay][lr]){
00280                     wir = m_mdcGeomSvc->Wire(lay, 0)->Id();
00281                     t0Cal[lay][lr] = calconst->getT0(wir);
00282                     t0Fit[lay][lr] = t0Cal[lay][lr] + m_param.timeShift;
00283                }
00284           }
00285 
00286           for(int iud=0; iud<2; iud++){
00287                sprintf(funname, "ftminCosm_%02d_%d", lay, iud);
00288                ftminCosm[lay][iud] = new TF1(funname, funTmin, 0, 150, 6);
00289                ftminCosm[lay][iud] -> SetParameter(0, 0);
00290                ftminCosm[lay][iud] -> SetParameter(4, initT0);
00291                ftminCosm[lay][iud] -> SetParameter(5, 1);
00292                m_hTrecCosm[lay][iud] -> Fit(funname, "Q", "",
00293                                             m_param.tminFitRange[lay][0],
00294                                             m_param.tminFitRange[lay][1]);
00295                gStyle -> SetOptFit(11);
00296                t0FitCosm[lay][iud] += m_param.t0Shift;
00297                t0FitCosm[lay][iud] = ftminCosm[lay][iud]->GetParameter(4);
00298           }
00299      }
00300 
00301      // fit Tmax
00302      TF1* ftmax[MdcCalNLayer][MdcCalLR];
00303      for(lay=0; lay<MdcCalNLayer; lay++){
00304           for(lr=0; lr<MdcCalLR; lr++){
00305                fitTmaxFg[lay][lr] = 0;
00306                chindfTmax[lay][lr] = -1;
00307                sprintf(funname, "ftmax%02d_%d", lay, lr);
00308                ftmax[lay][lr] = new TF1(funname, funTmax, 250, 500, 4);
00309 
00310                if(1 == m_param.fgCalib[lay]){
00311                     ftmax[lay][lr] -> SetParameter(2, m_param.initTm[lay]);
00312                     ftmax[lay][lr] -> SetParameter(3, 10);
00313                     m_hTrec[lay][lr] -> Fit(funname, "Q+", "",
00314                                             m_param.tmaxFitRange[lay][0],
00315                                             m_param.tmaxFitRange[lay][1]);
00316                     gStyle -> SetOptFit(11);
00317                     chisq = ftmax[lay][lr]->GetChisquare();
00318                     ndf = ftmax[lay][lr]->GetNDF();
00319                     chindfTmax[lay][lr] = chisq / ndf;
00320                     if(chindfTmax[lay][lr] < m_param.tmaxFitChindf){
00321                          fitTmaxFg[lay][lr] = 1;
00322                          tmax[lay][lr] = ftmax[lay][lr]->GetParameter(2);
00323                     }
00324                }
00325 
00326                if(0 == fitTmaxFg[lay][lr]){
00327                     tmax[lay][lr] = (calconst->getXtpar(lay, 0, lr, 6)) + t0Fit[lay][2];
00328                }
00329           }
00330      }
00331 
00332      // output for check
00333      ofstream ft0("preT0.dat");
00334      for(lay=0; lay<MdcCalNLayer; lay++){
00335           ft0 << setw(5) << lay << setw(3) << fitTminFg[lay][2]
00336               << setw(15) << t0Cal[lay][2] << setw(15) << t0Fit[lay][2]
00337               << setw(15) << chindfTmin[lay][2] << endl;
00338      }
00339      ft0 << endl;
00340      for(lay=0; lay<MdcCalNLayer; lay++){
00341           ft0 << setw(5) << lay
00342               << setw(3) << fitTmaxFg[lay][0] << setw(10) << tmax[lay][0]
00343               << setw(10) << chindfTmax[lay][0]
00344               << setw(3) << fitTmaxFg[lay][1] << setw(10) << tmax[lay][1]
00345               << setw(10) << chindfTmax[lay][1]
00346               << setw(3) << fitTmaxFg[lay][2] << setw(10) << tmax[lay][2]
00347               << setw(10) << chindfTmax[lay][2]
00348               << setw(10) << tmax[lay][0] - t0Fit[lay][2]
00349               << setw(10) << tmax[lay][1] - t0Fit[lay][2]
00350               << setw(10) << tmax[lay][2] - t0Fit[lay][2]
00351               << endl;
00352      }
00353      ft0.close();
00354      cout << "preT0.dat was written." << endl;
00355 
00356      // output for cosmic T0
00357      ofstream ft0cosm("cosmicT0.dat");
00358      for(lay=0; lay<MdcCalNLayer; lay++){
00359           ft0cosm << setw(5) << lay << setw(15) << t0Fit[lay][2]
00360                   << setw(15) << t0FitCosm[lay][0] << setw(15) << t0FitCosm[lay][1] << endl;
00361      }
00362      ft0cosm.close();
00363 
00364      // set T0
00365      int i;
00366      int nwire = m_mdcGeomSvc -> getWireSize();
00367      for(i=0; i<nwire; i++){
00368           lay = m_mdcGeomSvc -> Wire(i) -> Layer();
00369           if(1 == m_param.fgCalib[lay]){
00370                calconst -> resetT0(i, t0Cal[lay][2]);
00371                calconst -> resetDelT0(i, 0.0);
00372           }
00373      }
00374 
00375      // set tm of X-T
00376      if(m_param.preT0SetTm){
00377           int iEntr;
00378           double tm;
00379           for(lay=0; lay<MdcCalNLayer; lay++){
00380                if(1 != m_param.fgCalib[lay]) continue;
00381 
00382                for(iEntr=0; iEntr<MdcCalNENTRXT; iEntr++){
00383                     for(lr=0; lr<MdcCalLR; lr++){
00384                          tm = tmax[lay][lr] - t0Fit[lay][2];
00385                          if( (tmax[lay][lr] > m_param.tmaxFitRange[lay][0]) &&
00386                              (tmax[lay][lr] < m_param.tmaxFitRange[lay][1]) ){
00387                               calconst -> resetXtpar(lay, iEntr, lr, 6, tm);
00388                          }
00389                     }
00390                }
00391           }
00392      }
00393 
00394      for(lay=0; lay<MdcCalNLayer; lay++){
00395           for(lr=0; lr<MdcCalLR; lr++){     
00396                delete ftmin[lay][lr];
00397                delete ftmax[lay][lr];
00398           }
00399      }
00400      return 1;
00401 }

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

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


Member Data Documentation

TFolder* PreT0MdcCalib::m_fdTrec [private]
 

TFolder* PreT0MdcCalib::m_fdTrec [private]
 

TFolder* PreT0MdcCalib::m_fdTrecZ [private]
 

TFolder* PreT0MdcCalib::m_fdTrecZ [private]
 

TObjArray* PreT0MdcCalib::m_hlist [private]
 

Reimplemented from MdcCalib.

TObjArray* PreT0MdcCalib::m_hlist [private]
 

Reimplemented from MdcCalib.

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

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

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

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

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

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

IMdcCalibFunSvc* PreT0MdcCalib::m_mdcFunSvc [private]
 

Reimplemented from MdcCalib.

IMdcCalibFunSvc* PreT0MdcCalib::m_mdcFunSvc [private]
 

Reimplemented from MdcCalib.

IMdcGeomSvc* PreT0MdcCalib::m_mdcGeomSvc [private]
 

Reimplemented from MdcCalib.

IMdcGeomSvc* PreT0MdcCalib::m_mdcGeomSvc [private]
 

Reimplemented from MdcCalib.

int PreT0MdcCalib::m_nzbin [private]
 

MdcCalParams PreT0MdcCalib::m_param [private]
 

Reimplemented from MdcCalib.

double PreT0MdcCalib::m_vp [private]
 

double PreT0MdcCalib::m_zst [private]
 

double PreT0MdcCalib::m_zwid [private]
 


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