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

QtCalib Class Reference

#include <QtCalib.h>

Inheritance diagram for QtCalib:

CalibBase List of all members.

Public Member Functions

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

Static Public Member Functions

Double_t qtFun (Double_t *x, Double_t *par)

Private Member Functions

void renameHist ()

Private Attributes

TFolder * m_fdQ_T
TFolder * m_fdQt
TGraphErrors * m_grqdt [NLAYER]
TGraphErrors * m_grqt [NLAYER]
TH1F * m_hqhit [NLAYER]
TH1F * m_hqt [NLAYER][NQBin]
MdcCosGeom * m_pGeom
double m_qbinw [NLAYER]
double m_qmax [NLAYER]
double m_qmin [NLAYER]
double m_qtpar [NLAYER][QtOrd]

Static Private Attributes

const int NQBin = 10
const double QMaxL = 1200
const double QMaxS = 1000
const double QMinL = 400
const double QMinS = 350
const int QtOrd = 2

Constructor & Destructor Documentation

QtCalib::QtCalib (   ) 
  

00006                 {
00007      cout << "Calibration type: QtCalib" << endl;
00008 }

QtCalib::~QtCalib (   ) 
  

00010                  {
00011 }

Member Function Documentation

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

Implements CalibBase.

00082                                           {
00083      CalibBase::calib(calconst);
00084 
00085      double vdr = 0.03;
00086      Stat_t entry;
00087      double qtpar;
00088      double qbcen;
00089      double tw;
00090      double deltw;
00091      double qterr;
00092      TF1* funQt = new TF1("funQt", qtFun, 200, 2000, 2);
00093 
00094      ofstream fqtlog("qtlog");
00095      for(int lay=0; lay<NLAYER; lay++){
00096           if(0 == gFgCalib[lay]) continue;
00097 
00098           fqtlog << "Layer" << lay << endl;
00099           double qtini[2];
00100           for(int ord=0; ord<QtOrd; ord++) qtini[ord] = calconst->getQtpar(lay, ord);
00101           for(int bin=0; bin<NQBin; bin++){
00102                entry = m_hqt[lay][bin]->GetEntries();
00103                if(entry > 300){
00104                     deltw = m_hqt[lay][bin] -> GetMean();
00105                     qterr = ( m_hqt[lay][bin]->GetRMS() ) / sqrt((double)entry);
00106                     deltw /= vdr;
00107                     qterr /= vdr;
00108                } else{
00109                     continue;
00110                }
00111 
00112                qbcen = ( (double)bin + 0.5 ) * m_qbinw[lay] + m_qmin[lay];
00113 //             tw = qtFun(qbcen, m_qtpar[lay]) + deltw;
00114 //             tw = (m_mdcFunSvc->getTimeWalk(lay, qbcen)) + deltw;
00115                tw = qtini[1] / sqrt(qbcen) + qtini[0] + deltw;
00116 
00117                m_grqt[lay]->SetPoint(bin, qbcen, tw);
00118                m_grqt[lay]->SetPointError(bin, 0, qterr);
00119 
00120                m_grqdt[lay]->SetPoint(bin, qbcen, deltw);
00121                m_grqdt[lay]->SetPointError(bin, 0, qterr);
00122 
00123                fqtlog << setw(3) << bin << setw(12) << deltw << setw(12) << tw
00124                       << setw(12) << qbcen << setw(12) << qterr << endl;
00125           }
00126 
00127           m_grqt[lay]->Fit("funQt", "Q+", "", m_qmin[lay], m_qmax[lay]);
00128 
00129           fqtlog << "Qtpar:  ";
00130           for(int ord=0; ord<QtOrd; ord++){
00131                qtpar = funQt->GetParameter(ord);
00132                qterr = funQt->GetParError(ord);
00133                calconst -> resetQtpar(lay, ord, qtpar);
00134 
00135                fqtlog << setw(12) << qtpar << setw(12) << qterr << endl;
00136           }
00137      } // end of layer loop
00138      fqtlog.close();
00139      renameHist();
00140      delete funQt;
00141 }

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

Implements CalibBase.

