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

PreT0Calib Class Reference

#include <PreT0Calib.h>

Inheritance diagram for PreT0Calib:

CalibBase List of all members.

Public Member Functions

void calib (MdcCalibConst *calconst)
void init (TObjArray *hlist, MdcCosGeom *pGeom)
void mergeHist (TFile *fhist)
 PreT0Calib ()
 ~PreT0Calib ()

Private Member Functions

void renameHist ()

Static Private Member Functions

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

Private Attributes

TFolder * m_fdTrec
TFolder * m_fdTrecZ
TH1F * m_hTrec [NLAYER][NLR]
TH1F * m_hTrecCosm [NLAYER][2]
TH1F * m_hTrecZ [NLAYER][NLR][11]
int m_nzbin
MdcCosGeom * m_pGeom
double m_vp [NLAYER]
double m_zst [NLAYER]
double m_zwid [NLAYER]

Constructor & Destructor Documentation

PreT0Calib::PreT0Calib (   ) 
  

00007                       {
00008      cout << "Calibration type: PreT0Calib" << endl;
00009      m_nzbin = 11;
00010 }

PreT0Calib::~PreT0Calib (   ) 
  

00012                        {
00013 }

Member Function Documentation

void PreT0Calib::calib (  MdcCalibConst *  calconst  )  [virtual]
 

Implements CalibBase.

