QtMdcCalib Class Reference

#include <QtMdcCalib.h>

Inheritance diagram for QtMdcCalib:

MdcCalib List of all members.

Public Member Functions

 QtMdcCalib ()
 ~QtMdcCalib ()
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc, IMdcUtilitySvc *mdcUtilitySvc)
void setParam (MdcCalParams &param)
int fillHist (MdcCalEvent *event)
int updateConst (MdcCalibConst *calconst)
void clear ()

Static Public Member Functions

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

Private Attributes

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

Detailed Description

Definition at line 8 of file QtMdcCalib.h.

Constructor & Destructor Documentation

QtMdcCalib::QtMdcCalib (  ) 

Definition at line 21 of file QtMdcCalib.cxx.

References m_innNLay, m_nbin, m_nlayer, m_qtorder, m_vdr, MdcCalInnNLay, MdcCalNLayer, MdcCalNQBin, and MdcCalQtOrd.

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

Definition at line 30 of file QtMdcCalib.cxx.

00030                        {
00031 }

Member Function Documentation

void QtMdcCalib::clear (  )  [virtual]

Implements MdcCalib.

Definition at line 33 of file QtMdcCalib.cxx.

References bin, MdcCalib::clear(), m_fdQ_T, m_fdQt, m_grqdt, m_grqt, m_hqhit, m_hqt, MdcCalNLayer, and MdcCalQtOrd.

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.

Definition at line 106 of file QtMdcCalib.cxx.

References bin, Bes_Common::DEBUG, MdcCalParams::drCut, MdcCalParams::dzCut, MdcCalib::fillHist(), MdcCalRecTrk::getDr(), MdcCalRecTrk::getDz(), MdcCalEvent::getEsCutFlag(), MdcCalRecTrk::getFgNoiseRatio(), genRecEmupikp::i, m_hqhit, m_hqt, m_nbin, m_param, m_qbinw, m_qhit, m_qmin, m_resi, MdcCalNLayer, msgSvc(), MdcCalParams::nHitLayCut, and MdcCalParams::noiseCut.

00106                                           {
00107      IMessageSvc* msgSvc;
00108      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00109      MsgStream log(msgSvc, "QtMdcCalib");
00110      log << MSG::DEBUG << "QtMdcCalib::fillHist()" << endreq;
00111 
00112      MdcCalib::fillHist(event);
00113 
00114      // get EsTimeCol
00115      bool esCutFg = event->getEsCutFlag();
00116      if( ! esCutFg ) return -1;
00117 
00118      int i;
00119      int k;
00120      int bin;
00121      int lay;
00122 
00123      double doca;
00124      double dmeas;
00125 
00126      int ntrk;
00127      int nhit;
00128 
00129      bool fgHitLay[MdcCalNLayer];
00130 
00131      MdcCalRecTrk* rectrk;
00132      MdcCalRecHit* rechit;
00133 
00134      ntrk = event -> getNTrk();
00135      for(i=0; i<ntrk; i++){
00136           rectrk = event -> getRecTrk(i);
00137           nhit = rectrk -> getNHits();
00138 
00139           // dr cut
00140           double dr = rectrk->getDr();
00141           if(fabs(dr) > m_param.drCut) continue;
00142 
00143           // dz cut
00144           double dz = rectrk->getDz();
00145           if(fabs(dz) > m_param.dzCut) continue;
00146 
00147           for(lay=0; lay<MdcCalNLayer; lay++) fgHitLay[lay] = false;
00148           for(k=0; k<nhit; k++){
00149                rechit = rectrk -> getRecHit(k);
00150                lay = rechit -> getLayid();
00151                fgHitLay[lay] = true;
00152           }
00153 
00154           int nhitlay = 0;
00155           for(lay=0; lay<MdcCalNLayer; lay++) if(fgHitLay[lay]) nhitlay++;
00156           if(nhitlay < m_param.nHitLayCut) continue;
00157 
00158           bool fgNoise = rectrk->getFgNoiseRatio();
00159           if(m_param.noiseCut && (!fgNoise)) continue;
00160 
00161           for(k=0; k<nhit; k++){
00162                rechit = rectrk -> getRecHit(k);
00163                lay = rechit -> getLayid();
00164                doca = rechit -> getDocaInc();
00165                dmeas = rechit -> getDmeas();
00166                m_resi = rechit -> getResiInc();
00167                m_qhit = rechit -> getQhit();
00168 
00169                m_hqhit[lay] -> Fill(m_qhit);
00170 
00171                bin = (int)((m_qhit - m_qmin[lay]) / m_qbinw[lay]);
00172                if( (bin >= 0) && (bin < m_nbin) ){
00173                     m_hqt[lay][bin] -> Fill( m_resi );
00174                }
00175           }
00176      }
00177      return 1;
00178 }

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

