GrXtCalib Class Reference

#include <GrXtCalib.h>

Inheritance diagram for GrXtCalib:

CalibBase List of all members.

Public Member Functions

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

Private Member Functions

void renameHist ()
int findXtEntr (int lay, int iEntr, int lr) const

Private Attributes

int m_maxNhit
int m_nMaxEd
double m_tEd [NLAYER]
int m_nhitIn [NLAYER][NENTRXT][NLR]
int m_nhitEd [NLAYER][NENTRXT][NLR]
bool m_fgFit [NLAYER][NENTRXT][NLR]
TFolder * m_fdXt
TH2F * m_haxis
TGraph * m_grxt [NLAYER][NENTRXT][NLR]

Detailed Description

Definition at line 11 of file GrXtCalib.h.

Constructor & Destructor Documentation

GrXtCalib::GrXtCalib (  ) 

Definition at line 9 of file GrXtCalib.cpp.

References m_maxNhit, m_nMaxEd, m_tEd, and NLAYER.

00009                     {
00010      m_maxNhit = 5000;
00011      m_nMaxEd = 1000;
00012      for(int lay=0; lay<NLAYER; lay++){
00013           if(lay<8) m_tEd[lay] = 200.0;
00014           else m_tEd[lay] = 300.0;
00015      }
00016      cout << "Calibration type: GrXtCalib" << endl;
00017 }

GrXtCalib::~GrXtCalib (  ) 

Definition at line 19 of file GrXtCalib.cpp.

00019                      {
00020 }

Member Function Documentation

void GrXtCalib::calib ( MdcCalibConst *  calconst,
TObjArray *  newXtList,
TObjArray *  r2tList 
) [virtual]

Implements CalibBase.

Definition at line 81 of file GrXtCalib.cpp.

References CalibBase::calib(), Dmax, findXtEntr(), gFgCalib, gfixXtC0, m_fgFit, m_grxt, m_nhitEd, m_nhitIn, NENTRXT, NLAYER, NLR, renameHist(), MdcCalibConst::resetXtpar(), Tmax, xtFitEdge(), and xtFitFun().

00081                                                                                       {
00082      CalibBase::calib(calconst, newXtList, r2tList);
00083 
00084      int ord;
00085      double xtpar[NLAYER][NENTRXT][NLR][8];
00086      TF1* fxtDr = new TF1("fxtDr", xtFitFun, 0, 300, 6);
00087      TF1* fxtEd = new TF1("fxtEd", xtFitEdge, 150, 500, 1);
00088      if(1 == gfixXtC0) fxtDr -> FixParameter(0, 0);
00089 
00090      for(int lay=0; lay<NLAYER; lay++){
00091           for(int iEntr=0; iEntr<NENTRXT; iEntr++){
00092                for(int lr=0; lr<NLR; lr++){
00093                     m_fgFit[lay][iEntr][lr] = false;
00094                     if(0 == gFgCalib[lay]) continue;
00095 
00096                     if(m_nhitIn[lay][iEntr][lr] > 1000){
00097                          Tmax = calconst -> getXtpar(lay, iEntr, lr, 6);
00098 
00099                          m_grxt[lay][iEntr][lr] -> Fit("fxtDr", "Q+", "", 0, Tmax);
00100                          for(ord=0; ord<6; ord++){
00101                               xtpar[lay][iEntr][lr][ord] = fxtDr->GetParameter(ord);
00102                          }
00103                          xtpar[lay][iEntr][lr][6] = Tmax;
00104 
00105                          Dmax = 0.0;
00106                          for(ord=0; ord<6; ord++) Dmax += xtpar[lay][iEntr][lr][ord] * pow(Tmax, ord);
00107 
00108                          if(m_nhitEd[lay][iEntr][lr] > 300){
00109                               m_grxt[lay][iEntr][lr] -> Fit("fxtEd", "Q+", "", Tmax, Tmax+300);
00110                               xtpar[lay][iEntr][lr][7] = fxtEd->GetParameter(0);
00111                               if(xtpar[lay][iEntr][lr][7] < 0.0) xtpar[lay][iEntr][lr][7] = 0.0;
00112                          } else{
00113                               xtpar[lay][iEntr][lr][7] = 0.0;
00114                          }
00115 
00116                          m_fgFit[lay][iEntr][lr] = true;
00117                     }
00118 
00119                } // end of lr loop
00120           } // end of entrance angle loop
00121      } // end of layer loop
00122 
00123      ofstream fxtlog("xtlog");
00124      for(int lay=0; lay<NLAYER; lay++){
00125           for(int iEntr=0; iEntr<NENTRXT; iEntr++){
00126                for(int lr=0; lr<NLR; lr++){
00127                     fxtlog << setw(3) << lay << setw(3) << iEntr << setw(3) << lr;
00128 
00129                     int fgUpdate = -1;
00130                     if(m_fgFit[lay][iEntr][lr]){
00131                          fgUpdate = 1;
00132                          for(ord=0; ord<8; ord++) calconst->resetXtpar(lay, iEntr, lr, ord, xtpar[lay][iEntr][lr][ord]);
00133                     } else{
00134                          int iEntrNew = findXtEntr(lay, iEntr, lr);
00135                          if(-1 != iEntrNew){
00136                               fgUpdate = 2;
00137                               for(ord=0; ord<8; ord++){
00138                                    calconst->resetXtpar(lay, iEntr, lr, ord, xtpar[lay][iEntrNew][lr][ord]);
00139                               }
00140                          }
00141                     }
00142                     fxtlog << setw(3) << fgUpdate;
00143                     for(ord=0; ord<8; ord++){
00144                          double par = calconst -> getXtpar(lay, iEntr, lr, ord);
00145                          if(6==ord) fxtlog << setw(9) << par;
00146                          else fxtlog << setw(14) << par;
00147                     }
00148                     fxtlog << endl;
00149                }
00150           }
00151      }
00152      fxtlog.close();
00153 
00154      cout << "Xt update finished. File xtlog was written." << endl;
00155 
00156      renameHist();
00157      delete fxtDr;
00158      delete fxtEd;
00159 }