00101                                              {
00102      // fit Tmin int lay;
00103      double t0Fit[NLAYER][NLR];
00104      double t0Cal[NLAYER][NLR];
00105      double tmax[NLAYER][NLR];
00106      double initT0 = gInitT0;
00107 
00108      int fitTminFg[NLAYER][NLR];
00109      int fitTmaxFg[NLAYER][NLR];
00110      double chisq;
00111      double ndf;
00112      double chindfTmin[NLAYER][NLR];
00113      double chindfTmax[NLAYER][NLR];
00114      char funname[200];
00115 
00116      // add for cosmic-ray
00117      TF1* ftminCosm[NLAYER][2];
00118      double t0FitCosm[NLAYER][2];
00119 
00120      TF1* ftmin[NLAYER][NLR];
00121      for(int lay=0; lay<NLAYER; lay++){
00122           for(int lr=0; lr<NLR; lr++){
00123                fitTminFg[lay][lr] = 0;
00124                chindfTmin[lay][lr] = -1;
00125                sprintf(funname, "ftmin%02d_%d", lay, lr);
00126                ftmin[lay][lr] = new TF1(funname, funTmin, 0, 150, 6);
00127 
00128                if(1 == gFgCalib[lay]){
00129                     ftmin[lay][lr] -> SetParameter(0, 0);
00130                     ftmin[lay][lr] -> SetParameter(4, initT0);
00131                     ftmin[lay][lr] -> SetParameter(5, 1);
00132 
00133                     m_hTrec[lay][lr] -> Fit(funname, "Q", "", gTminFitRange[lay][0], gTminFitRange[lay][1]);
00134                     gStyle -> SetOptFit(11);
00135                     chisq = ftmin[lay][lr]->GetChisquare();
00136                     ndf = ftmin[lay][lr]->GetNDF();
00137                     chindfTmin[lay][lr] = chisq / ndf;
00138 
00139                     if(chindfTmin[lay][lr] < gTminFitChindf){
00140                          fitTminFg[lay][lr] = 1;
00141                          t0Fit[lay][lr] = ftmin[lay][lr]->GetParameter(4);
00142                          t0Fit[lay][lr] += gT0Shift;
00143                          t0Cal[lay][lr] = t0Fit[lay][lr] - gTimeShift;
00144                     }
00145                }
00146 
00147                if(0 == fitTminFg[lay][lr]){
00148                     int wir = m_pGeom->getWire(lay, 0)->getWireId();
00149                     t0Cal[lay][lr] = calconst->getT0(wir);
00150                     t0Fit[lay][lr] = t0Cal[lay][lr] + gTimeShift;
00151                }
00152           }
00153 
00154           for(int iud=0; iud<2; iud++){
00155                sprintf(funname, "ftminCosm_%02d_%d", lay, iud);
00156                ftminCosm[lay][iud] = new TF1(funname, funTmin, 0, 150, 6);
00157                ftminCosm[lay][iud] -> SetParameter(0, 0);
00158                ftminCosm[lay][iud] -> SetParameter(4, initT0);
00159                ftminCosm[lay][iud] -> SetParameter(5, 1);
00160                m_hTrecCosm[lay][iud] -> Fit(funname, "Q", "", gTminFitRange[lay][0], gTminFitRange[lay][1]);
00161                gStyle -> SetOptFit(11);
00162                t0FitCosm[lay][iud] += gT0Shift;
00163                t0FitCosm[lay][iud] = ftminCosm[lay][iud]->GetParameter(4);
00164           }
00165      }
00166 
00167      // fit Tmax
00168      TF1* ftmax[NLAYER][NLR];
00169      for(int lay=0; lay<NLAYER; lay++){
00170           for(int lr=0; lr<NLR; lr++){
00171                fitTmaxFg[lay][lr] = 0;
00172                chindfTmax[lay][lr] = -1;
00173                sprintf(funname, "ftmax%02d_%d", lay, lr);
00174                ftmax[lay][lr] = new TF1(funname, funTmax, 250, 500, 4);
00175 
00176                if(1 == gFgCalib[lay]){
00177                     ftmax[lay][lr] -> SetParameter(2, gInitTm[lay]);
00178                     ftmax[lay][lr] -> SetParameter(3, 10);
00179                     m_hTrec[lay][lr] -> Fit(funname, "Q+", "", gTmaxFitRange[lay][0], gTmaxFitRange[lay][1]);
00180                     gStyle -> SetOptFit(11);
00181                     chisq = ftmax[lay][lr]->GetChisquare();
00182                     ndf = ftmax[lay][lr]->GetNDF();
00183                     chindfTmax[lay][lr] = chisq / ndf;
00184                     if(chindfTmax[lay][lr] < gTmaxFitChindf){
00185                          fitTmaxFg[lay][lr] = 1;
00186                          tmax[lay][lr] = ftmax[lay][lr]->GetParameter(2);
00187                     }
00188                }
00189 
00190                if(0 == fitTmaxFg[lay][lr]){
00191                     tmax[lay][lr] = (calconst->getXtpar(lay, 0, lr, 6)) + t0Fit[lay][2];
00192                }
00193           }
00194      }
00195 
00196      // output for check
00197      ofstream ft0("preT0.dat");
00198      for(int lay=0; lay<NLAYER; lay++){
00199           ft0 << setw(5) << lay << setw(3) << fitTminFg[lay][2]
00200               << setw(15) << t0Cal[lay][2] << setw(15) << t0Fit[lay][2]
00201               << setw(15) << chindfTmin[lay][2] << endl;
00202      }
00203      ft0 << endl;
00204      for(int lay=0; lay<NLAYER; lay++){
00205           ft0 << setw(5) << lay
00206               << setw(3) << fitTmaxFg[lay][0] << setw(10) << tmax[lay][0]
00207               << setw(10) << chindfTmax[lay][0]
00208               << setw(3) << fitTmaxFg[lay][1] << setw(10) << tmax[lay][1]
00209               << setw(10) << chindfTmax[lay][1]
00210               << setw(3) << fitTmaxFg[lay][2] << setw(10) << tmax[lay][2]
00211               << setw(10) << chindfTmax[lay][2]
00212               << setw(10) << tmax[lay][0] - t0Fit[lay][2]
00213               << setw(10) << tmax[lay][1] - t0Fit[lay][2]
00214               << setw(10) << tmax[lay][2] - t0Fit[lay][2]
00215               << endl;
00216      }
00217      ft0.close();
00218      cout << "preT0.dat was written." << endl;
00219 
00220      // output for cosmic T0
00221      ofstream ft0cosm("cosmicT0.dat");
00222      for(int lay=0; lay<NLAYER; lay++){
00223           ft0cosm << setw(5) << lay << setw(15) << t0Fit[lay][2]
00224                   << setw(15) << t0FitCosm[lay][0] << setw(15) << t0FitCosm[lay][1] << endl;
00225      }
00226      ft0cosm.close();
00227 
00228      // set T0
00229      for(int i=0; i<NWIRE; i++){
00230           int lay = m_pGeom -> getWire(i) -> getLayerId();
00231           if(1 == gFgCalib[lay]){
00232                calconst -> resetT0(i, t0Cal[lay][2]);
00233                calconst -> resetDelT0(i, 0.0);
00234           }
00235      }
00236 
00237      // set tm of X-T
00238      if(gPreT0SetTm){
00239           double tm;
00240           for(int lay=0; lay<NLAYER; lay++){
00241                if(1 != gFgCalib[lay]) continue;
00242 
00243                for(int iEntr=0; iEntr<NENTRXT; iEntr++){
00244                     for(int lr=0; lr<NLR; lr++){
00245                          tm = tmax[lay][lr] - t0Fit[lay][2];
00246                          if( (tmax[lay][lr] > gTmaxFitRange[lay][0]) &&
00247                              (tmax[lay][lr] < gTmaxFitRange[lay][1]) ){
00248                               calconst -> resetXtpar(lay, iEntr, lr, 6, tm);
00249                          }
00250                     }
00251                }
00252           }
00253      }
00254 
00255      renameHist();
00256      for(int lay=0; lay<NLAYER; lay++){
00257           for(int lr=0; lr<NLR; lr++){     
00258                delete ftmin[lay][lr];
00259                delete ftmax[lay][lr];
00260           }
00261      }
00262 }

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

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

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

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

