IniCalib Class Reference

#include <IniCalib.h>

Inheritance diagram for IniCalib:

Public Member Functions
	IniCalib ()
	~IniCalib ()
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 IniCalib.h.

Constructor & Destructor Documentation

IniCalib()

IniCalib::IniCalib

(

)

Definition at line 8 of file IniCalib.cpp.

                  {
     cout << "Calibration type: IniCalib" << endl;
}

~IniCalib()

IniCalib::~IniCalib

(

)

Definition at line 12 of file IniCalib.cpp.

                   {
}

Member Function Documentation

calib()

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

virtual

Implements CalibBase.

Definition at line 166 of file IniCalib.cpp.

                                                                                     {
     int lay;
     int wir;
     double t0Fit[NLAYER];
     double t0Cal[NLAYER];
     double tmax[NLAYER];
     double initT0 = gInitT0;
 
     int fitTminFg[NLAYER];
     int fitTmaxFg[NLAYER];
     double chisq;
     double ndf;
     double chindfTmin[NLAYER];
     double chindfTmax[NLAYER];
     char funname[200];
 
     // fit Tmin
     TF1* ftmin[NLAYER];
     for(lay=0; lay<NLAYER; lay++){
      fitTminFg[lay] = 0;
      chindfTmin[lay] = -1;
      sprintf(funname, "ftmin%02d", lay);
      ftmin[lay] = new TF1(funname, funTmin, 0, 150, 6);
 
      if(1 == gFgCalib[lay]){
           Stat_t nEntryTot = 0;
           for(int ibin=1; ibin<=25; ibin++){
            Stat_t entry = m_htraw[lay]->GetBinContent(ibin);
            nEntryTot += entry;
           }
           double c0Ini = (double)nEntryTot / 25.0;
           double c1Ini = (m_htraw[lay]->GetMaximum()) - c0Ini;
 
           ftmin[lay] -> SetParameter(0, c0Ini);
           ftmin[lay] -> SetParameter(1, c1Ini);
           ftmin[lay] -> SetParameter(2, 0);
           ftmin[lay] -> SetParameter(4, initT0);
           ftmin[lay] -> SetParameter(5, 1);
 
           m_htraw[lay] -> Fit(funname, "Q", "", gTminFitRange[lay][0], gTminFitRange[lay][1]);
           gStyle -> SetOptFit(11);
           chisq = ftmin[lay]->GetChisquare();
           ndf = ftmin[lay]->GetNDF();
           chindfTmin[lay] = chisq / ndf;
           if(chindfTmin[lay] < gTminFitChindf){
            fitTminFg[lay] = 1;
            t0Fit[lay] = ftmin[lay]->GetParameter(4);
            t0Fit[lay] += gT0Shift;
            t0Cal[lay] = t0Fit[lay] - gTimeShift;
           }
      }
 
      if(0 == fitTminFg[lay]){
           wir = m_pGeom->getWire(lay, 0)->getWireId();
           t0Cal[lay] = calconst->getT0(wir);
           t0Fit[lay] = t0Cal[lay] + gTimeShift;
      }
     }
 
     // fit Tmax
     TF1* ftmax[NLAYER];
     for(lay=0; lay<NLAYER; lay++){
      fitTmaxFg[lay] = 0;
      chindfTmax[lay] = -1;
      sprintf(funname, "ftmax%02d", lay);
      ftmax[lay] = new TF1(funname, funTmax, 250, 500, 4);
 
      if(1 == gFgCalib[lay]){
           ftmax[lay] -> SetParameter(2, gInitTm[lay]);
           ftmax[lay] -> SetParameter(3, 10);
 
           m_htraw[lay] -> Fit(funname, "Q+", "", gTmaxFitRange[lay][0], gTmaxFitRange[lay][1]);
           gStyle -> SetOptFit(11);
           chisq = ftmax[lay]->GetChisquare();
           ndf = ftmax[lay]->GetNDF();
           chindfTmax[lay] = chisq / ndf;
           if(chindfTmax[lay] < gTmaxFitChindf){
            fitTmaxFg[lay] = 1;
            tmax[lay] = ftmax[lay]->GetParameter(2);
           }
      }
 
      if(0 == fitTmaxFg[lay]){
           tmax[lay] = (calconst->getXtpar(lay, 0, 0, 6)) + t0Fit[lay];
      }
     }
 
     // output for check
     ofstream ft0("iniT0.dat");
     for(lay=0; lay<NLAYER; lay++){
      ft0 << setw(5) << lay << setw(3) << fitTminFg[lay]
          << setw(12) << t0Cal[lay] << setw(12) << t0Fit[lay]
          << setw(12) << chindfTmin[lay] << setw(5) << fitTmaxFg[lay]
          << setw(12) << tmax[lay] << setw(12) << tmax[lay] - t0Fit[lay]
          << setw(12) << chindfTmax[lay] << endl;
     }
     ft0.close();
     cout << "iniT0.dat was written." << endl;
 
     // set T0
     int i;
     int nwire = m_pGeom -> getWireSize();
     for(i=0; i<nwire; i++){
      lay = m_pGeom -> getWire(i) -> getLayerId();
      if(1 == gFgCalib[lay]){
           calconst -> resetT0(i, t0Cal[lay]);
           calconst -> resetDelT0(i, 0.0);
      }
     }
 
     if(0 == gFgIniCalConst){
      // set X-T
      int lr;
      int iEntr;
      int ord;
      double xtpar;
      double xtini[8] = {0, 0.03, 0, 0, 0, 0, 999.9, 0};
      for(lay=0; lay<NLAYER; lay++){
           if(1 != gFgCalib[lay]) continue;
 
           for(iEntr=0; iEntr<NENTRXT; iEntr++){
            for(lr=0; lr<NLR; lr++){
             for(ord=0; ord<NXTPAR; ord++){
                  if(6 == ord){
                   xtpar = tmax[lay] - t0Fit[lay];
                  } else{
                   xtpar = xtini[ord];
                  }
                  calconst -> resetXtpar(lay, iEntr, lr, ord, xtpar);
             }
            }
           }
      }
 
      // set Q-T
      for(lay=0; lay<NLAYER; lay++){
           calconst -> resetQtpar0(lay, 0.0);
           calconst -> resetQtpar1(lay, 0.0);
      }
 
      // set S-D
      int bin;
      double sdpar = 0.18;  // mm
      for(lay=0; lay<NLAYER; lay++){
           for(iEntr=0; iEntr<NENTRSD; iEntr++){
            for(lr=0; lr<2; lr++){
             for(bin=0; bin<NSDBIN; bin++){
                  calconst -> resetSdpar(lay, iEntr, lr, bin, sdpar);
             }
            }
           }
      }
     } else if(2 == gFgIniCalConst){
      int lr;
      int iEntr;
      double xtpar;
      for(lay=0; lay<NLAYER; lay++){
           for(iEntr=0; iEntr<NENTRXT; iEntr++){
            for(lr=0; lr<NLR; lr++){
             xtpar = tmax[lay] - t0Fit[lay];
             calconst -> resetXtpar(lay, iEntr, lr, 6, xtpar);
            }
           }
      }
     }
 
     renameHist();
     for(lay=0; lay<NLAYER; lay++){
      delete ftmin[lay];
      delete ftmax[lay];
     }
}

