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

QtMdcCalib Class Reference

#include <QtMdcCalib.h>

Inheritance diagram for QtMdcCalib:

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)
 QtMdcCalib ()
 QtMdcCalib ()
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)
 ~QtMdcCalib ()
 ~QtMdcCalib ()

Static Public Member Functions

Double_t qtFun (Double_t *x, Double_t *par)
Double_t qtFun (Double_t *x, Double_t *par)

Private Attributes

TFolder * m_fdQ_T
TFolder * m_fdQ_T
TFolder * m_fdQt
TFolder * m_fdQt
TGraphErrors * m_grqdt [MdcCalNLayer]
TGraphErrors * m_grqdt [MdcCalNLayer]
TGraphErrors * m_grqt [MdcCalNLayer]
TGraphErrors * m_grqt [MdcCalNLayer]
TObjArray * m_hlist
TObjArray * m_hlist
TH1F * m_hqhit [MdcCalNLayer]
TH1F * m_hqhit [MdcCalNLayer]
TH1F * m_hqt [MdcCalNLayer][MdcCalNQBin]
TH1F * m_hqt [MdcCalNLayer][MdcCalNQBin]
int m_innNLay
IMdcCalibFunSvc * m_mdcFunSvc
IMdcCalibFunSvc * m_mdcFunSvc
IMdcGeomSvc * m_mdcGeomSvc
IMdcGeomSvc * m_mdcGeomSvc
int m_nbin
int m_nlayer
MdcCalParams m_param
double m_qbinw [MdcCalNLayer]
double m_qhit
double m_qmax [MdcCalNLayer]
double m_qmin [MdcCalNLayer]
int m_qtorder
double m_qtpar [MdcCalNLayer][MdcCalQtOrd]
double m_resi
double m_vdr

Constructor & Destructor Documentation

QtMdcCalib::QtMdcCalib (   ) 
  

00021                       {
00022      m_vdr = 0.03;
00023 
00024      m_nlayer = MdcCalNLayer;
00025      m_qtorder = MdcCalQtOrd;
00026      m_nbin = MdcCalNQBin;
00027      m_innNLay = MdcCalInnNLay;
00028 }

QtMdcCalib::~QtMdcCalib (   ) 
  

00030                        {
00031 }

QtMdcCalib::QtMdcCalib (   ) 
 

QtMdcCalib::~QtMdcCalib (   ) 
 

Member Function Documentation

void QtMdcCalib::clear (   )  [virtual]
 

Implements MdcCalib.

void QtMdcCalib::clear (   )  [virtual]
 

Implements MdcCalib.

00033                       {
00034      int bin;
00035      for(int lay=0; lay<MdcCalNLayer; lay++){
00036           delete m_hqhit[lay];
00037           delete m_grqt[lay];
00038           delete m_grqdt[lay];
00039           for(bin=0; bin<MdcCalQtOrd; bin++){
00040                delete m_hqt[lay][bin];
00041           }
00042      }
00043      delete m_fdQt;
00044      delete m_fdQ_T;
00045 
00046      MdcCalib::clear();
00047 }

int QtMdcCalib::fillHist (  MdcCalEvent *  event  )  [virtual]
 

Implements MdcCalib.

int QtMdcCalib::fillHist (  MdcCalEvent *  event  )  [virtual]
 

Implements MdcCalib.

00112                                           {
00113      IMessageSvc* msgSvc;
00114      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00115      MsgStream log(msgSvc, "QtMdcCalib");
00116      log << MSG::DEBUG << "QtMdcCalib::fillHist()" << endreq;
00117 
00118      MdcCalib::fillHist(event);
00119 
00120      // get EsTimeCol
00121      bool esCutFg = event->getEsCutFlag();
00122      if( ! esCutFg ) return -1;
00123 
00124      int i;
00125      int k;
00126      int bin;
00127      int lay;
00128 
00129      double doca;
00130      double dmeas;
00131 
00132      int ntrk;
00133      int nhit;
00134 
00135      MdcCalRecTrk* rectrk;
00136      MdcCalRecHit* rechit;
00137 
00138      ntrk = event -> getNTrk();
00139      for(i=0; i<ntrk; i++){
00140           rectrk = event -> getRecTrk(i);
00141           nhit = rectrk -> getNHits();
00142 
00143           for(k=0; k<nhit; k++){
00144                rechit = rectrk -> getRecHit(k);
00145                lay = rechit -> getLayid();
00146                doca = rechit -> getDocaInc();
00147                dmeas = rechit -> getDmeas();
00148                m_resi = rechit -> getResiInc();
00149                m_qhit = rechit -> getQhit();
00150 
00151                m_hqhit[lay] -> Fill(m_qhit);
00152 
00153                bin = (int)((m_qhit - m_qmin[lay]) / m_qbinw[lay]);
00154                if( (bin >= 0) && (bin < m_nbin) ){
00155                     m_hqt[lay][bin] -> Fill( m_resi );
00156                }
00157           }
00158      }
00159      return 1;
00160 }

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

