Single Class Reference

#include <Single.h>

Inheritance diagram for Single:

Public Member Functions
	Single (const std::string &name, ISvcLocator *pSvcLocator)
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()

Detailed Description

Definition at line 10 of file Single.h.

Constructor & Destructor Documentation

Single()

Single::Single	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 53 of file Single.cxx.

                                                              :
  Algorithm(name, pSvcLocator) {
  //Declare the properties  
  declareProperty("Vxy0cut", m_vxy0cut=2.0);
  declareProperty("Vz0cut", m_vz0cut=20.0);
  declareProperty("angdcut", m_angdcut=30.0);
  declareProperty("CheckDedx", m_checkDedx = 1);
  declareProperty("CheckTof",  m_checkTof = 1);
  declareProperty("CheckExt", m_checkExt = 1);
  declareProperty("CheckEmc",  m_checkEmc = 1);
  declareProperty("CheckMuc",  m_checkMuc = 1);
  declareProperty("ParticleID",  m_particleID = -211);
  declareProperty("Itrack",  m_itrack = 0);  
  declareProperty("PID_mode",  m_pid_mode = 0);//0:Combine  1:Only Dedx  2:Only Tof
 
}

Member Function Documentation

execute()

StatusCode Single::execute

(

)

Definition at line 455 of file Single.cxx.

                           {
  setFilterPassed(false);   
  //std::cout << "execute()" << std::endl;
 
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "in execute()" << endreq;
 
 
  // runinfo
  SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
  int runNo=eventHeader->runNumber();
  int event=eventHeader->eventNumber();
  log << MSG::DEBUG <<"run, evtnum = "
      << runNo << " , "
      << event <<endreq;
 
 
  //cout<<"event "<<event<<endl;
  Ncut0++;
 
  m_runNo=runNo;
  m_event=event;
 
 
 
  SmartDataPtr<EvtRecEvent> evtRecEvent(eventSvc(), EventModel::EvtRec::EvtRecEvent);
  //  log << MSG::INFO << "get event tag OK" << endreq;
    log << MSG::DEBUG <<"ncharg, nneu, tottks = " 
      << evtRecEvent->totalCharged() << " , "
      << evtRecEvent->totalNeutral() << " , "
      << evtRecEvent->totalTracks() <<endreq;
 
  SmartDataPtr<EvtRecTrackCol> evtRecTrkCol(eventSvc(),  EventModel::EvtRec::EvtRecTrackCol);
 
  Vint iGood;
  iGood.clear();
 
  int nCharge = 0;  
  
  Hep3Vector xorigin(0,0,0);
  IVertexDbSvc*  vtxsvc;
  Gaudi::svcLocator()->service("VertexDbSvc", vtxsvc);
  if(vtxsvc->isVertexValid()){
    double* dbv = vtxsvc->PrimaryVertex(); 
    double*  vv = vtxsvc->SigmaPrimaryVertex();  
 
    xorigin.setX(dbv[0]);
    xorigin.setY(dbv[1]);
    xorigin.setZ(dbv[2]);
  }
 
  //
  // check McParticle infomation
  //
 
  SmartDataPtr<Event::McParticleCol> mcParticleCol(eventSvc(),"/Event/MC/McParticleCol");
  if(!mcParticleCol){
    std::cout<<"could not retrieve McParticleCol"<<std::endl;
    return StatusCode::FAILURE;
  }
 
  double costhetamc=-9.;
  Event::McParticleCol::iterator iter_mc=mcParticleCol->begin();
  HepLorentzVector initialFourMomentum;
  for(;iter_mc!=mcParticleCol->end();iter_mc++){
    if(abs((*iter_mc)->particleProperty())!=abs(m_particleID))continue;
    HepLorentzVector initialPosition=(*iter_mc)->initialPosition();
    m_vx=initialPosition.x();
    m_vy=initialPosition.y();
    m_vz=initialPosition.z();
    m_vr0=sqrt(m_vx*m_vx+m_vy*m_vy);
    
    initialFourMomentum=(*iter_mc)->initialFourMomentum();
    m_pxmc=initialFourMomentum.px();
    m_pymc=initialFourMomentum.py();
    m_pzmc=initialFourMomentum.pz();
    m_e=initialFourMomentum.e();
    m_p=sqrt(m_pxmc*m_pxmc+m_pymc*m_pymc+m_pzmc*m_pzmc);
    m_pxymc=sqrt(m_pxmc*m_pxmc+m_pymc*m_pymc);
    m_thetamc=initialFourMomentum.theta()*180/(CLHEP::pi);
    m_phimc=initialFourMomentum.phi()*180/(CLHEP::pi);                         
    m_m=initialFourMomentum.m();
    m_costhetamc=initialFourMomentum.cosTheta();
 
    costhetamc=m_costhetamc;
 
    m_pro=(*iter_mc)->particleProperty();
    m_index=(*iter_mc)->trackIndex();
 
  }
    m_mctotcharged=evtRecEvent->totalCharged();
 
    int mm=0;
    if(m_costhetamc>-0.7&&m_costhetamc<0.7&&m_pxymc>0.2&&m_pxymc<0.3)   mm=1;
 
    double pxymc=m_pxymc;
    double pmc=m_p;
    //if(m_mctotcharged==0&&m_costhetamc>-0.7&&m_costhetamc<-0.6&&m_pxymc>0.25&&m_pxymc<0.3)  cout<<"runNo="<<runNo<<"  event"<<event<<endl;
    // if(m_mctotcharged==0&&m_costhetamc>-0.7&&m_costhetamc<-0.6&&m_pxymc>0.35&&m_pxymc<0.4)  cout<<"runNo1="<<runNo<<"  event1"<<event<<endl;
   m_tuple8->write(); 
 
 
 
  //
  // check MdcTrack infomation
  //
 
 
  int  itrack=0;
 
 
  double Rz_comp=30.;
  double Rxy_comp=10.;
  double Rang_comp=50.;
 
  for(int i = 0; i < evtRecEvent->totalCharged(); i++){
    EvtRecTrackIterator itTrk=evtRecTrkCol->begin() + i;
    if(!(*itTrk)->isMdcTrackValid()) continue;
    if(!(*itTrk)->isMdcKalTrackValid()) continue;
    RecMdcTrack *mdcTrk = (*itTrk)->mdcTrack();
    RecMdcTrack *mdcKalTrk = (*itTrk)->mdcTrack();    
    double pch=mdcTrk->p();
    double x0=mdcTrk->x();
    double y0=mdcTrk->y();
    double z0=mdcTrk->z();
    int    trackid=mdcTrk->trackId();
    int    charge=mdcTrk->charge(); 
    double pxy0=mdcTrk->pxy();
    double px0=mdcTrk->px();
    double py0=mdcTrk->py();
    double pz0=mdcTrk->pz();
    double r0 = mdcTrk->r();
    double phi=mdcTrk->phi()*180/(CLHEP::pi);
    double theta=mdcTrk->theta()*180/(CLHEP::pi);
    int    ndof=mdcTrk->ndof();
    int    nster=mdcTrk->nster();
    int    stat= mdcTrk->stat();
 
    double phi0=mdcTrk->helix(1);
    double xv=xorigin.x();
    double yv=xorigin.y();
    double Rxy=(x0-xv)*cos(phi0)+(y0-yv)*sin(phi0);
 
    m_vx0 = x0;
    m_vy0 = y0;
    m_vz0 = z0;
    m_pch = pch;
    m_trackid = trackid;
    m_charge = charge;
    m_pxy0=pxy0;
    m_px0=px0;
    m_py0=py0;
    m_pz0=pz0;
    m_r0=r0;
    m_phi=phi;
    m_theta=theta;
    m_ndof=ndof;
    m_nster=nster;
    m_stat=stat;
    m_vr0 = Rxy;
    
    HepVector a = mdcTrk->helix();
    m_d0=a[0];
    m_phi0=a[1];
    m_kappa=a[2];
    m_dzhelix=a[3];
    m_tanlamda=a[4];
    
    HepSymMatrix Ea = mdcTrk->err();
    
    m_err11=Ea[0][0];
    m_err21=Ea[1][0];    
    m_err22=Ea[1][1];
    m_err31=Ea[2][0];
    m_err32=Ea[2][1];
    m_err33=Ea[2][2];
    m_err41=Ea[3][0];
    m_err42=Ea[3][1];
    m_err43=Ea[3][2];    
    m_err44=Ea[3][3];
    m_err51=Ea[4][0];
    m_err52=Ea[4][1];
    m_err53=Ea[4][2];
    m_err54=Ea[4][3];
    m_err55=Ea[4][4];
 
  
    HepPoint3D point0(0.,0.,0.);   // the initial point for MDC recosntruction
    HepPoint3D IP(xorigin[0],xorigin[1],xorigin[2]); 
    VFHelix helixip(point0,a,Ea); 
    helixip.pivot(IP);
    HepVector vecipa = helixip.a();
    double  Rvxy0=fabs(vecipa[0]);  //the nearest distance to IP in xy plane
    double  Rvz0=vecipa[3];         //the nearest distance to IP in z direction
    double  Rvphi0=vecipa[1];
    m_rvxy0=Rvxy0;
    m_rvz0=Rvz0;
    // m_rvphi0=Rvphi0;
 
    HepLorentzVector  mdcpos(m_px0,m_py0,m_pz0,m_e);
    m_angd=initialFourMomentum.angle(mdcpos)*180/(CLHEP::pi);
 
    if(fabs(Rvz0) >= m_vz0cut) continue;
    if(fabs(Rvxy0) >= m_vxy0cut) continue;
    //if(m_angd>m_angdcut) continue;
 
    if(m_angd<Rang_comp){
    //if(Rvz0<Rz_comp||Rvxy0<Rxy_comp||m_angd<Rang_comp){
      Rz_comp=Rvz0;
      Rxy_comp=Rvxy0;
      Rang_comp=m_angd;
      itrack=i;
      }
 //   nCharge += mdcTrk->charge();
//if(nCharge!=-1) continue;
    //m_tuple1->write(); 
    iGood.push_back(i);
    nCharge += mdcTrk->charge();
  }
 
//if(nCharge!=-1) return StatusCode::SUCCESS;
 
  
  //
  // Finish MdcTrack and Good Charged Track Selection
  //
 
 
  int nGood = iGood.size();
  log << MSG::DEBUG << "nGood, totcharge = " << nGood << " , " << nCharge << endreq;
  //cout << "nGood, totcharge = " << nGood << " , " << nCharge << endl;
   if(mm==1&&nGood==0) setFilterPassed(true);
 
  m_ngch=nGood;
  m_ncharge=nCharge;
    for(int i = 0; i < nGood; i++) {
    EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGood[i];
 
    RecMdcKalTrack* mdcKalTrk = (*itTrk)->mdcKalTrack();
    if(abs(m_particleID)==211) RecMdcKalTrack::setPidType  (RecMdcKalTrack::pion);
    if(abs(m_particleID)==321) RecMdcKalTrack::setPidType  (RecMdcKalTrack::kaon);   
    if(abs(m_particleID)==2212) RecMdcKalTrack::setPidType  (RecMdcKalTrack::proton);
    if(abs(m_particleID)==11) RecMdcKalTrack::setPidType  (RecMdcKalTrack::electron);
    if(abs(m_particleID)==13) RecMdcKalTrack::setPidType  (RecMdcKalTrack::muon);
 
    m_mdc_kal_px=mdcKalTrk->px();
    m_mdc_kal_py=mdcKalTrk->py();   
    m_mdc_kal_pz=mdcKalTrk->pz();
    m_mdc_kal_p=sqrt(m_mdc_kal_px*m_mdc_kal_px+m_mdc_kal_py*m_mdc_kal_py+m_mdc_kal_pz*m_mdc_kal_pz);
    m_mdc_kal_pxy=sqrt(m_mdc_kal_px*m_mdc_kal_px+m_mdc_kal_py*m_mdc_kal_py);
 
    m_mdc_kal_costheta=cos(mdcKalTrk->theta());
 
    
    }
 
 
    double mdc_pxy0=m_pxy0;
    double mdc_pch=m_pch;
    double mdc_costheta=cos(m_theta);
    
 
  m_tuple1->write(); 
  //if(nGood!=1) return StatusCode::SUCCESS;
  //if(fabs(costhetamc)>0.93) return StatusCode::SUCCESS;
 
  Ncut1++;
 
  m_totcharged=evtRecEvent->totalCharged();
  m_totneutral=evtRecEvent->totalNeutral();
  m_tottracks =evtRecEvent->totalTracks();
  m_ngood = nGood;
  
  //  if(m_totneutral>0) return StatusCode::SUCCESS;
  
  //m_kaln=-9;
  //m_costhetan=-9;
 
    //for(int i = 0; i < nGood; i++) {
      //if (i != itrack) continue;
  m_kaln=pxymc;
  m_costhetan=costhetamc;
  m_pn=pmc;
    //}
  m_mat_charge=-2;
  m_diff_pxy=-2;
  m_diff_pch=-2; 
  m_diff_costheta=-2;
  
  for(int i = 0; i < nGood; i++) {
    if (i != itrack) continue;
    EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGood[i];
    RecMdcTrack *mdcTrk = (*itTrk)->mdcTrack();
    m_mat_charge=mdcTrk->charge();
    m_diff_pxy=fabs(m_kaln-mdc_pxy0);
    m_diff_pch=fabs(m_pn-mdc_pch);
    m_diff_costheta=fabs(m_costhetan-mdc_costheta);    
  }
 
 
 
  m_tuple7->write();
  
  //Finish runinfo check
 
 
 
 
 
  //
  //
  // check dedx infomation
  //
  //
 if(m_checkDedx==1){
  for(int i = 0; i < nGood; i++){
    if (m_itrack==1&&i != itrack) continue;
    EvtRecTrackIterator itTrk=evtRecTrkCol->begin() + i;
    if(!(*itTrk)->isMdcTrackValid()) continue;
    if(!(*itTrk)->isMdcDedxValid())continue;
    RecMdcTrack* mdcTrk = (*itTrk)->mdcTrack();
    RecMdcDedx* dedxTrk = (*itTrk)->mdcDedx();
    m_ptrk = mdcTrk->p();
 
    m_chie = dedxTrk->chiE();
    m_chimu = dedxTrk->chiMu();
    m_chipi = dedxTrk->chiPi();
    m_chik = dedxTrk->chiK();
    m_chip = dedxTrk->chiP();
    m_ghit = dedxTrk->numGoodHits();
    m_thit = dedxTrk->numTotalHits();
    m_probPH = dedxTrk->probPH();
    m_normPH = dedxTrk->normPH();
    m_tuple2->write();
  }
 }
 
 
  //
  //   
  // check ExtTrack  infomation
  //
  //
 if(m_checkExt==1){
  for(int i = 0; i <nGood; i++){
    if (m_itrack==1&&i != itrack) continue;
    EvtRecTrackIterator itTrk=evtRecTrkCol->begin() + i;   
    if(!(*itTrk)->isExtTrackValid())continue;
    RecExtTrack* extTrk = (*itTrk)->extTrack();
 
    m_tof1 =extTrk->tof1();
    m_tof1path=extTrk->tof1Path();
    m_tof1z=extTrk->tof1PosSigmaAlongZ();
    m_tof1t=extTrk->tof1PosSigmaAlongT();
    m_tof1x=extTrk->tof1PosSigmaAlongX();
    m_tof1y=extTrk->tof1PosSigmaAlongY();
 
    m_tof2 =extTrk->tof2();
    m_tof2path=extTrk->tof2Path();
    m_tof2z=extTrk->tof2PosSigmaAlongZ();
    m_tof2t=extTrk->tof2PosSigmaAlongT();
    m_tof2x=extTrk->tof2PosSigmaAlongX();
    m_tof2y=extTrk->tof2PosSigmaAlongY();
 
    m_emctheta=extTrk->emcPosSigmaAlongTheta()*180/(CLHEP::pi);
    m_emcphi=extTrk->emcPosSigmaAlongPhi()*180/(CLHEP::pi);
    m_emcpath=extTrk->emcPath();
 
    m_mucz=extTrk->mucPosSigmaAlongZ();
    m_muct=extTrk->mucPosSigmaAlongT();
    m_mucx=extTrk->mucPosSigmaAlongX();
    m_mucy=extTrk->mucPosSigmaAlongY();
 
    m_tuple3->write();
  }
 }
 
  //
  //   
  // check TOF  infomation
  //
  //
 if(m_checkTof==1){
  for(int i = 0; i < nGood; i++){
    if (m_itrack==1&&i != itrack) continue;
    EvtRecTrackIterator itTrk=evtRecTrkCol->begin() + i;   
    if(!(*itTrk)->isTofTrackValid())continue;
    
    SmartRefVector<RecTofTrack> tofTrkCol = (*itTrk)->tofTrack();
    SmartRefVector<RecTofTrack>::iterator iter_tof = tofTrkCol.begin();
 
    m_path=(*iter_tof)->path();
    m_zrhit=(*iter_tof)->zrhit();
    m_ph=(*iter_tof)->ph();
    m_tof=(*iter_tof)->tof();
    m_errtof=(*iter_tof)->errtof();
    m_beta=(*iter_tof)->beta();
    m_texpe=(*iter_tof)->texpElectron();
    m_texpmu=(*iter_tof)->texpMuon();
    m_texppi=(*iter_tof)->texpPion();
    m_texpka=(*iter_tof)->texpKaon();
    m_texppro=(*iter_tof)->texpProton();
    m_toffsete=(*iter_tof)->toffsetElectron();
    m_toffsetmu=(*iter_tof)->toffsetMuon();
    m_toffsetpi=(*iter_tof)->toffsetPion();
    m_toffsetka=(*iter_tof)->toffsetKaon();
    m_toffsetpro=(*iter_tof)->toffsetProton();
    m_toffsetatpr=(*iter_tof)->toffsetAntiProton();
    m_sigmae=(*iter_tof)->sigmaElectron();
    m_sigmamu=(*iter_tof)->sigmaMuon();
    m_sigmapi=(*iter_tof)->sigmaPion();
    m_sigmaka=(*iter_tof)->sigmaKaon();
    m_sigmapro=(*iter_tof)->sigmaProton();
    m_sigmaatpr=(*iter_tof)->sigmaAntiProton();
    m_quality=(*iter_tof)->quality();
    m_t0=(*iter_tof)->t0();
    m_errt0=(*iter_tof)->errt0();
    m_errz=(*iter_tof)->errz();
    m_phitof=(*iter_tof)->phi()*180/(CLHEP::pi);
    m_errphi=(*iter_tof)->errphi()*180/(CLHEP::pi);
    m_energy=(*iter_tof)->energy();
    m_errenergy=(*iter_tof)->errenergy();
    
    m_tuple4->write();
  }
 }
 
  //
  //   
  // check EmcTrack  infomation
  //
  //
 if(m_checkEmc==1){
  for(int i = 0; i < nGood; i++){
    if (m_itrack==1&&i != itrack) continue;
    EvtRecTrackIterator itTrk=evtRecTrkCol->begin() + i;   
    if(!(*itTrk)->isEmcShowerValid())continue;
    RecEmcShower* emcTrk = (*itTrk)->emcShower();
    
    m_x=emcTrk->x();
    m_y=emcTrk->y();
    m_z=emcTrk->z();
    m_thetaemc=emcTrk->theta()*180/(CLHEP::pi);
    m_phiemc=emcTrk->phi()*180/(CLHEP::pi);
    m_dx=emcTrk->dx();
    m_dy=emcTrk->dy();
    m_dz=emcTrk->dz();
    m_dtheta=emcTrk->dtheta()*180/(CLHEP::pi);
    m_dphi=emcTrk->dphi()*180/(CLHEP::pi);
    m_energyemc=emcTrk->energy();
    m_de=emcTrk->dE();
    m_eseed=emcTrk->eSeed();
    m_e3x3=emcTrk->e3x3();
    m_e5x5=emcTrk->e5x5();
    m_secp=emcTrk->secondMoment();
    m_latp=emcTrk->latMoment();
  
    m_tuple5->write();
  }
 }
 
 
 
 
 
  //
  // Assign 4-momentum to each charged track
  //
  ParticleID *pid = ParticleID::instance();
    for(int i = 0; i < nGood; i++) {
    if(nGood!=1) continue;
    if (m_itrack==1&&i != itrack) continue;
    EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGood[i]; 
    //    if(pid) delete pid;
 
    pid->init();
    pid->setMethod(pid->methodProbability());
    // pid->setMethod(pid->methodLikelihood());  //for Likelihood Method  
 
    pid->setChiMinCut(4);
    pid->setRecTrack(*itTrk);
    if(m_pid_mode == 0) pid->usePidSys(pid->useDedx() | pid->useTof1() | pid->useTof2() |pid->useTofE());
    if(m_pid_mode == 1) pid->usePidSys(pid->useDedx() );
    if(m_pid_mode == 2) pid->usePidSys(pid->useTof1() | pid->useTof2() |pid->useTofE());
    
    // pid->identify(pid->onlyPion() | pid->onlyKaon());    // seperater Pion/Kaon
    //   pid->identify(pid->onlyPion());
    pid->identify(pid->onlyPionKaonProton());
    pid->calculate();
 
    //if(!(pid->IsPidInfoValid())&&costhetamc>-0.7&&costhetamc<-0.6&&pxymc>0.25&&pxymc<0.3)  cout<<"pidrunNo="<<runNo<<"  pidevent"<<event<<endl;
    //if(!(pid->IsPidInfoValid())&&costhetamc>-0.7&&costhetamc<-0.6&&pxymc>0.35&&pxymc<0.4)  cout<<"pidrunNo1="<<runNo<<" pidevent1"<<event<<endl;
    if(!(pid->IsPidInfoValid()))  continue;
    RecMdcTrack* mdcTrk = (*itTrk)->mdcTrack();
    m_ptrk_pid = mdcTrk->p();
    m_cost_pid = cos(mdcTrk->theta());
    m_dedx_pid = pid->chiDedx(2);
    m_tof1_pid = pid->chiTof1(2);
    m_tof2_pid = pid->chiTof2(2);
    m_prob_pid_pion = pid->probPion();
    m_prob_pid_kaon = pid->probKaon();
    m_prob_pid_proton = pid->probProton();
 
 
  //   
  // check KalTrack  infomation
  //
 
    
    // if(!(*itTrk)->isMdcKalTrackValid()) {cout<<"kal"<<endl; continue;}
 
 
    RecMdcKalTrack* mdcKalTrk = (*itTrk)->mdcKalTrack();
    if(abs(m_particleID)==211) RecMdcKalTrack::setPidType  (RecMdcKalTrack::pion);
    if(abs(m_particleID)==321) RecMdcKalTrack::setPidType  (RecMdcKalTrack::kaon);   
    if(abs(m_particleID)==2212) RecMdcKalTrack::setPidType  (RecMdcKalTrack::proton);
    if(abs(m_particleID)==11) RecMdcKalTrack::setPidType  (RecMdcKalTrack::electron);
    if(abs(m_particleID)==13) RecMdcKalTrack::setPidType  (RecMdcKalTrack::muon);
 
    m_kalpx=mdcKalTrk->px();
    m_kalpy=mdcKalTrk->py();   
    m_kalpz=mdcKalTrk->pz();
    m_kalp=sqrt(m_kalpx*m_kalpx+m_kalpy*m_kalpy+m_kalpz*m_kalpz);
    m_kalpxy=sqrt(m_kalpx*m_kalpx+m_kalpy*m_kalpy);
 
    HepLorentzVector ptr;
 
    ptr=mdcKalTrk->p4(0.000511*0.000511);
    m_kalcostheta=ptr.cosTheta();
 
    double kalcostheta=m_kalcostheta;
    m_comp_costheta=costhetamc-kalcostheta;
    //cout<<"   kalcostheta="<<m_kalcostheta<<endl;
    HepVector k= mdcKalTrk->helix();
    HepSymMatrix Ek = mdcKalTrk->err();
 
    m_d0kal=k[0];
    m_phi0kal=k[1];
    m_kappakal=k[2];
    m_dzhelixkal=k[3];
    m_tanlamdakal=k[4];
    
   
    m_err11kal=Ek[0][0];
    m_err21kal=Ek[1][0];    
    m_err22kal=Ek[1][1];
 
    m_err31kal=Ek[2][0];
    m_err32kal=Ek[2][1];
    m_err33kal=Ek[2][2];
    m_err41kal=Ek[3][0];
    m_err42kal=Ek[3][1];
    m_err43kal=Ek[3][2];    
    m_err44kal=Ek[3][3];
    m_err51kal=Ek[4][0];
    m_err52kal=Ek[4][1];
    m_err53kal=Ek[4][2];
    m_err54kal=Ek[4][3];
    m_err55kal=Ek[4][4];
 
  
    m_kalnn=pxymc;
    m_costhetann=costhetamc;
    m_pnn=pmc;    
    //cout<<"pxy="<<pxymc<<'\t'<<'\t'<<m_kalpxy<<endl;
    //cout<<"costheta="<<costhetamc<<'\t'<<m_kalcostheta<<endl<<endl;
    
    m_tuple9->write();
   }
 
 
  //
  //   
  // check MucTrack  infomation
  //
  //
   if(m_checkMuc==1){
    for(int i = 0; i < nGood; i++){
    if (m_itrack==1&&i != itrack) continue;
      EvtRecTrackIterator itTrk=evtRecTrkCol->begin() + i;   
      if(!(*itTrk)->isMucTrackValid())continue;
      RecMucTrack* mucTrk = (*itTrk)->mucTrack();
 
      m_depth=mucTrk->depth();
      m_chi2=mucTrk->chi2();
      m_rms=mucTrk->rms();
      m_xpos=mucTrk->xPos();
      m_ypos=mucTrk->yPos();
      m_zpos=mucTrk->zPos();
      m_xpossigma=mucTrk->xPosSigma();
      m_ypossigma=mucTrk->yPosSigma();
      m_zpossigma=mucTrk->zPosSigma();
      m_px=mucTrk->px();
      m_py=mucTrk->py();
      m_pz=mucTrk->pz();
      m_distance=mucTrk->distance();
      m_deltaphi=mucTrk->deltaPhi()*180/(CLHEP::pi);
          
      m_tuple6->write();
    }
   }
  
    
 
   return StatusCode::SUCCESS;
   
}