init()

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

virtual

Implements CalibBase.

Definition at line 15 of file IniCalib.cpp.

                                                      {
     m_pGeom = pGeom;
     char hname[200];
     m_fdcom = new TFolder("mCommon", "mCommon");
     hlist->Add(m_fdcom);
 
     m_fdTmap = new TFolder("mThitmap", "mThitmap");
     hlist->Add(m_fdTmap);
 
     m_fdTraw = new TFolder("mTraw", "mTraw");
     hlist->Add(m_fdTraw);
 
     m_fdTrawCel = new TFolder("mTrawCell", "mTrawCell");
     hlist->Add(m_fdTrawCel);
 
     m_fdQmap = new TFolder("mQhitmap", "mQhitmap");
     hlist->Add(m_fdQmap);
 
     m_fdQraw = new TFolder("mQraw", "mQraw");
     hlist->Add(m_fdQraw);
 
     m_fdQrawCel = new TFolder("mQrawCell", "mQrawCell");
     hlist->Add(m_fdQrawCel);
 
     m_hLayerHitmapT = new TH1F("mT_Hitmap_Layer", "", 43, -0.5, 42.5);
     m_fdcom->Add(m_hLayerHitmapT);
                
     m_hWireHitMapT = new TH1F("mT_Hitmap_Wire", "", 6796, -0.5, 6795.5);
     m_fdcom->Add(m_hWireHitMapT);
 
     m_hLayerHitmapQ = new TH1F("mQ_Hitmap_Layer", "", 43, -0.5, 42.5);
     m_fdcom->Add(m_hLayerHitmapQ);
                
     m_hWireHitMapQ = new TH1F("mQ_Hitmap_Wire", "", 6796, -0.5, 6795.5);
     m_fdcom->Add(m_hWireHitMapQ);
 
     m_hTesAll = new TH1F("mTesAll", "", 750, 0, 1500);
     m_fdcom->Add(m_hTesAll);
 
     m_hTesCal = new TH1F("mTesCal", "", 750, 0, 1500);
     m_fdcom->Add(m_hTesCal);
 
     m_hTesFlag = new TH1F("mTes_Flag", "", 300, -0.5, 299.5);
     m_fdcom->Add(m_hTesFlag);
 
     for(int lay=0; lay<NLAYER; lay++){
      int ncel = pGeom->getLayer(lay)->getNcell();
 
      sprintf(hname, "mT_hitmap_Lay%02d", lay);
      m_hlaymapT[lay] = new TH1F(hname, "", ncel, -0.5, (float)ncel-0.5);
      m_fdTmap -> Add(m_hlaymapT[lay]);
 
      sprintf(hname, "mTDC_Lay%02d", lay);
          m_htdc[lay] = new TH1F(hname, "", 800, 0, 20000);
          m_fdTraw -> Add(m_htdc[lay]);
 
      sprintf(hname, "mTraw_Lay%02d", lay);
          m_htraw[lay] = new TH1F(hname, "", 500, 0, 1000);
          m_fdTraw -> Add(m_htraw[lay]);
 
      sprintf(hname, "mQ_hitmap_Lay%02d", lay);
      m_hlaymapQ[lay] = new TH1F(hname, "", ncel, -0.5, (float)ncel-0.5);
      m_fdQmap -> Add(m_hlaymapQ[lay]);
 
      sprintf(hname, "mQraw_Lay%02d", lay);
          m_hqraw[lay] = new TH1F(hname, "", 2000, 0, 4000);
          m_fdQraw -> Add(m_hqraw[lay]);
     }
 
     for(int wir=0; wir<NWIRE; wir++){
      int lay = m_pGeom -> getWire(wir) -> getLayerId();
      int cel = m_pGeom -> getWire(wir) -> getCellId();
 
      sprintf(hname, "mTraw_%02d_%03d_%04d", lay, cel, wir);
      m_htrawCel[wir] = new TH1F(hname, "", 300, 0, 600);
      m_fdTrawCel -> Add(m_htrawCel[wir]);
 
      sprintf(hname, "mQraw_%02d_%03d_%04d", lay, cel, wir);
      m_hqrawCel[wir] = new TH1F(hname, "", 2000, 0, 4000);
      m_fdQrawCel -> Add(m_hqrawCel[wir]);
     }
}