Implements MdcCalib.

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

Implements MdcCalib.

00050                                                         {
00051      IMessageSvc* msgSvc;
00052      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00053      MsgStream log(msgSvc, "QtMdcCalib");
00054      log << MSG::INFO << "QtMdcCalib::initialize()" << endreq;
00055 
00056      m_hlist = hlist;
00057      m_mdcGeomSvc = mdcGeomSvc;
00058      m_mdcFunSvc = mdcFunSvc;
00059 
00060      MdcCalib::initialize(m_hlist, m_mdcGeomSvc, m_mdcFunSvc);
00061 
00062      int bin;
00063      int lay;
00064      double qbinw;
00065      char hname[200];
00066 
00067      for(lay=0; lay<m_nlayer; lay++){
00068           if(lay < m_innNLay){
00069                m_qmin[lay] = MdcCalQMinS;
00070                m_qmax[lay] = MdcCalQMaxS;
00071           }else {
00072                m_qmin[lay] = MdcCalQMinL;
00073                m_qmax[lay] = MdcCalQMaxL;
00074           }
00075           m_qbinw[lay] = (m_qmax[lay] - m_qmin[lay]) / (double)m_nbin;
00076      }
00077 
00078      m_fdQt = new TFolder("fdQt", "fdQt");
00079      m_fdQ_T = new TFolder("QtPlot", "QtPlot");
00080      m_hlist -> Add(m_fdQt);
00081      m_hlist -> Add(m_fdQ_T);
00082 
00083      for(lay=0; lay<m_nlayer; lay++){
00084           sprintf(hname, "HQ_Layer%02d", lay);
00085           m_hqhit[lay] = new TH1F(hname, "", 1500, 0, 3000);
00086           m_fdQt -> Add(m_hqhit[lay]);
00087 
00088           sprintf(hname, "HQT_Plot_lay%02d", lay);
00089           m_grqt[lay] = new TGraphErrors();
00090           m_grqt[lay]->SetName(hname);
00091           m_grqt[lay]->SetMarkerStyle(20);
00092           m_grqt[lay]->SetMarkerColor(1);
00093           m_grqt[lay]->SetLineColor(10);
00094           m_fdQ_T->Add(m_grqt[lay]);
00095 
00096           sprintf(hname, "HQdelT_Plot_lay%02d", lay);
00097           m_grqdt[lay] = new TGraphErrors();
00098           m_grqdt[lay]->SetName(hname);
00099           m_grqdt[lay]->SetMarkerStyle(10);
00100           m_grqdt[lay]->SetMarkerColor(1);
00101           m_grqdt[lay]->SetLineColor(10);
00102           m_fdQ_T->Add(m_grqdt[lay]);
00103         
00104           for(bin=0; bin<m_nbin; bin++){
00105                sprintf(hname, "HQT_Lay%02d_Bin%02d", lay, bin);
00106                m_hqt[lay][bin] = new TH1F(hname, "", 200, -1, 1);
00107                m_fdQt -> Add(m_hqt[lay][bin]);
00108           }
00109      }
00110 }

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

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

00260                                                     {
00261      double tw = par[1] / sqrt(x[0]) + par[0];
00262      return tw;
00263 }

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

Reimplemented from MdcCalib.

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

Reimplemented from MdcCalib.

00310                                                     {
00311      MdcCalib::read_file(path);
00312 }

void QtMdcCalib::setParam (  MdcCalParams &  param  )  [virtual]
 

Implements MdcCalib.

void QtMdcCalib::setParam (  MdcCalParams &  param  )  [inline, virtual]
 

Implements MdcCalib.

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

virtual void QtMdcCalib::settuple (  std::string  path  )  [virtual]
 

Reimplemented from MdcCalib.

void QtMdcCalib::settuple (  std::string  path  )  [virtual]
 

Reimplemented from MdcCalib.