finalize()

StatusCode Single::finalize

(

)

Definition at line 1064 of file Single.cxx.

                            {
  cout<<"mdc"<<endl;
  cout<<"total number:         "<<Ncut0<<endl;
  cout<<"nGood: "<<Ncut1<<endl;
  MsgStream log(msgSvc(), name()); 
  log << MSG::INFO << "in finalize()" << endmsg;
  return StatusCode::SUCCESS;
}

initialize()

StatusCode Single::initialize

(

)

Definition at line 72 of file Single.cxx.

                             {
  MsgStream log(msgSvc(), name());
 
  log << MSG::INFO << "in initialize()" << endmsg;
  
  StatusCode status;
  NTuplePtr nt1(ntupleSvc(), "FILE1/mdctrack");
  if ( nt1 ) m_tuple1 = nt1;
  else {
    m_tuple1 = ntupleSvc()->book ("FILE1/mdctrack", CLID_ColumnWiseTuple, "ks N-Tuple example");
    if ( m_tuple1 )    {
      status = m_tuple1->addItem ("mdc_vx0",   m_vx0);
      status = m_tuple1->addItem ("mdc_vy0",   m_vy0);
      status = m_tuple1->addItem ("mdc_vz0",   m_vz0);
      status = m_tuple1->addItem ("mdc_pch",   m_pch);
      status = m_tuple1->addItem ("mdc_trackid",   m_trackid);
      status = m_tuple1->addItem ("mdc_charge",   m_charge);
      status = m_tuple1->addItem ("mdc_pxy0",   m_pxy0);
      status = m_tuple1->addItem ("mdc_px0",   m_px0);
      status = m_tuple1->addItem ("mdc_py0",   m_py0);
      status = m_tuple1->addItem ("mdc_pz0",   m_pz0);
      status = m_tuple1->addItem ("mdc_r0",   m_r0);
      status = m_tuple1->addItem ("mdc_phi",   m_phi);
      status = m_tuple1->addItem ("mdc_theta",   m_theta);
      status = m_tuple1->addItem ("mdc_ndof",   m_ndof);
      status = m_tuple1->addItem ("mdc_nster",   m_nster);
      status = m_tuple1->addItem ("mdc_stat",   m_stat);
      status = m_tuple1->addItem ("mdc_angd",   m_angd);
      status = m_tuple1->addItem ("mdc_rvxy0",   m_rvxy0);
      status = m_tuple1->addItem ("mdc_rvz0",   m_rvz0);
      status = m_tuple1->addItem ("mdc_d0",   m_d0);
      status = m_tuple1->addItem ("mdc_phi0",   m_phi0);
      status = m_tuple1->addItem ("mdc_kappa",   m_kappa);
      status = m_tuple1->addItem ("mdc_dz",   m_dzhelix);
      status = m_tuple1->addItem ("mdc_tanlamda",   m_tanlamda);
      status = m_tuple1->addItem ("mdc_err11",   m_err11);
      status = m_tuple1->addItem ("mdc_err21",   m_err21);
      status = m_tuple1->addItem ("mdc_err22",   m_err22);
      status = m_tuple1->addItem ("mdc_err31",   m_err31);
      status = m_tuple1->addItem ("mdc_err32",   m_err32);
      status = m_tuple1->addItem ("mdc_err33",   m_err33);
      status = m_tuple1->addItem ("mdc_err41",   m_err41);
      status = m_tuple1->addItem ("mdc_err42",   m_err42);
      status = m_tuple1->addItem ("mdc_err43",   m_err43);
      status = m_tuple1->addItem ("mdc_err44",   m_err44);
      status = m_tuple1->addItem ("mdc_err51",   m_err51);
      status = m_tuple1->addItem ("mdc_err52",   m_err52);
      status = m_tuple1->addItem ("mdc_err53",   m_err53);
      status = m_tuple1->addItem ("mdc_err54",   m_err54);
      status = m_tuple1->addItem ("mdc_err55",   m_err55);
 
      status = m_tuple1->addItem ("mdc_kal_px",   m_mdc_kal_px);
      status = m_tuple1->addItem ("mdc_kal_py",   m_mdc_kal_py);
      status = m_tuple1->addItem ("mdc_kal_pz",   m_mdc_kal_pz);
      status = m_tuple1->addItem ("mdc_kal_p",   m_mdc_kal_p);
      status = m_tuple1->addItem ("mdc_kal_pxy",   m_mdc_kal_pxy);
      status = m_tuple1->addItem ("mdc_kal_costheta",   m_mdc_kal_costheta);      
      
      status = m_tuple1->addItem ("NGch",   m_ngch);      
    }
    else    { 
      log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple1) << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  // check mdctrack
 
 
  if(m_checkDedx==1){
    NTuplePtr nt2(ntupleSvc(), "FILE1/dedx");
    if ( nt2 ) m_tuple2 = nt2;
    else {
      m_tuple2 = ntupleSvc()->book ("FILE1/dedx", CLID_ColumnWiseTuple, "ks N-Tuple example");
      if ( m_tuple2 )    {
    status = m_tuple2->addItem ("dedx_ptrk",   m_ptrk);
    status = m_tuple2->addItem ("dedx_chie",   m_chie);
    status = m_tuple2->addItem ("dedx_chimu",   m_chimu);
    status = m_tuple2->addItem ("dedx_chipi",   m_chipi);
    status = m_tuple2->addItem ("dedx_chik",   m_chik);
    status = m_tuple2->addItem ("dedx_chip",   m_chip);
    status = m_tuple2->addItem ("dedx_probPH",   m_probPH);
    status = m_tuple2->addItem ("dedx_normPH",   m_normPH);
    status = m_tuple2->addItem ("dedx_ghit",   m_ghit);
    status = m_tuple2->addItem ("dedx_thit",   m_thit);
      }
      else    { 
    log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple2) << endmsg;
    return StatusCode::FAILURE;
      }
    }
  }
    // check dE/dx
 
 
  if(m_checkExt==1){
    NTuplePtr nt3(ntupleSvc(), "FILE1/ext");
    if ( nt3 ) m_tuple3 = nt3;
    else {
      m_tuple3 = ntupleSvc()->book ("FILE1/ext",CLID_ColumnWiseTuple, "ks N-Tuple example");
      if ( m_tuple3 )    {
 
    status = m_tuple3->addItem ("ext_tof1",   m_tof1);
        status = m_tuple3->addItem ("ext_tof1path", m_tof1path);
        status = m_tuple3->addItem ("ext_tof1z",   m_tof1z);
    status = m_tuple3->addItem ("ext_tof1t",   m_tof1t);
        status = m_tuple3->addItem ("ext_tof1x",   m_tof1x);
        status = m_tuple3->addItem ("ext_tof1y",   m_tof1y);
 
    status = m_tuple3->addItem ("ext_tof2",   m_tof2);
        status = m_tuple3->addItem ("ext_tof2path", m_tof2path);
        status = m_tuple3->addItem ("ext_tof2z",   m_tof2z);
    status = m_tuple3->addItem ("ext_tof2t",   m_tof2t);
        status = m_tuple3->addItem ("ext_tof2x",   m_tof2x);
        status = m_tuple3->addItem ("ext_tof2y",   m_tof2y);
 
    status = m_tuple3->addItem ("ext_emctheta",   m_emctheta);
        status = m_tuple3->addItem ("ext_emcphi", m_emcphi);
        status = m_tuple3->addItem ("ext_emcpath",   m_emcpath);
 
    status = m_tuple3->addItem ("ext_mucz",   m_mucz);
    status = m_tuple3->addItem ("ext_muct",   m_muct);
        status = m_tuple3->addItem ("ext_mucx",   m_mucx);
        status = m_tuple3->addItem ("ext_mucy",   m_mucy);
 
 
      }
      else    { 
    log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple3) << endmsg;
    return StatusCode::FAILURE;
      }
    }
  }
    //check exttrack
 
   
 
 
   if(m_checkTof==1){ 
    NTuplePtr nt4(ntupleSvc(), "FILE1/tof");
    if ( nt4 ) m_tuple4 = nt4;
    else {
      m_tuple4 = ntupleSvc()->book ("FILE1/tof", CLID_ColumnWiseTuple, "ks N-Tuple example");
      if ( m_tuple2 )    {
    status = m_tuple4->addItem ("tof_path",   m_path);
    status = m_tuple4->addItem ("tof_zrhit",   m_zrhit);
    status = m_tuple4->addItem ("tof_ph",   m_ph);
        status = m_tuple4->addItem ("tof_tof",   m_tof);
        status = m_tuple4->addItem ("tof_errtof",   m_errtof);
    status = m_tuple4->addItem ("tof_beta",   m_beta);
    status = m_tuple4->addItem ("tof_texpe",   m_texpe);
        status = m_tuple4->addItem ("tof_texpmu",   m_texpmu);
        status = m_tuple4->addItem ("tof_texppi",   m_texppi);
    status = m_tuple4->addItem ("tof_texpka",   m_texpka);
    status = m_tuple4->addItem ("tof_texppro",   m_texppro);
        status = m_tuple4->addItem ("tof_toffsete",   m_toffsete);
        status = m_tuple4->addItem ("tof_toffsetmu",   m_toffsetmu);
    status = m_tuple4->addItem ("tof_toffsetpi",   m_toffsetpi);
    status = m_tuple4->addItem ("tof_toffsetka",   m_toffsetka);
        status = m_tuple4->addItem ("tof_toffsetpro",   m_toffsetpro);
        status = m_tuple4->addItem ("tof_toffsetatpr",   m_toffsetatpr);
    status = m_tuple4->addItem ("tof_sigmae",   m_sigmae);
        status = m_tuple4->addItem ("tof_sigmamu",   m_sigmamu);
        status = m_tuple4->addItem ("tof_sigmapi",   m_sigmapi);
    status = m_tuple4->addItem ("tof_sigmaka",   m_sigmaka);
    status = m_tuple4->addItem ("tof_sigmapro",   m_sigmapro);
        status = m_tuple4->addItem ("tof_sigmaatpr",   m_sigmaatpr);
        status = m_tuple4->addItem ("tof_quality",   m_quality);
    status = m_tuple4->addItem ("tof_t0",   m_t0);
        status = m_tuple4->addItem ("tof_errt0",   m_errt0);
        status = m_tuple4->addItem ("tof_errz",   m_errz);
    status = m_tuple4->addItem ("tof_phi",   m_phitof);
    status = m_tuple4->addItem ("tof_errphi",   m_errphi);
        status = m_tuple4->addItem ("tof_energy",   m_energy);
        status = m_tuple4->addItem ("tof_errenergy",   m_errenergy);
      }
      else    { 
    log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple4) << endmsg;
    return StatusCode::FAILURE;
      }
    }
   }
    //check tof
 
 
  
   if(m_checkEmc==1){
    NTuplePtr nt5(ntupleSvc(), "FILE1/emc");
    if ( nt5 ) m_tuple5 = nt5;
    else {
      m_tuple5 = ntupleSvc()->book ("FILE1/emc",CLID_ColumnWiseTuple, "ks N-Tuple example");
      if ( m_tuple5 )    {
 
    status = m_tuple5->addItem ("emc_x",   m_x);
        status = m_tuple5->addItem ("emc_y", m_y);
        status = m_tuple5->addItem ("emc_z",   m_z);
    status = m_tuple5->addItem ("emc_theta",   m_thetaemc);
        status = m_tuple5->addItem ("emc_phi",   m_phiemc);
        status = m_tuple5->addItem ("emc_dx",   m_dx);
    status = m_tuple5->addItem ("emc_dy",   m_dy);
        status = m_tuple5->addItem ("emc_dz",   m_dz);
        status = m_tuple5->addItem ("emc_dtheta",   m_dtheta);
    status = m_tuple5->addItem ("emc_dphi",   m_dphi);
        status = m_tuple5->addItem ("emc_energy",   m_energyemc);
        status = m_tuple5->addItem ("emc_dE",   m_de);
    status = m_tuple5->addItem ("emc_eseed",   m_eseed);
        status = m_tuple5->addItem ("emc_e3x3",   m_e3x3);
        status = m_tuple5->addItem ("emc_e5x5",   m_e5x5);
    status = m_tuple5->addItem ("emc_secp",   m_secp);
        status = m_tuple5->addItem ("emc_latp",   m_latp);
    }
      else    { 
    log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple5) << endmsg;
    return StatusCode::FAILURE;
      }
    }
   }
    //check emc
 
   if(m_checkMuc==1){
     NTuplePtr nt6(ntupleSvc(), "FILE1/muc");
    if ( nt6 ) m_tuple6 = nt6;
    else {
      m_tuple6 = ntupleSvc()->book ("FILE1/muc",CLID_ColumnWiseTuple, "ks N-Tuple example");
      if ( m_tuple6 )    {
 
    status = m_tuple6->addItem ("muc_depth",   m_depth);
        status = m_tuple6->addItem ("muc_chi2", m_chi2);
    status = m_tuple6->addItem ("muc_rms",   m_rms);
        status = m_tuple6->addItem ("muc_xpos", m_xpos);   
    status = m_tuple6->addItem ("muc_ypos",   m_ypos);
        status = m_tuple6->addItem ("muc_zpos", m_zpos);
    status = m_tuple6->addItem ("muc_xsigma",   m_xpossigma);
        status = m_tuple6->addItem ("muc_ysigma", m_ypossigma);
    status = m_tuple6->addItem ("muc_zsigma",   m_zpossigma);
        status = m_tuple6->addItem ("muc_px", m_px);
    status = m_tuple6->addItem ("muc_py",   m_py);
        status = m_tuple6->addItem ("muc_pz", m_pz);
    status = m_tuple6->addItem ("muc_distance",   m_distance);
        status = m_tuple6->addItem ("muc_deltaphi", m_deltaphi);
    }
      else    { 
    log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple6) << endmsg;
    return StatusCode::FAILURE;
      }
    } 
   }
    //check muc
 
 
    
     NTuplePtr nt7(ntupleSvc(), "FILE1/runinfo");
    if ( nt7 ) m_tuple7 = nt7;
    else {
      m_tuple7 = ntupleSvc()->book ("FILE1/runinfo",CLID_ColumnWiseTuple, "ks N-Tuple example");
      if ( m_tuple7 )    {
 
    status = m_tuple7->addItem ("runinfo_runNo",   m_runNo);
        status = m_tuple7->addItem ("runinfo_event", m_event);
        status = m_tuple7->addItem ("runinfo_totcharged",   m_totcharged);
        status = m_tuple7->addItem ("runinfo_totneutral", m_totneutral);
        status = m_tuple7->addItem ("runinfo_tottracks", m_tottracks); 
        status = m_tuple7->addItem ("runinfo_ngood", m_ngood);
        status = m_tuple7->addItem ("runinfo_ncharge", m_ncharge); 
    status = m_tuple7->addItem ("kal_n",   m_kaln);
    status = m_tuple7->addItem ("costheta_n",   m_costhetan);
    status = m_tuple7->addItem ("p_n",   m_pn);
        status = m_tuple7->addItem ("charge", m_mat_charge);
        status = m_tuple7->addItem ("diff_pxy", m_diff_pxy);
        status = m_tuple7->addItem ("diff_p", m_diff_pch);  
        status = m_tuple7->addItem ("diff_costheta", m_diff_costheta);  
    }
      else    { 
    log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple7) << endmsg;
    return StatusCode::FAILURE;
      }
    } 
    //check runinfo
 
 
 
     NTuplePtr nt8(ntupleSvc(), "FILE1/mcpart");
    if ( nt8 ) m_tuple8 = nt8;
    else {
      m_tuple8 = ntupleSvc()->book ("FILE1/mcpart",CLID_ColumnWiseTuple, "ks N-Tuple example");
      if ( m_tuple8 )    {
    status = m_tuple8->addItem ("mcpart_vx",   m_vx);   
        status = m_tuple8->addItem ("mcpart_vy",   m_vy);   
        status = m_tuple8->addItem ("mcpart_vz",   m_vz);
    status = m_tuple8->addItem ("mcpart_vr0",  m_vr0);
    status = m_tuple8->addItem ("mcpart_px",   m_pxmc); 
        status = m_tuple8->addItem ("mcpart_py",   m_pymc); 
    status = m_tuple8->addItem ("mcpart_pz",   m_pzmc);
    status = m_tuple8->addItem ("mcpart_e",    m_e);    
        status = m_tuple8->addItem ("mcpart_p",    m_p);    
        status = m_tuple8->addItem ("mcpart_pxy",   m_pxymc);
        status = m_tuple8->addItem ("mcpart_theta",   m_thetamc);
        status = m_tuple8->addItem ("mcpart_costheta",   m_costhetamc);
 
    status = m_tuple8->addItem ("mcpart_phi",   m_phimc);
    status = m_tuple8->addItem ("mcpart_m",   m_m); 
         status = m_tuple8->addItem ("mcpart_pro",   m_pro);
        status = m_tuple8->addItem ("mcpart_index",   m_index);
        status = m_tuple8->addItem ("totalcharged",   m_mctotcharged);  
 
    
      }
      else    { 
    log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple8) << endmsg;
    return StatusCode::FAILURE;
      }
    } 
    //check mctruth
 
 
  NTuplePtr nt9(ntupleSvc(), "FILE1/pid_kal");
  if ( nt9 ) m_tuple9 = nt9;
  else {
    m_tuple9 = ntupleSvc()->book ("FILE1/pid_kal", CLID_ColumnWiseTuple, "ks N-Tuple example");
    if ( m_tuple9 )    {
      status = m_tuple9->addItem ("pid_ptrk",   m_ptrk_pid);
      status = m_tuple9->addItem ("pid_cost",   m_cost_pid);
      status = m_tuple9->addItem ("pid_dedx",   m_dedx_pid);
      status = m_tuple9->addItem ("pid_tof1",   m_tof1_pid);
      status = m_tuple9->addItem ("pid_tof2",   m_tof2_pid);
      status = m_tuple9->addItem ("prob_pion",   m_prob_pid_pion);
      status = m_tuple9->addItem ("prob_kaon",   m_prob_pid_kaon);
      status = m_tuple9->addItem ("prob_proton",   m_prob_pid_proton);
 
      status = m_tuple9->addItem ("kal_px",   m_kalpx);
      status = m_tuple9->addItem ("kal_py",   m_kalpy);
      status = m_tuple9->addItem ("kal_pz",   m_kalpz);
      status = m_tuple9->addItem ("kal_p",   m_kalp);
      status = m_tuple9->addItem ("kal_pxy",   m_kalpxy);
 
      status = m_tuple9->addItem ("kal_costheta",   m_kalcostheta);
 
      status = m_tuple9->addItem ("kal_d0",   m_d0kal);
      status = m_tuple9->addItem ("kal_phi0",   m_phi0kal);
      status = m_tuple9->addItem ("kal_kappa",   m_kappakal);
      status = m_tuple9->addItem ("kal_dz",   m_dzhelixkal);
      status = m_tuple9->addItem ("kal_tanlamda",   m_tanlamdakal);
      status = m_tuple9->addItem ("kal_err11",   m_err11kal);
      status = m_tuple9->addItem ("kal_err21",   m_err21kal);
      status = m_tuple9->addItem ("kal_err22",   m_err22kal);
      status = m_tuple9->addItem ("kal_err31",   m_err31kal);
      status = m_tuple9->addItem ("kal_err32",   m_err32kal);
      status = m_tuple9->addItem ("kal_err33",   m_err33kal);
      status = m_tuple9->addItem ("kal_err41",   m_err41kal);
      status = m_tuple9->addItem ("kal_err42",   m_err42kal);
      status = m_tuple9->addItem ("kal_err43",   m_err43kal);
      status = m_tuple9->addItem ("kal_err44",   m_err44kal);
      status = m_tuple9->addItem ("kal_err51",   m_err51kal);
      status = m_tuple9->addItem ("kal_err52",   m_err52kal);
      status = m_tuple9->addItem ("kal_err53",   m_err53kal);
      status = m_tuple9->addItem ("kal_err54",   m_err54kal);
      status = m_tuple9->addItem ("kal_err55",   m_err55kal);
      status = m_tuple9->addItem ("kal_nn",   m_kalnn);
      status = m_tuple9->addItem ("costheta_nn",   m_costhetann);
      status = m_tuple9->addItem ("p_nn",   m_pnn);
 
      status = m_tuple9->addItem ("comp_costheta",   m_comp_costheta);
 
 
    }
    else    { 
      log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple9) << endmsg;
      return StatusCode::FAILURE;
    }
  }
  //check pid and kaltrack
 
 
  //
  //--------End of book--------
  //
 
  log << MSG::INFO << "successfully return from initialize()" <<endmsg;
  return StatusCode::SUCCESS;
 
}

---

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

• Single.h
• Single.cxx