BOSS6.5.5: MdcCalib Class Reference

00035                   {
00036      m_nEvt=0;
00037      m_cut1=0;
00038      m_cut2=0;
00039      m_cut3=0;
00040      m_cut4=0;
00041      m_cut5=0;
00042      m_cut6=0;
00043 
00044      int lay;
00045      for(lay=0; lay<43; lay++){
00046           if(lay < 15) m_nEntr[lay] = 1;
00047           else m_nEntr[lay] = 2;
00048      }
00049      m_dwid = 0.5;              // mm
00050      m_fgIni = false;
00051 
00052      m_phiWid = PI2 / (double)NPhiBin;
00053      m_theWid = 2.0 / (double)NThetaBin;
00054 
00055      m_nEvtNtuple = 0;
00056 
00057      for(lay=0; lay<MdcCalNLayer; lay++){
00058           if(lay < 8) m_nBin[lay] = 12;
00059           else m_nBin[lay] = 16;
00060      }
00061 
00062      // construction
00063      m_nTrk = 0;
00064      for(lay=0; lay<MdcCalNLayer; lay++){
00065           m_nGoodHit[lay] = 0;
00066      }
00067 
00068      // setting boundary layer flags
00069      for(lay=0; lay<MdcCalNLayer; lay++){
00070           if((0==lay) || (7==lay) || (8==lay) || (19==lay) || (20==lay) ||
00071              (35==lay) || (36==lay) || (42==lay) ) m_layBound[lay] = true;
00072           else m_layBound[lay] = false;
00073      }
00074 }

00079                     {
00080      int lay;
00081      for(lay=0; lay<m_nlayer; lay++){
00082           delete m_htraw[lay];
00083           delete m_htdr[lay];
00084           delete m_hresInc[lay];
00085           delete m_hresExc[lay];
00086           for (int lr=0; lr<2; lr++){
00087                delete m_htdrlr[lay][lr];
00088                delete m_hreslrInc[lay][lr];
00089                delete m_hreslrExc[lay][lr];
00090           }
00091      }
00092 
00093      delete m_hresAllInc;
00094      delete m_hresAllExc;
00095      delete m_hresAllAve;
00096      for(int i=0; i<14; i++){
00097           delete m_hresAveAllQ[i];
00098           delete m_hresAveOutQ[i];
00099      }
00100      for(lay=0; lay<43; lay++){
00101           for(int i=0; i<14; i++) delete m_hresAveLayQ[lay][i];
00102      }
00103      delete m_hresInnInc;
00104      delete m_hresInnExc;
00105      delete m_hresStpInc;
00106      delete m_hresStpExc;
00107      delete m_hresOutInc;
00108      delete m_hresOutExc;
00109      for(int iEs=0; iEs<m_param.nEsFlag; iEs++) delete m_hTes[iEs];
00110      delete m_hbbTrkFlg;
00111      delete m_hTesAll;
00112      delete m_hTesGood;
00113      delete m_hTesAllFlag;
00114      delete m_hTesRec;
00115      delete m_hTesCalFlag;
00116      delete m_hTesCalUse;
00117      delete m_hnRawHit;
00118      delete m_hpt;
00119      delete m_hpMax;
00120      delete m_hpMaxCms;
00121      delete m_hptPos;
00122      delete m_hptNeg;
00123      delete m_hp;
00124      delete m_hp_cms;
00125      delete m_hpPos;
00126      delete m_hpNeg;
00127      delete m_hpPoscms;
00128      delete m_hpNegcms;
00129      delete m_hp_cut;
00130      delete m_hchisq;
00131      delete m_hnTrk;
00132      delete m_hnTrkCal;
00133      delete m_hnhitsRec;
00134      delete m_hnhitsRecInn;
00135      delete m_hnhitsRecStp;
00136      delete m_hnhitsRecOut;
00137      delete m_hnhitsCal;
00138      delete m_hnhitsCalInn;
00139      delete m_hnhitsCalStp;
00140      delete m_hnhitsCalOut;
00141      delete m_wirehitmap;
00142      delete m_layerhitmap;
00143      delete m_hnoisephi;
00144      delete m_hnoiselay;
00145      delete m_hnoisenhits;
00146      delete m_hratio;
00147      delete m_hdr;
00148      delete m_hphi0;
00149      delete m_hkap;
00150      delete m_hdz;
00151      delete m_htanl;
00152      delete m_hcosthe;
00153      delete m_hcostheNeg;
00154      delete m_hcosthePos;
00155      delete m_hx0;
00156      delete m_hy0;
00157      delete m_hdelZ0;
00158      int bin;
00159      int thbin;
00160      for(bin=0; bin<NPhiBin; bin++){
00161           delete m_ppPhi[bin];
00162           delete m_pnPhi[bin];
00163           delete m_ppPhiCms[bin];
00164           delete m_pnPhiCms[bin];
00165           for(thbin=0; thbin<NThetaBin; thbin++){
00166                delete m_ppThePhi[thbin][bin];
00167                delete m_pnThePhi[thbin][bin];
00168                delete m_ppThePhiCms[thbin][bin];
00169                delete m_pnThePhiCms[thbin][bin];
00170           }
00171      }
00172      for(thbin=0; thbin<NThetaBin; thbin++){
00173           delete m_ppThe[thbin];
00174           delete m_pnThe[thbin];
00175           delete m_ppTheCms[thbin];
00176           delete m_pnTheCms[thbin];
00177      }
00178 
00179      for(unsigned i=0; i<m_hr2dInc.size(); i++){
00180           delete m_hr2dInc[i];
00181           delete m_hr2dExc[i];
00182      }
00183      m_hr2dInc.clear();
00184      m_hr2dExc.clear();
00185      m_mapr2d.clear();
00186 
00187      delete m_fdTime;
00188      delete m_fdres;
00189      delete m_fdres2d;
00190      delete m_fdcom;
00191      delete m_fdResQ;
00192 }

01513                                                                       {
01514      int i;
01515      double vst[3];   // P0 - W0
01516      double vp[3];    // (P * W) / |P * W|
01517      double modvp;
01518      double m2;
01519      double seca[3], secb[3];
01520      double tpa = 0.0;
01521      double twb = 0.0;
01522 
01523      for(i=0; i<3; i++) vst[i] = sta[i] - stb[i];  // vector P0-W0
01524 
01525      expd(veca, vecb, vp); // exterior product
01526 
01527      m2 = vp[0]*vp[0] + vp[1]*vp[1] + vp[2]*vp[2];
01528      modvp = sqrt(m2);
01529      for(i=0; i<3; i++) vp[i] /= modvp;  // (P * W) / |P * W|
01530 
01531      d = 0.0;
01532      for(i=0; i<3; i++)  d += vst[i] * vp[i];
01533 
01534      if( 0 == fgZcal ) return 1;
01535 
01536      double veca00 = veca[0]*veca[0];
01537      double veca11 = veca[1]*veca[1];
01538      double veca22 = veca[2]*veca[2];
01539 
01540      double veca01 = veca[0]*veca[1];
01541      double veca02 = veca[0]*veca[2];
01542      double veca12 = veca[1]*veca[2];
01543 
01544      double vecb00 = vecb[0]*vecb[0];
01545      double vecb11 = vecb[1]*vecb[1];
01546      double vecb22 = vecb[2]*vecb[2];
01547      double vecb01 = vecb[0]*vecb[1];
01548      double vecb02 = vecb[0]*vecb[2];
01549      double vecb12 = vecb[1]*vecb[2];
01550 
01551      seca[0] = veca[1]*vecb01 + veca[2]*vecb02 - veca[0]*(vecb11 + vecb22);
01552      seca[1] = veca[0]*vecb01 + veca[2]*vecb12 - veca[1]*(vecb00 + vecb22);
01553      seca[2] = veca[0]*vecb02 + veca[1]*vecb12 - veca[2]*(vecb00 + vecb11);
01554 
01555      secb[0] = vecb[1]*veca01 + vecb[2]*veca02 - vecb[0]*(veca11 + veca22);
01556      secb[1] = vecb[0]*veca01 + vecb[2]*veca12 - vecb[1]*(veca00 + veca22);
01557      secb[2] = vecb[0]*veca02 + vecb[1]*veca12 - vecb[2]*(veca00 + veca11);
01558 
01559      for(i=0; i<3; i++){
01560           tpa += seca[i] * (sta[i] - stb[i]);
01561           twb += secb[i] * (stb[i] - sta[i]);
01562      }
01563      tpa /= m2;
01564      twb /= m2;
01565      za = veca[2] * tpa + sta[2];
01566      zb = vecb[2] * twb + stb[2];
01567 
01568      return 1;
01569 }

01593                                                                           {
01594      double x0 = trkpar[0] * cos(trkpar[1]);
01595      double y0 = trkpar[0] * sin(trkpar[1]);
01596      double z0 = trkpar[3];
01597      double phi0 = trkpar[1] + HFPI;
01598      double g = 1000 / (0.3 * m_param.mag * trkpar[2]); // alpha/kappa
01599      double tanl = trkpar[4];
01600 
01601      double trkst[3];
01602      double trkv[3];
01603      double phi = phi0 + (zini - z0) / (g * tanl);
01604 
01605      double doca;
01606      double ztrk;
01607      double phiNew;
01608      int iter = 0;
01609      for(iter=0; iter<10; iter++){
01610           trkst[0] = x0 + g * (sin(phi) - sin(phi0));
01611           trkst[1] = y0 + g * (-cos(phi) + cos(phi0));
01612           trkst[2] = z0 + g * tanl * (phi - phi0);
01613 
01614           trkv[0] = cos(phi);
01615           trkv[1] = sin(phi);
01616           trkv[2] = tanl;
01617 
01618           dist2Line(trkst, wirest, trkv, wirev, doca, ztrk, zwire);
01619 
01620           phiNew = phi0 + (ztrk - z0) / (g*tanl);
01621           if(fabs(phiNew - phi) < 1.0E-8) break;
01622           phi = phiNew;
01623      }
01624 
01625      return doca;
01626 }

01572                                                                         {
01573 
01574      double d;
01575      double ztrk;
01576      double ps[3];
01577      double pv[3];
01578 
01579      ps[0] = trkpar[0] * cos(trkpar[1]);
01580      ps[1] = trkpar[0] * sin(trkpar[1]);
01581      ps[2] = trkpar[3];
01582 
01583      pv[0] = cos(trkpar[1] + HFPI);
01584      pv[1] = sin(trkpar[1] + HFPI);
01585      pv[2] = trkpar[4];
01586 
01587      dist2Line(ps, wirest, pv, wirev, d, ztrk, zwire, fgZcal);
01588 
01589      return d;
01590 }

01505                                                                 {
01506      val[0] = veca[1]*vecb[2] - veca[2]*vecb[1];
01507      val[1] = veca[2]*vecb[0] - veca[0]*vecb[2];
01508      val[2] = veca[0]*vecb[1] - veca[1]*vecb[0];
01509 }

