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

ResiAlign Class Reference

#include <ResiAlign.h>

Inheritance diagram for ResiAlign:

AlignBase MdcAlign MdcAlign List of all members.

Public Member Functions

void align (MdcAlignPar *alignPar)
void clear ()
void clear ()
bool fillHist (MdcAliEvent *event)
bool fillHist (MdcAliEvent *event)
void init (TObjArray *hlist, MdcCosGeom *pGeom)
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)
void initialize (TObjArray *hlist, IMdcGeomSvc *mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)
void mergeHist (TFile *fhist)
 ResiAlign ()
 ResiAlign ()
 ResiAlign ()
void setParam (MdcAliParams &param)
void setParam (MdcAliParams &param)
void updateConst (MdcAlignPar *alignPar)
void updateConst (MdcAlignPar *alignPar)
 ~ResiAlign ()
 ~ResiAlign ()
 ~ResiAlign ()

Static Public Member Functions

Double_t funResi (double *x, double *par)
Double_t funResi (double *x, double *par)

Public Attributes

std::string fixMomLab

Private Member Functions

void renameHist ()

Static Private Member Functions

Double_t funResi (Double_t *x, Double_t *par)

Private Attributes

NTuple::Item< float > m_cel [NEP+1]
NTuple::Item< float > m_cel [NEP+1]
double m_docaMax [LAYERNMAX]
double m_docaMin [LAYERNMAX]
std::ofstream m_fevt
TGraph * m_gr [NEP]
TGraph * m_gr [NEP]
TGraph * m_gr [NEP]
TH1F * m_hlayHitmap
TH1F * m_hlayHitmap
TH1F * m_hlayHitmap
TObjArray * m_hlist
TObjArray * m_hlist
TH1F * m_hnHit
TH1F * m_hnHit
TH1F * m_hnHit
TH1F * m_hnTrk
TH1F * m_hnTrk
TH1F * m_hnTrk
TH1F * m_hresAll
TH1F * m_hresAll
TH1F * m_hresAll
TH1F * m_hresInn
TH1F * m_hresInn
TH1F * m_hresInn
TH1F * m_hresLay [LAYERNMAX]
TH1F * m_hresLay [LAYERNMAX]
TH1F * m_hresLay [LAYERNMAX]
TH1F * m_hresOut
TH1F * m_hresOut
TH1F * m_hresOut
TH1F * m_hresStp
TH1F * m_hresStp
TH1F * m_hresStp
NTuple::Item< long > m_iEvt [NEP+1]
NTuple::Item< long > m_iEvt [NEP+1]
NTuple::Item< long > m_iRun [NEP+1]
NTuple::Item< long > m_iRun [NEP+1]
NTuple::Item< float > m_lay [NEP+1]
NTuple::Item< float > m_lay [NEP+1]
bool m_layBound [LAYERNMAX]
NTuple::Item< float > m_lr [NEP+1]
NTuple::Item< float > m_lr [NEP+1]
IMdcCalibFunSvc * m_mdcFunSvc
IMdcCalibFunSvc * m_mdcFunSvc
IMdcGeomSvc * m_mdcGeomSvc
IMdcGeomSvc * m_mdcGeomSvc
int m_ncut1
int m_ncut10
int m_ncut11
int m_ncut12
int m_ncut2
int m_ncut3
int m_ncut4
int m_ncut5
int m_ncut6
int m_ncut7
int m_ncut8
int m_ncut9
int m_ndiv
Long64_t m_npoint [NEP]
NTuple::Item< float > m_p [NEP+1]
NTuple::Item< float > m_p [NEP+1]
MdcAliParams m_param
MdcCosGeom * m_pGeom
NTuple::Item< float > m_phi [NEP+1]
NTuple::Item< float > m_phi [NEP+1]
NTuple::Item< float > m_pt [NEP+1]
NTuple::Item< float > m_pt [NEP+1]
double m_radii [LAYERNMAX]
NTuple::Item< float > m_resi [NEP+1]
NTuple::Item< float > m_resi [NEP+1]
double m_resiCut
NTuple::Tuple * m_tuple [NEP+1]
NTuple::Tuple * m_tuple [NEP+1]
double m_xe [WIRENMAX]
double m_xw [WIRENMAX]
double m_ye [WIRENMAX]
double m_yw [WIRENMAX]
double m_ze [WIRENMAX]
double m_zrange [LAYERNMAX][2]
double m_zw [WIRENMAX]
INTupleSvc * ntupleSvc
INTupleSvc * ntupleSvc