Implements MdcCalib.

Definition at line 49 of file QtMdcCalib.cxx.

References bin, Bes_Common::INFO, MdcCalib::initialize(), m_fdQ_T, m_fdQt, m_grqdt, m_grqt, m_hlist, m_hqhit, m_hqt, m_mdcFunSvc, m_mdcGeomSvc, m_mdcUtilitySvc, m_nbin, m_nlayer, m_param, m_qbinw, m_qmax, m_qmin, msgSvc(), MdcCalParams::qmax, and MdcCalParams::qmin.

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      m_mdcUtilitySvc = mdcUtilitySvc;
00060 
00061      MdcCalib::initialize(m_hlist, m_mdcGeomSvc, m_mdcFunSvc, m_mdcUtilitySvc);
00062 
00063      int bin;
00064      int lay;
00065      double qbinw;
00066      char hname[200];
00067 
00068      for(lay=0; lay<m_nlayer; lay++){
00069           m_qmin[lay] = m_param.qmin[lay];
00070           m_qmax[lay] = m_param.qmax[lay];
00071           m_qbinw[lay] = (m_qmax[lay] - m_qmin[lay]) / (double)m_nbin;
00072      }
00073 
00074      m_fdQt = new TFolder("fdQt", "fdQt");
00075      m_fdQ_T = new TFolder("QtPlot", "QtPlot");
00076      m_hlist -> Add(m_fdQt);
00077      m_hlist -> Add(m_fdQ_T);
00078 
00079      for(lay=0; lay<m_nlayer; lay++){
00080           sprintf(hname, "HQ_Layer%02d", lay);
00081           m_hqhit[lay] = new TH1F(hname, "", 1500, 0, 3000);
00082           m_fdQt -> Add(m_hqhit[lay]);
00083 
00084           sprintf(hname, "HQT_Plot_lay%02d", lay);
00085           m_grqt[lay] = new TGraphErrors();
00086           m_grqt[lay]->SetName(hname);
00087           m_grqt[lay]->SetMarkerStyle(20);
00088           m_grqt[lay]->SetMarkerColor(1);
00089           m_fdQ_T->Add(m_grqt[lay]);
00090 
00091           sprintf(hname, "HQdelT_Plot_lay%02d", lay);
00092           m_grqdt[lay] = new TGraphErrors();
00093           m_grqdt[lay]->SetName(hname);
00094           m_grqdt[lay]->SetMarkerStyle(10);
00095           m_grqdt[lay]->SetMarkerColor(1);
00096           m_fdQ_T->Add(m_grqdt[lay]);
00097         
00098           for(bin=0; bin<m_nbin; bin++){
00099                sprintf(hname, "HQT_Lay%02d_Bin%02d", lay, bin);
00100                m_hqt[lay][bin] = new TH1F(hname, "", 200, -1, 1);
00101                m_fdQt -> Add(m_hqt[lay][bin]);
00102           }
00103      }
00104 }

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

Definition at line 278 of file QtMdcCalib.cxx.

Referenced by updateConst().

00278                                                     {
00279      double tw = par[1] / sqrt(x[0]) + par[0];
00280      return tw;
00281 }

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

Implements MdcCalib.

Definition at line 52 of file QtMdcCalib.h.

References m_param, and MdcCalib::setParam().

00052                                                    {
00053      MdcCalib::setParam(param);
00054      m_param = param;
00055 }

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

Implements MdcCalib.

Definition at line 180 of file QtMdcCalib.cxx.