int GrXtCalib::findXtEntr ( int  lay,
int  iEntr,
int  lr 
) const [private]

Definition at line 174 of file GrXtCalib.cpp.

References genRecEmupikp::i, and m_fgFit.

Referenced by calib().

00174                                                           {
00175      int id0 = 8;
00176      int id1 = 9;
00177      int idmax = 17;
00178      int entrId = -1;
00179      if(iEntr <= id0){
00180           int id = -1;
00181           for(int i=iEntr; i<=id0; i++){
00182                if(m_fgFit[lay][i][lr]){
00183                     id = i;
00184                     break;
00185                }
00186           }
00187           if(-1 != id) entrId = id;
00188           else{
00189                for(int i=iEntr; i>=0; i--){
00190                     if(m_fgFit[lay][i][lr]){
00191                          id = i;
00192                          break;
00193                     }
00194                }
00195                entrId = id;
00196           }
00197      } else{
00198           int id = -1;
00199           for(int i=iEntr; i>=id1; i--){
00200                if(m_fgFit[lay][i][lr]){
00201                     id = i;
00202                     break;
00203                }
00204           }
00205           if(-1 != id) entrId = id;
00206           else{
00207                for(int i=iEntr; i<idmax; i++){
00208                     if(m_fgFit[lay][i][lr]){
00209                          id = i;
00210                          break;
00211                     }
00212                }
00213                entrId = id;
00214           }
00215      }
00216      if(-1 == entrId){
00217           cout << "find EntrId error " << "layer " << lay << "  iEntr " << iEntr << "  lr " << lr << endl;
00218      }
00219 
00220      return entrId;
00221 }

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

Implements CalibBase.

Definition at line 22 of file GrXtCalib.cpp.

References CalibBase::init(), m_fdXt, m_grxt, m_haxis, m_nhitEd, m_nhitIn, NENTRXT, NLAYER, and NLR.

00022                                                        {
00023      CalibBase::init(hlist, pGeom);
00024 
00025      m_fdXt = new TFolder("mfdxt","fdxt");
00026      hlist->Add(m_fdXt);
00027 
00028      m_haxis = new TH2F("axis", "", 50, 0, 300, 50, 0, 9);
00029      m_haxis -> SetStats(0);
00030      m_fdXt -> Add(m_haxis);
00031 
00032      char hname[200];
00033      for(int lay=0; lay<NLAYER; lay++){
00034           for(int iEntr=0; iEntr<NENTRXT; iEntr++){
00035                for(int lr=0; lr<NLR; lr++){
00036                     m_nhitIn[lay][iEntr][lr] = 0;
00037                     m_nhitEd[lay][iEntr][lr] = 0;
00038 
00039                     sprintf(hname, "mgrXt%02d_%02d_lr%01d", lay, iEntr, lr);
00040                     m_grxt[lay][iEntr][lr] = new TGraph();
00041                     m_grxt[lay][iEntr][lr] -> SetName(hname);
00042                     m_grxt[lay][iEntr][lr] -> SetMarkerStyle(10);
00043                     m_grxt[lay][iEntr][lr] -> SetLineColor(10);
00044                     m_fdXt -> Add(m_grxt[lay][iEntr][lr]);
00045                }
00046           }
00047      }
00048 }

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

