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

PreXtMdcCalib Class Reference

#include <PreXtMdcCalib.h>

Inheritance diagram for PreXtMdcCalib:

MdcCalib MdcCalib List of all members.

Public Member Functions

void clear ()
void clear ()
int fillHist (MdcCalEvent *event)
int fillHist (MdcCalEvent *event)
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)
 PreXtMdcCalib ()
 PreXtMdcCalib ()
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)
 ~PreXtMdcCalib ()
 ~PreXtMdcCalib ()

Static Private Member Functions

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

Private Attributes

TFolder * m_fdNhit
TFolder * m_fdNhit
TFolder * m_fdPreXt
TFolder * m_fdPreXt
bool m_fgIniTm
TGraph * m_grXt [MdcCalNLayer]
TGraph * m_grXt [MdcCalNLayer]
TH2F * m_haxis
TH2F * m_haxis
TObjArray * m_hlist
TObjArray * m_hlist
TH1F * m_htrec [MdcCalNLayer]
TH1F * m_htrec [MdcCalNLayer]
IMdcCalibFunSvc * m_mdcFunSvc
IMdcCalibFunSvc * m_mdcFunSvc
IMdcGeomSvc * m_mdcGeomSvc
IMdcGeomSvc * m_mdcGeomSvc
int m_nEntries [MdcCalNLayer][40]
TH1F * m_nhitBin [MdcCalNLayer]
TH1F * m_nhitBin [MdcCalNLayer]
TH1F * m_nhitTot
TH1F * m_nhitTot
int m_nLayer
int m_nTot [MdcCalNLayer]
int m_nWire
int m_nXtBin
MdcCalParams m_param
double m_t0 [MdcCalNLayer]
double m_tbin [40]
double m_tm [MdcCalNLayer]

Constructor & Destructor Documentation

PreXtMdcCalib::PreXtMdcCalib (   ) 
  

00031                             {
00032      m_fgIniTm = false;
00033 }

PreXtMdcCalib::~PreXtMdcCalib (   ) 
  

00035                              {
00036 }

PreXtMdcCalib::PreXtMdcCalib (   ) 
 

PreXtMdcCalib::~PreXtMdcCalib (   ) 
 

Member Function Documentation

void PreXtMdcCalib::clear (   )  [virtual]
 

Implements MdcCalib.

void PreXtMdcCalib::clear (   )  [virtual]
 

Implements MdcCalib.

00038                          {
00039      for(int lay=0; lay<MdcCalNLayer; lay++){
00040           delete m_grXt[lay];
00041           delete m_htrec[lay];
00042      }
00043      delete m_haxis;
00044      delete m_fdPreXt;
00045 }

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

Implements MdcCalib.

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

Implements MdcCalib.