00621                                         {
00622      IMessageSvc* msgSvc;
00623      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00624      MsgStream log(msgSvc, "MdcCalib");
00625      log << MSG::DEBUG << "MdcCalib::fillHist()" << endreq;
00626 
00627      int i;
00628      int k;
00629      int lay;
00630      int cel;
00631      int wir;
00632      int lr;
00633      int stat;
00634 
00635      int hid;
00636      int key;
00637      int iEntr;
00638      int bin;
00639 
00640      int phiBin;
00641      int phiBinCms;
00642      int theBin;
00643      int theBinCms;
00644      double lamda;
00645      double theta;
00646 
00647      double qhit;
00648      double traw;
00649      double tdr;
00650      double doca;
00651      double resiInc;
00652      double resiExc;
00653      double entr;
00654      double pt;
00655      double p;
00656      double p_cms;
00657      double chisq;
00658      double ecm = m_param.ecm;
00659      double xboost = m_param.boostPar[0] * ecm;
00660      double yboost = m_param.boostPar[1];
00661      double zboost = m_param.boostPar[2];
00662      HepLorentzVector p4;
00663 
00664      double dr;
00665      double phi0;
00666      double dz;
00667      double kap;
00668      double tanl;
00669 
00670      double x0;
00671      double y0;
00672      double zminus = 9999.0;
00673      double zplus = -9999.0;
00674 
00675      double hitphi;
00676      double philab;
00677      double phicms;
00678      double thetacms;
00679      double costheCMS;
00680 
00681      double dphi;
00682      double wphi;
00683      double xx;
00684      double yy;
00685      double rr;
00686 
00687      int nhitlay;
00688      bool fgHitLay[MdcCalNLayer];
00689      bool fgTrk;
00690 
00691      int ntrk = event -> getNTrk();
00692      int nhitRec;
00693      int nhitRecInn;
00694      int nhitRecStp;
00695      int nhitRecOut;
00696      int nhitCal;
00697      int nhitCalInn;
00698      int nhitCalStp;
00699      int nhitCalOut;
00700      MdcCalRecTrk* rectrk;
00701      MdcCalRecHit* rechit;
00702 
00703      int fgAdd[43];             // for calculating layer efficiency
00704 
00705      int nRawHit = event->getNRawHitTQ();
00706      m_hnRawHit->Fill(nRawHit);
00707 
00708      int iEvtOnline = event->getEvtNoOnline();
00709      int iEvtOffline = event->getEvtNoOffline();
00710      int esTimeflag = event->getEsFlag();
00711      double tes = event->getTes();
00712      bool esCutFg = event->getEsCutFlag();
00713      int iEs = event->getNesCutFlag();
00714      //calculate the efficiency of Bhabha event
00715      if (-1 != esTimeflag) {
00716           IDataProviderSvc* eventSvc = NULL;
00717           Gaudi::svcLocator()->service("EventDataSvc", eventSvc);
00718           SmartDataPtr<RecMdcTrackCol> newtrkCol(eventSvc, "/Event/Recon/RecMdcTrackCol");
00719           if(!newtrkCol){
00720                log << MSG::ERROR << "Could not find RecMdcTrackCol" << endreq;
00721                return ( StatusCode::FAILURE );
00722           }
00723           int nGoodTrk = 0;
00724           int icharge = 0;
00725           Vp4 p4p;
00726           Vp4 p4m;
00727           RecMdcTrackCol::iterator it_trk = newtrkCol->begin();
00728           for(; it_trk != newtrkCol->end(); it_trk++){
00729                double mass = 0.000511; // only for eletron
00730                HepLorentzVector p4 = (*it_trk)->p4(mass);
00731                icharge = (*it_trk)->charge();
00732                if (icharge > 0) p4p.push_back(p4);
00733                else p4m.push_back(p4);
00734           }
00735           if (1 == p4p.size() * p4m.size()){
00736                double dang = p4p[0].vect().angle(p4m[0].vect());
00737                m_hbbTrkFlg->Fill(1);
00738                if (dang > 2.94) {
00739                     m_hbbTrkFlg->Fill(2);
00740                }
00741           }
00742 
00743      }
00744      m_hTesAll->Fill(tes);
00745      if (-1 != esTimeflag) m_hTesGood->Fill(tes);
00746      m_hTesAllFlag->Fill(esTimeflag);
00747      if(ntrk > 0) m_hTesRec->Fill(tes);
00748      if( (iEs >= 0) && (iEs < m_param.nEsFlag) ) m_hTes[iEs]->Fill(tes);
00749      if( esCutFg ) m_hTesCalFlag->Fill(tes);
00750      else return -1;
00751 
00752      if(! m_fgIni){
00753           for(lay=0; lay<MdcCalNLayer; lay++){
00754                if(lay < 8) m_docaMax[lay] = m_param.maxDocaInner;
00755                else m_docaMax[lay] = m_param.maxDocaOuter;
00756           }
00757           m_fgIni = true;
00758      }
00759 
00760      bool trkFlag[200];         // for calculating hit efficiency without impact of track fitting
00761      for(i=0; i<200; i++) trkFlag[i] = false;
00762 
00763      int ntrkCal = 0;
00764      double pTrk[2];
00765      double pTrkcms[2];
00766      double hitphiplus = 9999.0;
00767      double hitthetaplus = 9999.0;
00768      double hitphiminus = -9999.0;
00769      double hitthetaminus = -9999.0;
00770      Vp4 pp;
00771      Vp4 pm;
00772      pp.clear();
00773      pm.clear();
00774      int phibinp;
00775      int phibinm;
00776 
00777      m_hnTrk->Fill(ntrk);
00778      if((ntrk < m_param.nTrkCut[0]) || (ntrk > m_param.nTrkCut[1])){
00779           m_cut1++;
00780           return -1;
00781      }
00782 //      if(ntrk > 2) return -1;
00783      for(i=0; i<ntrk; i++){
00784           fgTrk = true;
00785           rectrk = event -> getRecTrk(i);
00786           nhitRec = rectrk -> getNHits();
00787           m_hnhitsRec -> Fill( nhitRec );
00788 
00789           for(lay=0; lay<MdcCalNLayer; lay++){
00790                fgHitLay[lay] = false;
00791           }
00792 
00793           nhitRecInn = 0;
00794           nhitRecStp = 0;
00795           nhitRecOut = 0;
00796           for(k=0; k<nhitRec; k++){
00797                rechit = rectrk -> getRecHit(k);
00798                lay = rechit -> getLayid();
00799                doca = rechit -> getDocaExc();
00800                resiExc = rechit -> getResiExc();
00801                fgHitLay[lay] = true;
00802 
00803                if(lay < 8) nhitRecInn++;
00804                else if(lay < 20) nhitRecStp++;
00805                else nhitRecOut++;
00806           }
00807           m_hnhitsRecInn->Fill(nhitRecInn);
00808           m_hnhitsRecStp->Fill(nhitRecStp);
00809           m_hnhitsRecOut->Fill(nhitRecOut);
00810 
00811           // get momentum
00812           pt = rectrk -> getPt();
00813           p = rectrk -> getP();
00814 
00815           // boost P to the cms
00816           p4 = rectrk->getP4();
00817           HepLorentzVector psip(xboost, yboost, zboost, ecm);
00818           Hep3Vector boostv = psip.boostVector();
00819           p4.boost(- boostv);
00820           p_cms = p4.rho();
00821           phicms = p4.phi();
00822           if(phicms < 0) phicms += PI2;
00823           thetacms = p4.theta();
00824           costheCMS = cos(thetacms);
00825           if (pt < 0) p_cms *= -1.0;
00826           p4.boost(boostv);
00827 //        cout << setw(15) << p << setw(15) << p_cms << setw(15) << costheCMS << endl;
00828 
00829           // cos(theta) cut
00830           if( (costheCMS < m_param.costheCut[0]) || (costheCMS > m_param.costheCut[1]) ){
00831                m_cut2++;
00832                continue;
00833           }
00834 
00835           // dr cut
00836           dr = rectrk->getDr();
00837           if(fabs(dr) > m_param.drCut){
00838                m_cut3++;
00839                continue;
00840           }
00841 
00842           // dz cut
00843           dz = rectrk->getDz();
00844           if(fabs(dz) > m_param.dzCut){
00845                m_cut4++;
00846                continue;
00847           }
00848 
00849 //        if(! fgTrk) continue;
00850 
00851           // hit layer cut
00852           nhitlay = 0;
00853           for(lay=0; lay<MdcCalNLayer; lay++){
00854                if(fgHitLay[lay]) nhitlay++;
00855           }
00856           if(nhitlay < m_param.nHitLayCut){
00857                m_cut5++;
00858                continue;
00859           }
00860 
00861           // nhit cut
00862           if(nhitRec < m_param.nHitCut){
00863                m_cut6++;
00864                continue;
00865           }
00866 
00867 //        if(! ((fgHitLay[0]||fgHitLay[1]) && (fgHitLay[41]||fgHitLay[42])) ){
00868 //             continue;
00869 //        }
00870           m_nTrk++;
00871           for(lay=0; lay<m_nlayer; lay++) fgAdd[lay] = 0;
00872 
00873           chisq = rectrk -> getChisq();
00874           m_hchisq -> Fill( chisq );
00875 
00876           if(pt > 0){
00877                m_hpt -> Fill(pt);
00878                m_hptPos -> Fill(pt);
00879                m_hp -> Fill(p);
00880                m_hp_cms -> Fill(p_cms);
00881                m_hpPos -> Fill(p);
00882                m_hpPoscms -> Fill(p_cms);
00883           } else{
00884                m_hpt -> Fill(-1.0*pt);
00885                m_hptNeg -> Fill(-1.0*pt);
00886                m_hp -> Fill(-1.0*p);
00887                m_hp_cms -> Fill(-1.0*p_cms);
00888                m_hpNeg -> Fill(-1.0*p);
00889                m_hpNegcms -> Fill(-1.0*p_cms);
00890           }
00891           if(2 == ntrk){
00892                pTrk[i] = fabs(p);
00893                pTrkcms[i] = fabs(p_cms);
00894           }
00895 
00896           dr = rectrk -> getDr();
00897           phi0 = rectrk -> getPhi0();
00898           kap = rectrk -> getKappa();
00899           dz = rectrk -> getDz();
00900           tanl = rectrk -> getTanLamda();
00901           lamda = atan(tanl);
00902           theta = HFPI - lamda;
00903 
00904           m_hdr -> Fill(dr);
00905           m_hphi0 -> Fill(phi0);
00906           m_hkap -> Fill(kap);
00907           m_hdz -> Fill(dz);
00908           m_htanl -> Fill(tanl);
00909           m_hcosthe -> Fill(cos(theta));
00910           if(pt > 0) m_hcosthePos->Fill(cos(theta));
00911           else m_hcostheNeg->Fill(cos(theta));
00912 
00913           philab = phi0 + HFPI;
00914           if(philab > PI2) philab -= PI2;
00915 //        cout << setw(15) << phi0 << setw(15) << philab << setw(15) << phicms << endl;
00916 
00917           phiBin = (int)(philab / m_phiWid);
00918           phiBinCms = (int)(phicms / m_phiWid);
00919           theBin = (int)((cos(theta) + 1.0) / m_theWid);
00920           theBinCms = (int)((cos(thetacms) + 1.0) / m_theWid);
00921           if(phiBin < 0) phiBin = 0;
00922           if(phiBin >= NPhiBin) phiBin = NPhiBin-1;
00923           if(phiBinCms < 0) phiBinCms = 0;
00924           if(phiBinCms >= NPhiBin) phiBinCms = NPhiBin-1;
00925           if(theBin < 0) theBin = 0;
00926           if(theBin >= NThetaBin) theBin = NThetaBin-1;
00927           if(theBinCms < 0) theBinCms = 0;
00928           if(theBinCms >= NThetaBin) theBinCms = NThetaBin-1;
00929 
00930           if(pt > 0){
00931                m_ppPhi[phiBin]->Fill(p);
00932                m_ppPhiCms[phiBinCms]->Fill(p_cms);
00933                m_ppThe[theBin]->Fill(p);
00934                m_ppTheCms[theBinCms]->Fill(p_cms);
00935                m_ppThePhi[theBin][phiBin]->Fill(p);
00936                m_ppThePhiCms[theBinCms][phiBinCms]->Fill(p_cms);
00937           } else{
00938                m_pnPhi[phiBin]->Fill(-1.0*p);
00939                m_pnPhiCms[phiBinCms]->Fill(-1.0*p_cms);
00940                m_pnThe[theBin]->Fill(-1.0*p);
00941                m_pnTheCms[theBinCms]->Fill(-1.0*p_cms);
00942                m_pnThePhi[theBin][phiBin]->Fill(-1.0*p);
00943                m_pnThePhiCms[theBinCms][phiBinCms]->Fill(-1.0*p_cms);
00944           }
00945 
00946           x0 = dr * cos(phi0);
00947           y0 = dr * sin(phi0);
00948           m_hx0 -> Fill(x0);
00949           m_hy0 -> Fill(y0);
00950 
00951           if(kap < 0) {
00952                zminus = dz;
00953                pm.push_back(p4);
00954                phibinm = phiBinCms;
00955           } else {
00956                zplus = dz;
00957                pp.push_back(p4);
00958                phibinp = phiBinCms;
00959           }
00960 
00961           ntrkCal++;
00962           trkFlag[i] = true;
00963           nhitCal = 0;
00964           nhitCalInn = 0;
00965           nhitCalStp = 0;
00966           nhitCalOut = 0;
00967           for(k=0; k<nhitRec; k++){
00968                rechit    = rectrk -> getRecHit(k);
00969 
00970                lay    = rechit -> getLayid();
00971                cel    = rechit -> getCellid();
00972                lr     = rechit -> getLR();
00973                stat   = rechit -> getStat();
00974                doca   = rechit -> getDocaExc();
00975                resiInc = rechit -> getResiIncLR();
00976                resiExc = rechit -> getResiExcLR();
00977                entr    = rechit -> getEntra();
00978                tdr     = rechit -> getTdrift();
00979                traw    = (rechit -> getTdc()) * MdcCalTdcCnv;
00980                wir     = m_mdcGeomSvc -> Wire(lay, cel) -> Id();
00981 
00982                m_cel[lay] = (long)cel;
00983                m_lr[lay] = (long)lr;
00984                m_nEvtOnline[lay] = iEvtOnline;
00985                m_nEvtOffline[lay] = iEvtOffline;
00986                m_doca[lay] = doca;
00987                m_dm[lay] = rechit -> getDmeas();
00988                m_tdr[lay] = tdr;
00989                m_entr[lay] = entr*180.0/3.14;
00990                m_zhit[lay] = rechit -> getZhit();
00991                m_qhit[lay] = rechit -> getQhit();
00992                m_p[lay] = p;
00993                m_pt[lay] = pt;
00994                m_phi0[lay] = phi0;
00995                m_tanl[lay] = tanl;
00996                qhit = rechit -> getQhit();
00997 
00998                // calculating hitphi
00999                xx = (m_zhit[lay] - m_zw[wir]) * (m_xe[wir] - m_xw[wir]) / 
01000                     (m_ze[wir] - m_zw[wir]) + m_xw[wir];
01001                yy = (m_zhit[lay] - m_zw[wir]) * (m_ye[wir] - m_yw[wir]) / 
01002                     (m_ze[wir] - m_zw[wir]) + m_yw[wir];
01003                rr = sqrt( (xx * xx) + (yy * yy) );
01004                dphi = fabs(doca) / m_radii[lay];
01005 
01006                if( yy >= 0 )  wphi = acos(xx / rr);
01007                else           wphi = PI2 - acos(xx / rr);
01008                if(1 == lr)    hitphi = wphi + dphi; // mention
01009                else hitphi = wphi - dphi;
01010                if(hitphi < 0) hitphi += PI2;
01011                else if(hitphi > PI2) hitphi -= PI2;
01012 
01013                m_hitphi[lay] = hitphi;
01014 
01015                if( (fabs(doca) > m_docaMax[lay]) || 
01016                    (fabs(resiExc) > m_param.maxResi) ){
01017                     continue;
01018                }
01019 
01020                if(m_param.fgAdjacLayerCut){
01021                     if(0 == lay){
01022                          if( ! fgHitLay[1] ) continue;
01023                     } else if(42 == lay){
01024                          if( ! fgHitLay[41] ) continue;
01025                     } else{
01026                          if( (!fgHitLay[lay-1]) && (!fgHitLay[lay+1]) ) continue;
01027 
01028                          // for boundary layers
01029                          if( m_param.fgBoundLayerCut && m_layBound[lay] && 
01030                              ((!fgHitLay[lay-1]) || (!fgHitLay[lay+1])) ) continue;
01031                     }
01032                }
01033 
01034                if((1 == m_param.hitStatCut) && (1 != stat)) continue;
01035 //             if(lay < 8) nhitInn++;
01036 //             else if(lay < 20) nhitStp++;
01037 //             else nhitOut++;
01038 
01039                // fill xtplot tree
01040                if((1 == m_param.fillNtuple) && (m_nEvtNtuple < m_param.nEvtNtuple)){
01041                     m_xtTuple[lay] -> write();
01042                }
01043 
01044                if(1 == m_param.hitStatCut){
01045                     if( (0 == fgAdd[lay]) && (1 == stat) ){
01046                          m_nGoodHit[lay]++;
01047                          fgAdd[lay] = 1;
01048                     }
01049                } else{
01050                     if(0 == fgAdd[lay]){
01051                          m_nGoodHit[lay]++;
01052                          fgAdd[lay] = 1;
01053                     }
01054                }
01055 
01056                nhitCal++;
01057                if(lay < 8) nhitCalInn++;
01058                else if(lay < 20) nhitCalStp++;
01059                else nhitCalOut++;
01060 
01061                m_wirehitmap -> Fill(wir);
01062                m_layerhitmap -> Fill(lay);
01063 
01064                m_htraw[lay] -> Fill(traw);
01065                m_htdr[lay] -> Fill(tdr);
01066                m_htdrlr[lay][lr]->Fill(tdr);
01067 
01068                m_hresAllInc -> Fill(resiInc);
01069                m_hresAllExc -> Fill(resiExc);
01070                double resiAve = 0.5 * (resiInc + resiExc);
01071                m_hresAllAve -> Fill(resiAve);
01072 
01073                if(lay < 8){
01074                     m_hresInnInc -> Fill(resiInc);
01075                     m_hresInnExc -> Fill(resiExc);
01076                } else if(lay < 20){
01077                     m_hresStpInc -> Fill(resiInc);
01078                     m_hresStpExc -> Fill(resiExc);
01079                } else{
01080                     m_hresOutInc -> Fill(resiInc);
01081                     m_hresOutExc -> Fill(resiExc);
01082                }
01083 
01084                int qbin = (int)((qhit-100.0)/100.0);
01085                if(qbin>=0 && qbin<14){
01086                     m_hresAveAllQ[qbin]->Fill(resiAve);
01087                     m_hresAveLayQ[lay][qbin]->Fill(resiAve);
01088                     if(lay > 7) m_hresAveOutQ[qbin]->Fill(resiAve);
01089                }
01090 
01091                m_hresInc[lay] -> Fill(resiInc);
01092                m_hreslrInc[lay][lr]->Fill(resiInc);
01093                m_hresExc[lay] -> Fill(resiExc);
01094                m_hreslrExc[lay][lr]->Fill(resiExc);
01095 
01096                bin = (int)(fabs(doca) / m_dwid);
01097                iEntr = m_mdcFunSvc -> getSdEntrIndex(entr);
01098                if(1 == m_nEntr[lay]){
01099                     iEntr = 0;
01100                } else if(2 == m_nEntr[lay]){
01101                     if(entr > 0.0) iEntr = 1;
01102                     else iEntr = 0;
01103                }
01104 
01105                if((iEntr < MdcCalNENTRSD) && (bin < MdcCalSdNBIN)){
01106                     key = getHresId(lay, iEntr, lr, bin);
01107                     if( 1 == m_mapr2d.count(key) ){
01108                          hid = m_mapr2d[key];
01109                          m_hr2dInc[hid] -> Fill(resiInc);
01110                          m_hr2dExc[hid] -> Fill(resiExc);
01111                     }
01112                }
01113           } // loop of nhits
01114           m_nEvtNtuple++;
01115           m_hnhitsCal->Fill(nhitCal);
01116           m_hnhitsCalInn->Fill(nhitCalInn);
01117           m_hnhitsCalStp->Fill(nhitCalStp);
01118           m_hnhitsCalOut->Fill(nhitCalOut);
01119      } // end of track loop
01120      m_hnTrkCal->Fill(ntrkCal);
01121      if(2 == ntrkCal){
01122           if(pTrk[0] > pTrk[1]) m_hpMax->Fill(pTrk[0]);
01123           else m_hpMax->Fill(pTrk[1]);
01124 
01125           if(pTrkcms[0] > pTrkcms[1]) m_hpMaxCms->Fill(pTrkcms[0]);
01126           else m_hpMaxCms->Fill(pTrkcms[1]);
01127      }
01128      if(ntrkCal > 0) m_hTesCalUse->Fill(tes);
01129 
01130      double delZ0;
01131      if((fabs(zminus) < 9000.0) && (fabs(zplus) < 9000.0)) delZ0 = zplus - zminus;
01132      m_hdelZ0 -> Fill(delZ0);
01133 
01134      if (1 == pp.size() * pm.size()){
01135           HepLorentzVector ptot = pp[0] + pm[0];
01136           bool fourmomcut = false;
01137 //        fourmomcut = (ptot.x()>0.02 && ptot.x()<0.06) && (fabs(ptot.y()) < 0.02)
01138 //             && (ptot.z()>-0.01 && ptot.z()<0.03) && (ptot.e()>3.4 && ptot.e()<4.0);
01139           fourmomcut = (fabs(ptot.x()-0.04)<0.026) && (fabs(ptot.y()) < 0.026)
01140                && (fabs(ptot.z()-0.005)<0.036) && (fabs(ptot.e()-ecm)<0.058);
01141           //cout << "x = " << ptot.x() << ", y = " << ptot.y() << ", z = " << ptot.z() << ", e = " << ptot.e() << endl;
01142           if (fourmomcut) {
01143                HepLorentzVector psip(xboost, yboost, zboost, ecm);
01144                Hep3Vector boostv = psip.boostVector();
01145                pp[0].boost(- boostv);
01146                pm[0].boost(- boostv);
01147                m_hp_cut->Fill(pp[0].rho());
01148                m_hp_cut->Fill(pm[0].rho());
01149           }
01150      }
01151 
01152      if(2==ntrk) for(i=0; i<ntrk; i++) pTrk[i] = (event -> getRecTrk(i)) -> getP();
01153      if((5==m_param.particle) && (2==ntrk) && (fabs(pTrk[0])<5) && (fabs(pTrk[1])<5)){
01154 //      if(1==ntrk) p = (event->getRecTrk(0)) -> getP();
01155 //      if((5==m_param.particle) && (1==ntrk) && (fabs(p)<5)){
01156           m_tescos = tes;
01157           m_tesFlagcos = esTimeflag;
01158           for(i=0; i<ntrk; i++){
01159                rectrk = event -> getRecTrk(i);
01160                phi0 = rectrk -> getPhi0();
01161                phi0 = ((phi0+HFPI) > PI2) ? (phi0+HFPI-PI2) : (phi0+HFPI);
01162 
01163                tanl = rectrk -> getTanLamda();
01164                lamda = atan(tanl);
01165                theta = HFPI - lamda;
01166 
01167                if(phi0 < (2.0*HFPI)){
01168                     m_nhitUpcos = rectrk -> getNHits();
01169                     m_pUpcos = rectrk -> getP();
01170                     m_ptUpcos = rectrk -> getPt();
01171                     m_phiUpcos = phi0;
01172                     m_drUpcos = rectrk->getDr();
01173                     m_dzUpcos = rectrk->getDz();
01174                     m_ctheUpcos = cos(theta);
01175                } else{
01176                     m_nhitDwcos = rectrk -> getNHits();
01177                     m_pDwcos = rectrk -> getP();
01178                     m_ptDwcos = rectrk -> getPt();
01179                     m_phiDwcos = phi0;
01180                     m_drDwcos = rectrk->getDr();
01181                     m_dzDwcos = rectrk->getDz();
01182                     m_ctheDwcos = cos(theta);
01183 
01184                     if(m_pDwcos > 0) m_chargecos = 1;
01185                     else m_chargecos = 0;
01186                }
01187           }
01188           m_cosmic->write();
01189      }
01190 
01191      if(0 == m_param.fgCalDetEffi) return 1;
01192 
01193      // calculate efficiency without the impact of track fitting
01194      // retrieve Mdc digi
01195      IDataProviderSvc* eventSvc = NULL;
01196      Gaudi::svcLocator()->service("EventDataSvc", eventSvc);
01197      SmartDataPtr<MdcDigiCol> mdcDigiCol(eventSvc,"/Event/Digi/MdcDigiCol");
01198      if (!mdcDigiCol) {
01199           log << MSG::FATAL << "Could not find event" << endreq;
01200      }
01201 
01202      bool hitCel[43][288];
01203      int hitCel2[43][288];
01204      for(lay=0; lay<43; lay++){
01205           for(cel=0; cel<288; cel++){
01206                hitCel[lay][cel] = false;
01207                hitCel2[lay][cel] = 0;
01208           }
01209      }
01210 
01211      MdcDigiCol::iterator iter = mdcDigiCol->begin();
01212      unsigned fgOverFlow;
01213      int digiId = 0;
01214      Identifier id; 
01215      for(; iter != mdcDigiCol->end(); iter++, digiId++) {
01216           MdcDigi *aDigi = (*iter);
01217           id = (aDigi)->identify();
01218 
01219           lay = MdcID::layer(id);
01220           cel = MdcID::wire(id);
01221           wir = m_mdcGeomSvc->Wire(lay, cel)->Id();
01222           fgOverFlow = (aDigi) -> getOverflow();
01223 
01224           if ( !((fgOverFlow == 0)||(fgOverFlow ==12)) ||
01225                (aDigi->getTimeChannel() == 0x7FFFFFFF) ||
01226                (aDigi->getChargeChannel() == 0x7FFFFFFF) ) continue;
01227           hitCel[lay][cel] = true;
01228           hitCel2[lay][cel] = 1;
01229      }
01230 
01231      int fgGetDoca;
01232      int ncel;
01233      int fgLayHit[43];
01234      int celHit[43];
01235      int celDocaMin;
01236      double docaCal;
01237      double docaMin;
01238      double trkpar[5];
01239      double hitpos[3];
01240      double wpos[7];            // wpos[6] is wire tension
01241      const MdcGeoWire* pWire;
01242 
01243      double phiw;
01244 
01245      for(i=0; i<ntrk; i++){
01246           if(!trkFlag[i]) continue;
01247           rectrk = event -> getRecTrk(i);
01248           nhitRec = rectrk -> getNHits();
01249 
01250 //        HepVector helix = rectrk->getHelix();
01251 //        HepSymMatrix helixErr = rectrk->getHelixErr();
01252 
01253           for(lay=0; lay<43; lay++){
01254 //             m_hitNum[lay][0]++;
01255                fgLayHit[lay] = false;
01256                celHit[lay] = -1;
01257           }
01258           for(k=0; k<nhitRec; k++){
01259                rechit = rectrk -> getRecHit(k);
01260                lay = rechit -> getLayid();
01261                cel = rechit -> getCellid();
01262                fgLayHit[lay] = true;
01263                celHit[lay] = cel;
01264                hitCel2[lay][cel] = 2;
01265 
01266                HepVector helix = rechit->getHelix();
01267                HepSymMatrix helixErr = rechit->getHelixErr();
01268                double doca_rec = m_mdcCheckUtil->doca(lay, cel, helix, helixErr);
01269 
01270           }
01271 
01272           for(lay=0; lay<43; lay++){
01273                if(fgLayHit[lay]){
01274                     m_hitNum[lay][0]++;
01275                     m_hitNum[lay][1]++;
01276                } else{
01277                     if(lay<8) docaMin = 8.0;
01278                     else docaMin = 10.5;
01279                     celDocaMin = -1;
01280 
01281                     ncel = m_mdcGeomSvc->Layer(lay)->NCell();
01282                     for(cel=0; cel<ncel; cel++){
01283                          pWire = m_mdcGeomSvc -> Wire(lay, cel);
01284                          wpos[0] = pWire -> Backward().x(); // east end
01285                          wpos[1] = pWire -> Backward().y();
01286                          wpos[2] = pWire -> Backward().z();
01287                          wpos[3] = pWire -> Forward().x(); // west end
01288                          wpos[4] = pWire -> Forward().y();
01289                          wpos[5] = pWire -> Forward().z();
01290                          wpos[6] = 9999.0;
01291                          fgGetDoca = getDoca(trkpar, wpos, docaCal, hitpos, m_zhit[lay]);
01292 
01293                          if(fabs(docaCal) < docaMin){
01294                               docaMin = fabs(docaCal);
01295                               celDocaMin = cel;
01296                          }
01297                     }
01298                     if(celDocaMin > -1){
01299                          m_hitNum[lay][0]++;
01300                          if(hitCel[lay][celDocaMin]) m_hitNum[lay][1]++;
01301                     }
01302                }
01303           }
01304      }
01305 
01306      int nraw = 0;
01307      int nrec = 0;
01308      for(lay=0; lay<43; lay++){
01309           for(cel=0; cel<288; cel++){
01310                if(hitCel2[lay][cel] > 0) nraw++;
01311                if(hitCel2[lay][cel] > 1) nrec++;
01312           }
01313      }
01314      double ratio = (double)nrec / (double)nraw;
01315      m_hratio->Fill(ratio);
01316 
01317      return 1;
01318 }

