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

CalibBase Class Reference

#include <CalibBase.h>

Inheritance diagram for CalibBase:

IniCalib PreT0Calib PreXtCalib QtCalib T0Calib XtCalib List of all members.

Public Member Functions

virtual void calib (MdcCalibConst *calconst)=0
 CalibBase ()
virtual void init (TObjArray *hlist, MdcCosGeom *pGeom)=0
virtual void mergeHist (TFile *fhist)=0
virtual ~CalibBase ()

Private Member Functions

void renameHist ()

Private Attributes

TFolder * m_fdcom
TFolder * m_fdmomPhi
TFolder * m_fdr2d
TFolder * m_fdres
TFolder * m_fdResQ
TFolder * m_fdTime
TH1F * m_hbbTrkFlg
TH1F * m_hchisq
TH1F * m_hcosthe
TH1F * m_hcostheNeg
TH1F * m_hcosthePos
TH1F * m_hdelZ0
TH1F * m_hdr
TH1F * m_hdz
TH1F * m_hkap
TH1F * m_hnhitsCal
TH1F * m_hnhitsCalInn
TH1F * m_hnhitsCalOut
TH1F * m_hnhitsCalStp
TH1F * m_hnhitsRec
TH1F * m_hnhitsRecInn
TH1F * m_hnhitsRecOut
TH1F * m_hnhitsRecStp
TH1F * m_hnoiselay
TH1F * m_hnoisenhits
TH1F * m_hnoisephi
TH1F * m_hnRawHit
TH1F * m_hnTrk
TH1F * m_hnTrkCal
TH1F * m_hp
TH1F * m_hp_cms
TH1F * m_hp_cut
TH1F * m_hphi0
TH1F * m_hpMax
TH1F * m_hpMaxCms
TH1F * m_hpNeg
TH1F * m_hpNegcms
TH1F * m_hpPos
TH1F * m_hpPoscms
TH1F * m_hpt
TH1F * m_hptNeg
TH1F * m_hptPos
TH1F * m_hr2dExc [43][2][2][NSDBIN]
TH1F * m_hr2dInc [43][2][2][NSDBIN]
TH1F * m_hratio
TH1F * m_hresAllAve
TH1F * m_hresAllExc
TH1F * m_hresAllInc
TH1F * m_hresAveAllQ [14]
TH1F * m_hresAveLayQ [43][14]
TH1F * m_hresAveOutQ [14]
TH1F * m_hresExc [NLAYER]
TH1F * m_hresInc [NLAYER]
TH1F * m_hresInnExc
TH1F * m_hresInnInc
TH1F * m_hreslrExc [NLAYER][2]
TH1F * m_hreslrInc [NLAYER][2]
TH1F * m_hresOutExc
TH1F * m_hresOutInc
TH1F * m_hresStpExc
TH1F * m_hresStpInc
TH1F * m_htanl
TH1F * m_htdr [NLAYER]
TH1F * m_htdrlr [NLAYER][2]
TH1F * m_hTesAll
TH1F * m_hTesAllFlag
TH1F * m_hTesCalFlag
TH1F * m_hTesCalUse
TH1F * m_hTesGood
TH1F * m_hTesRec
TH1F * m_htraw [NLAYER]
TH1F * m_hx0
TH1F * m_hy0
TH1F * m_layerhitmap
TH1F * m_pnPhi [NPhiBin]
TH1F * m_pnPhiCms [NPhiBin]
TH1F * m_pnThe [NThetaBin]
TH1F * m_pnTheCms [NThetaBin]
TH1F * m_pnThePhi [NThetaBin][NPhiBin]
TH1F * m_pnThePhiCms [NThetaBin][NPhiBin]
TH1F * m_ppPhi [NPhiBin]
TH1F * m_ppPhiCms [NPhiBin]
TH1F * m_ppThe [NThetaBin]
TH1F * m_ppTheCms [NThetaBin]
TH1F * m_ppThePhi [NThetaBin][NPhiBin]
TH1F * m_ppThePhiCms [NThetaBin][NPhiBin]
TH1F * m_wirehitmap

Static Private Attributes

const int NPhiBin = 20
const int NThetaBin = 9

Detailed Description

Used as a base for all objects in the calibration data store. Implement IValidity.

Permits implementation of deep copy by means of virtual update method. [Used in CalibMySQLCnvSvc::updateCalib]

Author:
J. Bogart


Constructor & Destructor Documentation

CalibBase::CalibBase  ) 
 

00006                     {
00007 }

CalibBase::~CalibBase  )  [virtual]
 

00009                      {
00010 }


Member Function Documentation

void CalibBase::calib MdcCalibConst calconst  )  [pure virtual]
 

Implemented in IniCalib, PreT0Calib, PreXtCalib, QtCalib, T0Calib, and XtCalib.

00636                                             {
00637      // update resolution function
00638      Stat_t histEntry;
00639      int nSdBin[43];
00640      for(int lay=0; lay<8; lay++) nSdBin[lay] = 12;
00641      for(int lay=8; lay<43; lay++) nSdBin[lay] = 16;
00642      double sigm[NSDBIN];
00643      if(1 == gCalSigma){
00644           ofstream fr2d("logr2d.dat");
00645           for(int lay=0; lay<43; lay++){
00646                for(int iEntr=0; iEntr<gNEntr[lay]; iEntr++){
00647                     for(int lr=0; lr<2; lr++){
00648                          fr2d << setw(3) << lay << setw(3) << iEntr << setw(3) << lr << endl;
00649                          for(int bin=0; bin<nSdBin[lay]; bin++){
00650                               if(1 == gResiType){
00651                                    histEntry = m_hr2dExc[lay][iEntr][lr][bin]->GetEntries();
00652                                    if(histEntry > 500){
00653                                         m_hr2dExc[lay][iEntr][lr][bin]->Fit("gaus", "Q");
00654                                         sigm[bin] = m_hr2dExc[lay][iEntr][lr][bin]->GetFunction("gaus")->GetParameter(2);
00655                                    } else if(histEntry>100){
00656                                         sigm[bin] = m_hr2dExc[lay][iEntr][lr][bin]->GetRMS();
00657                                    } else{
00658                                         sigm[bin] = 0.2;
00659                                    }
00660                               } else{
00661                                    histEntry = m_hr2dInc[lay][iEntr][lr][bin]->GetEntries();
00662                                    if(histEntry > 500){
00663                                         m_hr2dInc[lay][iEntr][lr][bin]->Fit("gaus", "Q");
00664                                         sigm[bin] = m_hr2dInc[lay][iEntr][lr][bin]->GetFunction("gaus")->GetParameter(2);
00665                                    } else if(histEntry>100){
00666                                         sigm[bin] = m_hr2dInc[lay][iEntr][lr][bin]->GetRMS();
00667                                    } else{
00668                                         sigm[bin] = 0.2;
00669                                    }
00670                               }
00671                               if(sigm[bin] < 0.05) sigm[bin] = 0.05;    // for boundary layers
00672                          } // end of bin loop
00673                          for(int bin=nSdBin[lay]; bin<NSDBIN; bin++){
00674                               sigm[bin] = sigm[nSdBin[lay]-1];
00675                          }
00676 
00677                          for(int bin=0; bin<NSDBIN; bin++){
00678                               if(1 == gNEntr[lay]){
00679                                    for(int i=0; i<6; i++) calconst->resetSdpar(lay, i, lr, bin, sigm[bin]);
00680                               } else if(2 == gNEntr[lay]){
00681                                    if(0 == iEntr){
00682                                         for(int i=0; i<3; i++){ // entr<0
00683                                              calconst->resetSdpar(lay, i, lr, bin, sigm[bin]);
00684                                         }
00685                                    } else{
00686                                         for(int i=3; i<6; i++){ // entr>0
00687                                              calconst->resetSdpar(lay, i, lr, bin, sigm[bin]);
00688                                         }
00689                                    }
00690                               }
00691                               fr2d << setw(5) << bin << setw(15) << sigm[bin] << endl;
00692                          }
00693                     } // lr loop
00694                } // entr loop
00695           } // layer loop
00696           fr2d.close();
00697      }
00698      renameHist();
00699 }

