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

GrXtMdcCalib Class Reference

#include <GrXtMdcCalib.h>

Inheritance diagram for GrXtMdcCalib:

MdcCalib MdcCalib List of all members.

Public Member Functions

void clear ()
void clear ()
int fillHist (MdcCalEvent *event)
int fillHist (MdcCalEvent *event)
int getHxtKey (int layid, int entr, int lr, int bin) const
int getHxtKey (int layid, int entr, int lr, int bin) const
 GrXtMdcCalib ()
 GrXtMdcCalib ()
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)
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)
 ~GrXtMdcCalib ()
 ~GrXtMdcCalib ()

Static Public Member Functions

Double_t xtedge (Double_t *x, Double_t *par)
Double_t xtedge (Double_t *x, Double_t *par)
Double_t xtfun (Double_t *x, Double_t *par)
Double_t xtfun (Double_t *x, Double_t *par)

Private Attributes

double m_docaMax [MdcCalNLayer]
TFolder * m_fdXt
TFolder * m_fdXt
bool m_fgIni
TGraph * m_grxt [MdcCalNLayer][MdcCalNENTRXT][MdcCalLR]
TGraph * m_grxt [MdcCalNLayer][MdcCalNENTRXT][MdcCalLR]
TH2F * m_haxis
TH2F * m_haxis
TObjArray * m_hlist
TObjArray * m_hlist
int m_maxNhit
IMdcCalibFunSvc * m_mdcFunSvc
IMdcCalibFunSvc * m_mdcFunSvc
IMdcGeomSvc * m_mdcGeomSvc
IMdcGeomSvc * m_mdcGeomSvc
int m_nhit [MdcCalNLayer][MdcCalNENTRXT][MdcCalLR]
MdcCalParams m_param

Static Private Attributes

double DMAX
double TMAX

Constructor & Destructor Documentation

GrXtMdcCalib::GrXtMdcCalib (   ) 
  

00022                           {
00023      m_maxNhit = 5000;
00024      m_fgIni = false;
00025 }

GrXtMdcCalib::~GrXtMdcCalib (   ) 
  

00027                            {
00028 }

GrXtMdcCalib::GrXtMdcCalib (   ) 
 

GrXtMdcCalib::~GrXtMdcCalib (   ) 
 

Member Function Documentation

void GrXtMdcCalib::clear (   )  [virtual]
 

Implements MdcCalib.

void GrXtMdcCalib::clear (   )  [virtual]
 

Implements MdcCalib.

00030                         {
00031      cout << "~GrXtMdcCalib" << endl;
00032      for(int lay=0; lay<MdcCalNLayer; lay++){
00033           for(int iEntr=0; iEntr<MdcCalNENTRXT; iEntr++){
00034                for(int iLR=0; iLR<MdcCalLR; iLR++){
00035                     delete m_grxt[lay][iEntr][iLR];
00036                }
00037           }
00038      }
00039      delete m_haxis;
00040      delete m_fdXt;
00041 
00042      MdcCalib::clear();
00043 }

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

Implements MdcCalib.

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

Implements MdcCalib.