01629                                                      {
01630      int i = 0;
01631      double zp;      // z of the point above in the plane of the wire
01632      double xyz[3];  // coordinate of the point on wire according to zc
01633      double dxyz[3]; // orientation of the tangent line at the point above
01634 
01635      double ten = wpos[6];
01636      double a = 9.47e-06 / (2 * ten); // a = density(g/mm)/2T(g)
01637      double dx = wpos[0] - wpos[3]; // the differential of xyz between the end planes
01638      double dz = wpos[2] - wpos[5]; // 
01639      double length = sqrt(dx*dx + dz*dz);
01640 
01641      double ztan = 0.0;  // z of the doca point in the tangent line
01642      if(whitPos[2] < 0.5*length)  ztan = whitPos[2];
01643 
01644      double zc=0.0;  // z of the calculated point of the wire
01645      if( m_param.flagMag ) zc = zini;
01646 
01647      // alf is the angle between z and the projection of the wire on xz
01648      double sinalf = dx / sqrt(dx*dx + dz*dz);
01649      double cosalf = dz / sqrt(dx*dx + dz*dz);
01650      double tanalf = dx / dz;
01651 
01652      if(dz < 50){
01653           std::cout << "ERROR: wire position error in getdocaLine() !!!"
01654                     << std::endl;
01655           return false;
01656      }
01657 
01658      while( 1 ){
01659           i++;
01660           if(i > 5){
01661                return false;
01662           }
01663           zp = zc / cosalf;
01664 
01665           xyz[0] = (zc - wpos[5]) * tanalf + wpos[3];
01666           xyz[1] = a*zp*zp + (wpos[1] - wpos[4])*zp/length
01667                + 0.5*(wpos[1] + wpos[4]) - a*length*length/4.0;
01668           xyz[2] = zc;
01669 
01670           dxyz[0] = sinalf;
01671           dxyz[1] = 2.0 * a * zp + (wpos[1] - wpos[4]) / length;
01672           dxyz[2] = cosalf;
01673 
01674           if( m_param.flagMag ) doca = docaHelixWire(trkpar, xyz, dxyz, ztan, zc);
01675           else doca = docaLineWire(trkpar, xyz, dxyz, ztan);
01676 
01677           if( fabs(zc-ztan) < 0.5 )  break;
01678           else if( fabs(ztan) > (0.5*length) ){
01679                doca = 99999.0;
01680                break;
01681           }
01682           zc = ztan;
01683      }
01684      whitPos[2] = ztan;
01685      zp = ztan / cosalf;
01686      whitPos[1] = a*zp*zp + (wpos[1] - wpos[4])*zp/length
01687           + 0.5*(wpos[1] + wpos[4]) - a*length*length/4.0;
01688      whitPos[0] = (ztan - wpos[5]) * tanalf + wpos[3];
01689 
01690      return true;
01691 }