Constructor & Destructor Documentation

ResiAlign::ResiAlign (   ) 
  

00008                     {
00009      cout << "Alignment type: ResiAlign" << endl;
00010 }

ResiAlign::~ResiAlign (   ) 
  

00012                      {
00013 }

ResiAlign::ResiAlign (   ) 
 

ResiAlign::~ResiAlign (   ) 
 

ResiAlign::ResiAlign (   ) 
 

ResiAlign::~ResiAlign (   ) 
 

Member Function Documentation

void ResiAlign::align (  MdcAlignPar *  alignPar  )  [virtual]
 

Implements AlignBase.

00098                                           {
00099      int iEP;
00100      double par[3];
00101      double err[3];
00102      double dx;
00103      double dy;
00104      double rz;
00105      double rLayer[] = { 120.225, 205.0, 237.55, 270.175, 302.625, 334.775, 366.65, 500.0,
00106                          120.225, 205.0, 237.55, 270.175, 302.625, 334.775, 366.65, 500.0 };
00107 
00108      TCanvas c1("c1", "c1", 10, 10, 700, 500);
00109      c1.SetFillColor(10);
00110 
00111      TF1* fResPhi = new TF1("fResPhi", funResi, 0, PI2, 3);
00112      fResPhi->SetParameter(0, 0.0);
00113      fResPhi->SetParameter(1, 0.0);
00114      fResPhi->SetParameter(2, 0.0);
00115 
00116      for(iEP=0; iEP<NEP; iEP++){
00117           if((m_gr[iEP]->GetN()) > 500){
00118                m_gr[iEP]->Fit("fResPhi", "V");
00119                par[0] = fResPhi->GetParameter(0);
00120                par[1] = fResPhi->GetParameter(1);
00121                par[2] = fResPhi->GetParameter(2);
00122 
00123                err[0] = fResPhi->GetParError(0);
00124                err[1] = fResPhi->GetParError(1);
00125                err[2] = fResPhi->GetParError(2);
00126 
00127                dx = -1.0 * par[1];
00128                dy = par[2];
00129                rz = par[0] / rLayer[iEP];
00130 
00131                if (7==iEP || 15==iEP) {
00132                     dx = 0.0;
00133                     dy = 0.0;
00134                     rz = 0.0;
00135                     par[0] = 0.0;
00136                     par[1] = 0.0;
00137                     par[2] = 0.0;
00138                }
00139                alignPar->setDelDx(iEP, dx);
00140                alignPar->setDelDy(iEP, dy);
00141                alignPar->setDelRz(iEP, rz);
00142 
00143                alignPar->setErrDx(iEP, err[1]);
00144                alignPar->setErrDy(iEP, err[2]);
00145                alignPar->setErrRz(iEP, err[0]/rLayer[iEP]);
00146           }
00147      }
00148      renameHist();
00149      delete fResPhi;
00150 }

void ResiAlign::clear (   )  [virtual]
 

Implements MdcAlign.

void ResiAlign::clear (   )  [virtual]
 

Implements MdcAlign.

00067                      {
00068      delete m_hresAll;
00069      delete m_hresInn;
00070      delete m_hresStp;
00071      delete m_hresOut;
00072      for(int lay=0; lay<LAYERNMAX; lay++) delete m_hresLay[lay];
00073      for(int i=0; i<NEP; i++) delete m_gr[i];
00074 }

bool ResiAlign::fillHist (  MdcAliEvent *  event  )  [virtual]
 

Implements MdcAlign.

bool ResiAlign::fillHist (  MdcAliEvent *  event  )  [virtual]
 

Implements MdcAlign.