00086                                             {
00087      IMessageSvc* msgSvc;
00088      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00089      MsgStream log(msgSvc, "GrXtMdcCalib");
00090      log << MSG::DEBUG << "GrXtMdcCalib::fillHist()" << endreq;
00091 
00092      MdcCalib::fillHist(event);
00093 
00094      // get EsTimeCol
00095      bool esCutFg = event->getEsCutFlag();
00096      if( ! esCutFg ) return -1;
00097 
00098      int i;
00099      int k;
00100      int lay;
00101      int iLR;
00102      int iEntr;
00103 
00104      double dr;
00105      double dz;
00106      double doca;
00107      double tdr;
00108      double resi;
00109      double entrance;
00110 
00111      int nhitlay;
00112      bool fgHitLay[MdcCalNLayer];
00113      bool fgTrk;
00114      
00115      if(! m_fgIni){
00116           for(lay=0; lay<MdcCalNLayer; lay++){
00117                if(lay < 8) m_docaMax[lay] = m_param.maxDocaInner;
00118                else m_docaMax[lay] = m_param.maxDocaOuter;
00119           }
00120           m_fgIni = true;
00121      }
00122 
00123      MdcCalRecTrk* rectrk;
00124      MdcCalRecHit* rechit;
00125 
00126      int nhit;
00127      int ntrk = event -> getNTrk();
00128      for(i=0; i<ntrk; i++){
00129           fgTrk = true;
00130           rectrk = event->getRecTrk(i);
00131           nhit = rectrk -> getNHits();
00132 
00133           // dr cut
00134           dr = rectrk->getDr();
00135           if(fabs(dr) > m_param.drCut) continue;
00136         
00137           // dz cut
00138           dz = rectrk->getDz();
00139           if(fabs(dz) > m_param.dzCut) continue;
00140 
00141           for(lay=0; lay<MdcCalNLayer; lay++){
00142                fgHitLay[lay] = false;
00143           }
00144 
00145           for(k=0; k<nhit; k++){
00146                rechit = rectrk -> getRecHit(k);
00147                lay = rechit -> getLayid();
00148                doca = rechit -> getDocaInc();
00149                resi = rechit -> getResiInc();
00150                fgHitLay[lay] = true;
00151 
00152                if( (fabs(doca) > m_docaMax[lay]) || 
00153                    (fabs(resi) > m_param.maxResi) ){
00154                     fgTrk = false;
00155                }
00156           }
00157           if(! fgTrk) continue;
00158 
00159           nhitlay = 0;
00160           for(lay=0; lay<MdcCalNLayer; lay++){
00161                if(fgHitLay[lay]) nhitlay++;
00162           }
00163           if(nhitlay < m_param.nHitLayCut) continue;
00164 
00165           for(k=0; k<nhit; k++){
00166                rechit = rectrk -> getRecHit(k);
00167                lay = rechit -> getLayid();
00168                doca = rechit -> getDocaInc();
00169                resi = rechit -> getResiInc();
00170                iLR = rechit -> getLR();
00171                entrance = rechit -> getEntra();
00172                tdr = rechit -> getTdrift();
00173 
00174 //             if( (fabs(doca) > m_docaMax[lay]) || 
00175 //                 (fabs(resi) > m_param.maxResi) ){
00176 //                  continue;
00177 //             }
00178 
00179                if(0 == lay){
00180                     if( ! fgHitLay[1] ) continue;
00181                } else if(42 == lay){
00182                     if( ! fgHitLay[41] ) continue;
00183                } else{
00184                     if( (!fgHitLay[lay-1]) && (!fgHitLay[lay+1]) ) continue;
00185                }
00186 
00187                iEntr = m_mdcFunSvc -> getXtEntrIndex(entrance);
00188 
00189                if(iLR < 2){
00190                     if(m_nhit[lay][iEntr][iLR] < m_maxNhit){
00191                          m_grxt[lay][iEntr][iLR] -> SetPoint(m_nhit[lay][iEntr][iLR],
00192                                                              tdr, fabs(doca));
00193                          m_nhit[lay][iEntr][iLR]++;
00194                     }
00195                }
00196 
00197                if(m_nhit[lay][iEntr][2] < m_maxNhit){
00198                     m_grxt[lay][iEntr][2] -> SetPoint(m_nhit[lay][iEntr][2],
00199                                                       tdr, fabs(doca));
00200                     m_nhit[lay][iEntr][2]++;
00201                }
00202           } // hit loop
00203      } // track loop
00204      return 1;
00205 }

int GrXtMdcCalib::getHxtKey (  int  layid,
int  entr,
int  lr,
int  bin
)  const
 

int GrXtMdcCalib::getHxtKey (  int  layid,
int  entr,
int  lr,
int  bin
)  const
 

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

Implements MdcCalib.

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

Implements MdcCalib.