00103                                              {
00104      IMessageSvc* msgSvc;
00105      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00106      MsgStream log(msgSvc, "PreXtMdcCalib");
00107      log << MSG::DEBUG << "PreXtMdcCalib::fillHist()" << endreq;
00108 
00109      int bin;
00110      int lay;
00111      int digiId;
00112      unsigned fgOverFlow;
00113      double tdc;
00114      double adc;
00115      double traw;
00116      double trec;
00117      Identifier id; 
00118 
00119      IDataProviderSvc* eventSvc = NULL;
00120      Gaudi::svcLocator()->service("EventDataSvc", eventSvc);
00121 
00122      double xtpar[8];
00123      if(! m_fgIniTm){
00124           for(lay=0; lay<MdcCalNLayer; lay++){
00125                m_t0[lay] = m_mdcFunSvc -> getT0(lay, 0);
00126                m_mdcFunSvc->getXtpar(lay, 0, 0, xtpar);
00127                m_tm[lay] = xtpar[6];
00128           }
00129           m_fgIniTm = true;
00130      }
00131 
00132      // get EsTimeCol
00133      double tes = -9999.0;
00134      int esTimeflag = -1;
00135      SmartDataPtr<RecEsTimeCol> aevtimeCol(eventSvc,"/Event/Recon/RecEsTimeCol");
00136      if( (!aevtimeCol) || (aevtimeCol->size()==0) ){
00137           tes = -9999.0;
00138           esTimeflag = -1;
00139      }else{
00140           RecEsTimeCol::iterator iter_evt = aevtimeCol->begin();
00141           for(; iter_evt!=aevtimeCol->end(); iter_evt++){
00142                tes = (*iter_evt)->getTest();
00143                esTimeflag = (*iter_evt)->getStat();
00144           }
00145      }
00146      bool flagTes = false;
00147      for(int iEs=0; iEs<m_param.nEsFlag; iEs++){
00148           if(esTimeflag == m_param.esFlag[iEs]){
00149                flagTes = true;
00150                break;
00151           }
00152      }
00153      if( (!flagTes) || (tes < m_param.tesMin) || (tes > m_param.tesMax) ) return -1;
00154 
00155      // retrieve Mdc digi
00156      SmartDataPtr<MdcDigiCol> mdcDigiCol(eventSvc,"/Event/Digi/MdcDigiCol");
00157      if (!mdcDigiCol) {
00158           log << MSG::FATAL << "Could not find event" << endreq;
00159      }
00160 
00161      MdcDigiCol::iterator iter = mdcDigiCol->begin();
00162      digiId = 0;
00163      for(; iter != mdcDigiCol->end(); iter++, digiId++) {
00164           MdcDigi *aDigi = (*iter);
00165           id = (aDigi)->identify();
00166 
00167           lay = MdcID::layer(id);
00168 
00169           tdc = (aDigi) -> getTimeChannel();
00170           adc = (aDigi) -> getChargeChannel();
00171           fgOverFlow = (aDigi) -> getOverflow();
00172           traw = tdc * MdcCalTdcCnv;
00173           trec = traw - tes - m_t0[lay];
00174 
00175 //        if ( !((fgOverFlow == 0)||(fgOverFlow ==12)) ||
00176 //             (aDigi->getTimeChannel() == 0x7FFFFFFF) ||
00177 //             (aDigi->getChargeChannel() == 0x7FFFFFFF) ) continue;
00178           if ( ((fgOverFlow & 3) !=0 ) || ((fgOverFlow & 12) != 0) ||
00179                (aDigi->getTimeChannel() == 0x7FFFFFFF) ||
00180                (aDigi->getChargeChannel() == 0x7FFFFFFF) ) continue;
00181 
00182 
00183           /* integrated time Spectrum for determination X-T */
00184           if(trec > 0){
00185                if(trec < m_tm[lay]){
00186                     m_nTot[lay]++;
00187                     m_htrec[lay]->Fill(trec);
00188                     m_nhitTot->Fill(lay);
00189                }
00190                for(bin=0; bin<m_nXtBin; bin++){
00191                     if(trec < m_tbin[bin]){
00192                          m_nEntries[lay][bin]++;
00193                          m_nhitBin[lay]->Fill(m_tbin[bin]);
00194                     }
00195                }
00196           }
00197      }
00198      return 1;
00199 }

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

Implements MdcCalib.

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

Implements MdcCalib.

00048                                                            {
00049      IMessageSvc* msgSvc;
00050      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00051      MsgStream log(msgSvc, "PreXtMdcCalib");
00052      log << MSG::INFO << "PreXtMdcCalib::initialize()" << endreq;
00053 
00054      m_hlist = hlist;
00055      m_mdcGeomSvc = mdcGeomSvc;
00056      m_mdcFunSvc = mdcFunSvc;
00057 
00058      int lay;
00059 
00060      m_nWire = m_mdcGeomSvc -> getWireSize();
00061      m_nLayer = m_mdcGeomSvc -> getLayerSize();
00062 
00063      m_fdPreXt = new TFolder("PreXt", "PreXt");
00064      m_hlist->Add(m_fdPreXt);
00065 
00066      m_fdNhit = new TFolder("XtNhit", "XtNhit");
00067      m_hlist->Add(m_fdNhit);
00068 
00069      m_haxis = new TH2F("axis", "", 50, 0, 300, 50, 0, 9);
00070      m_haxis -> SetStats(0);
00071      m_fdPreXt -> Add(m_haxis);
00072 
00073      char hname[200];
00074      for(lay=0; lay<MdcCalNLayer; lay++){
00075           sprintf(hname, "trec%02d", lay);
00076           m_htrec[lay] = new TH1F(hname, "", 310, -20, 600);
00077           m_fdPreXt -> Add(m_htrec[lay]);
00078      }
00079 
00080      m_nhitTot = new TH1F("nhitTot", "", 43, -0.5, 42.5);
00081      m_fdNhit -> Add(m_nhitTot);
00082 
00083      for(lay=0; lay<MdcCalNLayer; lay++){
00084           sprintf(hname, "nhitBin%02d", lay);
00085           m_nhitBin[lay] = new TH1F(hname, "", 40, 5.0, 405.0);
00086           m_fdNhit -> Add(m_nhitBin[lay]);
00087      }
00088 
00089      /* integrated time Spectrum for determination X-T */
00090      int bin;
00091      m_nXtBin = 40;
00092      double twid = 10.0;        // ns
00093      for(bin=0; bin<m_nXtBin; bin++)  m_tbin[bin] = (double)(bin+1) * twid;
00094 
00095      for(lay=0; lay<MdcCalNLayer; lay++){
00096           m_nTot[lay] = 0;
00097           for(bin=0; bin<m_nXtBin; bin++){
00098                m_nEntries[lay][bin] = 0;
00099           }
00100      }
00101 }

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