00173                                           {
00174      IMessageSvc* msgSvc;
00175      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00176      MsgStream log(msgSvc, "ResiAlign");
00177      log << MSG::DEBUG << "ResiAlign::fillHist()" << endreq;
00178 
00179      bool esCutFg = event->getEsCutFlag();
00180      if( ! esCutFg ){
00181           m_ncut1++;
00182           return true;
00183      }
00184 
00185      int i = 0;
00186      int k;
00187 
00188      int trkStat;
00189      double dr;
00190      double phi0;
00191      double kappa;
00192      double dz;
00193      double tanl;
00194      double chisq;
00195      double p;
00196      double pt;
00197 
00198      int nhits;
00199      int lay;
00200      int cel;
00201      int wir;
00202      int lr;
00203      int iEnd;
00204      int iEP;
00205 
00206      double doca;
00207      double resi;
00208      double zhit;
00209      double wphi;
00210      double dphi;
00211      double hitPhi;
00212      double xx;
00213      double yy;
00214      double rr;
00215      int stat;
00216      MdcAliRecTrk* rectrk;
00217      MdcAliRecHit* rechit;
00218      int nhitlay;
00219      bool fgHitLay[LAYERNMAX];
00220 
00221      IDataProviderSvc* eventSvc = NULL;
00222      Gaudi::svcLocator()->service("EventDataSvc", eventSvc);
00223      SmartDataPtr<Event::EventHeader> eventHeader(eventSvc,"/Event/EventHeader");
00224      if (!eventHeader) {
00225           log << MSG::FATAL << "Could not find Event Header" << endreq;
00226           m_ncut3++;
00227           return( StatusCode::FAILURE);
00228      }
00229      int iEvt = eventHeader->eventNumber();
00230      int iRun = eventHeader->runNumber();
00231 
00232      int nTrk = event -> getNTrk();
00233      m_hnTrk->Fill(nTrk);
00234      m_fevt << setw(10) << iRun << setw(10) << iEvt << setw(10) << nTrk << endl;
00235      if((nTrk < m_param.nTrkCut[0]) || (nTrk > m_param.nTrkCut[1])){
00236           m_ncut2++;
00237           return true;
00238      }
00239 
00240      for(i=0; i<nTrk; i++){
00241           rectrk = event->getRecTrk(i);
00242           nhits = rectrk->getNHits();
00243           trkStat = rectrk->getStat();
00244 //        if (0 != trkStat) continue;
00245 
00246           // dr cut
00247           dr = rectrk -> getDr();
00248           if(fabs(dr) > m_param.drCut){ m_ncut4++; continue; }
00249 
00250           phi0 = rectrk -> getPhi0();
00251           kappa = rectrk -> getKappa();
00252 
00253           // dz cut
00254           dz = rectrk -> getDz();
00255           if(fabs(dz) > m_param.dzCut){ m_ncut5++; continue; }
00256 
00257           for(lay=0; lay<LAYERNMAX; lay++){
00258                fgHitLay[lay] = false;
00259           }
00260 
00261           m_hnHit->Fill(nhits);
00262           for(k=0; k<nhits; k++){
00263                rechit = rectrk -> getRecHit(k);
00264                lay = rechit -> getLayid();
00265                fgHitLay[lay] = true;
00266           }
00267 
00268           nhitlay = 0;
00269           for(lay=0; lay<LAYERNMAX; lay++){
00270                if(fgHitLay[lay]) nhitlay++;
00271           }
00272           if(nhitlay < m_param.nHitLayCut){ m_ncut6++; continue; }
00273 
00274           tanl = rectrk -> getTanLamda();
00275           chisq = rectrk -> getChisq();
00276           p = rectrk -> getP();
00277           pt = rectrk -> getPt();
00278 
00279           for(k=0; k<nhits; k++){
00280                rechit = rectrk->getRecHit(k);
00281                lay = rechit->getLayid();
00282                cel = rechit->getCellid();
00283                lr = rechit->getLR();
00284                doca = rechit -> getDocaInc();
00285                zhit = rechit->getZhit();
00286 
00287                stat = rechit -> getStat();
00288                if((1 == m_param.hitStatCut) && (1 != stat)){ m_ncut7++; continue; }
00289 
00290                if (1 == m_param.resiType) {
00291                     resi = rechit->getResiExcLR();
00292                } else {
00293                     resi = rechit->getResiIncLR();
00294                }
00295                resi *= -1.0;
00296                if( (1==isnan(resi)) || (fabs(resi) > m_resiCut) ||
00297                    (fabs(doca) > m_docaMax[lay]) || (fabs(doca) < m_docaMin[lay]) ){
00298                     m_ncut8++;
00299                     continue;
00300                }
00301 
00302                if(m_param.fgAdjacLayerCut){
00303                     if(0 == lay){
00304                          if( ! fgHitLay[1] ){ m_ncut9++; continue; }
00305                     } else if(42 == lay){
00306                          if( ! fgHitLay[41] ){ m_ncut10++; continue; }
00307                     } else{
00308                          if( (!fgHitLay[lay-1]) && (!fgHitLay[lay+1]) ){ m_ncut11++; continue; }
00309                          // for boundary layers
00310                          if( m_param.fgBoundLayerCut && m_layBound[lay] && 
00311                              ((!fgHitLay[lay-1]) || (!fgHitLay[lay+1])) ){
00312                               m_ncut12++;
00313                               continue;
00314                          }
00315                     }
00316                }
00317 
00318                m_hlayHitmap->Fill(lay);
00319 
00320                // fill alignment trees
00321                if((zhit < m_zrange[lay][0]) || (zhit > m_zrange[lay][1])){
00322                     wir = m_mdcGeomSvc -> Wire(lay, cel) -> Id();
00323                     xx = (zhit - m_zw[wir]) * (m_xe[wir] - m_xw[wir]) / 
00324                          (m_ze[wir] - m_zw[wir]) + m_xw[wir];
00325                     yy = (zhit - m_zw[wir]) * (m_ye[wir] - m_yw[wir]) / 
00326                          (m_ze[wir] - m_zw[wir]) + m_yw[wir];
00327                     rr = sqrt( (xx * xx) + (yy * yy) );
00328                     dphi = fabs(doca) / m_radii[lay];
00329 
00330                     if( yy >= 0 )  wphi = acos(xx / rr);
00331                     else           wphi = PI2 - acos(xx / rr);
00332                     if(1 == lr)    hitPhi = wphi + dphi; // mention
00333                     else hitPhi = wphi - dphi;
00334                     if(hitPhi < 0) hitPhi += PI2;
00335                     else if(hitPhi > PI2) hitPhi -= PI2;
00336 
00337                     if(zhit < m_zrange[lay][0]) iEnd = 0; // west
00338                     else iEnd = 1; // east
00339                     iEP = Alignment::getEpId(lay, iEnd);
00340 
00341                     m_iRun[iEP] = iRun;
00342                     m_iEvt[iEP] = iEvt;
00343                     m_resi[iEP] = resi;
00344                     m_p[iEP] = p;
00345                     m_pt[iEP] = pt;
00346                     m_phi[iEP] = hitPhi;
00347                     m_lay[iEP] = lay;
00348                     m_lr[iEP] = lr;
00349                     m_cel[iEP] = cel;
00350                     m_tuple[iEP]->write();
00351 
00352                     m_resi[NEP] = resi;
00353                     m_p[NEP] = p;
00354                     m_pt[NEP] = pt;
00355                     m_phi[NEP] = hitPhi;
00356                     m_lay[NEP] = lay;
00357                     m_lr[NEP] = lr;
00358                     m_cel[NEP] = cel;
00359                     m_tuple[NEP]->write();
00360 
00361                     m_hresAll->Fill(resi);
00362                     if(lay < 8) m_hresInn->Fill(resi);
00363                     else if(lay < 20) m_hresStp->Fill(resi);
00364                     else m_hresOut->Fill(resi);
00365                     m_hresLay[lay]->Fill(resi);
00366 
00367                     m_gr[iEP]->SetPoint(m_npoint[iEP], hitPhi, resi);
00368                     m_npoint[iEP]++;
00369                }
00370           }
00371      }
00372 
00373      return true;
00374 }