void PreT0Calib::init (  TObjArray *  hlist,
MdcCosGeom *  pGeom
)  [virtual]
 

Implements CalibBase.

00015                                                         {
00016      m_pGeom = pGeom;
00017      char hname[200];
00018 
00019      m_fdTrec = new TFolder("mTrec", "Trec");
00020      hlist->Add(m_fdTrec);
00021 
00022      m_fdTrecZ = new TFolder("mTrecZ", "TrecZ");
00023      hlist->Add(m_fdTrecZ);
00024 
00025      for(int lay=0; lay<NLAYER; lay++){
00026           for(int lr=0; lr<NLR; lr++){
00027                if(0 == lr) sprintf(hname, "mTrec%02d_L", lay);
00028                else if(1 == lr) sprintf(hname, "mTrec%02d_R", lay);
00029                else sprintf(hname, "mTrec%02d_C", lay);
00030 
00031                if(lay < 8) m_hTrec[lay][lr] = new TH1F(hname, "", 100, 0, 400);
00032                else m_hTrec[lay][lr] = new TH1F(hname, "", 125, 0, 500);
00033                m_fdTrec -> Add(m_hTrec[lay][lr]);
00034           }
00035      }
00036 
00037      for(int lay=0; lay<NLAYER; lay++){
00038           for(int iud=0; iud<2; iud++){
00039                if(0 == iud) sprintf(hname, "mTrecCosm%02d_Up", lay);
00040                else sprintf(hname, "mTrecCosm%02d_Dw", lay);
00041                if(lay < 8) m_hTrecCosm[lay][iud] = new TH1F(hname, "", 100, 0, 400);
00042                else m_hTrecCosm[lay][iud] = new TH1F(hname, "", 125, 0, 500);
00043                m_fdTrec -> Add(m_hTrecCosm[lay][iud]);
00044           }
00045      }
00046 
00047      for(int lay=0; lay<NLAYER; lay++){
00048           for(int lr=0; lr<NLR; lr++){
00049                for(int bin=0; bin<m_nzbin; bin++){
00050                     if(0 == lr) sprintf(hname, "mTrec%02d_z%02d_L", lay, bin);
00051                     else if(1 == lr) sprintf(hname, "mTrec%02d_z%02d_R", lay, bin);
00052                     else sprintf(hname, "mTrec%02d_z%02d_C", lay, bin);
00053 
00054                     if(lay < 8) m_hTrecZ[lay][lr][bin] = new TH1F(hname, "", 100, 0, 400);
00055                     else m_hTrecZ[lay][lr][bin] = new TH1F(hname, "", 125, 0, 500);
00056                     m_fdTrecZ -> Add(m_hTrecZ[lay][lr][bin]);
00057                }
00058           }
00059      }
00060 
00061 }

void PreT0Calib::mergeHist (  TFile *  fhist  )  [virtual]
 

Implements CalibBase.