Reimplemented from MdcCalib.

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

Reimplemented from MdcCalib.

00328                                                        {
00329      MdcCalib::read_file(path);
00330 }

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

Implements MdcCalib.

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

Implements MdcCalib.

00061                                                       {
00062      MdcCalib::setParam(param);
00063      m_param = param;
00064 }

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

Reimplemented from MdcCalib.

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

Reimplemented from MdcCalib.

00289                                            {
00290      MdcCalib::settuple(path);
00291      TFile *f1 = new TFile(path.c_str());
00292      std::cout<<path<<std::endl;
00293   
00294      //m_mdcGeomSvc = mdcGeomSvc;
00295      //m_mdcFunSvc = mdcFunSvc;
00296 
00297      int lay;
00298 
00299      m_nWire = m_mdcGeomSvc -> getWireSize();
00300      m_nLayer = m_mdcGeomSvc -> getLayerSize();
00301 
00302      m_fdPreXt=(TFolder *)f1->Get("PreXt;1");
00303   
00304      m_haxis=(TH2F *) m_fdPreXt ->FindObject("axis");
00305      m_haxis->SetStats(0);
00306 
00307      char hname[200];
00308      for(lay=0; lay<MdcCalNLayer; lay++){
00309           sprintf(hname, "trec%02d", lay);
00310           m_htrec[lay]=(TH1F *) m_fdPreXt -> FindObject(hname);
00311      }
00312 
00313      /* integrated time Spectrum for determination X-T */
00314      int bin;
00315      m_nXtBin = 40;
00316      double twid = 10.0;        // ns
00317      for(bin=0; bin<m_nXtBin; bin++) 
00318           m_tbin[bin] = (double)(bin+1) * twid;
00319      for(lay=0; lay<MdcCalNLayer; lay++){
00320           m_nTot[lay] = 0;
00321           for(bin=0; bin<m_nXtBin; bin++){
00322                m_nEntries[lay][bin] = 0;
00323           }
00324      }
00325 }

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

Implements MdcCalib.

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

Implements MdcCalib.

00201                                                      {
00202      IMessageSvc* msgSvc;
00203      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00204      MsgStream log(msgSvc, "PreXtMdcCalib");
00205      log << MSG::DEBUG << "PreXtMdcCalib::updateConst()" << endreq;
00206 
00207      int lay;
00208      int bin;
00209      int iLR;
00210      int iEntr;
00211      int ord;
00212 
00213      double layRad;
00214      double ncel;
00215      double pi = 3.141592653;
00216 
00217      double dm;
00218      double dist[40];
00219      double xtpar[6];
00220      char hname[200];
00221 
00222      TF1* funXt = new TF1("funXt", xtfun, 0, 300, 6);
00223      funXt -> FixParameter(0, 0.0);
00224      funXt -> SetParameter(1, 0.03);
00225      funXt -> SetParameter(2, 0.0);
00226      funXt -> SetParameter(3, 0.0);
00227      funXt -> SetParameter(4, 0.0);
00228      funXt -> SetParameter(5, 0.0);
00229 
00230      ofstream fxtlog("preXtpar.dat");
00231      for(lay=0; lay<MdcCalNLayer; lay++){
00232           sprintf(hname, "grPreXt%02d", lay);
00233           m_grXt[lay] = new TGraph();
00234           m_grXt[lay] -> SetName(hname);
00235           m_grXt[lay] -> SetMarkerStyle(20);
00236           m_fdPreXt -> Add(m_grXt[lay]);
00237 
00238           layRad = m_mdcGeomSvc -> Layer(lay) -> Radius();
00239           ncel = m_mdcGeomSvc -> Layer(lay) -> NCell();
00240           dm = pi * layRad / ncel;
00241 
00242           fxtlog << "layer " << lay << endl;
00243           for(bin=0; bin<m_nXtBin; bin++){
00244                dist[bin] = dm * m_nEntries[lay][bin] / m_nTot[lay];
00245                m_grXt[lay] -> SetPoint(bin, m_tbin[bin], dist[bin]);
00246                fxtlog << setw(4) << bin << setw(15) << m_tbin[bin]
00247                       << setw(15) << dist[bin] << setw(15) << dm
00248                       << setw(10) << m_nEntries[lay][bin]
00249                       << setw(10) << m_nTot[lay] << endl;
00250 
00251                if(m_tbin[bin] >= m_tm[lay]) break;
00252           }
00253 
00254           if(1 == m_param.fgCalib[lay]){
00255                m_grXt[lay] -> Fit(funXt, "Q", "", 0.0, m_tm[lay]);
00256                for(ord=0; ord<6; ord++){
00257                     xtpar[ord] = funXt -> GetParameter(ord);
00258                }
00259 
00260                for(iEntr=0; iEntr<MdcCalNENTRXT; iEntr++){
00261                     for(iLR=0; iLR<MdcCalLR; iLR++){
00262                          for(ord=0; ord<6; ord++){
00263                               calconst -> resetXtpar(lay, iEntr, iLR, ord, xtpar[ord]);
00264                          }
00265                     }
00266                }
00267           } else{
00268                for(ord=0; ord<6; ord++) xtpar[ord] = calconst->getXtpar(lay, 0, 0, ord);
00269           }
00270 
00271           for(ord=0; ord<6; ord++)  fxtlog << setw(14) << xtpar[ord];
00272           fxtlog << setw(10) << m_tm[lay] << "  0" << endl;
00273      } // end of layer loop
00274      fxtlog.close();
00275      cout << "preXt.dat was written." << endl;
00276 
00277      delete funXt;
00278      return 1;
00279 }

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

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