Double_t ResiAlign::funResi (  Double_t *  x,
Double_t *  par
)  [static, private]
  

00171                                                      {
00172      Double_t val;
00173      val = par[0] + par[1]*sin(x[0]) + par[2]*cos(x[0]);
00174      return val;
00175 }

Double_t ResiAlign::funResi (  double *  x,
double *  par
)  [static]
 

Double_t ResiAlign::funResi (  double *  x,
double *  par
)  [static]
 

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

Implements AlignBase.

00015                                                        {
00016      m_pGeom = pGeom;
00017      char hname[200];
00018      m_hnTrk = new TH1F("mHNtrack", "", 10, -0.5, 9.5);
00019      hlist->Add(m_hnTrk);
00020 
00021      m_hnHit = new TH1F("mHNhit", "", 100, -0.5, 99.5);
00022      hlist->Add(m_hnHit);
00023 
00024      m_hlayHitmap = new TH1F("mHitmap", "", 43, -0.5, 42.5);
00025      hlist->Add(m_hnHit);
00026 
00027      m_hresAll = new TH1F("mHResAllInc", "", 200, -1.0, 1.0);
00028      hlist->Add(m_hresAll);
00029 
00030      m_hresInn = new TH1F("mHResInnInc", "", 200, -1.0, 1.0);
00031      hlist->Add(m_hresInn);
00032 
00033      m_hresStp = new TH1F("mHResStpInc", "", 200, -1.0, 1.0);
00034      hlist->Add(m_hresStp);
00035 
00036      m_hresOut = new TH1F("mHResOutInc", "", 200, -1.0, 1.0);
00037      hlist->Add(m_hresOut);
00038 
00039      for(int lay=0; lay<LAYERNMAX; lay++){
00040           sprintf(hname, "mRes_Layer%02d", lay);
00041           m_hresLay[lay] = new TH1F(hname, "", 200, -1.0, 1.0);
00042           hlist->Add(m_hresLay[lay]);
00043      }
00044 
00045      for(int iEP=0; iEP<NEP; iEP++){
00046           m_gr[iEP] = new TGraph();
00047           sprintf(hname, "mgrResi%02d", iEP);
00048           m_gr[iEP]->SetName(hname);
00049           hlist->Add(m_gr[iEP]);
00050           m_npoint[iEP] = 0;
00051      }
00052 }

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