00265                                        {
00266      MdcCalib::settuple(path);
00267      TFile *f1 = new TFile(path.c_str());
00268      std::cout<<path<<std::endl;
00269      //
00270      //  m_mdcGeomSvc = mdcGeomSvc;
00271      //m_mdcFunSvc = mdcFunSvc;
00272      int bin;
00273      int lay;
00274      double qbinw;
00275      char hname[200];
00276 
00277      for(lay=0; lay<m_nlayer; lay++){
00278           if(lay < m_innNLay){
00279                m_qmin[lay] = MdcCalQMinS;
00280                m_qmax[lay] = MdcCalQMaxS;
00281           }else {
00282                m_qmin[lay] = MdcCalQMinL;
00283                m_qmax[lay] = MdcCalQMaxL;
00284           }
00285           m_qbinw[lay] = (m_qmax[lay] - m_qmin[lay]) / (double)m_nbin;
00286      }
00287 
00288      m_fdQt =(TFolder *)f1->Get("fdQt;1");
00289      m_fdQ_T =(TFolder *)f1->Get("QtPlot;1");
00290     
00291      for(lay=0; lay<m_nlayer; lay++){
00292           sprintf(hname, "HQ_Layer%02d", lay);
00293           m_hqhit[lay] =(TH1F *)m_fdQt ->FindObject(hname);
00294        
00295           sprintf(hname, "HQT_Plot_lay%02d", lay);
00296           m_grqt[lay]=(TGraphErrors *) m_fdQ_T->FindObject(hname);
00297           m_grqdt[lay]->SetName(hname);
00298           m_grqdt[lay]->SetMarkerStyle(10);
00299           m_grqdt[lay]->SetMarkerColor(1);
00300           m_grqdt[lay]->SetLineColor(10);
00301   
00302           for(bin=0; bin<m_nbin; bin++){
00303                sprintf(hname, "HQT_Lay%02d_Bin%02d", lay, bin);
00304                m_hqt[lay][bin] =(TH1F *) m_fdQt ->FindObject(hname);
00305           }
00306      }
00307 
00308 }

int QtMdcCalib::updateConst (  MdcCalibConst *  calconst  )  [virtual]
 

Implements MdcCalib.

int QtMdcCalib::updateConst (  MdcCalibConst *  calconst  )  [virtual]
 

Implements MdcCalib.

00162                                                   {
00163      IMessageSvc* msgSvc;
00164      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00165      MsgStream log(msgSvc, "QtMdcCalib");
00166      log << MSG::INFO << "QtMdcCalib::updateConst()" << endreq;
00167 
00168      MdcCalib::updateConst(calconst);
00169 
00170      int lay;
00171      int bin;
00172      int ord;
00173 
00174      Stat_t entry;
00175      double qtpar;
00176      double qbcen;
00177      double tw;
00178      double deltw;
00179      double qterr;
00180 
00181      TF1* funQt = new TF1("funQt", qtFun, 200, 2000, 2);
00182 
00183      ofstream fqtlog("qtlog");
00184      for(lay=0; lay<m_nlayer; lay++){
00185           if(0 == m_param.fgCalib[lay]) continue;
00186 
00187           fqtlog << "Layer" << lay << endl;
00188 
00189           for(ord=0; ord<m_qtorder; ord++){
00190                m_qtpar[lay][ord] = calconst -> getQtpar(lay, ord);
00191           }
00192 
00193           for(bin=0; bin<m_nbin; bin++){
00194                entry = m_hqt[lay][bin] -> GetEntries();
00195 
00196                if(entry > 300){
00197                     deltw = m_hqt[lay][bin] -> GetMean();
00198                     qterr = ( m_hqt[lay][bin]->GetRMS() ) / sqrt((double)entry);
00199                     deltw /= m_vdr;
00200                     qterr /= m_vdr;
00201                } else{
00202                     continue;
00203                }
00204 
00205                qbcen = ( (double)bin + 0.5 ) * m_qbinw[lay] + m_qmin[lay];
00206 //             tw = qtFun(qbcen, m_qtpar[lay]) + deltw;
00207                tw = (m_mdcFunSvc->getTimeWalk(lay, qbcen)) + deltw;
00208 
00209                m_grqt[lay]->SetPoint(bin, qbcen, tw);
00210                m_grqt[lay]->SetPointError(bin, 0, qterr);
00211 
00212                m_grqdt[lay]->SetPoint(bin, qbcen, deltw);
00213                m_grqdt[lay]->SetPointError(bin, 0, qterr);
00214 
00215                fqtlog << setw(3) << bin
00216                       << setw(12) << deltw
00217                       << setw(12) << tw
00218                       << setw(12) << qbcen
00219                       << setw(12) << qterr
00220                       << endl;
00221           }
00222 
00223           m_grqt[lay]->Fit("funQt", "Q+", "", m_qmin[lay], m_qmax[lay]);
00224 
00225           fqtlog << "Qtpar:  ";
00226           for(ord=0; ord<m_qtorder; ord++){
00227                qtpar = funQt->GetParameter(ord);
00228                qterr = funQt->GetParError(ord);
00229                calconst -> resetQtpar(lay, ord, qtpar);
00230 
00231                fqtlog << setw(12) << qtpar
00232                       << setw(12) << qterr
00233                       << endl;
00234           }
00235 
00236 //        if( (0 == ierflg) && (3 == istat) ){
00237 //             for(ord=0; ord<m_qtorder; ord++){
00238 //                  gmqt -> GetParameter(ord, qtpar, qterr);
00239 //                  calconst -> resetQtpar(lay, ord, qtpar);
00240 
00241 //                  fqtlog << setw(12) << qtpar
00242 //                         << setw(12) << qterr
00243 //                         << endl;
00244 //             }
00245 //        } else{
00246 //             fqtlog << setw(12) << m_qtpar[lay][0] 
00247 //                    << setw(12) << "0"
00248 //                    << setw(12) << m_qtpar[lay][1]
00249 //                    << setw(12) << "0"
00250 //                    << endl;
00251 //        }
00252 
00253      } // end of layer loop
00254 
00255      fqtlog.close();
00256      delete funQt;
00257      return 1;
00258 }