00046                                                         {
00047      IMessageSvc* msgSvc;
00048      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00049      MsgStream log(msgSvc, "GrXtMdcCalib");
00050      log << MSG::INFO << "GrXtMdcCalib::initialize()" << endreq;
00051 
00052      m_hlist = hlist;
00053      m_mdcGeomSvc = mdcGeomSvc;
00054      m_mdcFunSvc = mdcFunSvc;
00055 
00056      MdcCalib::initialize(m_hlist, m_mdcGeomSvc, m_mdcFunSvc);
00057 
00058      int lay;
00059      int iLR;
00060      int iEntr;
00061      char hname[200];
00062 
00063      m_fdXt = new TFolder("fdXtGr", "fdXtGr");
00064      m_hlist -> Add(m_fdXt);
00065 
00066      m_haxis = new TH2F("axis", "", 50, 0, 300, 50, 0, 9);
00067      m_haxis -> SetStats(0);
00068      m_fdXt -> Add(m_haxis);
00069 
00070      for(lay=0; lay<MdcCalNLayer; lay++){
00071           for(iEntr=0; iEntr<MdcCalNENTRXT; iEntr++){
00072                for(iLR=0; iLR<MdcCalLR; iLR++){
00073                     m_nhit[lay][iEntr][iLR] = 0;
00074 
00075                     sprintf(hname, "grXt%02d_%02d_lr%01d", lay, iEntr, iLR);
00076                     m_grxt[lay][iEntr][iLR] = new TGraph();
00077                     m_grxt[lay][iEntr][iLR] -> SetName(hname);
00078                     m_grxt[lay][iEntr][iLR] -> SetMarkerStyle(10);
00079                     m_grxt[lay][iEntr][iLR] -> SetLineColor(10);
00080                     m_fdXt -> Add(m_grxt[lay][iEntr][iLR]);
00081                }
00082           }
00083      }
00084 }

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

Reimplemented from MdcCalib.

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

Reimplemented from MdcCalib.

00326                                                       {
00327      MdcCalib::read_file(path);
00328 }

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

Implements MdcCalib.

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

Implements MdcCalib.

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

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

Reimplemented from MdcCalib.

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

Reimplemented from MdcCalib.

00285                                          { 
00286      MdcCalib::settuple(path);
00287      TFile *f1 = new TFile(path.c_str());
00288      std::cout<<path<<std::endl;
00289   
00290      int lay;
00291      int iLR;
00292      int iEntr;
00293      char hname[200];
00294 
00295      m_fdXt=(TFolder *)f1->Get("fdXtGr;1");
00296      m_haxis=(TH2F *) m_fdXt->FindObject("axis");
00297      m_haxis -> SetStats(0);
00298 
00300 
00301      for(lay=0; lay<MdcCalNLayer; lay++){
00302           for(iEntr=0; iEntr<MdcCalNENTRXT; iEntr++){
00303                for(iLR=0; iLR<MdcCalLR; iLR++){
00304                     m_nhit[lay][iEntr][iLR] = 0;
00305 
00306                     sprintf(hname, "grXt%02d_%02d_lr%01d", lay, iEntr, iLR);
00307                     m_grxt[lay][iEntr][iLR]=(TGraph *) m_fdXt ->FindObject(hname);
00308                     m_grxt[lay][iEntr][iLR] -> SetName(hname);
00309                     m_grxt[lay][iEntr][iLR] -> SetMarkerStyle(10);
00310                     m_grxt[lay][iEntr][iLR] -> SetLineColor(10);
00311                }
00312           }
00313      }
00314 
00315 
00316      if(! m_fgIni){
00317           for(lay=0; lay<MdcCalNLayer; lay++){
00318                if(lay < 8) m_docaMax[lay] = m_param.maxDocaInner;
00319                else m_docaMax[lay] = m_param.maxDocaOuter;
00320           }
00321           m_fgIni = true;
00322      }
00323 
00324 }

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

Implements MdcCalib.

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

Implements MdcCalib.