Implements MdcAlign.

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

Implements MdcAlign.

00077                                                       {
00078      IMessageSvc* msgSvc;
00079      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00080      MsgStream log(msgSvc, "ResiAlign");
00081      log << MSG::INFO << "ResiAlign::initialize()" << endreq;
00082 
00083      m_hlist = hlist;
00084      m_mdcGeomSvc = mdcGeomSvc;
00085      m_mdcFunSvc = mdcFunSvc;
00086 
00087      double zeast;
00088      for(int lay=0; lay<43; lay++){
00089           zeast = m_mdcGeomSvc->Wire(lay, 0)->Backward().z();
00090           m_zrange[lay][1] = 2.0 * fabs(zeast) / (double)m_ndiv;
00091           m_zrange[lay][0] = -1.0 * m_zrange[lay][1];
00092 
00093           m_radii[lay] = m_mdcGeomSvc->Layer(lay)->Radius();
00094      }
00095 
00096      for(int wir=0; wir<WIRENMAX; wir++){
00097           m_xe[wir] = m_mdcGeomSvc->Wire(wir)->Backward().x();
00098           m_ye[wir] = m_mdcGeomSvc->Wire(wir)->Backward().y();
00099           m_ze[wir] = m_mdcGeomSvc->Wire(wir)->Backward().z();
00100           m_xw[wir] = m_mdcGeomSvc->Wire(wir)->Forward().x();
00101           m_yw[wir] = m_mdcGeomSvc->Wire(wir)->Forward().y();
00102           m_zw[wir] = m_mdcGeomSvc->Wire(wir)->Forward().z();
00103      }
00104 
00105      char hname[200];
00106      int iEP;
00107 
00108      INTupleSvc* ntupleSvc;
00109      Gaudi::svcLocator() -> service("NTupleSvc", ntupleSvc);
00110      for(iEP=0; iEP<=NEP; iEP++){
00111           if(iEP < NEP) sprintf(hname, "FILE137/align%02d", iEP);
00112           else sprintf(hname, "FILE137/alignAll");
00113 
00114           NTuplePtr nt(ntupleSvc, hname);
00115           if( nt ) m_tuple[iEP] = nt;
00116           else{
00117                m_tuple[iEP] = ntupleSvc->book(hname, CLID_ColumnWiseTuple,"align");
00118                if (m_tuple[iEP]) {
00119                     m_tuple[iEP]->addItem ("run", m_iRun[iEP]);
00120                     m_tuple[iEP]->addItem ("evt", m_iEvt[iEP]);
00121                     m_tuple[iEP]->addItem ("resi", m_resi[iEP]);
00122                     m_tuple[iEP]->addItem ("p", m_p[iEP]);
00123                     m_tuple[iEP]->addItem ("pt", m_pt[iEP]);
00124                     m_tuple[iEP]->addItem ("phi", m_phi[iEP]);
00125                     m_tuple[iEP]->addItem ("lay", m_lay[iEP]);
00126                     m_tuple[iEP]->addItem ("lr", m_lr[iEP]);
00127                     m_tuple[iEP]->addItem ("cel", m_cel[iEP]);
00128                }
00129                else {
00130                     log << MSG::FATAL << "Cannot book N-tuple:"
00131                         << long(m_tuple[iEP]) << endmsg;
00132                }
00133           }
00134      }
00135 
00136      m_hnTrk = new TH1F("HNtrack", "", 10, -0.5, 9.5);
00137      m_hlist->Add(m_hnTrk);
00138 
00139      m_hnHit = new TH1F("HNhit", "", 100, -0.5, 99.5);
00140      m_hlist->Add(m_hnHit);
00141 
00142      m_hlayHitmap = new TH1F("Hitmap", "", 43, -0.5, 42.5);
00143      m_hlist->Add(m_hlayHitmap);
00144 
00145      m_hresAll = new TH1F("HResAllInc", "", 200, -1.0, 1.0);
00146      m_hlist->Add(m_hresAll);
00147 
00148      m_hresInn = new TH1F("HResInnInc", "", 200, -1.0, 1.0);
00149      m_hlist->Add(m_hresInn);
00150 
00151      m_hresStp = new TH1F("HResStpInc", "", 200, -1.0, 1.0);
00152      m_hlist->Add(m_hresStp);
00153 
00154      m_hresOut = new TH1F("HResOutInc", "", 200, -1.0, 1.0);
00155      m_hlist->Add(m_hresOut);
00156 
00157      int lay;
00158      for(lay=0; lay<LAYERNMAX; lay++){
00159           sprintf(hname, "Res_Layer%02d", lay);
00160           m_hresLay[lay] = new TH1F(hname, "", 200, -1.0, 1.0);
00161           m_hlist->Add(m_hresLay[lay]);
00162      }
00163 
00164      for(iEP=0; iEP<NEP; iEP++){
00165           m_gr[iEP] = new TGraph();
00166           sprintf(hname, "grResi%02d", iEP);
00167           m_gr[iEP]->SetName(hname);
00168           m_hlist->Add(m_gr[iEP]);
00169      }
00170      m_fevt.open("evt.txt");
00171 }

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