00281                                                        {
00282      Double_t val = 0.0;
00283      for(Int_t ord=0; ord<6; ord++){
00284           val += par[ord] * pow(x[0], ord);
00285      }
00286      return val;
00287 }

Member Data Documentation

TFolder* PreXtMdcCalib::m_fdNhit [private]
 

TFolder* PreXtMdcCalib::m_fdNhit [private]
 

TFolder* PreXtMdcCalib::m_fdPreXt [private]
 

TFolder* PreXtMdcCalib::m_fdPreXt [private]
 

bool PreXtMdcCalib::m_fgIniTm [private]
 

TGraph* PreXtMdcCalib::m_grXt[MdcCalNLayer] [private]
 

TGraph* PreXtMdcCalib::m_grXt[MdcCalNLayer] [private]
 

TH2F* PreXtMdcCalib::m_haxis [private]
 

TH2F* PreXtMdcCalib::m_haxis [private]
 

TObjArray* PreXtMdcCalib::m_hlist [private]
 

Reimplemented from MdcCalib.

TObjArray* PreXtMdcCalib::m_hlist [private]
 

Reimplemented from MdcCalib.

TH1F* PreXtMdcCalib::m_htrec[MdcCalNLayer] [private]
 

TH1F* PreXtMdcCalib::m_htrec[MdcCalNLayer] [private]
 

IMdcCalibFunSvc* PreXtMdcCalib::m_mdcFunSvc [private]
 

Reimplemented from MdcCalib.

IMdcCalibFunSvc* PreXtMdcCalib::m_mdcFunSvc [private]
 

Reimplemented from MdcCalib.

IMdcGeomSvc* PreXtMdcCalib::m_mdcGeomSvc [private]
 

Reimplemented from MdcCalib.

IMdcGeomSvc* PreXtMdcCalib::m_mdcGeomSvc [private]
 

Reimplemented from MdcCalib.

int PreXtMdcCalib::m_nEntries [private]
 

TH1F* PreXtMdcCalib::m_nhitBin[MdcCalNLayer] [private]
 

TH1F* PreXtMdcCalib::m_nhitBin[MdcCalNLayer] [private]
 

TH1F* PreXtMdcCalib::m_nhitTot [private]
 

TH1F* PreXtMdcCalib::m_nhitTot [private]
 

int PreXtMdcCalib::m_nLayer [private]
 

int PreXtMdcCalib::m_nTot [private]
 

int PreXtMdcCalib::m_nWire [private]
 

int PreXtMdcCalib::m_nXtBin [private]
 

MdcCalParams PreXtMdcCalib::m_param [private]
 

Reimplemented from MdcCalib.

double PreXtMdcCalib::m_t0 [private]
 

double PreXtMdcCalib::m_tbin [private]
 

double PreXtMdcCalib::m_tm [private]
 

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