Implements CalibBase.

Definition at line 50 of file GrXtCalib.cpp.

References genRecEmupikp::i, m_grxt, m_maxNhit, m_nhitEd, m_nhitIn, m_nMaxEd, m_tEd, CalibBase::mergeHist(), NENTRXT, NLAYER, and NLR.

00050                                      {
00051      CalibBase::mergeHist(fhist);
00052 
00053      double tdr, doca;
00054      char hname[200];
00055      TFolder* fd = (TFolder*)fhist->Get("fdXtGr");
00056      for(int lay=0; lay<NLAYER; lay++){
00057           for(int iEntr=0; iEntr<NENTRXT; iEntr++){
00058                for(int lr=0; lr<NLR; lr++){
00059                     if((m_nhitIn[lay][iEntr][lr] > m_maxNhit) && (m_nhitEd[lay][iEntr][lr] > m_nMaxEd)) continue;
00060 
00061                     sprintf(hname, "grXt%02d_%02d_lr%01d", lay, iEntr, lr);
00062                     TGraph* gr = (TGraph*)fd->FindObjectAny(hname);
00063                     int nPoint = gr->GetN();
00064                     for(int i=0; i<nPoint; i++){
00065                          gr->GetPoint(i, tdr, doca);
00066                          if((tdr < m_tEd[lay]) && (m_nhitIn[lay][iEntr][lr] <= m_maxNhit)){
00067                               int np = m_grxt[lay][iEntr][lr]->GetN();
00068                               m_grxt[lay][iEntr][lr]->SetPoint(np, tdr, doca);
00069                               m_nhitIn[lay][iEntr][lr]++;
00070                          } else if((tdr >= m_tEd[lay]) && (m_nhitEd[lay][iEntr][lr] <= m_nMaxEd)){
00071                               int np = m_grxt[lay][iEntr][lr]->GetN();
00072                               m_grxt[lay][iEntr][lr]->SetPoint(np, tdr, doca);
00073                               m_nhitEd[lay][iEntr][lr]++;
00074                          }
00075                     }
00076                }
00077           }
00078      }
00079 }

void GrXtCalib::renameHist (  )  [private]

Reimplemented from CalibBase.

Definition at line 161 of file GrXtCalib.cpp.

References m_fdXt, m_grxt, NENTRXT, NLAYER, and NLR.

Referenced by calib().

00161                           {
00162      char hname[200];
00163      m_fdXt->SetName("fdXtGr");
00164      for(int lay=0; lay<NLAYER; lay++){
00165           for(int iEntr=0; iEntr<NENTRXT; iEntr++){
00166                for(int lr=0; lr<NLR; lr++){
00167                     sprintf(hname, "grXt%02d_%02d_lr%01d", lay, iEntr, lr);
00168                     m_grxt[lay][iEntr][lr] -> SetName(hname);
00169                }
00170           }
00171      }
00172 }

Member Data Documentation

TFolder* GrXtCalib::m_fdXt [private]

Definition at line 31 of file GrXtCalib.h.

Referenced by init(), and renameHist().

bool GrXtCalib::m_fgFit[NLAYER][NENTRXT][NLR] [private]

Definition at line 29 of file GrXtCalib.h.

Referenced by calib(), and findXtEntr().

TGraph* GrXtCalib::m_grxt[NLAYER][NENTRXT][NLR] [private]

Definition at line 33 of file GrXtCalib.h.

Referenced by calib(), init(), mergeHist(), and renameHist().

TH2F* GrXtCalib::m_haxis [private]

Definition at line 32 of file GrXtCalib.h.

Referenced by init().

int GrXtCalib::m_maxNhit [private]

Definition at line 23 of file GrXtCalib.h.

Referenced by GrXtCalib(), and mergeHist().

int GrXtCalib::m_nhitEd[NLAYER][NENTRXT][NLR] [private]

Definition at line 28 of file GrXtCalib.h.

Referenced by calib(), init(), and mergeHist().

int GrXtCalib::m_nhitIn[NLAYER][NENTRXT][NLR] [private]

Definition at line 27 of file GrXtCalib.h.

Referenced by calib(), init(), and mergeHist().

int GrXtCalib::m_nMaxEd [private]

Definition at line 24 of file GrXtCalib.h.

Referenced by GrXtCalib(), and mergeHist().

double GrXtCalib::m_tEd[NLAYER] [private]

Definition at line 25 of file GrXtCalib.h.

Referenced by GrXtCalib(), and mergeHist().

Generated on Tue Nov 29 23:19:39 2016 for BOSS_7.0.2 by  doxygen 1.4.7