Implements AlignBase.

00054                                      {
00055      char hname[200];
00056      TH1F* hist;
00057      hist = (TH1F*)fhist->Get("HNtrack");
00058      m_hnTrk->Add(hist);
00059 
00060      hist = (TH1F*)fhist->Get("HNhit");
00061      m_hnHit->Add(hist);
00062 
00063      hist = (TH1F*)fhist->Get("Hitmap");
00064      m_hlayHitmap->Add(hist);
00065 
00066      hist = (TH1F*)fhist->Get("HResAllInc");
00067      m_hresAll->Add(hist);
00068 
00069      hist = (TH1F*)fhist->Get("HResInnInc");
00070      m_hresInn->Add(hist);
00071 
00072      hist = (TH1F*)fhist->Get("HResStpInc");
00073      m_hresStp->Add(hist);
00074 
00075      hist = (TH1F*)fhist->Get("HResOutInc");
00076      m_hresOut->Add(hist);
00077 
00078      for(int lay=0; lay<LAYERNMAX; lay++){
00079           sprintf(hname, "Res_Layer%02d", lay);
00080           hist = (TH1F*)fhist->Get(hname);
00081           m_hresLay[lay]->Add(hist);
00082      }
00083 
00084      for(int iEP=0; iEP<NEP; iEP++){
00085           sprintf(hname, "grResi%02d", iEP);
00086           TGraph* gr = (TGraph*)fhist->Get(hname);
00087           int np = gr->GetN();
00088           double xx;
00089           double yy;
00090           for(int i=0; i<np; i++){
00091                gr->GetPoint(i, xx, yy);
00092                m_gr[iEP]->SetPoint(m_npoint[iEP], xx, yy);
00093                m_npoint[iEP]++;
00094           }
00095      }
00096 }

void ResiAlign::renameHist (   )  [private]
  

00152                           {
00153      char hname[200];
00154      m_hnTrk->SetName("HNtrack");
00155      m_hnHit->SetName("HNhit");
00156      m_hlayHitmap->SetName("Hitmap");
00157      m_hresAll->SetName("HResAllInc");
00158      m_hresInn->SetName("HResInnInc");
00159      m_hresStp->SetName("HResStpInc");
00160      m_hresOut->SetName("HResOutInc");
00161      for(int lay=0; lay<LAYERNMAX; lay++){
00162           sprintf(hname, "Res_Layer%02d", lay);
00163           m_hresLay[lay]->SetName(hname);
00164      }
00165      for(int iEP=0; iEP<NEP; iEP++){
00166           sprintf(hname, "grResi%02d", iEP);
00167           m_gr[iEP]->SetName(hname);
00168      }
00169 }