Member Data Documentation

TFolder* QtMdcCalib::m_fdQ_T [private]
 

TFolder* QtMdcCalib::m_fdQ_T [private]
 

TFolder* QtMdcCalib::m_fdQt [private]
 

TFolder* QtMdcCalib::m_fdQt [private]
 

TGraphErrors* QtMdcCalib::m_grqdt[MdcCalNLayer] [private]
 

TGraphErrors* QtMdcCalib::m_grqdt[MdcCalNLayer] [private]
 

TGraphErrors* QtMdcCalib::m_grqt[MdcCalNLayer] [private]
 

TGraphErrors* QtMdcCalib::m_grqt[MdcCalNLayer] [private]
 

TObjArray* QtMdcCalib::m_hlist [private]
 

Reimplemented from MdcCalib.

TObjArray* QtMdcCalib::m_hlist [private]
 

Reimplemented from MdcCalib.

TH1F* QtMdcCalib::m_hqhit[MdcCalNLayer] [private]
 

TH1F* QtMdcCalib::m_hqhit[MdcCalNLayer] [private]
 

TH1F* QtMdcCalib::m_hqt[MdcCalNLayer][MdcCalNQBin] [private]
 

TH1F* QtMdcCalib::m_hqt[MdcCalNLayer][MdcCalNQBin] [private]
 

int QtMdcCalib::m_innNLay [private]
 

IMdcCalibFunSvc* QtMdcCalib::m_mdcFunSvc [private]
 

Reimplemented from MdcCalib.

IMdcCalibFunSvc* QtMdcCalib::m_mdcFunSvc [private]
 

Reimplemented from MdcCalib.

IMdcGeomSvc* QtMdcCalib::m_mdcGeomSvc [private]
 

Reimplemented from MdcCalib.

IMdcGeomSvc* QtMdcCalib::m_mdcGeomSvc [private]
 

Reimplemented from MdcCalib.

int QtMdcCalib::m_nbin [private]
 

int QtMdcCalib::m_nlayer [private]
 

Reimplemented from MdcCalib.

MdcCalParams QtMdcCalib::m_param [private]
 

Reimplemented from MdcCalib.

double QtMdcCalib::m_qbinw [private]
 

double QtMdcCalib::m_qhit [private]
 

Reimplemented from MdcCalib.

double QtMdcCalib::m_qmax [private]
 

double QtMdcCalib::m_qmin [private]
 

int QtMdcCalib::m_qtorder [private]
 

double QtMdcCalib::m_qtpar [private]
 

double QtMdcCalib::m_resi [private]
 

double QtMdcCalib::m_vdr [private]
 

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