00013                                                      {
00014      CalibBase::init(hlist, pGeom);
00015      m_pGeom = pGeom;
00016 
00017      char hname[200];
00018      for(int lay=0; lay<NLAYER; lay++){
00019           if(lay < 8){
00020                m_qmin[lay] = QMinS;
00021                m_qmax[lay] = QMaxS;
00022           }else {
00023                m_qmin[lay] = QMinL;
00024                m_qmax[lay] = QMaxL;
00025           }
00026           m_qbinw[lay] = (m_qmax[lay] - m_qmin[lay]) / (double)NQBin;
00027      }
00028 
00029      m_fdQt = new TFolder("mfdQt", "fdQt");
00030      m_fdQ_T = new TFolder("mQtPlot", "QtPlot");
00031      hlist -> Add(m_fdQt);
00032      hlist -> Add(m_fdQ_T);
00033 
00034      for(int lay=0; lay<NLAYER; lay++){
00035           sprintf(hname, "mHQ_Layer%02d", lay);
00036           m_hqhit[lay] = new TH1F(hname, "", 1500, 0, 3000);
00037           m_fdQt -> Add(m_hqhit[lay]);
00038 
00039           sprintf(hname, "mHQT_Plot_lay%02d", lay);
00040           m_grqt[lay] = new TGraphErrors();
00041           m_grqt[lay]->SetName(hname);
00042           m_grqt[lay]->SetMarkerStyle(20);
00043           m_grqt[lay]->SetMarkerColor(1);
00044           m_grqt[lay]->SetLineColor(10);
00045           m_fdQ_T->Add(m_grqt[lay]);
00046 
00047           sprintf(hname, "mHQdelT_Plot_lay%02d", lay);
00048           m_grqdt[lay] = new TGraphErrors();
00049           m_grqdt[lay]->SetName(hname);
00050           m_grqdt[lay]->SetMarkerStyle(10);
00051           m_grqdt[lay]->SetMarkerColor(1);
00052           m_grqdt[lay]->SetLineColor(10);
00053           m_fdQ_T->Add(m_grqdt[lay]);
00054         
00055           for(int bin=0; bin<NQBin; bin++){
00056                sprintf(hname, "mHQT_Lay%02d_Bin%02d", lay, bin);
00057                m_hqt[lay][bin] = new TH1F(hname, "", 200, -1, 1);
00058                m_fdQt -> Add(m_hqt[lay][bin]);
00059           }
00060      }
00061 }

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

Implements CalibBase.

00063                                    {
00064      CalibBase::mergeHist(fhist);
00065 
00066      char hname[200];
00067      TH1F* hist;
00068      TFolder* fdQt = (TFolder*)fhist->Get("fdQt");
00069      for(int lay=0; lay<NLAYER; lay++){
00070           sprintf(hname, "HQ_Layer%02d", lay);
00071           hist = (TH1F*)fdQt->FindObjectAny(hname);
00072           m_hqhit[lay]->Add(hist);
00073 
00074           for(int bin=0; bin<NQBin; bin++){
00075                sprintf(hname, "HQT_Lay%02d_Bin%02d", lay, bin);
00076                hist = (TH1F*)fdQt->FindObjectAny(hname);
00077                m_hqt[lay][bin]->Add(hist);
00078           }
00079      }
00080 }

Double_t QtCalib::qtFun (  Double_t *  x,
Double_t *  par
)  [static]
  

00143                                                  {
00144      Double_t tw = par[1] / sqrt(x[0]) + par[0];
00145      return tw;
00146 }

void QtCalib::renameHist (   )  [private]
 

Reimplemented from CalibBase.

00148                         {
00149      char hname[200];
00150      m_fdQt->SetName("fdQt");
00151      m_fdQ_T->SetName("QtPlot");
00152      for(int lay=0; lay<NLAYER; lay++){
00153           sprintf(hname, "HQ_Layer%02d", lay);
00154           m_hqhit[lay]->SetName(hname);
00155 
00156           sprintf(hname, "HQT_Plot_lay%02d", lay);
00157           m_grqt[lay]->SetName(hname);
00158 
00159           sprintf(hname, "HQdelT_Plot_lay%02d", lay);
00160           m_grqdt[lay]->SetName(hname);
00161 
00162           for(int bin=0; bin<NQBin; bin++){
00163                sprintf(hname, "HQT_Lay%02d_Bin%02d", lay, bin);
00164                m_hqt[lay][bin]->SetName(hname);
00165           }
00166      }
00167 }

Member Data Documentation

TFolder* QtCalib::m_fdQ_T [private]
 

TFolder* QtCalib::m_fdQt [private]
 

TGraphErrors* QtCalib::m_grqdt[NLAYER] [private]
 

TGraphErrors* QtCalib::m_grqt[NLAYER] [private]
 

TH1F* QtCalib::m_hqhit[NLAYER] [private]
 

TH1F* QtCalib::m_hqt[NLAYER][NQBin] [private]
 

MdcCosGeom* QtCalib::m_pGeom [private]
 

double QtCalib::m_qbinw[NLAYER] [private]
 

double QtCalib::m_qmax[NLAYER] [private]
 

double QtCalib::m_qmin[NLAYER] [private]
 

double QtCalib::m_qtpar[NLAYER][QtOrd] [private]
 

const int QtCalib::NQBin = 10 [static, private]
 

const double QtCalib::QMaxL = 1200 [static, private]
 

const double QtCalib::QMaxS = 1000 [static, private]
 

const double QtCalib::QMinL = 400 [static, private]
 

const double QtCalib::QMinS = 350 [static, private]
 

const int QtCalib::QtOrd = 2 [static, private]
 

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