void ResiAlign::setParam (  MdcAliParams &  param  )  [virtual]
 

Implements MdcAlign.

void ResiAlign::setParam (  MdcAliParams &  param  )  [inline, virtual]
 

Implements MdcAlign.

00093                                                   {
00094      MdcAlign::setParam(param);
00095      m_param = param;
00096 }

void ResiAlign::updateConst (  MdcAlignPar *  alignPar  )  [virtual]
 

Implements MdcAlign.

void ResiAlign::updateConst (  MdcAlignPar *  alignPar  )  [virtual]
 

Implements MdcAlign.

00376                                                 {
00377      IMessageSvc* msgSvc;
00378      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00379      MsgStream log(msgSvc, "ResiAlign");
00380      log << MSG::INFO << "ResiAlign::updateConst()" << endreq;
00381      m_fevt.close();
00382 
00383      int iEP;
00384      double par[3];
00385      double err[3];
00386      double dx;
00387      double dy;
00388      double rz;
00389      double rLayer[] = { 120.225, 205.0, 237.55, 270.175,
00390                          302.625, 334.775, 366.65, 500.0,
00391                          120.225, 205.0, 237.55, 270.175,
00392                          302.625, 334.775, 366.65, 500.0 };
00393 
00394      TCanvas c1("c1", "c1", 10, 10, 700, 500);
00395 
00396      TF1* fResPhi = new TF1("fResPhi", funResi, 0, PI2, 3);
00397      fResPhi->SetParameter(0, 0.0);
00398      fResPhi->SetParameter(1, 0.0);
00399      fResPhi->SetParameter(2, 0.0);
00400 
00401      for(iEP=0; iEP<NEP; iEP++){
00402           if((m_gr[iEP]->GetN()) > 500){
00403                m_gr[iEP]->Fit("fResPhi", "V");
00404                par[0] = fResPhi->GetParameter(0);
00405                par[1] = fResPhi->GetParameter(1);
00406                par[2] = fResPhi->GetParameter(2);
00407 
00408                err[0] = fResPhi->GetParError(0);
00409                err[1] = fResPhi->GetParError(1);
00410                err[2] = fResPhi->GetParError(2);
00411 
00412                dx = -1.0 * par[1];
00413                dy = par[2];
00414                rz = par[0] / rLayer[iEP];
00415 
00416                // assume the shift of the outer section is 0
00417                if (7==iEP || 15==iEP) {
00418                     dx = 0.0;
00419                     dy = 0.0;
00420                     rz = 0.0;
00421                     par[0] = 0.0;
00422                     par[1] = 0.0;
00423                     par[2] = 0.0;
00424                }
00425                alignPar->setDelDx(iEP, dx);
00426                alignPar->setDelDy(iEP, dy);
00427                alignPar->setDelRz(iEP, rz);
00428 
00429                alignPar->setErrDx(iEP, err[1]);
00430                alignPar->setErrDy(iEP, err[2]);
00431                alignPar->setErrRz(iEP, err[0]/rLayer[iEP]);
00432           }
00433      }
00434 
00435      cout << "TrackCut: cut1: " << m_ncut1 << ",  cut2: " << m_ncut2 << ",  cut3: " << m_ncut3
00436           << ",  cut4: " << m_ncut4 << ",  cut5: " << m_ncut5 << ",  cut6: " << m_ncut6 << endl;
00437      cout << "HitCut:   cut7: " << m_ncut7 << ",  cut8: " << m_ncut8 << ",  cut9: " << m_ncut9
00438           << ",  cut10: " << m_ncut10 << ",  cut11: " << m_ncut11 << ",  cut12: " << m_ncut12 << endl;
00439 
00440      delete fResPhi;
00441 }

Member Data Documentation

std::string MdcAlign::fixMomLab [inherited]
 

Reimplemented in MilleAlign.