01497                                                                {
01498      int index = ( (lay << HRESLAYER_INDEX) & HRESLAYER_MASK ) |
01499           ( (entr << HRESENTRA_INDEX) & HRESENTRA_MASK ) |
01500           ( (lr << HRESLR_INDEX) & HRESLR_MASK ) |
01501           ( (bin << HRESBIN_INDEX) & HRESBIN_MASK );
01502      return index;
01503 }

00195                                                       {
00196      IMessageSvc* msgSvc;
00197      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
00198      MsgStream log(msgSvc, "MdcCalib");
00199      log << MSG::INFO << "MdcCalib::initialize()" << endreq;
00200 
00201      m_hlist = hlist;
00202      m_mdcGeomSvc = mdcGeomSvc;
00203      m_mdcFunSvc = mdcFunSvc;
00204      m_mdcCheckUtil = new MdcCheckUtil();
00205 
00206      int lay;
00207      int iEntr;
00208      int lr;
00209      int bin;
00210      char hname[200];
00211 
00212      m_nlayer = m_mdcGeomSvc -> getLayerSize();
00213 
00214      for(lay=0; lay<m_nlayer; lay++){
00215           m_radii[lay] = m_mdcGeomSvc->Layer(lay)->Radius();
00216      }
00217      ofstream fwpc("wirelog.txt");
00218      for(int wir=0; wir<MdcCalTotCell; wir++){
00219           m_xe[wir] = m_mdcGeomSvc->Wire(wir)->Backward().x();
00220           m_ye[wir] = m_mdcGeomSvc->Wire(wir)->Backward().y();
00221           m_ze[wir] = m_mdcGeomSvc->Wire(wir)->Backward().z();
00222           m_xw[wir] = m_mdcGeomSvc->Wire(wir)->Forward().x();
00223           m_yw[wir] = m_mdcGeomSvc->Wire(wir)->Forward().y();
00224           m_zw[wir] = m_mdcGeomSvc->Wire(wir)->Forward().z();
00225           fwpc << setw(6) << wir << setw(15) << m_xe[wir] << setw(15) << m_ye[wir]
00226                << setw(15) << m_ze[wir] << setw(15) << m_xw[wir]
00227                << setw(15) << m_yw[wir] << setw(15) << m_zw[wir] << endl;
00228      }
00229      fwpc.close();
00230 
00231      m_fdcom = new TFolder("common", "common");
00232      m_hlist -> Add(m_fdcom);
00233 
00234      m_hresAllInc = new TH1F("HResAllInc", "", 200, -1.0, 1.0);
00235      m_fdcom -> Add(m_hresAllInc);
00236 
00237      m_hresAllExc = new TH1F("HResAllExc", "", 200, -1.0, 1.0);
00238      m_fdcom -> Add(m_hresAllExc);
00239 
00240      m_hresAllAve = new TH1F("HResAllAve", "", 200, -1.0, 1.0);
00241      m_fdcom -> Add(m_hresAllAve);
00242 
00243      m_hresInnInc = new TH1F("HResInnInc", "", 200, -1.0, 1.0);
00244      m_fdcom -> Add(m_hresInnInc);
00245 
00246      m_hresInnExc = new TH1F("HResInnExc", "", 200, -1.0, 1.0);
00247      m_fdcom -> Add(m_hresInnExc);
00248 
00249      m_hresStpInc = new TH1F("HResStpInc", "", 200, -1.0, 1.0);
00250      m_fdcom -> Add(m_hresStpInc);
00251 
00252      m_hresStpExc = new TH1F("HResStpExc", "", 200, -1.0, 1.0);
00253      m_fdcom -> Add(m_hresStpExc);
00254 
00255      m_hresOutInc = new TH1F("HResOutInc", "", 200, -1.0, 1.0);
00256      m_fdcom -> Add(m_hresOutInc);
00257 
00258      m_hresOutExc = new TH1F("HResOutExc", "", 200, -1.0, 1.0);
00259      m_fdcom -> Add(m_hresOutExc);
00260 
00261      m_fdResQ = new TFolder("ResQ", "ResQ");
00262      m_hlist->Add(m_fdResQ);
00263      for(int i=0; i<14; i++){
00264           sprintf(hname, "resoAll_qbin%02d", i);
00265           m_hresAveAllQ[i] = new TH1F(hname, "", 200, -1, 1);
00266           m_fdResQ->Add(m_hresAveAllQ[i]);
00267 
00268           sprintf(hname, "resoOut_qbin%02d", i);
00269           m_hresAveOutQ[i] = new TH1F(hname, "", 200, -1, 1);
00270           m_fdResQ->Add(m_hresAveOutQ[i]);
00271      }
00272      for(lay=0; lay<43; lay++){
00273           for(int i=0; i<14; i++){
00274                sprintf(hname, "resoLay%02d_qbin%02d", lay, i);
00275                m_hresAveLayQ[lay][i] = new TH1F(hname, "", 200, -1, 1);
00276                m_fdResQ->Add(m_hresAveLayQ[lay][i]);
00277           }
00278      }
00279 
00280      for(int iEs=0; iEs<m_param.nEsFlag; iEs++){
00281           sprintf(hname, "Tes_%d", m_param.esFlag[iEs]);
00282           m_hTes[iEs] = new TH1F(hname, "", 750, 0, 1500);
00283           m_fdcom->Add(m_hTes[iEs]);
00284      }
00285 
00286      m_hbbTrkFlg = new TH1F("BbTrkFlg", "", 100, 0, 6);
00287      m_fdcom -> Add(m_hbbTrkFlg);
00288 
00289      m_hTesAll = new TH1F("TesAll", "", 1000, 0, 2000);
00290      m_fdcom -> Add(m_hTesAll);
00291 
00292      m_hTesGood = new TH1F("TesGood", "", 1000, 0, 2000);
00293      m_fdcom -> Add(m_hTesGood);
00294 
00295      m_hTesAllFlag = new TH1F("TesAllFlag", "", 300, -0.5, 299.5);
00296      m_fdcom -> Add(m_hTesAllFlag);
00297 
00298      m_hTesRec = new TH1F("TesRec", "", 1000, 0, 2000);
00299      m_fdcom -> Add(m_hTesRec);
00300 
00301      m_hTesCalFlag = new TH1F("TesCalFlag", "", 1000, 0, 2000);
00302      m_fdcom -> Add(m_hTesCalFlag);
00303 
00304      m_hTesCalUse = new TH1F("TesCalUse", "", 1000, 0, 2000);
00305      m_fdcom -> Add(m_hTesCalUse);
00306 
00307      m_hnRawHit = new TH1F("nRawHit", "", 6797, -0.5, 6796.5);
00308      m_fdcom -> Add(m_hnRawHit);
00309 
00310      m_hpt = new TH1F("HPt", "", 800, 0, 3);
00311      m_fdcom -> Add(m_hpt);
00312 
00313      m_hptPos = new TH1F("HPtPos", "", 800, 0, 3);
00314      m_fdcom -> Add(m_hptPos);
00315 
00316      m_hptNeg = new TH1F("HPtNeg", "", 800, 0, 3);
00317      m_fdcom -> Add(m_hptNeg);
00318 
00319      m_hp = new TH1F("HP", "", 800, 0, 3);
00320      m_fdcom -> Add(m_hp);
00321 
00322      m_hp_cms = new TH1F("HPCMS", "", 800, 0, 3);
00323      m_fdcom -> Add(m_hp_cms);
00324 
00325      m_hpMax = new TH1F("HPMax", "", 800, 0, 3);
00326      m_fdcom -> Add(m_hpMax);
00327 
00328      m_hpMaxCms = new TH1F("HPMax_Cms", "", 800, 0, 3);
00329      m_fdcom -> Add(m_hpMaxCms);
00330 
00331      m_hpPos = new TH1F("HP_Pos", "", 800, 0, 3);
00332      m_fdcom -> Add(m_hpPos);
00333 
00334      m_hpNeg = new TH1F("HP_Neg", "", 800, 0, 3);
00335      m_fdcom -> Add(m_hpNeg);
00336 
00337      m_hpPoscms = new TH1F("HP_Pos_cms", "", 800, 0, 3);
00338      m_fdcom -> Add(m_hpPoscms);
00339 
00340      m_hpNegcms = new TH1F("HP_Neg_cms", "", 800, 0, 3);
00341      m_fdcom -> Add(m_hpNegcms);
00342 
00343      m_hp_cut = new TH1F("HPCut", "", 800, 0, 3);
00344      m_fdcom -> Add(m_hp_cut);
00345 
00346      m_hchisq = new TH1F("Chisq", "", 10, 0, 100);
00347      m_fdcom -> Add(m_hchisq);
00348 
00349      m_hnTrk = new TH1F("HNtrack", "HNtrack", 10, -0.5, 9.5);
00350      m_fdcom -> Add(m_hnTrk);
00351 
00352      m_hnTrkCal = new TH1F("HNtrackCal", "HNtrackCal", 10, -0.5, 9.5);
00353      m_fdcom -> Add(m_hnTrkCal);
00354 
00355      m_hnhitsRec = new TH1F("HNhitsRec", "", 100, -0.5, 99.5);
00356      m_fdcom -> Add(m_hnhitsRec);
00357 
00358      m_hnhitsRecInn = new TH1F("HNhitsInnRec", "", 60, 0.5, 60.5);
00359      m_fdcom -> Add(m_hnhitsRecInn);
00360 
00361      m_hnhitsRecStp = new TH1F("HNhitsStpRec", "", 60, 0.5, 60.5);
00362      m_fdcom -> Add(m_hnhitsRecStp);
00363 
00364      m_hnhitsRecOut = new TH1F("HNhitsOutRec", "", 60, 0.5, 60.5);
00365      m_fdcom -> Add(m_hnhitsRecOut);
00366 
00367      m_hnhitsCal = new TH1F("HNhitsCal", "", 100, -0.5, 99.5);
00368      m_fdcom -> Add(m_hnhitsCal);
00369 
00370      m_hnhitsCalInn = new TH1F("HNhitsCalInn", "", 60, 0.5, 60.5);
00371      m_fdcom -> Add(m_hnhitsCalInn);
00372 
00373      m_hnhitsCalStp = new TH1F("HNhitsCalStp", "", 60, 0.5, 60.5);
00374      m_fdcom -> Add(m_hnhitsCalStp);
00375 
00376      m_hnhitsCalOut = new TH1F("HNhitsCalOut", "", 60, 0.5, 60.5);
00377      m_fdcom -> Add(m_hnhitsCalOut);
00378 
00379      m_wirehitmap = new TH1F("Wire_HitMap", "Wire_HitMap", 6796, -0.5, 6795.5);
00380      m_fdcom -> Add(m_wirehitmap);
00381 
00382      m_layerhitmap = new TH1F("Layer_HitMap", "Layer_HitMap", 43, -0.5, 42.5);
00383      m_fdcom -> Add(m_layerhitmap);
00384 
00385      m_hnoisephi = new TH1F("phi_noise", "", 100, 0, 6.284);
00386      m_fdcom -> Add(m_hnoisephi);
00387 
00388      m_hnoiselay = new TH1F("Layer_noise", "Layer_noise", 43, -0.5, 42.5);
00389      m_fdcom -> Add(m_hnoiselay);
00390 
00391      m_hnoisenhits = new TH1F("nhits_noise", "nhits_noise", 6796, -0.5, 6795.5);
00392      m_fdcom -> Add(m_hnoisenhits);
00393 
00394      m_hratio = new TH1F("ratio", "", 100, 0, 1);
00395      m_fdcom -> Add(m_hratio);
00396 
00397      m_hdr = new TH1F("dr", "", 400, -100, 100);
00398      m_fdcom -> Add(m_hdr);
00399 
00400      m_hphi0 = new TH1F("phi0", "", 100, 0, 6.284);
00401      m_fdcom -> Add(m_hphi0);
00402 
00403      m_hkap = new TH1F("kappa", "", 400, -50, 50);
00404      m_fdcom -> Add(m_hkap);
00405 
00406      m_hdz = new TH1F("dz", "", 500, -500, 500);
00407      m_fdcom -> Add(m_hdz);
00408 
00409      m_htanl = new TH1F("tanl", "", 200, -5, 5);
00410      m_fdcom -> Add(m_htanl);
00411 
00412      m_hcosthe = new TH1F("costheta", "", 200, -1, 1);
00413      m_fdcom -> Add(m_hcosthe);
00414 
00415      m_hcostheNeg = new TH1F("costhetaNeg", "", 200, -1, 1);
00416      m_fdcom -> Add(m_hcostheNeg);
00417 
00418      m_hcosthePos = new TH1F("costhetaPos", "", 200, -1, 1);
00419      m_fdcom -> Add(m_hcosthePos);
00420 
00421      m_hx0 = new TH1F("x0", "", 100, -10, 10);
00422      m_fdcom -> Add(m_hx0);
00423 
00424      m_hy0 = new TH1F("y0", "", 100, -10, 10);
00425      m_fdcom -> Add(m_hy0);
00426 
00427      m_hdelZ0 = new TH1F("delta_z0", "", 100, -50, 50);
00428      m_fdcom -> Add(m_hdelZ0);
00429 
00430      // histograms for drift time
00431      m_fdTime = new TFolder("time", "time");
00432      m_hlist -> Add(m_fdTime);
00433 
00434      for(lay=0; lay<m_nlayer; lay++){
00435           sprintf(hname, "Traw%02d", lay);
00436           m_htraw[lay] = new TH1F(hname, "", 1000, 0, 1000);
00437           m_fdTime -> Add(m_htraw[lay]);
00438 
00439           sprintf(hname, "Tdr%02d", lay);
00440           m_htdr[lay] = new TH1F(hname, "", 510, -10, 500);
00441           m_fdTime -> Add(m_htdr[lay]);
00442 
00443           for (lr=0; lr<2; lr++){
00444                sprintf(hname, "Tdr%02d_lr%01d", lay, lr);
00445                m_htdrlr[lay][lr] = new TH1F(hname, "", 510, -10, 500);
00446                m_fdTime -> Add(m_htdrlr[lay][lr]);
00447           }
00448      }
00449 
00450      // histograms for resolution
00451      m_fdres = new TFolder("resolution", "resolution");
00452      m_hlist -> Add(m_fdres);
00453 
00454      for(lay=0; lay<m_nlayer; lay++){
00455           sprintf(hname, "Reso%02dInc", lay);
00456           m_hresInc[lay] = new TH1F(hname, "", 200, -1, 1);
00457           m_fdres -> Add(m_hresInc[lay]);
00458 
00459           sprintf(hname, "Reso%02dExc", lay);
00460           m_hresExc[lay] = new TH1F(hname, "", 200, -1, 1);
00461           m_fdres -> Add(m_hresExc[lay]);
00462 
00463           for (lr=0; lr<2; lr++){
00464                sprintf(hname, "Reso%02dInc_lr%01d", lay, lr);
00465                m_hreslrInc[lay][lr] = new TH1F(hname, "", 200, -1, 1);
00466                m_fdres->Add(m_hreslrInc[lay][lr]);
00467 
00468                sprintf(hname, "Reso%02dExc_lr%01d", lay, lr);
00469                m_hreslrExc[lay][lr] = new TH1F(hname, "", 200, -1, 1);
00470                m_fdres->Add(m_hreslrExc[lay][lr]);
00471           }
00472      }
00473 
00474      /* histograms for momentum vs phi */
00475      m_fdmomPhi = new TFolder("momPhi", "momPhi");
00476      m_hlist -> Add(m_fdmomPhi);
00477 
00478      int thbin;
00479      for(bin=0; bin<NPhiBin; bin++){
00480           sprintf(hname, "hPpos_phi%02d", bin);
00481           m_ppPhi[bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00482           m_fdmomPhi->Add(m_ppPhi[bin]);
00483 
00484           sprintf(hname, "hPneg_phi%02d", bin);
00485           m_pnPhi[bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00486           m_fdmomPhi->Add(m_pnPhi[bin]);
00487 
00488           sprintf(hname, "hPpos_phi_cms%02d", bin);
00489           m_ppPhiCms[bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00490           m_fdmomPhi->Add(m_ppPhiCms[bin]);
00491 
00492           sprintf(hname, "hPneg_phi_cms%02d", bin);
00493           m_pnPhiCms[bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00494           m_fdmomPhi->Add(m_pnPhiCms[bin]);
00495 
00496           for(thbin=0; thbin<NThetaBin; thbin++){
00497                sprintf(hname, "hPpos_theta%02d_phi%02d", thbin, bin);
00498                m_ppThePhi[thbin][bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00499                m_fdmomPhi->Add(m_ppThePhi[thbin][bin]);
00500 
00501                sprintf(hname, "hPneg_theta%02d_phi%02d", thbin, bin);
00502                m_pnThePhi[thbin][bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00503                m_fdmomPhi->Add(m_pnThePhi[thbin][bin]);
00504 
00505                sprintf(hname, "hPposCms_theta%02d_phi%02d", thbin, bin);
00506                m_ppThePhiCms[thbin][bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00507                m_fdmomPhi->Add(m_ppThePhiCms[thbin][bin]);
00508 
00509                sprintf(hname, "hPnegCms_theta%02d_phi%02d", thbin, bin);
00510                m_pnThePhiCms[thbin][bin] = new TH1F(hname, "", 400, 1.0, 2.5);
00511                m_fdmomPhi->Add(m_pnThePhiCms[thbin][bin]);
00512           }
00513      }
00514      for(thbin=0; thbin<NThetaBin; thbin++){
00515           sprintf(hname, "hPpos_the%02d", thbin);
00516           m_ppThe[thbin] = new TH1F(hname, "", 400, 1.0, 2.5);
00517           m_fdmomPhi->Add(m_ppThe[thbin]);
00518 
00519           sprintf(hname, "hPneg_the%02d", thbin);
00520           m_pnThe[thbin] = new TH1F(hname, "", 400, 1.0, 2.5);
00521           m_fdmomPhi->Add(m_pnThe[thbin]);
00522 
00523           sprintf(hname, "hPposCms_the%02d", thbin);
00524           m_ppTheCms[thbin] = new TH1F(hname, "", 400, 1.0, 2.5);
00525           m_fdmomPhi->Add(m_ppTheCms[thbin]);
00526 
00527           sprintf(hname, "hPnegCms_the%02d", thbin);
00528           m_pnTheCms[thbin] = new TH1F(hname, "", 400, 1.0, 2.5);
00529           m_fdmomPhi->Add(m_pnTheCms[thbin]);
00530      }
00531 
00532      // histograms for resolution vs distance
00533      m_fdres2d = new TFolder("res2d", "res2d");
00534      m_hlist -> Add(m_fdres2d);
00535 
00536      int hid = 0;
00537      int key;
00538      TH1F* hist;
00539      for(lay=0; lay<m_nlayer; lay++){
00540           for(iEntr=0; iEntr<MdcCalNENTRSD; iEntr++){
00541                for(lr=0; lr<2; lr++){
00542                     for(bin=0; bin<MdcCalSdNBIN; bin++){
00543                          sprintf(hname, "r2d%02d_%02d_%01d_%02dInc", lay, iEntr, lr, bin);
00544                          hist = new TH1F(hname, "", 200, -1, 1);
00545                          m_hr2dInc.push_back(hist);
00546                          m_fdres2d -> Add(hist);
00547 
00548                          sprintf(hname, "r2d%02d_%02d_%01d_%02dExc", lay, iEntr, lr, bin);
00549                          hist = new TH1F(hname, "", 200, -1, 1);
00550                          m_hr2dExc.push_back(hist);
00551                          m_fdres2d -> Add(hist);
00552 
00553                          key = getHresId(lay, iEntr, lr, bin);
00554                          m_mapr2d.insert( valType3(key, hid) );
00555                          hid++;
00556                     }
00557                }
00558           }
00559      } // end of layer loop
00560 
00561      INTupleSvc* ntupleSvc;
00562      Gaudi::svcLocator() -> service("NTupleSvc", ntupleSvc);
00563      for(lay=0; lay<m_nlayer; lay++){
00564           sprintf(hname, "FILE136/xt%02d", lay);
00565           NTuplePtr nt(ntupleSvc, hname);
00566           if ( nt ) m_xtTuple[lay] = nt;
00567           else{
00568                m_xtTuple[lay] = ntupleSvc->book(hname, CLID_ColumnWiseTuple, "MdcXtNtuple");
00569                if( m_xtTuple[lay] ){
00570                     m_xtTuple[lay]->addItem("cel", m_cel[lay]);
00571                     m_xtTuple[lay]->addItem("lr", m_lr[lay]);
00572                     m_xtTuple[lay]->addItem("evtOnline", m_nEvtOnline[lay]);
00573                     m_xtTuple[lay]->addItem("evtOffline", m_nEvtOffline[lay]);
00574                     m_xtTuple[lay]->addItem("doca", m_doca[lay]);
00575                     m_xtTuple[lay]->addItem("dm", m_dm[lay]);
00576                     m_xtTuple[lay]->addItem("tdr", m_tdr[lay]);
00577                     m_xtTuple[lay]->addItem("entr", m_entr[lay]);
00578                     m_xtTuple[lay]->addItem("zhit", m_zhit[lay]);
00579                     m_xtTuple[lay]->addItem("qhit", m_qhit[lay]);
00580                     m_xtTuple[lay]->addItem("p", m_p[lay]);
00581                     m_xtTuple[lay]->addItem("pt", m_pt[lay]);
00582                     m_xtTuple[lay]->addItem("phi0", m_phi0[lay]);
00583                     m_xtTuple[lay]->addItem("tanl", m_tanl[lay]);
00584                     m_xtTuple[lay]->addItem("hitphi", m_hitphi[lay]);
00585                } else{
00586                     log << MSG::FATAL << "Cannot book Xt N-tuple:"
00587                         << long(m_xtTuple[lay]) << endreq;
00588                }
00589           }
00590      }
00591 
00592      if(5==m_param.particle){
00593           sprintf(hname, "FILE136/cosmic", lay);
00594           NTuplePtr nt(ntupleSvc, hname);
00595           if ( nt ) m_cosmic = nt;
00596           else{
00597                m_cosmic = ntupleSvc->book(hname, CLID_ColumnWiseTuple, "MdcXtNtuple");
00598                if( m_cosmic ){
00599                     m_cosmic->addItem("pUp", m_pUpcos);
00600                     m_cosmic->addItem("pDw", m_pDwcos);
00601                     m_cosmic->addItem("ptUp", m_ptUpcos);
00602                     m_cosmic->addItem("ptDw", m_ptDwcos);
00603                     m_cosmic->addItem("phiUp", m_phiUpcos);
00604                     m_cosmic->addItem("phiDw", m_phiDwcos);
00605                     m_cosmic->addItem("drUp", m_drUpcos);
00606                     m_cosmic->addItem("drDw", m_drDwcos);
00607                     m_cosmic->addItem("dzUp", m_dzUpcos);
00608                     m_cosmic->addItem("dzDw", m_dzDwcos);
00609                     m_cosmic->addItem("ctheUp", m_ctheUpcos);
00610                     m_cosmic->addItem("ctheDw", m_ctheDwcos);
00611                     m_cosmic->addItem("nhitUp", m_nhitUpcos);
00612                     m_cosmic->addItem("nhitDw", m_nhitDwcos);
00613                     m_cosmic->addItem("char", m_chargecos);
00614                     m_cosmic->addItem("tesfg", m_tesFlagcos);
00615                     m_cosmic->addItem("tes", m_tescos);
00616                }
00617           }
00618      }
00619 }

01876                                                   {
01877      for(int i=0;i<path.size();i++){
01878           ifstream in;
01879           int aa;
01880           double bb,cc,dd,ee;
01881           in.open(path[i].c_str(),std::ios_base::in);
01882           for (int lay=0;lay<m_nlayer;lay++){
01883                in>>aa>>bb>>cc>>dd>>ee;
01884                m_nGoodHit[lay]=m_nGoodHit[lay]+dd;
01885           }
01886           m_nTrk=m_nTrk+ee;
01887           in.close();
01888      }
01889 }

00288                                                  {
00289      m_param = param;
00290 }

01693                                      {
01694      TFile *f1 = new TFile(path.c_str());
01695      std::cout<<path<<std::endl;
01696      //
01697      char hname[200];
01699      m_fdcom=(TFolder*)f1->Get("common;1");
01700      m_hresAllInc=(TH1F*)m_fdcom->FindObject("HResAllInc");
01701      m_hresAllExc=(TH1F*)m_fdcom->FindObject("HResAllExc");
01702      m_hresAllAve=(TH1F*)m_fdcom->FindObject("HResAllAve");
01703      m_hresInnInc=(TH1F*)m_fdcom->FindObject("HResInnInc");
01704      m_hresInnExc=(TH1F*)m_fdcom->FindObject("HResInnExc");
01705      m_hresStpInc=(TH1F*)m_fdcom->FindObject("HResStpInc");
01706      m_hresStpExc=(TH1F*)m_fdcom->FindObject("HResStpExc");
01707      m_hresOutInc=(TH1F*)m_fdcom->FindObject("HResOutInc");
01708      m_hresOutExc=(TH1F*)m_fdcom->FindObject("HResOutExc");
01710      m_fdResQ=(TFolder *)f1->Get("ResQ;1");
01712      for(int i=0; i<14; i++){
01713           sprintf(hname, "resoAll_qbin%02d", i);
01714           m_hresAveAllQ[i]=(TH1F*)m_fdResQ->FindObject(hname);
01715           sprintf(hname, "resoOut_qbin%02d", i);
01716           m_hresAveOutQ[i]=(TH1F*)m_fdResQ->FindObject(hname);
01717      }
01719      for(int lay=0; lay<43; lay++){
01720           for(int i=0; i<14; i++){
01721                sprintf(hname, "resoLay%02d_qbin%02d", lay, i);
01722                m_hresAveLayQ[lay][i]=(TH1F*)m_fdResQ->FindObject(hname);
01723           }
01724      }
01725 
01726      for(int iEs=0; iEs<10; iEs++){
01727           sprintf(hname, "Tes_%d", m_param.esFlag[iEs]);
01728           m_hTes[iEs]=(TH1F*)m_fdcom->FindObject(hname);
01729      }
01730 
01731      m_hbbTrkFlg=(TH1F*)m_fdcom->FindObject("BbTrkFlg");
01732      m_hTesAll=(TH1F*)m_fdcom->FindObject("TesAll");
01733      m_hTesGood=(TH1F*)m_fdcom->FindObject("TesGood");
01734      m_hTesAllFlag=(TH1F*)m_fdcom->FindObject("TesAllFlag");
01735      m_hTesRec=(TH1F*)m_fdcom->FindObject("TesRec");
01736      m_hTesCalFlag=(TH1F*)m_fdcom->FindObject("TesCalFlag");
01737      m_hTesCalUse=(TH1F*)m_fdcom->FindObject("TesCalUse");
01738      m_hnRawHit= (TH1F*)m_fdcom->FindObject("nRawHit");
01739      m_hpt=(TH1F*)m_fdcom->FindObject("HPt");
01740      m_hptPos=(TH1F*)m_fdcom->FindObject("HPtPos");
01741      m_hptNeg =(TH1F*)m_fdcom->FindObject("HPtNeg");
01742      m_hp=(TH1F*)m_fdcom->FindObject("HP");
01743      m_hp_cms=(TH1F*)m_fdcom->FindObject("HPCMS");
01744      m_hpMax=(TH1F*)m_fdcom->FindObject("HPMax");
01745      m_hpMaxCms=(TH1F*)m_fdcom->FindObject("HPMax_Cms");
01746      m_hpPos=(TH1F*)m_fdcom->FindObject("HP_Pos");
01747      m_hpNeg =(TH1F*)m_fdcom->FindObject("HP_Neg");
01748      m_hpPoscms=(TH1F*)m_fdcom->FindObject("HP_Pos_cms");
01749      m_hpNegcms =(TH1F*)m_fdcom->FindObject("HP_Neg_cms");
01750      m_hp_cut =(TH1F*)m_fdcom->FindObject("HPCut");
01751      m_hchisq=(TH1F*)m_fdcom->FindObject("Chisq");
01752      m_hnTrk=(TH1F*)m_fdcom->FindObject("HNtrack");
01753      m_hnTrkCal=(TH1F*)m_fdcom->FindObject("HNtrackCal");
01754      m_hnhitsRec=(TH1F*)m_fdcom->FindObject("HNhitsRec");
01755      m_hnhitsRecInn=(TH1F*)m_fdcom->FindObject("HNhitsInnRec");
01756      m_hnhitsRecStp=(TH1F*)m_fdcom->FindObject("HNhitsStpRec");
01757      m_hnhitsRecOut=(TH1F*)m_fdcom->FindObject("HNhitsOutRec");
01758      m_hnhitsCal=(TH1F*)m_fdcom->FindObject("HNhitsCal");
01759      m_hnhitsCalInn=(TH1F*)m_fdcom->FindObject("HNhitsCalInn");
01760      m_hnhitsCalStp =(TH1F*)m_fdcom->FindObject("HNhitsCalStp");
01761      m_hnhitsCalOut =(TH1F*)m_fdcom->FindObject("HNhitsCalOut");
01762      m_wirehitmap =(TH1F*)m_fdcom->FindObject("Wire_HitMap");
01763      m_layerhitmap=(TH1F*)m_fdcom->FindObject("Layer_HitMap");
01764      m_hnoisephi=(TH1F*)m_fdcom->FindObject("phi_noise");
01765      m_hnoiselay=(TH1F*)m_fdcom->FindObject("Layer_noise");
01766      m_hnoisenhits =(TH1F*)m_fdcom->FindObject("nhits_noise");
01767      m_hratio =(TH1F*)m_fdcom->FindObject("ratio");
01768      m_hdr=(TH1F*)m_fdcom->FindObject("dr");
01769      m_hphi0=(TH1F*)m_fdcom->FindObject("phi0");
01770      m_hkap =(TH1F*)m_fdcom->FindObject("kappa");
01771      m_hdz =(TH1F*)m_fdcom->FindObject("dz");
01772      m_htanl =(TH1F*)m_fdcom->FindObject("tanl");
01773      m_hcosthe =(TH1F*)m_fdcom->FindObject("costheta");
01774      m_hx0 =(TH1F*)m_fdcom->FindObject("x0");
01775      m_hy0 =(TH1F*)m_fdcom->FindObject("y0");
01776      m_hdelZ0 =(TH1F*)m_fdcom->FindObject("delta_z0");
01777 // histograms for drift time
01778      m_fdTime=(TFolder *)f1->Get("time;1");
01779 
01780      for(int lay=0; lay<m_nlayer; lay++){
01781           sprintf(hname, "Traw%02d", lay);
01782           m_htraw[lay]=(TH1F*)m_fdTime->FindObject(hname);
01783           sprintf(hname, "Tdr%02d", lay);
01784           m_htdr[lay]=(TH1F*)m_fdTime->FindObject(hname);
01785           //
01786           for(int lr=0; lr<2; lr++){
01787                sprintf(hname, "Tdr%02d_lr%01d", lay, lr);
01788                m_htdrlr[lay][lr]=(TH1F*)m_fdTime->FindObject(hname);
01789           }
01790      }
01791     
01792      /* histograms for spatial resolution */
01793      m_fdres=(TFolder *)f1->Get("resolution;1");
01794 
01795      for(int lay=0; lay<m_nlayer; lay++){
01796           sprintf(hname, "Reso%02dInc", lay);
01797           m_hresInc[lay]=(TH1F*) m_fdres->FindObject(hname);
01798           sprintf(hname, "Reso%02dExc", lay);
01799           m_hresExc[lay]=(TH1F*) m_fdres->FindObject(hname);
01800           //
01801           for (int lr=0; lr<2; lr++){
01802                sprintf(hname, "Reso%02dInc_lr%01d", lay, lr);
01803                m_hreslrInc[lay][lr]=(TH1F*)m_fdres->FindObject(hname);
01804                sprintf(hname, "Reso%02dExc_lr%01d", lay, lr);
01805                m_hreslrExc[lay][lr]=(TH1F*)m_fdres->FindObject(hname);
01806           }
01807      }
01808      /* histograms for momentum vs phi */
01809      m_fdmomPhi = (TFolder *)f1->Get("momPhi;1");
01810      for(int bin=0; bin<NPhiBin; bin++){
01811           sprintf(hname, "hPpos_phi%02d", bin);
01812           m_ppPhi[bin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01813           sprintf(hname, "hPneg_phi%02d", bin);
01814           m_pnPhi[bin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01815           sprintf(hname, "hPpos_phi_cms%02d", bin);
01816           m_ppPhiCms[bin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01817           sprintf(hname, "hPneg_phi_cms%02d", bin);
01818           m_pnPhiCms[bin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01819           for(int thbin=0; thbin<NThetaBin; thbin++){
01820                sprintf(hname, "hPpos_theta%02d_phi%02d", thbin, bin);
01821                m_ppThePhi[thbin][bin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01822                sprintf(hname, "hPneg_theta%02d_phi%02d", thbin, bin);
01823                m_pnThePhi[thbin][bin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01824                sprintf(hname, "hPposCms_theta%02d_phi%02d", thbin, bin);
01825                m_ppThePhiCms[thbin][bin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01826                sprintf(hname,"hPnegCms_theta%02d_phi%02d",thbin, bin);
01827                m_pnThePhiCms[thbin][bin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01828           }
01829      }
01830 
01831 
01832      for(int thbin=0; thbin<NThetaBin; thbin++){
01833           sprintf(hname, "hPpos_the%02d", thbin);
01834 
01835           m_ppThe[thbin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01836           sprintf(hname, "hPneg_the%02d", thbin);
01837 
01838           m_pnThe[thbin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01839           sprintf(hname, "hPposCms_the%02d",thbin);
01840 
01841           m_ppTheCms[thbin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01842           sprintf(hname, "hPnegCms_the%02d", thbin);
01843 
01844           m_pnTheCms[thbin]=(TH1F*)m_fdmomPhi->FindObject(hname);
01845      }
01846      m_fdres2d = (TFolder *)f1->Get("res2d;1");
01847 
01848      m_hr2dInc.clear();
01849      m_hr2dExc.clear();
01850      m_mapr2d.clear();
01851      int hid = 0;
01852      int key;
01853      TH1F* hist, *hist1;
01854      for(int lay=0; lay<m_nlayer; lay++){
01855           for(int iEntr=0; iEntr<MdcCalNENTRSD; iEntr++){
01856                for(int lr=0; lr<2; lr++){
01857                     for(int bin=0; bin<MdcCalSdNBIN; bin++){
01858                          sprintf(hname,"r2d%02d_%02d_%01d_%02dInc", lay, iEntr, lr, bin);
01859                          hist=(TH1F*) m_fdres2d->FindObject(hname);
01860                          m_hr2dInc.push_back(hist);
01862                          sprintf(hname, "r2d%02d_%02d_%01d_%02dExc", lay, iEntr, lr, bin);
01863                          hist1=(TH1F*) m_fdres2d->FindObject(hname);
01864                          m_hr2dExc.push_back(hist1);
01865                          key = getHresId(lay, iEntr, lr, bin);
01866                          m_mapr2d.insert( valType3(key, hid) );
01867                          hid++;
01868                     }
01869                }
01870           }
01871      } // end of layer loop 
01872 
01873 }  // end of func

01320                                                 {
01321      IMessageSvc* msgSvc;
01322      Gaudi::svcLocator() -> service("MessageSvc", msgSvc);
01323      MsgStream log(msgSvc, "MdcCalib");
01324      log << MSG::DEBUG << "MdcCalib::updateConst()" << endreq;
01325 
01326      cout << "Tot " << m_hnTrk->GetEntries()
01327           << ",  cut1 " << m_cut1 << ",  cut2 " << m_cut2 << ",  cut3 " << m_cut3
01328           << ",  cut4 " << m_cut4 << ",  cut5 " << m_cut5 << ",  cut6 " << m_cut6 << endl;
01329 
01330 
01331      int lay;
01332      double effi;
01333      double effErr;
01334 
01335      int nGoodAll = 0;
01336      int nGoodInn = 0;
01337      int nGoodStp = 0;
01338      int nGoodOut = 0;
01339      ofstream feffi("MdcLayerEffi.dat");
01340      for(lay=0; lay<m_nlayer; lay++){
01341           nGoodAll += m_nGoodHit[lay];
01342           if(lay < 8) nGoodInn += m_nGoodHit[lay];
01343           else if (lay < 20) nGoodStp += m_nGoodHit[lay];
01344           else nGoodOut += m_nGoodHit[lay];
01345 
01346           effi = (double)m_nGoodHit[lay] / (double)m_nTrk;
01347           effErr = sqrt(effi * (1-effi) / (double)m_nTrk);
01348           feffi << setw(5) << lay << setw(15) << effi << setw(15) << effErr
01349                 << setw(15) << m_nGoodHit[lay] << setw(15) << m_nTrk << endl;
01350      }
01351      double effiAll = (double)nGoodAll / (double)(m_nTrk * 43);
01352      double errAll = sqrt(effiAll * (1-effiAll) / (double)(m_nTrk * 43));
01353      double effiInn = (double)nGoodInn / (double)(m_nTrk * 8);
01354      double errInn = sqrt(effiInn * (1-effiInn) / (double)(m_nTrk * 8));
01355      double effiStp = (double)nGoodStp / (double)(m_nTrk * 12);
01356      double errStp = sqrt(effiStp * (1-effiStp) / (double)(m_nTrk * 12));
01357      double effiOut = (double)nGoodOut / (double)(m_nTrk * 23);
01358      double errOut = sqrt(effiOut * (1-effiOut) / (double)(m_nTrk * 23));
01359      feffi << endl << "EffiAll: " << setw(15) << effiAll << setw(15) << errAll
01360            << setw(15) << nGoodAll << setw(15) << m_nTrk << endl;
01361      feffi << endl << "EffiInn: " << setw(15) << effiInn << setw(15) << errInn
01362            << setw(15) << nGoodInn << setw(15) << m_nTrk << endl;
01363      feffi << endl << "EffiStp: " << setw(15) << effiStp << setw(15) << errStp
01364            << setw(15) << nGoodStp << setw(15) << m_nTrk << endl;
01365      feffi << endl << "EffiOut: " << setw(15) << effiOut << setw(15) << errOut
01366            << setw(15) << nGoodOut << setw(15) << m_nTrk << endl;
01367      feffi.close();
01368 
01369      // calculate efficiency without the impact of track fitting
01370      if(0 != m_param.fgCalDetEffi){
01371           int nHitAll[] = {0, 0};
01372           int nHitInn[] = {0, 0};
01373           int nHitStp[] = {0, 0};
01374           int nHitOut[] = {0, 0};
01375           ofstream feff2("MdcHitEffi.dat");
01376           for(lay=0; lay<m_nlayer; lay++){
01377                nHitAll[0] += m_hitNum[lay][0];
01378                nHitAll[1] += m_hitNum[lay][1];
01379                if(lay < 8){
01380                     nHitInn[0] += m_hitNum[lay][0];
01381                     nHitInn[1] += m_hitNum[lay][1];
01382                } else if (lay < 20){
01383                     nHitStp[0] += m_hitNum[lay][0];
01384                     nHitStp[1] += m_hitNum[lay][1];
01385                } else{
01386                     nHitOut[0] += m_hitNum[lay][0];
01387                     nHitOut[1] += m_hitNum[lay][1];
01388                }
01389 
01390                effi = (double)m_hitNum[lay][1] / (double)m_hitNum[lay][0];
01391                effErr = sqrt(effi * (1-effi) / (double)m_hitNum[lay][0]);
01392                feff2 << setw(5) << lay << setw(15) << effi << setw(15) << effErr
01393                      << setw(15) << m_hitNum[lay][1] << setw(15) << m_hitNum[lay][0] << endl;
01394           }
01395           effiAll = (double)nHitAll[1] / (double)nHitAll[0];
01396           errAll = sqrt(effiAll * (1-effiAll)) / (double)nHitAll[0];
01397           effiInn = (double)nHitInn[1] / (double)nHitInn[0];
01398           errInn = sqrt(effiInn * (1-effiInn)) / (double)nHitInn[0];
01399           effiStp = (double)nHitStp[1] / (double)nHitStp[0];
01400           errStp = sqrt(effiStp * (1-effiStp)) / (double)nHitStp[0];
01401           effiOut = (double)nHitOut[1] / (double)nHitOut[0];
01402           errOut = sqrt(effiOut * (1-effiOut)) / (double)nHitOut[0];
01403           feff2 << endl << "EffiAll: " << setw(15) << effiAll << setw(15) << errAll
01404                 << setw(15) << nHitAll[1] << setw(15) << nHitAll[0] << endl;
01405           feff2 << endl << "EffiInn: " << setw(15) << effiInn << setw(15) << errInn
01406                 << setw(15) << nHitInn[1] << setw(15) << nHitInn[0] << endl;
01407           feff2 << endl << "EffiStp: " << setw(15) << effiStp << setw(15) << errStp
01408                 << setw(15) << nHitStp[1] << setw(15) << nHitStp[0] << endl;
01409           feff2 << endl << "EffiOut: " << setw(15) << effiOut << setw(15) << errOut
01410                 << setw(15) << nHitOut[1] << setw(15) << nHitOut[0] << endl;
01411           feff2.close();
01412      }
01413 
01414      // get resolution
01415      int i;
01416      int iEntr;
01417      int lr;
01418      int bin;
01419      int key;
01420      int hid;
01421 
01422      Stat_t entry;
01423      double sigm[MdcCalSdNBIN];
01424      m_hp->Fit("gaus", "Q", "", m_param.pFitMin, m_param.pFitMax);
01425      m_hp_cms->Fit("gaus", "Q", "", m_param.pFitMin, m_param.pFitMax);
01426      m_hpPoscms->Fit("gaus", "Q", "", m_param.pFitMin, m_param.pFitMax);
01427      m_hpNegcms->Fit("gaus", "Q", "", m_param.pFitMin, m_param.pFitMax);
01428      m_hp_cut->Fit("gaus", "Q", "", m_param.pFitMin, m_param.pFitMax);
01429      gStyle -> SetOptFit(11);
01430 
01431      ofstream fr2d("logr2d.dat");
01432      for(lay=0; lay<m_nlayer; lay++){
01433           for(iEntr=0; iEntr<m_nEntr[lay]; iEntr++){
01434                for(lr=0; lr<2; lr++){
01435                     fr2d << setw(3) << lay << setw(3) << iEntr << setw(3) << lr << endl;
01436                     for(bin=0; bin<m_nBin[lay]; bin++){
01437                          key = getHresId(lay, iEntr, lr, bin);
01438                          hid = m_mapr2d[key];
01439 
01440                          if(1 == m_param.resiType){
01441                               entry = m_hr2dExc[hid] -> GetEntries();
01442                               if(entry > 500){
01443                                    m_hr2dExc[hid] -> Fit("gaus", "Q");
01444                                    sigm[bin] = m_hr2dExc[hid]->GetFunction("gaus")->GetParameter(2);
01445                               } else if(entry > 100){
01446                                    sigm[bin] = m_hr2dExc[hid]->GetRMS();
01447                               } else{
01448                                    sigm[bin] = 0.2;
01449                               }
01450                          } else{
01451                               entry = m_hr2dInc[hid] -> GetEntries();
01452                               if(entry > 500){
01453                                    m_hr2dInc[hid] -> Fit("gaus", "Q");
01454                                    sigm[bin] = m_hr2dInc[hid]->GetFunction("gaus")->GetParameter(2);
01455                               } else if(entry > 100){
01456                                    sigm[bin] = m_hr2dInc[hid]->GetRMS();
01457                               } else{
01458                                    sigm[bin] = 0.2;
01459                               }
01460                          }
01461                          if(sigm[bin] < 0.05) sigm[bin] = 0.05; // for boundary layers
01462                     } // end of bin loop
01463 
01464                     for(bin=m_nBin[lay]; bin<MdcCalSdNBIN; bin++){
01465                          sigm[bin] = sigm[m_nBin[lay]-1];
01466                     }
01467 
01468                     for(bin=0; bin<MdcCalSdNBIN; bin++){
01469                          if(1 == m_param.fgCalib[lay]){
01470 //                            calconst -> resetSdpar(lay, iEntr, lr, bin, sigm[bin]);
01471                               if(1 == m_nEntr[lay]){
01472                                    for(i=0; i<6; i++) calconst -> resetSdpar(lay, i, lr, bin, sigm[bin]);
01473                               } else if(2 == m_nEntr[lay]){
01474                                    if(0 == iEntr){
01475                                         for(i=0; i<3; i++){ // entr<0
01476                                              calconst -> resetSdpar(lay, i, lr, bin, sigm[bin]);
01477                                         }
01478                                    } else{
01479                                         for(i=3; i<6; i++){ // entr>0
01480                                              calconst -> resetSdpar(lay, i, lr, bin, sigm[bin]);
01481                                         }
01482                                    }
01483                               }
01484                          } else{
01485                               sigm[bin] = calconst->getSdpar(lay, iEntr, lr, bin);
01486                          }
01487                          fr2d << setw(5) << bin << setw(15) << sigm[bin] << endl;
01488                     } // end of bin loop
01489                }
01490           } // end of entr loop
01491      }
01492      fr2d.close();
01493 
01494      return 1;
01495 }

MdcCalib Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
virtual void	clear ()=0
virtual void	clear ()=0
virtual int	fillHist (MdcCalEvent *event)=0
virtual int	fillHist (MdcCalEvent *event)=0
virtual void	initialize (TObjArray hlist, IMdcGeomSvc mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)=0
virtual void	initialize (TObjArray hlist, IMdcGeomSvc mdcGeomSvc, IMdcCalibFunSvc *mdcFunSvc)=0
	MdcCalib ()
	MdcCalib ()
virtual void	read_file (std::vector< std::string > path)
virtual void	read_file (std::vector< std::string > path)
virtual void	setParam (MdcCalParams &param)=0
virtual void	setParam (MdcCalParams &param)=0
virtual void	settuple (std::string path)
virtual void	settuple (std::string path)
virtual int	updateConst (MdcCalibConst *calconst)=0
virtual int	updateConst (MdcCalibConst *calconst)=0
virtual	~MdcCalib ()
virtual	~MdcCalib ()
Private Member Functions
int	dist2Line (double sta[3], double stb[3], double veca[3], double vecb[3], double &d, double &za, double &zb, int fgZcal=1)
int	dist2Line (double sta[3], double stb[3], double veca[3], double vecb[3], double &d, double &za, double &zb, int fgZcal=1)
double	docaHelixWire (double trkpar[], double wirest[], double wirev[], double &zwire, double zini)
double	docaHelixWire (double trkpar[], double wirest[], double wirev[], double &zwire, double zini)
double	docaLineWire (double trkpar[], double wirest[], double wirev[], double &zwire, int fgZcal=1)
double	docaLineWire (double trkpar[], double wirest[], double wirev[], double &zwire, int fgZcal=1)
void	expd (double veca[3], double vecb[3], double val[3])
void	expd (double veca[3], double vecb[3], double val[3])
bool	getDoca (double trkpar[], double wpos[], double &doca, double whitPos[], double zini)
bool	getDoca (double trkpar[], double wpos[], double &doca, double whitPos[], double zini)
int	getHresId (int lay, int entr, int lr, int bin) const
int	getHresId (int lay, int entr, int lr, int bin) const
Private Attributes
NTuple::Item< long >	m_cel [MdcCalNLayer]
NTuple::Item< long >	m_cel [MdcCalNLayer]
NTuple::Item< long >	m_chargecos
NTuple::Item< long >	m_chargecos
NTuple::Tuple *	m_cosmic
NTuple::Tuple *	m_cosmic
NTuple::Item< double >	m_ctheDwcos
NTuple::Item< double >	m_ctheDwcos
NTuple::Item< double >	m_ctheUpcos
NTuple::Item< double >	m_ctheUpcos
int	m_cut1
int	m_cut2
int	m_cut3
int	m_cut4
int	m_cut5
int	m_cut6
NTuple::Item< double >	m_dm [MdcCalNLayer]
NTuple::Item< double >	m_dm [MdcCalNLayer]
NTuple::Item< double >	m_doca [MdcCalNLayer]
NTuple::Item< double >	m_doca [MdcCalNLayer]
double	m_docaMax [MdcCalNLayer]
NTuple::Item< double >	m_drDwcos
NTuple::Item< double >	m_drDwcos
NTuple::Item< double >	m_drUpcos
NTuple::Item< double >	m_drUpcos
double	m_dwid
NTuple::Item< double >	m_dzDwcos
NTuple::Item< double >	m_dzDwcos
NTuple::Item< double >	m_dzUpcos
NTuple::Item< double >	m_dzUpcos
NTuple::Item< double >	m_entr [MdcCalNLayer]
NTuple::Item< double >	m_entr [MdcCalNLayer]
TFolder *	m_fdcom
TFolder *	m_fdcom
TFolder *	m_fdmomPhi
TFolder *	m_fdmomPhi
TFolder *	m_fdres
TFolder *	m_fdres
TFolder *	m_fdres2d
TFolder *	m_fdres2d
TFolder *	m_fdResQ
TFolder *	m_fdResQ
TFolder *	m_fdTime
TFolder *	m_fdTime
bool	m_fgIni
TH1F *	m_hbbTrkFlg
TH1F *	m_hbbTrkFlg
TH1F *	m_hchisq
TH1F *	m_hchisq
TH1F *	m_hcosthe
TH1F *	m_hcosthe
TH1F *	m_hcostheNeg
TH1F *	m_hcostheNeg
TH1F *	m_hcosthePos
TH1F *	m_hcosthePos
TH1F *	m_hdelZ0
TH1F *	m_hdelZ0
TH1F *	m_hdr
TH1F *	m_hdr
TH1F *	m_hdz
TH1F *	m_hdz
int	m_hitNum [43][2]
NTuple::Item< double >	m_hitphi [MdcCalNLayer]
NTuple::Item< double >	m_hitphi [MdcCalNLayer]
TH1F *	m_hkap
TH1F *	m_hkap
TObjArray *	m_hlist
TObjArray *	m_hlist
TH1F *	m_hnhitsCal
TH1F *	m_hnhitsCal
TH1F *	m_hnhitsCalInn
TH1F *	m_hnhitsCalInn
TH1F *	m_hnhitsCalOut
TH1F *	m_hnhitsCalOut
TH1F *	m_hnhitsCalStp
TH1F *	m_hnhitsCalStp
TH1F *	m_hnhitsRec
TH1F *	m_hnhitsRec
TH1F *	m_hnhitsRecInn
TH1F *	m_hnhitsRecInn
TH1F *	m_hnhitsRecOut
TH1F *	m_hnhitsRecOut
TH1F *	m_hnhitsRecStp
TH1F *	m_hnhitsRecStp
TH1F *	m_hnoiselay
TH1F *	m_hnoiselay
TH1F *	m_hnoisenhits
TH1F *	m_hnoisenhits
TH1F *	m_hnoisephi
TH1F *	m_hnoisephi
TH1F *	m_hnRawHit
TH1F *	m_hnRawHit
TH1F *	m_hnTrk
TH1F *	m_hnTrk
TH1F *	m_hnTrkCal
TH1F *	m_hnTrkCal
TH1F *	m_hp
TH1F *	m_hp
TH1F *	m_hp_cms
TH1F *	m_hp_cms
TH1F *	m_hp_cut
TH1F *	m_hp_cut
TH1F *	m_hphi0
TH1F *	m_hphi0
TH1F *	m_hpMax
TH1F *	m_hpMax
TH1F *	m_hpMaxCms
TH1F *	m_hpMaxCms
TH1F *	m_hpNeg
TH1F *	m_hpNeg
TH1F *	m_hpNegcms
TH1F *	m_hpNegcms
TH1F *	m_hpPos
TH1F *	m_hpPos
TH1F *	m_hpPoscms
TH1F *	m_hpPoscms
TH1F *	m_hpt
TH1F *	m_hpt
TH1F *	m_hptNeg
TH1F *	m_hptNeg
TH1F *	m_hptPos
TH1F *	m_hptPos
std::vector< TH1F * >	m_hr2dExc
std::vector< TH1F * >	m_hr2dExc
std::vector< TH1F * >	m_hr2dInc
std::vector< TH1F * >	m_hr2dInc
TH1F *	m_hratio
TH1F *	m_hratio
TH1F *	m_hresAllAve
TH1F *	m_hresAllAve
TH1F *	m_hresAllExc
TH1F *	m_hresAllExc
TH1F *	m_hresAllInc
TH1F *	m_hresAllInc
TH1F *	m_hresAveAllQ [14]
TH1F *	m_hresAveAllQ [14]
TH1F *	m_hresAveLayQ [43][14]
TH1F *	m_hresAveLayQ [43][14]
TH1F *	m_hresAveOutQ [14]
TH1F *	m_hresAveOutQ [14]
TH1F *	m_hresExc [MdcCalNLayer]
TH1F *	m_hresExc [MdcCalNLayer]
TH1F *	m_hresInc [MdcCalNLayer]
TH1F *	m_hresInc [MdcCalNLayer]
TH1F *	m_hresInnExc
TH1F *	m_hresInnExc
TH1F *	m_hresInnInc
TH1F *	m_hresInnInc
TH1F *	m_hreslrExc [MdcCalNLayer][2]
TH1F *	m_hreslrExc [MdcCalNLayer][2]
TH1F *	m_hreslrInc [MdcCalNLayer][2]
TH1F *	m_hreslrInc [MdcCalNLayer][2]
TH1F *	m_hresOutExc
TH1F *	m_hresOutExc
TH1F *	m_hresOutInc
TH1F *	m_hresOutInc
TH1F *	m_hresStpExc
TH1F *	m_hresStpExc
TH1F *	m_hresStpInc
TH1F *	m_hresStpInc
TH1F *	m_htanl
TH1F *	m_htanl
TH1F *	m_htdr [MdcCalNLayer]
TH1F *	m_htdr [MdcCalNLayer]
TH1F *	m_htdrlr [MdcCalNLayer][2]
TH1F *	m_htdrlr [MdcCalNLayer][2]
TH1F *	m_hTes [10]
TH1F *	m_hTes [10]
TH1F *	m_hTesAll
TH1F *	m_hTesAll
TH1F *	m_hTesAllFlag
TH1F *	m_hTesAllFlag
TH1F *	m_hTesCalFlag
TH1F *	m_hTesCalFlag
TH1F *	m_hTesCalUse
TH1F *	m_hTesCalUse
TH1F *	m_hTesGood
TH1F *	m_hTesGood
TH1F *	m_hTesRec
TH1F *	m_hTesRec
TH1F *	m_htraw [MdcCalNLayer]
TH1F *	m_htraw [MdcCalNLayer]
TH1F *	m_hx0
TH1F *	m_hx0
TH1F *	m_hy0
TH1F *	m_hy0
bool	m_layBound [MdcCalNLayer]
TH1F *	m_layerhitmap
TH1F *	m_layerhitmap
NTuple::Item< long >	m_lr [MdcCalNLayer]
NTuple::Item< long >	m_lr [MdcCalNLayer]
std::map< int, int >	m_mapr2d
std::map< int, int >	m_mapr2d
MdcCheckUtil *	m_mdcCheckUtil
MdcCheckUtil *	m_mdcCheckUtil
IMdcCalibFunSvc *	m_mdcFunSvc
IMdcCalibFunSvc *	m_mdcFunSvc
IMdcGeomSvc *	m_mdcGeomSvc
IMdcGeomSvc *	m_mdcGeomSvc
int	m_nBin [MdcCalNLayer]
int	m_nEntr [43]
int	m_nEvt
int	m_nEvtNtuple
NTuple::Item< long >	m_nEvtOffline [MdcCalNLayer]
NTuple::Item< long >	m_nEvtOffline [MdcCalNLayer]
NTuple::Item< long >	m_nEvtOnline [MdcCalNLayer]
NTuple::Item< long >	m_nEvtOnline [MdcCalNLayer]
int	m_nGoodHit [43]
NTuple::Item< long >	m_nhitDwcos
NTuple::Item< long >	m_nhitDwcos
NTuple::Item< long >	m_nhitUpcos
NTuple::Item< long >	m_nhitUpcos
int	m_nlayer
int	m_nTrk
NTuple::Item< double >	m_p [MdcCalNLayer]
NTuple::Item< double >	m_p [MdcCalNLayer]
MdcCalParams	m_param
NTuple::Item< double >	m_pDwcos
NTuple::Item< double >	m_pDwcos
NTuple::Item< double >	m_phi0 [MdcCalNLayer]
NTuple::Item< double >	m_phi0 [MdcCalNLayer]
NTuple::Item< double >	m_phiDwcos
NTuple::Item< double >	m_phiDwcos
NTuple::Item< double >	m_phiUpcos
NTuple::Item< double >	m_phiUpcos
double	m_phiWid
TH1F *	m_pnPhi [NPhiBin]
TH1F *	m_pnPhi [NPhiBin]
TH1F *	m_pnPhiCms [NPhiBin]
TH1F *	m_pnPhiCms [NPhiBin]
TH1F *	m_pnThe [NThetaBin]
TH1F *	m_pnThe [NThetaBin]
TH1F *	m_pnTheCms [NThetaBin]
TH1F *	m_pnTheCms [NThetaBin]
TH1F *	m_pnThePhi [NThetaBin][NPhiBin]
TH1F *	m_pnThePhi [NThetaBin][NPhiBin]
TH1F *	m_pnThePhiCms [NThetaBin][NPhiBin]
TH1F *	m_pnThePhiCms [NThetaBin][NPhiBin]
TH1F *	m_ppPhi [NPhiBin]
TH1F *	m_ppPhi [NPhiBin]
TH1F *	m_ppPhiCms [NPhiBin]
TH1F *	m_ppPhiCms [NPhiBin]
TH1F *	m_ppThe [NThetaBin]
TH1F *	m_ppThe [NThetaBin]
TH1F *	m_ppTheCms [NThetaBin]
TH1F *	m_ppTheCms [NThetaBin]
TH1F *	m_ppThePhi [NThetaBin][NPhiBin]
TH1F *	m_ppThePhi [NThetaBin][NPhiBin]
TH1F *	m_ppThePhiCms [NThetaBin][NPhiBin]
TH1F *	m_ppThePhiCms [NThetaBin][NPhiBin]
NTuple::Item< double >	m_pt [MdcCalNLayer]
NTuple::Item< double >	m_pt [MdcCalNLayer]
NTuple::Item< double >	m_ptDwcos
NTuple::Item< double >	m_ptDwcos
NTuple::Item< double >	m_ptUpcos
NTuple::Item< double >	m_ptUpcos
NTuple::Item< double >	m_pUpcos
NTuple::Item< double >	m_pUpcos
NTuple::Item< double >	m_qhit [MdcCalNLayer]
NTuple::Item< double >	m_qhit [MdcCalNLayer]
double	m_radii [MdcCalNLayer]
NTuple::Item< double >	m_tanl [MdcCalNLayer]
NTuple::Item< double >	m_tanl [MdcCalNLayer]
NTuple::Item< double >	m_tdr [MdcCalNLayer]
NTuple::Item< double >	m_tdr [MdcCalNLayer]
NTuple::Item< double >	m_tescos
NTuple::Item< double >	m_tescos
NTuple::Item< long >	m_tesFlagcos
NTuple::Item< long >	m_tesFlagcos
double	m_theWid
TH1F *	m_wirehitmap
TH1F *	m_wirehitmap
double	m_xe [MdcCalTotCell]
NTuple::Tuple *	m_xtTuple [MdcCalNLayer]
NTuple::Tuple *	m_xtTuple [MdcCalNLayer]
double	m_xw [MdcCalTotCell]
double	m_ye [MdcCalTotCell]
double	m_yw [MdcCalTotCell]
double	m_ze [MdcCalTotCell]
NTuple::Item< double >	m_zhit [MdcCalNLayer]
NTuple::Item< double >	m_zhit [MdcCalNLayer]
double	m_zw [MdcCalTotCell]
Static Private Attributes
const int	HRESBIN_INDEX = 0
const int	HRESBIN_MASK = 0x1F
const int	HRESENTRA_INDEX = 7
const int	HRESENTRA_MASK = 0x380
const int	HRESLAYER_INDEX = 10
const int	HRESLAYER_MASK = 0xFC00
const int	HRESLR_INDEX = 5
const int	HRESLR_MASK = 0x60
const int	NPhiBin = 20
const int	NThetaBin = 9