mergeHist()

void IniCalib::mergeHist ( TFile *  fhist )

virtual

Implements CalibBase.

Definition at line 98 of file IniCalib.cpp.

                                    {
     TFolder* fdcom = (TFolder*)fhist->Get("Common");
     TFolder* fdTmap = (TFolder*)fhist->Get("Thitmap");
     TFolder* fdTraw = (TFolder*)fhist->Get("Traw");
     TFolder* fdTrawCel = (TFolder*)fhist->Get("TrawCell");
     TFolder* fdQmap = (TFolder*)fhist->Get("Qhitmap");
     TFolder* fdQraw = (TFolder*)fhist->Get("Qraw");
     TFolder* fdQrawCel = (TFolder*)fhist->Get("QrawCell");
 
     char hname[200];
     TH1F* hist;
     hist = (TH1F*)fdcom->FindObjectAny("T_Hitmap_Layer");
     m_hLayerHitmapT->Add(hist);
 
     hist = (TH1F*)fdcom->FindObjectAny("T_Hitmap_Wire");
     m_hWireHitMapT->Add(hist);
 
     hist = (TH1F*)fdcom->FindObjectAny("Q_Hitmap_Layer");
     m_hLayerHitmapQ->Add(hist);
 
     hist = (TH1F*)fdcom->FindObjectAny("Q_Hitmap_Wire");
     m_hWireHitMapQ->Add(hist);
 
     hist = (TH1F*)fdcom->FindObjectAny("TesAll");
     m_hTesAll->Add(hist);
 
     hist = (TH1F*)fdcom->FindObjectAny("TesCal");
     m_hTesCal->Add(hist);
 
     hist = (TH1F*)fdcom->FindObjectAny("Tes_Flag");
     m_hTesFlag->Add(hist);
 
     for(int lay=0; lay<NLAYER; lay++){
      sprintf(hname, "T_hitmap_Lay%02d", lay);
      hist = (TH1F*)fdTmap->FindObjectAny(hname);
      m_hlaymapT[lay]->Add(hist);
 
      sprintf(hname, "TDC_Lay%02d", lay);
      hist = (TH1F*)fdTraw->FindObjectAny(hname);
      m_htdc[lay]->Add(hist);
 
      sprintf(hname, "Traw_Lay%02d", lay);
      hist = (TH1F*)fdTraw->FindObjectAny(hname);
      m_htraw[lay]->Add(hist);
 
      sprintf(hname, "Q_hitmap_Lay%02d", lay);
      hist = (TH1F*)fdQmap->FindObjectAny(hname);
      m_hlaymapQ[lay]->Add(hist);
 
      sprintf(hname, "Qraw_Lay%02d", lay);
      hist = (TH1F*)fdQraw->FindObjectAny(hname);
      m_hqraw[lay]->Add(hist);
     }
 
     for(int wir=0; wir<NWIRE; wir++){
      int lay = m_pGeom -> getWire(wir) -> getLayerId();
      int cel = m_pGeom -> getWire(wir) -> getCellId();
 
      sprintf(hname, "Traw_%02d_%03d_%04d", lay, cel, wir);
      hist = (TH1F*)fdTrawCel->FindObjectAny(hname);
      m_htrawCel[wir]->Add(hist);
 
      sprintf(hname, "Qraw_%02d_%03d_%04d", lay, cel, wir);
      hist = (TH1F*)fdQrawCel->FindObjectAny(hname);
      m_hqrawCel[wir]->Add(hist);
     }
}

---

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

• IniCalib.h
• IniCalib.cpp