References bin, MdcCalParams::fgCalib, IMdcCalibFunSvc::getTimeWalk(), Bes_Common::INFO, m_grqdt, m_grqt, m_hqt, m_mdcFunSvc, m_nbin, m_nlayer, m_param, m_qbinw, m_qmax, m_qmin, m_qtorder, m_qtpar, m_vdr, msgSvc(), qtFun(), and MdcCalib::updateConst().

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

Member Data Documentation

TFolder* QtMdcCalib::m_fdQ_T [private]

Definition at line 47 of file QtMdcCalib.h.

Referenced by clear(), and initialize().

TFolder* QtMdcCalib::m_fdQt [private]

Definition at line 44 of file QtMdcCalib.h.

Referenced by clear(), and initialize().

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

Definition at line 49 of file QtMdcCalib.h.

Referenced by clear(), initialize(), and updateConst().

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

Definition at line 48 of file QtMdcCalib.h.

Referenced by clear(), initialize(), and updateConst().

TObjArray* QtMdcCalib::m_hlist [private]

Reimplemented from MdcCalib.

Definition at line 25 of file QtMdcCalib.h.

Referenced by initialize().

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

Definition at line 45 of file QtMdcCalib.h.

Referenced by clear(), fillHist(), and initialize().

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

Definition at line 46 of file QtMdcCalib.h.

Referenced by clear(), fillHist(), initialize(), and updateConst().

int QtMdcCalib::m_innNLay [private]

Definition at line 32 of file QtMdcCalib.h.

Referenced by QtMdcCalib().

IMdcCalibFunSvc* QtMdcCalib::m_mdcFunSvc [private]

Reimplemented from MdcCalib.

Definition at line 27 of file QtMdcCalib.h.

Referenced by initialize(), and updateConst().

IMdcGeomSvc* QtMdcCalib::m_mdcGeomSvc [private]

Reimplemented from MdcCalib.

Definition at line 26 of file QtMdcCalib.h.

Referenced by initialize().

IMdcUtilitySvc* QtMdcCalib::m_mdcUtilitySvc [private]

Reimplemented from MdcCalib.

Definition at line 28 of file QtMdcCalib.h.

Referenced by initialize().

int QtMdcCalib::m_nbin [private]

Definition at line 31 of file QtMdcCalib.h.

Referenced by fillHist(), initialize(), QtMdcCalib(), and updateConst().

int QtMdcCalib::m_nlayer [private]

Reimplemented from MdcCalib.

Definition at line 30 of file QtMdcCalib.h.

Referenced by initialize(), QtMdcCalib(), and updateConst().

MdcCalParams QtMdcCalib::m_param [private]

Reimplemented from MdcCalib.

Definition at line 23 of file QtMdcCalib.h.

Referenced by fillHist(), initialize(), setParam(), and updateConst().

double QtMdcCalib::m_qbinw[MdcCalNLayer] [private]

Definition at line 39 of file QtMdcCalib.h.

Referenced by fillHist(), initialize(), and updateConst().

double QtMdcCalib::m_qhit [private]

Reimplemented from MdcCalib.

Definition at line 35 of file QtMdcCalib.h.

Referenced by fillHist().

double QtMdcCalib::m_qmax[MdcCalNLayer] [private]

Definition at line 41 of file QtMdcCalib.h.

Referenced by initialize(), and updateConst().

double QtMdcCalib::m_qmin[MdcCalNLayer] [private]

Definition at line 40 of file QtMdcCalib.h.

Referenced by fillHist(), initialize(), and updateConst().

int QtMdcCalib::m_qtorder [private]

Definition at line 33 of file QtMdcCalib.h.

Referenced by QtMdcCalib(), and updateConst().

double QtMdcCalib::m_qtpar[MdcCalNLayer][MdcCalQtOrd] [private]

Definition at line 42 of file QtMdcCalib.h.

Referenced by updateConst().

double QtMdcCalib::m_resi [private]

Definition at line 36 of file QtMdcCalib.h.

Referenced by fillHist().

double QtMdcCalib::m_vdr [private]

Definition at line 37 of file QtMdcCalib.h.

Referenced by QtMdcCalib(), and updateConst().

Generated on Tue Nov 29 23:20:44 2016 for BOSS_7.0.2 by  doxygen 1.4.7