void CalibBase::init TObjArray *  hlist,
MdcCosGeom pGeom
[pure virtual]
 

Implemented in IniCalib, PreT0Calib, PreXtCalib, QtCalib, T0Calib, and XtCalib.

00012                                                        {
00013      char hname[200];
00014 
00015      m_fdcom = new TFolder("mcommon", "common");
00016      hlist -> Add(m_fdcom);
00017 
00018      m_hresAllInc = new TH1F("mHResAllInc", "", 200, -1.0, 1.0);
00019      m_fdcom -> Add(m_hresAllInc);
00020 
00021      m_hresAllExc = new TH1F("mHResAllExc", "", 200, -1.0, 1.0);
00022      m_fdcom -> Add(m_hresAllExc);
00023 
00024      m_hresAllAve = new TH1F("mHResAllAve", "", 200, -1.0, 1.0);
00025      m_fdcom -> Add(m_hresAllAve);
00026 
00027      m_hresInnInc = new TH1F("mHResInnInc", "", 200, -1.0, 1.0);
00028      m_fdcom -> Add(m_hresInnInc);
00029 
00030      m_hresInnExc = new TH1F("mHResInnExc", "", 200, -1.0, 1.0);
00031      m_fdcom -> Add(m_hresInnExc);
00032 
00033      m_hresStpInc = new TH1F("mHResStpInc", "", 200, -1.0, 1.0);
00034      m_fdcom -> Add(m_hresStpInc);
00035 
00036      m_hresStpExc = new TH1F("mHResStpExc", "", 200, -1.0, 1.0);
00037      m_fdcom -> Add(m_hresStpExc);
00038 
00039      m_hresOutInc = new TH1F("mHResOutInc", "", 200, -1.0, 1.0);
00040      m_fdcom -> Add(m_hresOutInc);
00041 
00042      m_hresOutExc = new TH1F("mHResOutExc", "", 200, -1.0, 1.0);
00043      m_fdcom -> Add(m_hresOutExc);
00044 
00045      m_fdResQ = new TFolder("mResQ", "ResQ");
00046      hlist->Add(m_fdResQ);
00047      for(int i=0; i<14; i++){
00048           sprintf(hname, "mresoAll_qbin%02d", i);
00049           m_hresAveAllQ[i] = new TH1F(hname, "", 200, -1, 1);
00050           m_fdResQ->Add(m_hresAveAllQ[i]);
00051 
00052           sprintf(hname, "mresoOut_qbin%02d", i);
00053           m_hresAveOutQ[i] = new TH1F(hname, "", 200, -1, 1);
00054           m_fdResQ->Add(m_hresAveOutQ[i]);
00055      }
00056      for(int lay=0; lay<43; lay++){
00057           for(int i=0; i<14; i++){
00058                sprintf(hname, "mresoLay%02d_qbin%02d", lay, i);
00059                m_hresAveLayQ[lay][i] = new TH1F(hname, "", 200, -1, 1);
00060                m_fdResQ->Add(m_hresAveLayQ[lay][i]);
00061           }
00062      }
00063 
00064      m_hbbTrkFlg = new TH1F("mBbTrkFlg", "", 100, 0, 6);
00065      m_fdcom -> Add(m_hbbTrkFlg);
00066 
00067      m_hTesAll = new TH1F("mTesAll", "", 1000, 0, 2000);
00068      m_fdcom -> Add(m_hTesAll);
00069 
00070      m_hTesGood = new TH1F("mTesGood", "", 1000, 0, 2000);
00071      m_fdcom -> Add(m_hTesGood);
00072 
00073      m_hTesAllFlag = new TH1F("mTesAllFlag", "", 300, -0.5, 299.5);
00074      m_fdcom -> Add(m_hTesAllFlag);
00075 
00076      m_hTesRec = new TH1F("mTesRec", "", 1000, 0, 2000);
00077      m_fdcom -> Add(m_hTesRec);
00078 
00079      m_hTesCalFlag = new TH1F("mTesCalFlag", "", 1000, 0, 2000);
00080      m_fdcom -> Add(m_hTesCalFlag);
00081 
00082      m_hTesCalUse = new TH1F("mTesCalUse", "", 1000, 0, 2000);
00083      m_fdcom -> Add(m_hTesCalUse);
00084 
00085      m_hnRawHit = new TH1F("mNRawHit", "", 6797, -0.5, 6796.5);
00086      m_fdcom -> Add(m_hnRawHit);
00087 
00088      m_hpt = new TH1F("mHPt", "", 800, 0, 3);
00089      m_fdcom -> Add(m_hpt);
00090 
00091      m_hptPos = new TH1F("mHPtPos", "", 800, 0, 3);
00092      m_fdcom -> Add(m_hptPos);
00093 
00094      m_hptNeg = new TH1F("mHPtNeg", "", 800, 0, 3);
00095      m_fdcom -> Add(m_hptNeg);
00096 
00097      m_hp = new TH1F("mHP", "", 800, 0, 3);
00098      m_fdcom -> Add(m_hp);
00099 
00100      m_hp_cms = new TH1F("mHPCMS", "", 800, 0, 3);
00101      m_fdcom -> Add(m_hp_cms);
00102 
00103      m_hpMax = new TH1F("mHPMax", "", 800, 0, 3);
00104      m_fdcom -> Add(m_hpMax);
00105 
00106      m_hpMaxCms = new TH1F("mHPMax_Cms", "", 800, 0, 3);
00107      m_fdcom -> Add(m_hpMaxCms);
00108 
00109      m_hpPos = new TH1F("mHP_Pos", "", 800, 0, 3);
00110      m_fdcom -> Add(m_hpPos);
00111 
00112      m_hpNeg = new TH1F("mHP_Neg", "", 800, 0, 3);
00113      m_fdcom -> Add(m_hpNeg);
00114 
00115      m_hpPoscms = new TH1F("mHP_Pos_cms", "", 800, 0, 3);
00116      m_fdcom -> Add(m_hpPoscms);
00117 
00118      m_hpNegcms = new TH1F("mHP_Neg_cms", "", 800, 0, 3);
00119      m_fdcom -> Add(m_hpNegcms);
00120 
00121      m_hp_cut = new TH1F("mHPCut", "", 800, 0, 3);
00122      m_fdcom -> Add(m_hp_cut);
00123 
00124      m_hchisq = new TH1F("mChisq", "", 10, 0, 100);
00125      m_fdcom -> Add(m_hchisq);
00126 
00127      m_hnTrk = new TH1F("mHNtrack", "HNtrack", 10, -0.5, 9.5);
00128      m_fdcom -> Add(m_hnTrk);
00129 
00130      m_hnTrkCal = new TH1F("mHNtrackCal", "HNtrackCal", 10, -0.5, 9.5);
00131      m_fdcom -> Add(m_hnTrkCal);
00132 
00133      m_hnhitsRec = new TH1F("mHNhitsRec", "", 100, -0.5, 99.5);
00134      m_fdcom -> Add(m_hnhitsRec);
00135 
00136      m_hnhitsRecInn = new TH1F("mHNhitsInnRec", "", 60, 0.5, 60.5);
00137      m_fdcom -> Add(m_hnhitsRecInn);
00138 
00139      m_hnhitsRecStp = new TH1F("mHNhitsStpRec", "", 60, 0.5, 60.5);
00140      m_fdcom -> Add(m_hnhitsRecStp);
00141 
00142      m_hnhitsRecOut = new TH1F("mHNhitsOutRec", "", 60, 0.5, 60.5);
00143      m_fdcom -> Add(m_hnhitsRecOut);
00144 
00145      m_hnhitsCal = new TH1F("mHNhitsCal", "", 100, -0.5, 99.5);
00146      m_fdcom -> Add(m_hnhitsCal);
00147 
00148      m_hnhitsCalInn = new TH1F("mHNhitsCalInn", "", 60, 0.5, 60.5);
00149      m_fdcom -> Add(m_hnhitsCalInn);
00150 
00151      m_hnhitsCalStp = new TH1F("mHNhitsCalStp", "", 60, 0.5, 60.5);
00152      m_fdcom -> Add(m_hnhitsCalStp);
00153 
00154      m_hnhitsCalOut = new TH1F("mHNhitsCalOut", "", 60, 0.5, 60.5);
00155      m_fdcom -> Add(m_hnhitsCalOut);
00156 
00157      m_wirehitmap = new TH1F("mWire_HitMap", "Wire_HitMap", 6796, -0.5, 6795.5);
00158      m_fdcom -> Add(m_wirehitmap);
00159 
00160      m_layerhitmap = new TH1F("mLayer_HitMap", "Layer_HitMap", 43, -0.5, 42.5);
00161      m_fdcom -> Add(m_layerhitmap);
00162 
00163      m_hnoisephi = new TH1F("mphi_noise", "", 100, 0, 6.284);
00164      m_fdcom -> Add(m_hnoisephi);
00165 
00166      m_hnoiselay = new TH1F("mLayer_noise", "Layer_noise", 43, -0.5, 42.5);
00167      m_fdcom -> Add(m_hnoiselay);
00168 
00169      m_hnoisenhits = new TH1F("mnhits_noise", "nhits_noise", 6796, -0.5, 6795.5);
00170      m_fdcom -> Add(m_hnoisenhits);
00171 
00172      m_hratio = new TH1F("mratio", "", 100, 0, 1);
00173      m_fdcom -> Add(m_hratio);
00174 
00175      m_hdr = new TH1F("mdr", "", 400, -100, 100);
00176      m_fdcom -> Add(m_hdr);
00177 
00178      m_hphi0 = new TH1F("mphi0", "", 100, 0, 6.284);
00179      m_fdcom -> Add(m_hphi0);
00180 
00181      m_hkap = new TH1F("mkappa", "", 400, -50, 50);
00182      m_fdcom -> Add(m_hkap);
00183 
00184      m_hdz = new TH1F("mdz", "", 500, -500, 500);
00185      m_fdcom -> Add(m_hdz);
00186 
00187      m_htanl = new TH1F("mtanl", "", 200, -5, 5);
00188      m_fdcom -> Add(m_htanl);
00189 
00190      m_hcosthe = new TH1F("mcostheta", "", 200, -1, 1);
00191      m_fdcom -> Add(m_hcosthe);
00192 
00193      m_hcostheNeg = new TH1F("mcosthetaNeg", "", 200, -1, 1);
00194      m_fdcom -> Add(m_hcostheNeg);
00195 
00196      m_hcosthePos = new TH1F("mcosthetaPos", "", 200, -1, 1);
00197      m_fdcom -> Add(m_hcosthePos);
00198 
00199      m_hx0 = new TH1F("mx0", "", 100, -10, 10);
00200      m_fdcom -> Add(m_hx0);
00201 
00202      m_hy0 = new TH1F("my0", "", 100, -10, 10);
00203      m_fdcom -> Add(m_hy0);
00204 
00205      m_hdelZ0 = new TH1F("mdelta_z0", "", 100, -50, 50);
00206      m_fdcom -> Add(m_hdelZ0);
00207 
00208      // histograms for drift time
00209      m_fdTime = new TFolder("mtime", "time");
00210      hlist -> Add(m_fdTime);
00211 
00212      for(int lay=0; lay<NLAYER; lay++){
00213           sprintf(hname, "mTraw%02d", lay);
00214           m_htraw[lay] = new TH1F(hname, "", 1000, 0, 1000);
00215           m_fdTime -> Add(m_htraw[lay]);
00216 
00217           sprintf(hname, "mTdr%02d", lay);
00218           m_htdr[lay] = new TH1F(hname, "", 510, -10, 500);
00219           m_fdTime -> Add(m_htdr[lay]);
00220 
00221           for(int lr=0; lr<2; lr++){
00222                sprintf(hname, "mTdr%02d_lr%01d", lay, lr);
00223                m_htdrlr[lay][lr] = new TH1F(hname, "", 510, -10, 500);
00224                m_fdTime -> Add(m_htdrlr[lay][lr]);
00225           }
00226      }
00227 
00228      // histograms for resolution
00229      m_fdres = new TFolder("mresolution", "resolution");
00230      hlist -> Add(m_fdres);
00231 
00232      for(int lay=0; lay<NLAYER; lay++){
00233           sprintf(hname, "mReso%02dInc", lay);
00234           m_hresInc[lay] = new TH1F(hname, "", 200, -1, 1);
00235           m_fdres -> Add(m_hresInc[lay]);
00236 
00237           sprintf(hname, "mReso%02dExc", lay);
00238           m_hresExc[lay] = new TH1F(hname, "", 200, -1, 1);
00239           m_fdres -> Add(m_hresExc[lay]);
00240 
00241           for (int lr=0; lr<2; lr++){
00242                sprintf(hname, "mReso%02dInc_lr%01d", lay, lr);
00243                m_hreslrInc[lay][lr] = new TH1F(hname, "", 200, -1, 1);
00244                m_fdres->Add(m_hreslrInc[lay][lr]);
00245 
00246                sprintf(hname, "mReso%02dExc_lr%01d", lay, lr);
00247                m_hreslrExc[lay][lr] = new TH1F(hname, "", 200, -1, 1);
00248                m_fdres->Add(m_hreslrExc[lay][lr]);
00249           }
00250      }
00251 
00252      /* histograms for momentum vs phi */
00253      m_fdmomPhi = new TFolder("mmomPhi", "momPhi");
00254      hlist -> Add(m_fdmomPhi);
00255 
00256      int thbin;
00257      for(int bin=0; bin<NPhiBin; bin++){
00258           sprintf(hname, "mhPpos_phi%02d", bin);
00259           m_ppPhi[bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00260           m_fdmomPhi->Add(m_ppPhi[bin]);
00261 
00262           sprintf(hname, "mhPneg_phi%02d", bin);
00263           m_pnPhi[bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00264           m_fdmomPhi->Add(m_pnPhi[bin]);
00265 
00266           sprintf(hname, "mhPpos_phi_cms%02d", bin);
00267           m_ppPhiCms[bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00268           m_fdmomPhi->Add(m_ppPhiCms[bin]);
00269 
00270           sprintf(hname, "mhPneg_phi_cms%02d", bin);
00271           m_pnPhiCms[bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00272           m_fdmomPhi->Add(m_pnPhiCms[bin]);
00273 
00274           for(thbin=0; thbin<NThetaBin; thbin++){
00275                sprintf(hname, "mhPpos_theta%02d_phi%02d", thbin, bin);
00276                m_ppThePhi[thbin][bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00277                m_fdmomPhi->Add(m_ppThePhi[thbin][bin]);
00278 
00279                sprintf(hname, "mhPneg_theta%02d_phi%02d", thbin, bin);
00280                m_pnThePhi[thbin][bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00281                m_fdmomPhi->Add(m_pnThePhi[thbin][bin]);
00282 
00283                sprintf(hname, "mhPposCms_theta%02d_phi%02d", thbin, bin);
00284                m_ppThePhiCms[thbin][bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00285                m_fdmomPhi->Add(m_ppThePhiCms[thbin][bin]);
00286 
00287                sprintf(hname, "mhPnegCms_theta%02d_phi%02d", thbin, bin);
00288                m_pnThePhiCms[thbin][bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00289                m_fdmomPhi->Add(m_pnThePhiCms[thbin][bin]);
00290           }
00291      }
00292      for(thbin=0; thbin<NThetaBin; thbin++){
00293           sprintf(hname, "mhPpos_the%02d", thbin);
00294           m_ppThe[thbin] = new TH1F(hname, "", 400, 1.0, 2.5);
00295           m_fdmomPhi->Add(m_ppThe[thbin]);
00296 
00297           sprintf(hname, "mhPneg_the%02d", thbin);
00298           m_pnThe[thbin] = new TH1F(hname, "", 400, 1.0, 2.5);
00299           m_fdmomPhi->Add(m_pnThe[thbin]);
00300 
00301           sprintf(hname, "mhPposCms_the%02d", thbin);
00302           m_ppTheCms[thbin] = new TH1F(hname, "", 400, 1.0, 2.5);
00303           m_fdmomPhi->Add(m_ppTheCms[thbin]);
00304 
00305           sprintf(hname, "mhPnegCms_the%02d", thbin);
00306           m_pnTheCms[thbin] = new TH1F(hname, "", 400, 1.0, 2.5);
00307           m_fdmomPhi->Add(m_pnTheCms[thbin]);
00308      }
00309 
00310      m_fdr2d = new TFolder("mres2d", "res2d");
00311      hlist -> Add(m_fdr2d);
00312      for(int lay=0; lay<43; lay++){
00313           for(int iEntr=0; iEntr<gNEntr[lay]; iEntr++){
00314                for(int lr=0; lr<2; lr++){
00315                     for(int bin=0; bin<NSDBIN; bin++){
00316                          sprintf(hname, "mR2d%02d_%02d_%01d_%02dInc", lay, iEntr, lr, bin);
00317                          m_hr2dInc[lay][iEntr][lr][bin] = new TH1F(hname, "", 200, -1, 1);
00318                          m_fdr2d -> Add(m_hr2dInc[lay][iEntr][lr][bin]);
00319 
00320                          sprintf(hname, "mR2d%02d_%02d_%01d_%02dExc", lay, iEntr, lr, bin);
00321                          m_hr2dExc[lay][iEntr][lr][bin] = new TH1F(hname, "", 200, -1, 1);
00322                          m_fdr2d -> Add(m_hr2dExc[lay][iEntr][lr][bin]);
00323                     }
00324                }
00325           }
00326      }
00327 }

void CalibBase::mergeHist TFile *  fhist  )  [pure virtual]
 

Implemented in IniCalib, PreT0Calib, PreXtCalib, QtCalib, T0Calib, and XtCalib.

00329                                      {
00330      char hname[200];
00331      TH1F* hist;
00332      TFolder* fdcom = (TFolder*)fhist->Get("common");
00333      TFolder* fdResQ = (TFolder*)fhist->Get("ResQ");
00334      TFolder* fdTime = (TFolder*)fhist->Get("time");
00335      TFolder* fdres = (TFolder*)fhist->Get("resolution");
00336      TFolder* fdmomPhi = (TFolder*)fhist->Get("momPhi");
00337      TFolder* fdres2d = (TFolder*)fhist->Get("res2d");
00338 
00339      hist = (TH1F*)fdcom->FindObjectAny("HResAllInc");
00340      m_hresAllInc->Add(hist);
00341 
00342      hist = (TH1F*)fdcom->FindObjectAny("HResAllExc");
00343      m_hresAllExc->Add(hist);
00344 
00345      hist = (TH1F*)fdcom->FindObjectAny("HResAllAve");
00346      m_hresAllAve->Add(hist);
00347 
00348      hist = (TH1F*)fdcom->FindObjectAny("HResInnInc");
00349      m_hresInnInc->Add(hist);
00350 
00351      hist = (TH1F*)fdcom->FindObjectAny("HResInnExc");
00352      m_hresInnExc->Add(hist);
00353 
00354      hist = (TH1F*)fdcom->FindObjectAny("HResStpInc");
00355      m_hresStpInc->Add(hist);
00356 
00357      hist = (TH1F*)fdcom->FindObjectAny("HResStpExc");
00358      m_hresStpExc->Add(hist);
00359 
00360      hist = (TH1F*)fdcom->FindObjectAny("HResOutInc");
00361      m_hresOutInc->Add(hist);
00362 
00363      hist = (TH1F*)fdcom->FindObjectAny("HResOutExc");
00364      m_hresOutExc->Add(hist);
00365 
00366      hist = (TH1F*)fdcom->FindObjectAny("BbTrkFlg");
00367      m_hbbTrkFlg->Add(hist);
00368 
00369      hist = (TH1F*)fdcom->FindObjectAny("TesAll");
00370      m_hTesAll->Add(hist);
00371 
00372      hist = (TH1F*)fdcom->FindObjectAny("TesGood");
00373      m_hTesGood->Add(hist);
00374 
00375      hist = (TH1F*)fdcom->FindObjectAny("TesAllFlag");
00376      m_hTesAllFlag->Add(hist);
00377 
00378      hist = (TH1F*)fdcom->FindObjectAny("TesRec");
00379      m_hTesRec->Add(hist);
00380 
00381      hist = (TH1F*)fdcom->FindObjectAny("TesCalFlag");
00382      m_hTesCalFlag->Add(hist);
00383 
00384      hist = (TH1F*)fdcom->FindObjectAny("TesCalUse");
00385      m_hTesCalUse->Add(hist);
00386 
00387      hist = (TH1F*)fdcom->FindObjectAny("nRawHit");
00388      m_hnRawHit->Add(hist);
00389 
00390      hist = (TH1F*)fdcom->FindObjectAny("HPt");
00391      m_hpt->Add(hist);
00392 
00393      hist = (TH1F*)fdcom->FindObjectAny("HPtPos");
00394      m_hptPos->Add(hist);
00395 
00396      hist = (TH1F*)fdcom->FindObjectAny("HPtNeg");
00397      m_hptNeg->Add(hist);
00398 
00399      hist = (TH1F*)fdcom->FindObjectAny("HP");
00400      m_hp->Add(hist);
00401 
00402      hist = (TH1F*)fdcom->FindObjectAny("HPCMS");
00403      m_hp_cms->Add(hist);
00404 
00405      hist = (TH1F*)fdcom->FindObjectAny("HPMax");
00406      m_hpMax->Add(hist);
00407 
00408      hist = (TH1F*)fdcom->FindObjectAny("HPMax_Cms");
00409      m_hpMaxCms->Add(hist);
00410 
00411      hist = (TH1F*)fdcom->FindObjectAny("HP_Pos");
00412      m_hpPos->Add(hist);
00413 
00414      hist = (TH1F*)fdcom->FindObjectAny("HP_Neg");
00415      m_hpNeg->Add(hist);
00416 
00417      hist = (TH1F*)fdcom->FindObjectAny("HP_Pos_cms");
00418      m_hpPoscms->Add(hist);
00419 
00420      hist = (TH1F*)fdcom->FindObjectAny("HP_Neg_cms");
00421      m_hpNegcms->Add(hist);
00422 
00423      hist = (TH1F*)fdcom->FindObjectAny("HPCut");
00424      m_hp_cut->Add(hist);
00425 
00426      hist = (TH1F*)fdcom->FindObjectAny("Chisq");
00427      m_hchisq->Add(hist);
00428 
00429      hist = (TH1F*)fdcom->FindObjectAny("HNtrack");
00430      m_hnTrk->Add(hist);
00431 
00432      hist = (TH1F*)fdcom->FindObjectAny("HNtrackCal");
00433      m_hnTrkCal->Add(hist);
00434 
00435      hist = (TH1F*)fdcom->FindObjectAny("HNhitsRec");
00436      m_hnhitsRec->Add(hist);
00437 
00438      hist = (TH1F*)fdcom->FindObjectAny("HNhitsInnRec");
00439      m_hnhitsRecInn->Add(hist);
00440 
00441      hist = (TH1F*)fdcom->FindObjectAny("HNhitsStpRec");
00442      m_hnhitsRecStp->Add(hist);
00443 
00444      hist = (TH1F*)fdcom->FindObjectAny("HNhitsOutRec");
00445      m_hnhitsRecOut->Add(hist);
00446 
00447      hist = (TH1F*)fdcom->FindObjectAny("HNhitsCal");
00448      m_hnhitsCal->Add(hist);
00449 
00450      hist = (TH1F*)fdcom->FindObjectAny("HNhitsCalInn");
00451      m_hnhitsCalInn->Add(hist);
00452 
00453      hist = (TH1F*)fdcom->FindObjectAny("HNhitsCalStp");
00454      m_hnhitsCalStp->Add(hist);
00455 
00456      hist = (TH1F*)fdcom->FindObjectAny("HNhitsCalOut");
00457      m_hnhitsCalOut->Add(hist);
00458 
00459      hist = (TH1F*)fdcom->FindObjectAny("Wire_HitMap");
00460      m_wirehitmap->Add(hist);
00461 
00462      hist = (TH1F*)fdcom->FindObjectAny("Layer_HitMap");
00463      m_layerhitmap->Add(hist);
00464 
00465      hist = (TH1F*)fdcom->FindObjectAny("phi_noise");
00466      m_hnoisephi->Add(hist);
00467 
00468      hist = (TH1F*)fdcom->FindObjectAny("Layer_noise");
00469      m_hnoiselay->Add(hist);
00470 
00471      hist = (TH1F*)fdcom->FindObjectAny("nhits_noise");
00472      m_hnoisenhits->Add(hist);
00473 
00474      hist = (TH1F*)fdcom->FindObjectAny("ratio");
00475      m_hratio->Add(hist);
00476 
00477      hist = (TH1F*)fdcom->FindObjectAny("dr");
00478      m_hdr->Add(hist);
00479 
00480      hist = (TH1F*)fdcom->FindObjectAny("phi0");
00481      m_hphi0->Add(hist);
00482 
00483      hist = (TH1F*)fdcom->FindObjectAny("kappa");
00484      m_hkap->Add(hist);
00485 
00486      hist = (TH1F*)fdcom->FindObjectAny("dz");
00487      m_hdz->Add(hist);
00488 
00489      hist = (TH1F*)fdcom->FindObjectAny("tanl");
00490      m_htanl->Add(hist);
00491 
00492      hist = (TH1F*)fdcom->FindObjectAny("costheta");
00493      m_hcosthe->Add(hist);
00494 
00495      hist = (TH1F*)fdcom->FindObjectAny("costhetaNeg");
00496      m_hcostheNeg->Add(hist);
00497 
00498      hist = (TH1F*)fdcom->FindObjectAny("costhetaPos");
00499      m_hcosthePos->Add(hist);
00500 
00501      hist = (TH1F*)fdcom->FindObjectAny("x0");
00502      m_hx0->Add(hist);
00503 
00504      hist = (TH1F*)fdcom->FindObjectAny("y0");
00505      m_hy0->Add(hist);
00506 
00507      hist = (TH1F*)fdcom->FindObjectAny("delta_z0");
00508      m_hdelZ0->Add(hist);
00509 
00510      for(int i=0; i<14; i++){
00511           sprintf(hname, "resoAll_qbin%02d", i);
00512           hist = (TH1F*)fdResQ->FindObjectAny(hname);
00513           m_hresAveAllQ[i]->Add(hist);
00514 
00515           sprintf(hname, "resoOut_qbin%02d", i);
00516           hist = (TH1F*)fdResQ->FindObjectAny(hname);
00517           m_hresAveOutQ[i]->Add(hist);
00518      }
00519 
00520      for(int lay=0; lay<43; lay++){
00521           for(int i=0; i<14; i++){
00522                sprintf(hname, "resoLay%02d_qbin%02d", lay, i);
00523                hist = (TH1F*)fdResQ->FindObjectAny(hname);
00524                m_hresAveLayQ[lay][i]->Add(hist);
00525           }
00526      }
00527 
00528      for(int lay=0; lay<NLAYER; lay++){
00529           sprintf(hname, "Traw%02d", lay);
00530           hist = (TH1F*)fdTime->FindObjectAny(hname);
00531           m_htraw[lay]->Add(hist);
00532 
00533           sprintf(hname, "Tdr%02d", lay);
00534           hist = (TH1F*)fdTime->FindObjectAny(hname);
00535           m_htdr[lay]->Add(hist);
00536 
00537           for(int lr=0; lr<2; lr++){
00538                sprintf(hname, "Tdr%02d_lr%01d", lay, lr);
00539                hist = (TH1F*)fdTime->FindObjectAny(hname);
00540                m_htdrlr[lay][lr]->Add(hist);
00541           }
00542      }
00543 
00544      for(int lay=0; lay<NLAYER; lay++){
00545           sprintf(hname, "Reso%02dInc", lay);
00546           hist = (TH1F*)fdres->FindObjectAny(hname);
00547           m_hresInc[lay]->Add(hist);
00548 
00549           sprintf(hname, "Reso%02dExc", lay);
00550           hist = (TH1F*)fdres->FindObjectAny(hname);
00551           m_hresExc[lay]->Add(hist);
00552 
00553           for (int lr=0; lr<2; lr++){
00554                sprintf(hname, "Reso%02dInc_lr%01d", lay, lr);
00555                hist = (TH1F*)fdres->FindObjectAny(hname);
00556                m_hreslrInc[lay][lr]->Add(hist);
00557 
00558                sprintf(hname, "Reso%02dExc_lr%01d", lay, lr);
00559                hist = (TH1F*)fdres->FindObjectAny(hname);
00560                m_hreslrExc[lay][lr]->Add(hist);
00561           }
00562      }
00563 
00564      int thbin;
00565      for(int bin=0; bin<NPhiBin; bin++){
00566           sprintf(hname, "hPpos_phi%02d", bin);
00567           hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00568           m_ppPhi[bin]->Add(hist);
00569 
00570           sprintf(hname, "hPneg_phi%02d", bin);
00571           hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00572           m_pnPhi[bin]->Add(hist);
00573 
00574           sprintf(hname, "hPpos_phi_cms%02d", bin);
00575           hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00576           m_ppPhiCms[bin]->Add(hist);
00577 
00578           sprintf(hname, "hPneg_phi_cms%02d", bin);
00579           hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00580           m_pnPhiCms[bin]->Add(hist);
00581 
00582           for(thbin=0; thbin<NThetaBin; thbin++){
00583                sprintf(hname, "hPpos_theta%02d_phi%02d", thbin, bin);
00584                hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00585                m_ppThePhi[thbin][bin]->Add(hist);
00586 
00587                sprintf(hname, "hPneg_theta%02d_phi%02d", thbin, bin);
00588                hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00589                m_pnThePhi[thbin][bin]->Add(hist);
00590 
00591                sprintf(hname, "hPposCms_theta%02d_phi%02d", thbin, bin);
00592                hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00593                m_ppThePhiCms[thbin][bin]->Add(hist);
00594 
00595                sprintf(hname, "hPnegCms_theta%02d_phi%02d", thbin, bin);
00596                hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00597                m_pnThePhiCms[thbin][bin]->Add(hist);
00598           }
00599      }
00600 
00601      for(thbin=0; thbin<NThetaBin; thbin++){
00602           sprintf(hname, "hPpos_the%02d", thbin);
00603           hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00604           m_ppThe[thbin]->Add(hist);
00605 
00606           sprintf(hname, "hPneg_the%02d", thbin);
00607           hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00608           m_ppThe[thbin]->Add(hist);
00609 
00610           sprintf(hname, "hPposCms_the%02d", thbin);
00611           hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00612           m_ppTheCms[thbin]->Add(hist);
00613 
00614           sprintf(hname, "hPnegCms_the%02d", thbin);
00615           hist = (TH1F*)fdmomPhi->FindObjectAny(hname);
00616           m_pnTheCms[thbin]->Add(hist);
00617      }
00618 
00619      for(int lay=0; lay<43; lay++){
00620           for(int iEntr=0; iEntr<gNEntr[lay]; iEntr++){
00621                for(int lr=0; lr<2; lr++){
00622                     for(int bin=0; bin<NSDBIN; bin++){
00623                          sprintf(hname, "r2d%02d_%02d_%01d_%02dInc", lay, iEntr, lr, bin);
00624                          hist = (TH1F*)fdres2d->FindObjectAny(hname);
00625                          m_hr2dInc[lay][iEntr][lr][bin]->Add(hist);
00626 
00627                          sprintf(hname, "r2d%02d_%02d_%01d_%02dExc", lay, iEntr, lr, bin);
00628                          hist = (TH1F*)fdres2d->FindObjectAny(hname);
00629                          m_hr2dExc[lay][iEntr][lr][bin]->Add(hist);
00630                     }
00631                }
00632           }
00633      }
00634 }

void CalibBase::renameHist  )  [private]
 

Reimplemented in IniCalib, PreT0Calib, PreXtCalib, QtCalib, T0Calib, and XtCalib.

00701                           {
00702      char hname[200];
00703      m_fdcom->SetName("common");
00704      m_hresAllInc->SetName("HResAllInc");
00705      m_hresAllExc->SetName("HResAllExc");
00706      m_hresAllAve->SetName("HResAllAve");
00707      m_hresInnInc->SetName("HResInnInc");
00708      m_hresInnExc->SetName("HResInnExc");
00709      m_hresStpInc->SetName("HResStpInc");
00710      m_hresStpExc->SetName("HResStpExc");
00711      m_hresOutInc->SetName("HResOutInc");
00712      m_hresOutExc->SetName("HResOutExc");
00713      m_fdResQ->SetName("ResQ");
00714      m_hbbTrkFlg->SetName("BbTrkFlg");
00715      m_hTesAll->SetName("TesAll");
00716      m_hTesGood->SetName("TesGood");
00717      m_hTesAllFlag->SetName("TesAllFlag");
00718      m_hTesRec->SetName("TesRec");
00719      m_hTesCalFlag->SetName("TesCalFlag");
00720      m_hTesCalUse->SetName("TesCalUse");
00721      m_hnRawHit->SetName("nRawHit");
00722      m_hpt->SetName("HPt");
00723      m_hptPos->SetName("HPtPos");
00724      m_hptNeg->SetName("HPtNeg");
00725      m_hp->SetName("HP");
00726      m_hp_cms->SetName("HPCMS");
00727      m_hpMax->SetName("HPMax");
00728      m_hpMaxCms->SetName("HPMax_Cms");
00729      m_hpPos->SetName("HP_Pos");
00730      m_hpNeg->SetName("HP_Neg");
00731      m_hpPoscms->SetName("HP_Pos_cms");
00732      m_hpNegcms->SetName("HP_Neg_cms");
00733      m_hp_cut->SetName("HPCut");
00734      m_hchisq->SetName("Chisq");
00735      m_hnTrk->SetName("HNtrack");
00736      m_hnTrkCal->SetName("HNtrackCal");
00737      m_hnhitsRec->SetName("HNhitsRec");
00738      m_hnhitsRecInn->SetName("HNhitsInnRec");
00739      m_hnhitsRecStp->SetName("HNhitsStpRec");
00740      m_hnhitsRecOut->SetName("HNhitsOutRec");
00741      m_hnhitsCal->SetName("HNhitsCal");
00742      m_hnhitsCalInn->SetName("HNhitsCalInn");
00743      m_hnhitsCalStp->SetName("HNhitsCalStp");
00744      m_hnhitsCalOut->SetName("HNhitsCalOut");
00745      m_wirehitmap->SetName("Wire_HitMap");
00746      m_layerhitmap->SetName("Layer_HitMap");
00747      m_hnoisephi->SetName("phi_noise");
00748      m_hnoiselay->SetName("Layer_noise");
00749      m_hnoisenhits->SetName("nhits_noise");
00750      m_hratio->SetName("ratio");
00751      m_hdr->SetName("dr");
00752      m_hphi0->SetName("phi0");
00753      m_hkap->SetName("kappa");
00754      m_hdz->SetName("dz");
00755      m_htanl->SetName("tanl");
00756      m_hcosthe->SetName("costheta");
00757      m_hcostheNeg->SetName("costhetaNeg");
00758      m_hcosthePos->SetName("costhetaPos");
00759      m_hx0->SetName("x0");
00760      m_hy0->SetName("y0");
00761      m_hdelZ0->SetName("delta_z0");
00762      m_fdTime->SetName("time");
00763 
00764      for(int i=0; i<14; i++){
00765           sprintf(hname, "resoAll_qbin%02d", i);
00766           m_hresAveAllQ[i]->SetName(hname);
00767 
00768           sprintf(hname, "resoOut_qbin%02d", i);
00769           m_hresAveOutQ[i]->SetName(hname);
00770      }
00771      for(int lay=0; lay<43; lay++){
00772           for(int i=0; i<14; i++){
00773                sprintf(hname, "resoLay%02d_qbin%02d", lay, i);
00774                m_hresAveLayQ[lay][i]->SetName(hname);
00775           }
00776      }
00777 
00778      for(int lay=0; lay<NLAYER; lay++){
00779           sprintf(hname, "Traw%02d", lay);
00780           m_htraw[lay]->SetName(hname);
00781 
00782           sprintf(hname, "Tdr%02d", lay);
00783           m_htdr[lay]->SetName(hname);
00784 
00785           for(int lr=0; lr<2; lr++){
00786                sprintf(hname, "Tdr%02d_lr%01d", lay, lr);
00787                m_htdrlr[lay][lr]->SetName(hname);
00788           }
00789      }
00790 
00791      // histograms for resolution
00792      m_fdres->SetName("resolution");
00793      for(int lay=0; lay<NLAYER; lay++){
00794           sprintf(hname, "Reso%02dInc", lay);
00795           m_hresInc[lay]->SetName(hname);
00796 
00797           sprintf(hname, "Reso%02dExc", lay);
00798           m_hresExc[lay]->SetName(hname);
00799 
00800           for (int lr=0; lr<2; lr++){
00801                sprintf(hname, "Reso%02dInc_lr%01d", lay, lr);
00802                m_hreslrInc[lay][lr]->SetName(hname);
00803 
00804                sprintf(hname, "Reso%02dExc_lr%01d", lay, lr);
00805                m_hreslrExc[lay][lr]->SetName(hname);
00806           }
00807      }
00808 
00809      /* histograms for momentum vs phi */
00810      m_fdmomPhi->SetName("momPhi");
00811      int thbin;
00812      for(int bin=0; bin<NPhiBin; bin++){
00813           sprintf(hname, "hPpos_phi%02d", bin);
00814           m_ppPhi[bin]->SetName(hname);
00815 
00816           sprintf(hname, "hPneg_phi%02d", bin);
00817           m_pnPhi[bin]->SetName(hname);
00818 
00819           sprintf(hname, "hPpos_phi_cms%02d", bin);
00820           m_ppPhiCms[bin]->SetName(hname);
00821 
00822           sprintf(hname, "hPneg_phi_cms%02d", bin);
00823           m_pnPhiCms[bin]->SetName(hname);
00824 
00825           for(thbin=0; thbin<NThetaBin; thbin++){
00826                sprintf(hname, "hPpos_theta%02d_phi%02d", thbin, bin);
00827                m_ppThePhi[thbin][bin]->SetName(hname);
00828 
00829                sprintf(hname, "hPneg_theta%02d_phi%02d", thbin, bin);
00830                m_pnThePhi[thbin][bin]->SetName(hname);
00831 
00832                sprintf(hname, "hPposCms_theta%02d_phi%02d", thbin, bin);
00833                m_ppThePhiCms[thbin][bin]->SetName(hname);
00834 
00835                sprintf(hname, "hPnegCms_theta%02d_phi%02d", thbin, bin);
00836                m_pnThePhiCms[thbin][bin]->SetName(hname);
00837           }
00838      }
00839      for(thbin=0; thbin<NThetaBin; thbin++){
00840           sprintf(hname, "hPpos_the%02d", thbin);
00841           m_ppThe[thbin]->SetName(hname);
00842 
00843           sprintf(hname, "hPneg_the%02d", thbin);
00844           m_pnThe[thbin]->SetName(hname);
00845 
00846           sprintf(hname, "hPposCms_the%02d", thbin);
00847           m_ppTheCms[thbin]->SetName(hname);
00848 
00849           sprintf(hname, "hPnegCms_the%02d", thbin);
00850           m_pnTheCms[thbin]->SetName(hname);
00851      }
00852 
00853      m_fdr2d->SetName("res2d");
00854      for(int lay=0; lay<43; lay++){
00855           for(int iEntr=0; iEntr<gNEntr[lay]; iEntr++){
00856                for(int lr=0; lr<2; lr++){
00857                     for(int bin=0; bin<NSDBIN; bin++){
00858                          sprintf(hname, "R2d%02d_%02d_%01d_%02dInc", lay, iEntr, lr, bin);
00859                          m_hr2dInc[lay][iEntr][lr][bin]->SetName(hname);
00860                          sprintf(hname, "R2d%02d_%02d_%01d_%02dExc", lay, iEntr, lr, bin);
00861                          m_hr2dExc[lay][iEntr][lr][bin]->SetName(hname);
00862                     }
00863                }
00864           }
00865      }
00866 }


Member Data Documentation

TFolder* CalibBase::m_fdcom [private]
 

Reimplemented in IniCalib.

TFolder* CalibBase::m_fdmomPhi [private]
 

TFolder* CalibBase::m_fdr2d [private]
 

TFolder* CalibBase::m_fdres [private]
 

TFolder* CalibBase::m_fdResQ [private]
 

TFolder* CalibBase::m_fdTime [private]
 

TH1F* CalibBase::m_hbbTrkFlg [private]
 

TH1F* CalibBase::m_hchisq [private]
 

TH1F* CalibBase::m_hcosthe [private]
 

TH1F* CalibBase::m_hcostheNeg [private]
 

TH1F* CalibBase::m_hcosthePos [private]
 

TH1F* CalibBase::m_hdelZ0 [private]
 

TH1F* CalibBase::m_hdr [private]
 

TH1F* CalibBase::m_hdz [private]
 

TH1F* CalibBase::m_hkap [private]
 

TH1F* CalibBase::m_hnhitsCal [private]
 

TH1F* CalibBase::m_hnhitsCalInn [private]
 

TH1F* CalibBase::m_hnhitsCalOut [private]
 

TH1F* CalibBase::m_hnhitsCalStp [private]
 

TH1F* CalibBase::m_hnhitsRec [private]
 

TH1F* CalibBase::m_hnhitsRecInn [private]
 

TH1F* CalibBase::m_hnhitsRecOut [private]
 

TH1F* CalibBase::m_hnhitsRecStp [private]
 

TH1F* CalibBase::m_hnoiselay [private]
 

TH1F* CalibBase::m_hnoisenhits [private]
 

TH1F* CalibBase::m_hnoisephi [private]
 

TH1F* CalibBase::m_hnRawHit [private]
 

TH1F* CalibBase::m_hnTrk [private]
 

TH1F* CalibBase::m_hnTrkCal [private]
 

TH1F* CalibBase::m_hp [private]
 

TH1F* CalibBase::m_hp_cms [private]
 

TH1F* CalibBase::m_hp_cut [private]
 

TH1F* CalibBase::m_hphi0 [private]
 

TH1F* CalibBase::m_hpMax [private]
 

TH1F* CalibBase::m_hpMaxCms [private]
 

TH1F* CalibBase::m_hpNeg [private]
 

TH1F* CalibBase::m_hpNegcms [private]
 

TH1F* CalibBase::m_hpPos [private]
 

TH1F* CalibBase::m_hpPoscms [private]
 

TH1F* CalibBase::m_hpt [private]
 

TH1F* CalibBase::m_hptNeg [private]
 

TH1F* CalibBase::m_hptPos [private]
 

TH1F* CalibBase::m_hr2dExc[43][2][2][NSDBIN] [private]
 

TH1F* CalibBase::m_hr2dInc[43][2][2][NSDBIN] [private]
 

TH1F* CalibBase::m_hratio [private]
 

TH1F* CalibBase::m_hresAllAve [private]
 

TH1F* CalibBase::m_hresAllExc [private]
 

TH1F* CalibBase::m_hresAllInc [private]
 

TH1F* CalibBase::m_hresAveAllQ[14] [private]
 

TH1F* CalibBase::m_hresAveLayQ[43][14] [private]
 

TH1F* CalibBase::m_hresAveOutQ[14] [private]
 

TH1F* CalibBase::m_hresExc[NLAYER] [private]
 

TH1F* CalibBase::m_hresInc[NLAYER] [private]
 

TH1F* CalibBase::m_hresInnExc [private]
 

TH1F* CalibBase::m_hresInnInc [private]
 

TH1F* CalibBase::m_hreslrExc[NLAYER][2] [private]
 

TH1F* CalibBase::m_hreslrInc[NLAYER][2] [private]
 

TH1F* CalibBase::m_hresOutExc [private]
 

TH1F* CalibBase::m_hresOutInc [private]
 

TH1F* CalibBase::m_hresStpExc [private]
 

TH1F* CalibBase::m_hresStpInc [private]
 

TH1F* CalibBase::m_htanl [private]
 

TH1F* CalibBase::m_htdr[NLAYER] [private]
 

TH1F* CalibBase::m_htdrlr[NLAYER][2] [private]
 

TH1F* CalibBase::m_hTesAll [private]
 

Reimplemented in IniCalib.

TH1F* CalibBase::m_hTesAllFlag [private]
 

TH1F* CalibBase::m_hTesCalFlag [private]
 

TH1F* CalibBase::m_hTesCalUse [private]
 

TH1F* CalibBase::m_hTesGood [private]
 

TH1F* CalibBase::m_hTesRec [private]
 

TH1F* CalibBase::m_htraw[NLAYER] [private]
 

Reimplemented in IniCalib.

TH1F* CalibBase::m_hx0 [private]
 

TH1F* CalibBase::m_hy0 [private]
 

TH1F* CalibBase::m_layerhitmap [private]
 

TH1F* CalibBase::m_pnPhi[NPhiBin] [private]
 

TH1F* CalibBase::m_pnPhiCms[NPhiBin] [private]
 

TH1F* CalibBase::m_pnThe[NThetaBin] [private]
 

TH1F* CalibBase::m_pnTheCms[NThetaBin] [private]
 

TH1F* CalibBase::m_pnThePhi[NThetaBin][NPhiBin] [private]
 

TH1F* CalibBase::m_pnThePhiCms[NThetaBin][NPhiBin] [private]
 

TH1F* CalibBase::m_ppPhi[NPhiBin] [private]
 

TH1F* CalibBase::m_ppPhiCms[NPhiBin] [private]
 

TH1F* CalibBase::m_ppThe[NThetaBin] [private]
 

TH1F* CalibBase::m_ppTheCms[NThetaBin] [private]
 

TH1F* CalibBase::m_ppThePhi[NThetaBin][NPhiBin] [private]
 

TH1F* CalibBase::m_ppThePhiCms[NThetaBin][NPhiBin] [private]
 

TH1F* CalibBase::m_wirehitmap [private]
 

const int CalibBase::NPhiBin = 20 [static, private]
 

const int CalibBase::NThetaBin = 9 [static, private]
 


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