00207                                                     {
00208      IMessageSvc* msgSvc;
00209      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00210      MsgStream log(msgSvc, "GrXtMdcCalib");
00211      log << MSG::INFO << "GrXtMdcCalib::updateConst()" << endreq;
00212 
00213      MdcCalib::updateConst(calconst);
00214 
00215      int lay;
00216      int iLR;
00217      int iEntr;
00218      int bin;
00219      int ord;
00220      double par;
00221      double xtpar[8];
00222 
00223      TF1* fxtDr = new TF1("fxtDr", xtfun, 0, 300, 6);
00224      TF1* fxtEd = new TF1("fxtEd", xtedge, 150, 500, 1);
00225 
00226      if(1 == m_param.fixXtC0) fxtDr -> FixParameter(0, 0);
00227 
00228      ofstream fxtlog("xtlog");
00229      for(lay=0; lay<MdcCalNLayer; lay++){
00230           if(0 == m_param.fgCalib[lay]) continue;
00231 
00232           for(iEntr=0; iEntr<MdcCalNENTRXT; iEntr++){
00233                for(iLR=0; iLR<MdcCalLR; iLR++){
00234                     if(m_nhit[lay][iEntr][iLR] > 500){
00235                          TMAX = calconst -> getXtpar(lay, iEntr, iLR, 6);
00236 
00237                          m_grxt[lay][iEntr][iLR] -> Fit("fxtDr", "Q+", "", 0, TMAX);
00238 
00239                          for(ord=0; ord<6; ord++){
00240                               xtpar[ord] = fxtDr->GetParameter(ord);
00241                          }
00242                          xtpar[6] = TMAX;
00243 
00244                          DMAX = 0.0;
00245                          for(ord=0; ord<6; ord++) DMAX += xtpar[ord] * pow(TMAX, ord);
00246 
00247                          m_grxt[lay][iEntr][iLR] -> Fit("fxtEd", "Q+", "", TMAX, TMAX+200);
00248                          xtpar[7] = fxtEd->GetParameter(0);
00249                          if(xtpar[7] < 0.0) xtpar[7] = 0.0;
00250 
00251                          for(ord=0; ord<8; ord++){
00252                               calconst -> resetXtpar(lay, iEntr, iLR, ord, xtpar[ord]);
00253                          }
00254                     }
00255 
00256                     fxtlog << setw(3) << lay << setw(3) << iEntr << setw(3) << iLR;
00257                     for(ord=0; ord<8; ord++){
00258                          par = calconst -> getXtpar(lay, iEntr, iLR, ord);
00259                          fxtlog << setw(14) << par;
00260                     }
00261                     fxtlog << endl;
00262                } // end of lr loop
00263           } // end of entrance angle loop
00264      } // end of layer loop
00265      fxtlog.close();
00266      cout << "Xt update finished. File xtlog was written." << endl;
00267 
00268      delete fxtDr;
00269      delete fxtEd;
00270 }

Double_t GrXtMdcCalib::xtedge (  Double_t *  x,
Double_t *  par
)  [static]
 

Double_t GrXtMdcCalib::xtedge (  Double_t *  x,
Double_t *  par
)  [static]
  

00280                                                        {
00281      double val = DMAX + (x[0] - TMAX) * par[0];
00282      return val;
00283 }

Double_t GrXtMdcCalib::xtfun (  Double_t *  x,
Double_t *  par
)  [static]
 

Double_t GrXtMdcCalib::xtfun (  Double_t *  x,
Double_t *  par
)  [static]
  

00272                                                       {
00273      Double_t val = 0.0;
00274      for(Int_t ord=0; ord<6; ord++){
00275           val += par[ord] * pow(x[0], ord);
00276      }
00277      return val;
00278 }

Member Data Documentation

double GrXtMdcCalib::DMAX [static, private]
 

double GrXtMdcCalib::m_docaMax [private]
 

Reimplemented from MdcCalib.

TFolder* GrXtMdcCalib::m_fdXt [private]
 

TFolder* GrXtMdcCalib::m_fdXt [private]
 

bool GrXtMdcCalib::m_fgIni [private]
 

Reimplemented from MdcCalib.

TGraph* GrXtMdcCalib::m_grxt[MdcCalNLayer][MdcCalNENTRXT][MdcCalLR] [private]
 

TGraph* GrXtMdcCalib::m_grxt[MdcCalNLayer][MdcCalNENTRXT][MdcCalLR] [private]
 

TH2F* GrXtMdcCalib::m_haxis [private]
 

TH2F* GrXtMdcCalib::m_haxis [private]
 

TObjArray* GrXtMdcCalib::m_hlist [private]
 

Reimplemented from MdcCalib.

TObjArray* GrXtMdcCalib::m_hlist [private]
 

Reimplemented from MdcCalib.

int GrXtMdcCalib::m_maxNhit [private]
 

IMdcCalibFunSvc* GrXtMdcCalib::m_mdcFunSvc [private]
 

Reimplemented from MdcCalib.

IMdcCalibFunSvc* GrXtMdcCalib::m_mdcFunSvc [private]
 

Reimplemented from MdcCalib.

IMdcGeomSvc* GrXtMdcCalib::m_mdcGeomSvc [private]
 

Reimplemented from MdcCalib.

IMdcGeomSvc* GrXtMdcCalib::m_mdcGeomSvc [private]
 

Reimplemented from MdcCalib.

int GrXtMdcCalib::m_nhit [private]
 

MdcCalParams GrXtMdcCalib::m_param [private]
 

Reimplemented from MdcCalib.

double GrXtMdcCalib::TMAX [static, private]
 

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