NTuple::Item<float> ResiAlign::m_cel[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_cel[NEP+1] [private]
 

double ResiAlign::m_docaMax [private]
 

double ResiAlign::m_docaMin [private]
 

std::ofstream ResiAlign::m_fevt [private]
 

TGraph* ResiAlign::m_gr[NEP] [private]
 

TGraph* ResiAlign::m_gr[NEP] [private]
 

TGraph* ResiAlign::m_gr[NEP] [private]
 

TH1F* ResiAlign::m_hlayHitmap [private]
 

TH1F* ResiAlign::m_hlayHitmap [private]
 

TH1F* ResiAlign::m_hlayHitmap [private]
 

TObjArray* ResiAlign::m_hlist [private]
 

TObjArray* ResiAlign::m_hlist [private]
 

TH1F* ResiAlign::m_hnHit [private]
 

TH1F* ResiAlign::m_hnHit [private]
 

TH1F* ResiAlign::m_hnHit [private]
 

TH1F* ResiAlign::m_hnTrk [private]
 

TH1F* ResiAlign::m_hnTrk [private]
 

TH1F* ResiAlign::m_hnTrk [private]
 

TH1F* ResiAlign::m_hresAll [private]
 

TH1F* ResiAlign::m_hresAll [private]
 

TH1F* ResiAlign::m_hresAll [private]
 

TH1F* ResiAlign::m_hresInn [private]
 

TH1F* ResiAlign::m_hresInn [private]
 

TH1F* ResiAlign::m_hresInn [private]
 

TH1F* ResiAlign::m_hresLay[LAYERNMAX] [private]
 

TH1F* ResiAlign::m_hresLay[LAYERNMAX] [private]
 

TH1F* ResiAlign::m_hresLay[LAYERNMAX] [private]
 

TH1F* ResiAlign::m_hresOut [private]
 

TH1F* ResiAlign::m_hresOut [private]
 

TH1F* ResiAlign::m_hresOut [private]
 

TH1F* ResiAlign::m_hresStp [private]
 

TH1F* ResiAlign::m_hresStp [private]
 

TH1F* ResiAlign::m_hresStp [private]
 

NTuple::Item<long> ResiAlign::m_iEvt[NEP+1] [private]
 

NTuple::Item<long> ResiAlign::m_iEvt[NEP+1] [private]
 

NTuple::Item<long> ResiAlign::m_iRun[NEP+1] [private]
 

NTuple::Item<long> ResiAlign::m_iRun[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_lay[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_lay[NEP+1] [private]
 

bool ResiAlign::m_layBound [private]
 

NTuple::Item<float> ResiAlign::m_lr[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_lr[NEP+1] [private]
 

IMdcCalibFunSvc* ResiAlign::m_mdcFunSvc [private]
 

IMdcCalibFunSvc* ResiAlign::m_mdcFunSvc [private]
 

IMdcGeomSvc* ResiAlign::m_mdcGeomSvc [private]
 

IMdcGeomSvc* ResiAlign::m_mdcGeomSvc [private]
 

int ResiAlign::m_ncut1 [private]
 

int ResiAlign::m_ncut10 [private]
 

int ResiAlign::m_ncut11 [private]
 

int ResiAlign::m_ncut12 [private]
 

int ResiAlign::m_ncut2 [private]
 

int ResiAlign::m_ncut3 [private]
 

int ResiAlign::m_ncut4 [private]
 

int ResiAlign::m_ncut5 [private]
 

int ResiAlign::m_ncut6 [private]
 

int ResiAlign::m_ncut7 [private]
 

int ResiAlign::m_ncut8 [private]
 

int ResiAlign::m_ncut9 [private]
 

int ResiAlign::m_ndiv [private]
 

Long64_t ResiAlign::m_npoint [private]
 

NTuple::Item<float> ResiAlign::m_p[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_p[NEP+1] [private]
 

MdcAliParams ResiAlign::m_param [private]
 

Reimplemented from MdcAlign.

MdcCosGeom* ResiAlign::m_pGeom [private]
 

NTuple::Item<float> ResiAlign::m_phi[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_phi[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_pt[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_pt[NEP+1] [private]
 

double ResiAlign::m_radii [private]
 

NTuple::Item<float> ResiAlign::m_resi[NEP+1] [private]
 

NTuple::Item<float> ResiAlign::m_resi[NEP+1] [private]
 

double ResiAlign::m_resiCut [private]
 

NTuple::Tuple* ResiAlign::m_tuple[NEP+1] [private]
 

NTuple::Tuple* ResiAlign::m_tuple[NEP+1] [private]
 

double ResiAlign::m_xe [private]
 

double ResiAlign::m_xw [private]
 

double ResiAlign::m_ye [private]
 

double ResiAlign::m_yw [private]
 

double ResiAlign::m_ze [private]
 

double ResiAlign::m_zrange [private]
 

double ResiAlign::m_zw [private]
 

INTupleSvc* ResiAlign::ntupleSvc [private]
 

INTupleSvc* ResiAlign::ntupleSvc [private]
 

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