GrXtCalib Class Reference

#include <GrXtCalib.h>

Inheritance diagram for GrXtCalib:

Public Member Functions
	GrXtCalib ()
	~GrXtCalib ()
void	init (TObjArray *hlist, MdcCosGeom *pGeom)
void	mergeHist (TFile *fhist)
void	calib (MdcCalibConst *calconst, TObjArray *newXtList, TObjArray *r2tList)
Public Member Functions inherited from CalibBase
	CalibBase ()
virtual	~CalibBase ()
virtual void	init (TObjArray *hlist, MdcCosGeom *pGeom)=0
virtual void	mergeHist (TFile *fhist)=0
virtual void	calib (MdcCalibConst *calconst, TObjArray *newXtList, TObjArray *r2tList)=0

Detailed Description

Definition at line 11 of file GrXtCalib.h.

Constructor & Destructor Documentation

GrXtCalib()

GrXtCalib::GrXtCalib

(

)

Definition at line 9 of file GrXtCalib.cpp.

                    {
     m_maxNhit = 5000;
     m_nMaxEd = 1000;
     for(int lay=0; lay<NLAYER; lay++){
      if(lay<8) m_tEd[lay] = 200.0;
      else m_tEd[lay] = 300.0;
     }
     cout << "Calibration type: GrXtCalib" << endl;
}

~GrXtCalib()

GrXtCalib::~GrXtCalib

(

)

Definition at line 19 of file GrXtCalib.cpp.

                     {
}

Member Function Documentation

calib()

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

virtual

Implements CalibBase.

Definition at line 81 of file GrXtCalib.cpp.

                                                                                      {
     CalibBase::calib(calconst, newXtList, r2tList);
 
     int ord;
     double xtpar[NLAYER][NENTRXT][NLR][8];
     TF1* fxtDr = new TF1("fxtDr", xtFitFun, 0, 300, 6);
     TF1* fxtEd = new TF1("fxtEd", xtFitEdge, 150, 500, 1);
     if(1 == gfixXtC0) fxtDr -> FixParameter(0, 0);
 
     for(int lay=0; lay<NLAYER; lay++){
      for(int iEntr=0; iEntr<NENTRXT; iEntr++){
           for(int lr=0; lr<NLR; lr++){
            m_fgFit[lay][iEntr][lr] = false;
            if(0 == gFgCalib[lay]) continue;
 
            if(m_nhitIn[lay][iEntr][lr] > 1000){
             Tmax = calconst -> getXtpar(lay, iEntr, lr, 6);
 
             m_grxt[lay][iEntr][lr] -> Fit("fxtDr", "Q+", "", 0, Tmax);
             for(ord=0; ord<6; ord++){
                  xtpar[lay][iEntr][lr][ord] = fxtDr->GetParameter(ord);
             }
             xtpar[lay][iEntr][lr][6] = Tmax;
 
             Dmax = 0.0;
             for(ord=0; ord<6; ord++) Dmax += xtpar[lay][iEntr][lr][ord] * pow(Tmax, ord);
 
             if(m_nhitEd[lay][iEntr][lr] > 300){
                  m_grxt[lay][iEntr][lr] -> Fit("fxtEd", "Q+", "", Tmax, Tmax+300);
                  xtpar[lay][iEntr][lr][7] = fxtEd->GetParameter(0);
                  if(xtpar[lay][iEntr][lr][7] < 0.0) xtpar[lay][iEntr][lr][7] = 0.0;
             } else{
                  xtpar[lay][iEntr][lr][7] = 0.0;
             }
 
             m_fgFit[lay][iEntr][lr] = true;
            }
 
           } // end of lr loop
      } // end of entrance angle loop
     } // end of layer loop
 
     ofstream fxtlog("xtlog");
     for(int lay=0; lay<NLAYER; lay++){
      for(int iEntr=0; iEntr<NENTRXT; iEntr++){
           for(int lr=0; lr<NLR; lr++){
            fxtlog << setw(3) << lay << setw(3) << iEntr << setw(3) << lr;
 
            int fgUpdate = -1;
            if(m_fgFit[lay][iEntr][lr]){
             fgUpdate = 1;
             for(ord=0; ord<8; ord++) calconst->resetXtpar(lay, iEntr, lr, ord, xtpar[lay][iEntr][lr][ord]);
            } else{
             int iEntrNew = findXtEntr(lay, iEntr, lr);
             if(-1 != iEntrNew){
                  fgUpdate = 2;
                  for(ord=0; ord<8; ord++){
                   calconst->resetXtpar(lay, iEntr, lr, ord, xtpar[lay][iEntrNew][lr][ord]);
                  }
             }
            }
            fxtlog << setw(3) << fgUpdate;
            for(ord=0; ord<8; ord++){
             double par = calconst -> getXtpar(lay, iEntr, lr, ord);
             if(6==ord) fxtlog << setw(9) << par;
             else fxtlog << setw(14) << par;
            }
            fxtlog << endl;
           }
      }
     }
     fxtlog.close();
 
     cout << "Xt update finished. File xtlog was written." << endl;
 
     renameHist();
     delete fxtDr;
     delete fxtEd;
}