00063                                       {
00064      char hname[200];
00065      TFolder* fdTrec = (TFolder*)fhist->Get("Trec");
00066      TFolder* fdTrecZ = (TFolder*)fhist->Get("TrecZ");
00067 
00068      TH1F* hist;
00069      for(int lay=0; lay<NLAYER; lay++){
00070           for(int lr=0; lr<NLR; lr++){
00071                if(0 == lr) sprintf(hname, "Trec%02d_L", lay);
00072                else if(1 == lr) sprintf(hname, "Trec%02d_R", lay);
00073                else sprintf(hname, "Trec%02d_C", lay);
00074                hist = (TH1F*)fdTrec->FindObjectAny(hname);
00075                m_hTrec[lay][lr]->Add(hist);
00076           }
00077      }
00078 
00079      for(int lay=0; lay<NLAYER; lay++){
00080           for(int iud=0; iud<2; iud++){
00081                if(0 == iud) sprintf(hname, "TrecCosm%02d_Up", lay);
00082                else sprintf(hname, "TrecCosm%02d_Dw", lay);
00083                hist = (TH1F*)fdTrec->FindObjectAny(hname);
00084                m_hTrecCosm[lay][iud]->Add(hist);
00085           }
00086      }
00087 
00088      for(int lay=0; lay<NLAYER; lay++){
00089           for(int lr=0; lr<NLR; lr++){
00090                for(int bin=0; bin<m_nzbin; bin++){
00091                     if(0 == lr) sprintf(hname, "Trec%02d_z%02d_L", lay, bin);
00092                     else if(1 == lr) sprintf(hname, "Trec%02d_z%02d_R", lay, bin);
00093                     else sprintf(hname, "Trec%02d_z%02d_C", lay, bin);
00094                     hist = (TH1F*)fdTrecZ->FindObjectAny(hname);
00095                     m_hTrecZ[lay][lr][bin]->Add(hist);
00096                }
00097           }
00098      }
00099 }

void PreT0Calib::renameHist (   )  [private]
 

Reimplemented from CalibBase.

00264                            {
00265      char hname[200];
00266      for(int lay=0; lay<NLAYER; lay++){
00267           for(int lr=0; lr<NLR; lr++){
00268                if(0 == lr) sprintf(hname, "Trec%02d_L", lay);
00269                else if(1 == lr) sprintf(hname, "Trec%02d_R", lay);
00270                else sprintf(hname, "Trec%02d_C", lay);
00271                m_hTrec[lay][lr]->SetName(hname);
00272           }
00273      }
00274      for(int lay=0; lay<NLAYER; lay++){
00275           for(int iud=0; iud<2; iud++){
00276                if(0 == iud) sprintf(hname, "TrecCosm%02d_Up", lay);
00277                else sprintf(hname, "TrecCosm%02d_Dw", lay);
00278                m_hTrecCosm[lay][iud]->SetName(hname);
00279           }
00280      }
00281      for(int lay=0; lay<NLAYER; lay++){
00282           for(int lr=0; lr<NLR; lr++){
00283                for(int bin=0; bin<m_nzbin; bin++){
00284                     if(0 == lr) sprintf(hname, "Trec%02d_z%02d_L", lay, bin);
00285                     else if(1 == lr) sprintf(hname, "Trec%02d_z%02d_R", lay, bin);
00286                     else sprintf(hname, "Trec%02d_z%02d_C", lay, bin);
00287                     m_hTrecZ[lay][lr][bin]->SetName(hname);
00288                }
00289           }
00290      }
00291 }

Member Data Documentation

TFolder* PreT0Calib::m_fdTrec [private]
 

TFolder* PreT0Calib::m_fdTrecZ [private]
 

TH1F* PreT0Calib::m_hTrec[NLAYER][NLR] [private]
 

TH1F* PreT0Calib::m_hTrecCosm[NLAYER][2] [private]
 

TH1F* PreT0Calib::m_hTrecZ[NLAYER][NLR][11] [private]
 

int PreT0Calib::m_nzbin [private]
 

MdcCosGeom* PreT0Calib::m_pGeom [private]
 

double PreT0Calib::m_vp[NLAYER] [private]
 

double PreT0Calib::m_zst[NLAYER] [private]
 

double PreT0Calib::m_zwid[NLAYER] [private]
 

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