init()

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

virtual

Implements CalibBase.

Definition at line 22 of file GrXtCalib.cpp.

                                                       {
     CalibBase::init(hlist, pGeom);
 
     m_fdXt = new TFolder("mfdxt","fdxt");
     hlist->Add(m_fdXt);
 
     m_haxis = new TH2F("axis", "", 50, 0, 300, 50, 0, 9);
     m_haxis -> SetStats(0);
     m_fdXt -> Add(m_haxis);
 
     char hname[200];
     for(int lay=0; lay<NLAYER; lay++){
      for(int iEntr=0; iEntr<NENTRXT; iEntr++){
           for(int lr=0; lr<NLR; lr++){
            m_nhitIn[lay][iEntr][lr] = 0;
            m_nhitEd[lay][iEntr][lr] = 0;
 
            sprintf(hname, "mgrXt%02d_%02d_lr%01d", lay, iEntr, lr);
            m_grxt[lay][iEntr][lr] = new TGraph();
            m_grxt[lay][iEntr][lr] -> SetName(hname);
            m_grxt[lay][iEntr][lr] -> SetMarkerStyle(10);
            m_grxt[lay][iEntr][lr] -> SetLineColor(10);
            m_fdXt -> Add(m_grxt[lay][iEntr][lr]);
           }
      }
     }
}

mergeHist()

void GrXtCalib::mergeHist ( TFile *  fhist )

virtual

Implements CalibBase.

Definition at line 50 of file GrXtCalib.cpp.

                                     {
     CalibBase::mergeHist(fhist);
 
     double tdr, doca;
     char hname[200];
     TFolder* fd = (TFolder*)fhist->Get("fdXtGr");
     for(int lay=0; lay<NLAYER; lay++){
      for(int iEntr=0; iEntr<NENTRXT; iEntr++){
           for(int lr=0; lr<NLR; lr++){
            if((m_nhitIn[lay][iEntr][lr] > m_maxNhit) && (m_nhitEd[lay][iEntr][lr] > m_nMaxEd)) continue;
 
            sprintf(hname, "grXt%02d_%02d_lr%01d", lay, iEntr, lr);
            TGraph* gr = (TGraph*)fd->FindObjectAny(hname);
            int nPoint = gr->GetN();
            for(int i=0; i<nPoint; i++){
             gr->GetPoint(i, tdr, doca);
             if((tdr < m_tEd[lay]) && (m_nhitIn[lay][iEntr][lr] <= m_maxNhit)){
                  int np = m_grxt[lay][iEntr][lr]->GetN();
                  m_grxt[lay][iEntr][lr]->SetPoint(np, tdr, doca);
                  m_nhitIn[lay][iEntr][lr]++;
             } else if((tdr >= m_tEd[lay]) && (m_nhitEd[lay][iEntr][lr] <= m_nMaxEd)){
                  int np = m_grxt[lay][iEntr][lr]->GetN();
                  m_grxt[lay][iEntr][lr]->SetPoint(np, tdr, doca);
                  m_nhitEd[lay][iEntr][lr]++;
             }
            }
           }
      }
     }
}

---

The documentation for this class was generated from the following files:

• GrXtCalib.h
• GrXtCalib.cpp