TestV Class Reference

#include <TestV.h>

Inheritance diagram for TestV:

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

Detailed Description

Definition at line 11 of file TestV.h.

Constructor & Destructor Documentation

TestV()

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

Definition at line 66 of file TestV.cxx.

                                                            :
  Algorithm(name, pSvcLocator) {
  
  //Declare the properties  
  declareProperty("Vr0cut", m_vr0cut=1.0);
  declareProperty("Vz0cut", m_vz0cut=10.0);
  declareProperty("Coscut", m_coscut=0.93);
  declareProperty("EnergyThreshold", m_energyThreshold=0.04);
  declareProperty("GammaPhiCut", m_gammaPhiCut=20.0);
  declareProperty("GammaThetaCut", m_gammaThetaCut=20.0);
  declareProperty("Test4C", m_test4C = 1);
  declareProperty("Test5C", m_test5C = 1);
  declareProperty("CheckDedx", m_checkDedx = 1);
  declareProperty("CheckTof",  m_checkTof = 1);
 
  declareProperty("tagPPbar",  m_tagPPbar = false);
}

Member Function Documentation

execute()

StatusCode TestV::execute

(

)

please use is_cluster rather is_counter please use texp(i) rahter than calculations by yourself

Definition at line 349 of file TestV.cxx.

                          {
  
 
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "in execute()" << endreq;
 
  counter[0]++;
 
  SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");   
  SmartDataPtr<EvtRecEvent> evtRecEvent(eventSvc(), EventModel::EvtRec::EvtRecEvent);
  SmartDataPtr<EvtRecTrackCol> evtRecTrkCol(eventSvc(),  EventModel::EvtRec::EvtRecTrackCol);
 
  m_run   = eventHeader->runNumber();
  m_event = eventHeader->eventNumber();
  m_nchrg = evtRecEvent->totalCharged();
  m_nneu  = evtRecEvent->totalNeutral(); 
 
  log << MSG::INFO << "get event tag OK" << endreq;
  log << MSG::DEBUG <<"ncharg, nneu, tottks = " 
    << evtRecEvent->totalCharged() << " , "
    << evtRecEvent->totalNeutral() << " , "
    << evtRecEvent->totalTracks() <<endreq;
 
  //
  // check x0, y0, z0, r0
  // suggest cut: |z0|<10 && r0<1
  //
  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]);
  }
  
  Vint iGood; 
  iGood.clear(); 
  int nCharge = 0;
  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();
      double x0=mdcTrk->x();
      double y0=mdcTrk->y();
      double z0=mdcTrk->z();
      double phi0=mdcTrk->helix(1);
      double xv=xorigin.x();
      double yv=xorigin.y();
      double zv=xorigin.z();
      double rv=(x0-xv)*cos(phi0)+(y0-yv)*sin(phi0);
      double cost = cos(mdcTrk->theta());
      if(fabs(z0-zv) >= m_vz0cut) continue;
      if(fabs(rv) >= m_vr0cut) continue;
      if(fabs(cost) >= m_coscut ) continue; 
      
      iGood.push_back((*itTrk)->trackId());
      nCharge += mdcTrk->charge();
  }
 
  //
  // Finish Good Charged Track Selection
  //
  int nGood = iGood.size();
  m_ngch = iGood.size(); 
  log << MSG::DEBUG << "ngood, totcharge = " << nGood << " , " << nCharge << endreq;
  //
  // Charge track number cut
  //
 
  if((nGood != 2) || (nCharge!=0) ){
    return StatusCode::SUCCESS;
  }
  counter[1]++;
 
 
  //
  // Assign 4-momentum to each charged track
  //
 
  Vint ipp, ipm;   ipp.clear();  ipm.clear();
  Vp4  p_pp, p_pm;   p_pp.clear();  p_pm.clear();
  Vp4  p_kal_pp, p_kal_pm;   p_kal_pp.clear();  p_kal_pm.clear();
  RecMdcTrack *ppTrk, *pmTrk; 
  RecMdcKalTrack *ppKalTrk = 0 , *pmKalTrk = 0 ; 
  int ii ; 
 
  ParticleID *pid = ParticleID::instance();
  for(int i = 0; i < nGood; i++) {
 
    EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGood[i]; 
    if(!(*itTrk)->isMdcTrackValid()) continue; 
    RecMdcTrack* mdcTrk = (*itTrk)->mdcTrack(); 
    if(!(*itTrk)->isMdcKalTrackValid()) continue; 
    RecMdcKalTrack* mdcKalTrk = (*itTrk)->mdcKalTrack(); 
 
    //    if(pid) delete pid;
    pid->init();
    pid->setMethod(pid->methodProbability());
    pid->setChiMinCut(4);
    pid->setRecTrack(*itTrk);
    pid->usePidSys(pid->useDedx() | pid->useTof1() | pid->useTof2()); // use PID sub-system
    pid->identify(pid->onlyPionKaonProton());    // seperater Pion/Kaon/Proton
    //    pid->identify(pid->onlyProton());
    //    pid->identify(pid->onlyPion() | pid->onlyKaon());    // seperater Pion/Kaon
    //    pid->identify(pid->onlyPion());
    //    pid->identify(pid->onlyKaon());
    pid->calculate();
    if(!(pid->IsPidInfoValid())) continue;
 
    double prob_pi = pid->probPion();
    double prob_k  = pid->probKaon();
    double prob_p  = pid->probProton();
 
    //    if(pid->probPion() < 0.001 || (pid->probPion() < pid->probKaon())) continue;
    //    if(pid->probPion() < 0.001) continue;
    //    if (prob_p > prob_pi && prob_p > prob_k) {
    if (prob_p > prob_pi && prob_p > prob_k) {
 
      HepLorentzVector ptrk, pkaltrk;
 
      ptrk.setPx(mdcTrk->px());
      ptrk.setPy(mdcTrk->py());
      ptrk.setPz(mdcTrk->pz());
      double p3 = ptrk.mag();
      ptrk.setE(sqrt(p3*p3+xmass[4]*xmass[4]));
 
      mdcKalTrk->setPidType(RecMdcKalTrack::proton);
      pkaltrk.setPx(mdcKalTrk->px());
      pkaltrk.setPy(mdcKalTrk->py());
      pkaltrk.setPz(mdcKalTrk->pz());
      p3 = pkaltrk.mag();
      pkaltrk.setE(sqrt(p3*p3+xmass[4]*xmass[4]));
 
      if(mdcTrk->charge() > 0) {
    ii=0 ;
 
    ipp.push_back(iGood[i]);
    p_pp.push_back(ptrk);
    p_kal_pp.push_back(pkaltrk);
    ppTrk = mdcTrk ; 
    ppKalTrk = mdcKalTrk ; 
      }
      if (mdcTrk->charge() < 0) {
    ii = 1 ; 
 
    ipm.push_back(iGood[i]);
    p_pm.push_back(ptrk); 
    p_kal_pm.push_back(pkaltrk); 
    pmTrk = mdcTrk ; 
    pmKalTrk = mdcKalTrk ; 
      }
      m_ptrk_pid[ii] = mdcTrk->p();
      m_cost_pid[ii] = cos(mdcTrk->theta());
      m_dedx_pid[ii] = pid->chiDedx(4);
      m_tof1_pid[ii] = pid->chiTof1(4);
      m_tof2_pid[ii] = pid->chiTof2(4);
      m_prob_pi[ii] = pid->probPion();
      m_prob_k[ii]  = pid->probKaon();
      m_prob_p[ii]  = pid->probProton();
 
    }
  }
  m_np  = ipp.size();
  m_npb = ipm.size();
 
  if(m_np*m_npb != 1) return SUCCESS;
 
  counter[2]++;
 
 
 
  //boosted   mdcTrk
  p_pp[0].boost(u_cms);
  p_pm[0].boost(u_cms);
  for (int i=0; i<=1; i++ ) {
    HepLorentzVector p; 
    if (i==0) p = p_pp[0]; 
    if (i==1) p = p_pm[0]; 
    
    m_bst_px[i] = p.px(); 
    m_bst_py[i] = p.py(); 
    m_bst_pz[i] = p.pz(); 
    m_bst_p[i]  = p.rho(); 
    m_bst_cos[i]= p.cosTheta(); 
  }
 
  m_m2p = (p_pp[0] + p_pm[0]).m();
  m_angle = (p_pp[0].vect()).angle((p_pm[0]).vect()) * 180.0/(CLHEP::pi) ;
 
  //boosted   mdcKalTrk
  p_kal_pp[0].boost(u_cms);
  p_kal_pm[0].boost(u_cms);
 
  for (int i=0; i<=1; i++ ) {
    HepLorentzVector p; 
    if (i==0) p = p_kal_pp[0]; 
    if (i==1) p = p_kal_pm[0]; 
    
    m_bst_kal_px[i] = p.px(); 
    m_bst_kal_py[i] = p.py(); 
    m_bst_kal_pz[i] = p.pz(); 
    m_bst_kal_p[i]  = p.rho(); 
    m_bst_kal_cos[i]= p.cosTheta(); 
  }
  m_kal_m2p = (p_kal_pp[0] + p_kal_pm[0]).m();
  m_kal_angle = (p_kal_pp[0].vect()).angle((p_kal_pm[0]).vect()) * 180.0/(CLHEP::pi) ;
  
  //
  //
  // full information for charged tracks
  //
  //
  
  //////////////////////////////////////////// 
  // Get all information for good charged tracks
  ////////////////////////////////////////////
 
  for(int i = 0; i < m_ngch; i++ ){
    //////////////////////////////////////////// 
    // MDC information 
    ////////////////////////////////////////////
    EvtRecTrackIterator itTrk=evtRecTrkCol->begin() + iGood[i];
    if(!(*itTrk)->isMdcTrackValid()) continue;
    RecMdcTrack *mdcTrk = (*itTrk)->mdcTrack();
    if(!(*itTrk)->isMdcKalTrackValid()) continue;
    RecMdcKalTrack *mdcKalTrk = (*itTrk)->mdcKalTrack();
    
    if (mdcTrk->charge() > 0 ) {
      ii =0 ; 
    }else{
      ii = 1 ; 
    }
 
    m_charge[ii] = mdcTrk->charge(); 
 
    double x0=mdcTrk->x();
    double y0=mdcTrk->y();
    double z0=mdcTrk->z();
    double phi0=mdcTrk->helix(1);
    double xv=xorigin.x();
    double yv=xorigin.y();
    double zv=xorigin.z();
    double rv=(x0-xv)*cos(phi0)+(y0-yv)*sin(phi0);
 
    m_vx0[ii]    = x0-xv ;
    m_vy0[ii]    = y0-yv ;
    m_vz0[ii]    = z0-zv ;
    m_vr0[ii]    = rv ;
    
    m_px[ii]   = mdcTrk->px();
    m_py[ii]   = mdcTrk->py();
    m_pz[ii]   = mdcTrk->pz();
    m_p[ii]    = mdcTrk->p();
    m_cos[ii]  = mdcTrk->pz()/mdcTrk->p();
 
    mdcKalTrk->setPidType(RecMdcKalTrack::proton);
    x0=mdcKalTrk->x();
    y0=mdcKalTrk->y();
    z0=mdcKalTrk->z();
    rv=(x0-xv)*cos(phi0)+(y0-yv)*sin(phi0);
    
    m_kal_vx0[ii] = x0-xv ;
    m_kal_vy0[ii] = y0-yv ;
    m_kal_vz0[ii] = z0-zv ;
    m_kal_vr0[ii] = rv ;
 
    m_kal_px[ii]   = mdcKalTrk->px();
    m_kal_py[ii]   = mdcKalTrk->py();
    m_kal_pz[ii]   = mdcKalTrk->pz();
    m_kal_p[ii]    = mdcKalTrk->p();
    m_kal_cos[ii]  = mdcKalTrk->pz()/mdcKalTrk->p();
 
    double ptrk = mdcKalTrk->p() ; 
 
    //////////////////////////////////////////// 
    // DEDX information  
    ////////////////////////////////////////////
    if ((*itTrk)->isMdcDedxValid()) { //Dedx information 
      RecMdcDedx* dedxTrk = (*itTrk)->mdcDedx();
      m_chie[ii]  = dedxTrk->chiE();
      m_chimu[ii] = dedxTrk->chiMu();
      m_chipi[ii] = dedxTrk->chiPi();
      m_chik[ii]  = dedxTrk->chiK();
      m_chip[ii]  = dedxTrk->chiP();
      m_ghit[ii]  = dedxTrk->numGoodHits();
      m_thit[ii]  = dedxTrk->numTotalHits();
      m_probPH[ii]= dedxTrk->probPH();
      m_normPH[ii]= dedxTrk->normPH();
 
    }
  
    //////////////////////////////////////////// 
    // TOF information  
    ////////////////////////////////////////////
    log << MSG::INFO << "TOF info "<< endreq;
    m_clus_tof[ii]      = 100.0 ;  
    m_clus_texp_e[ii]   = 100.0 ;  
    m_clus_texp_mu[ii]  = 100.0 ;  
    m_clus_texp_pi[ii]  = 100.0 ;  
    m_clus_texp_k[ii]   = 100.0 ;  
    m_clus_texp_p[ii]   = 100.0 ;  
     
    m_clus_toff_e[ii]   = 100.0 ;  
    m_clus_toff_mu[ii]  = 100.0 ;  
    m_clus_toff_pi[ii]  = 100.0 ;  
    m_clus_toff_k[ii]   = 100.0 ;  
    m_clus_toff_p[ii]   = 100.0 ;  
     
    m_clus_tsig_e[ii]   = 100.0 ; 
    m_clus_tsig_mu[ii]  = 100.0 ; 
    m_clus_tsig_pi[ii]  = 100.0 ; 
    m_clus_tsig_k[ii]   = 100.0 ; 
    m_clus_tsig_p[ii]   = 100.0 ; 
     
    m_clus_path[ii]     = 100.0 ; 
    m_clus_zrhit[ii]    = 100.0 ; 
    m_clus_ph[ii]       = 100.0 ; 
    m_clus_beta[ii]     = 100.0 ; 
    m_clus_qual[ii]     = 100.0 ; 
    m_clus_t0[ii]       = 100.0 ; 
 
    if((*itTrk)->isEmcShowerValid()) {
      RecEmcShower *emcTrk = (*itTrk)->emcShower();
      m_e_emc[ii] = emcTrk->energy();
    }
    
    
    if((*itTrk)->isTofTrackValid()) {
 
      SmartRefVector<RecTofTrack> tofTrkCol = (*itTrk)->tofTrack();
      
      SmartRefVector<RecTofTrack>::iterator iter_tof = tofTrkCol.begin();
      for(;iter_tof != tofTrkCol.end(); iter_tof++ ) { 
        TofHitStatus *status = new TofHitStatus; 
        status->setStatus((*iter_tof)->status());
 
        if(!(status->is_barrel())){//endcap
          if( !(status->is_counter()) ) continue; // ? 
          if( status->layer()!=0 ) continue;//layer1
          double path=(*iter_tof)->path(); // ? 
          double tof  = (*iter_tof)->tof();
          double ph   = (*iter_tof)->ph();
          double rhit = (*iter_tof)->zrhit();
          double qual = 0.0 + (*iter_tof)->quality();
          double cntr = 0.0 + (*iter_tof)->tofID();
          double texp[5];
          for(int j = 0; j < 5; j++) {
            double gb = ptrk/xmass[j];
            double beta = gb/sqrt(1+gb*gb);
            texp[j] = path /beta/velc;
          }
 
          m_cntr_etof[ii]  = cntr;
          m_ptot_etof[ii]  = ptrk;
          m_ph_etof[ii]    = ph;
          m_rhit_etof[ii]  = rhit;
          m_qual_etof[ii]  = qual;
      m_tof_etof[ii]   = tof ; 
          m_te_etof[ii]    = tof - texp[0];
          m_tmu_etof[ii]   = tof - texp[1];
          m_tpi_etof[ii]   = tof - texp[2];
          m_tk_etof[ii]    = tof - texp[3];
          m_tp_etof[ii]    = tof - texp[4];
    }
        else {//barrel
      if(( status->is_cluster() )) {
         //////////////////////////////////////////////////////////
         ///  please use is_cluster rather is_counter
         ///  please use texp(i) rahter than calculations by yourself
         //   if( !(status->is_counter()) ) continue; // ? 
         //   if(status->layer()==1){   //barrel TOF layer1
         m_clus_tof[ii]      = (*iter_tof)->tof() ; 
         m_clus_texp_e[ii]   = (*iter_tof)->texp(0);
         m_clus_texp_mu[ii]  = (*iter_tof)->texp(1);
         m_clus_texp_pi[ii]  = (*iter_tof)->texp(2);
         m_clus_texp_k[ii]   = (*iter_tof)->texp(3);
         m_clus_texp_p[ii]   = (*iter_tof)->texp(4);
         
         m_clus_toff_e[ii]   = (*iter_tof)->toffset(0);
         m_clus_toff_mu[ii]  = (*iter_tof)->toffset(1);
         m_clus_toff_pi[ii]  = (*iter_tof)->toffset(2);
         m_clus_toff_k[ii]   = (*iter_tof)->toffset(3);
         m_clus_toff_p[ii]   = (*iter_tof)->toffset(4);
         
         m_clus_tsig_e[ii]   = (*iter_tof)->sigma(0);
         m_clus_tsig_mu[ii]  = (*iter_tof)->sigma(1);
         m_clus_tsig_pi[ii]  = (*iter_tof)->sigma(2);
         m_clus_tsig_k[ii]   = (*iter_tof)->sigma(3);
         m_clus_tsig_p[ii]   = (*iter_tof)->sigma(4);
         
         m_clus_path[ii]   = (*iter_tof)->path();
         m_clus_zrhit[ii]  = (*iter_tof)->zrhit();
         m_clus_ph[ii]     = (*iter_tof)->ph();
         m_clus_beta[ii]   = (*iter_tof)->beta();
         m_clus_qual[ii]   = (*iter_tof)->quality();
         m_clus_t0[ii]     = (*iter_tof)->t0();
      }
      if( !(status->is_counter()) ) continue; // ? 
          if(status->layer()==1){ //layer1
            double path=(*iter_tof)->path(); // ? 
            double tof  = (*iter_tof)->tof();
            double ph   = (*iter_tof)->ph();
            double rhit = (*iter_tof)->zrhit();
            double qual = 0.0 + (*iter_tof)->quality();
            double cntr = 0.0 + (*iter_tof)->tofID();
            double texp[5];
            for(int j = 0; j < 5; j++) {
              double gb = ptrk/xmass[j];
              double beta = gb/sqrt(1+gb*gb);
              texp[j] = path /beta/velc;
            }
        
            m_cntr_btof1[ii]  = cntr;
            m_ptot_btof1[ii] = ptrk;
            m_ph_btof1[ii]   = ph;
            m_zhit_btof1[ii]  = rhit;
            m_qual_btof1[ii]  = qual;
        m_tof_btof1[ii]   = tof ; 
            m_te_btof1[ii]    = tof - texp[0];
            m_tmu_btof1[ii]   = tof - texp[1];
            m_tpi_btof1[ii]   = tof - texp[2];
            m_tk_btof1[ii]    = tof - texp[3];
            m_tp_btof1[ii]    = tof - texp[4];
 
          }
 
          if(status->layer()==2){//layer2
            double path=(*iter_tof)->path(); // ? 
            double tof  = (*iter_tof)->tof();
            double ph   = (*iter_tof)->ph();
            double rhit = (*iter_tof)->zrhit();
            double qual = 0.0 + (*iter_tof)->quality();
            double cntr = 0.0 + (*iter_tof)->tofID();
            double texp[5];
            for(int j = 0; j < 5; j++) {
              double gb = ptrk/xmass[j];
              double beta = gb/sqrt(1+gb*gb);
              texp[j] = path /beta/velc;
            }
 
            m_cntr_btof2[ii]  = cntr;
            m_ptot_btof2[ii] = ptrk;
            m_ph_btof2[ii]   = ph;
            m_zhit_btof2[ii]  = rhit;
            m_qual_btof2[ii]  = qual;
        m_tof_btof2[ii]   = tof ; 
            m_te_btof2[ii]    = tof - texp[0];
            m_tmu_btof2[ii]   = tof - texp[1];
            m_tpi_btof2[ii]   = tof - texp[2];
            m_tk_btof2[ii]    = tof - texp[3];
            m_tp_btof2[ii]    = tof - texp[4];
          } 
        }
        delete status; 
      } 
    }
    double deltatof = 0.0 ; 
    if(m_tof_btof1[0]*m_tof_btof1[1] != 0.0) deltatof+=fabs(m_tof_btof1[0]-m_tof_btof1[1]);
    if(m_tof_btof2[0]*m_tof_btof2[1] != 0.0) deltatof+=fabs(m_tof_btof2[0]-m_tof_btof2[1]);
    if(m_tof_etof[0]*m_tof_etof[1] != 0.0) deltatof+=fabs(m_tof_etof[0]-m_tof_etof[1]);
    m_deltatof = deltatof ;  
  }
 
  counter[3]++;
 
  if(m_tagPPbar){
  m_pp_mass->Fill(m_kal_m2p);
  m_pp_angle->Fill(m_kal_angle);
  m_pp_deltatof->Fill(m_deltatof);
 
  m_pp_x_pp->Fill(m_vx0[0]);
  m_pp_y_pp->Fill(m_vy0[0]);
  m_pp_z_pp->Fill(m_vz0[0]);
  m_pp_r_pp->Fill(m_vr0[0]);
  m_pp_px_pp->Fill(m_bst_kal_px[0]);
  m_pp_py_pp->Fill(m_bst_kal_py[0]);
  m_pp_pz_pp->Fill(m_bst_kal_pz[0]);
  m_pp_p_pp->Fill(m_bst_kal_p[0]);
  m_pp_cos_pp->Fill(m_bst_kal_cos[0]);
  m_pp_emc_pp->Fill(m_e_emc[0]);
  m_pp_pidchidedx_pp->Fill(m_dedx_pid[0]);
  m_pp_pidchitof1_pp->Fill(m_tof1_pid[0]);
  m_pp_pidchitof2_pp->Fill(m_tof2_pid[0]);
 
  m_pp_x_pb->Fill(m_vx0[1]);
  m_pp_y_pb->Fill(m_vy0[1]);
  m_pp_z_pb->Fill(m_vz0[1]);
  m_pp_r_pb->Fill(m_vr0[1]);
  m_pp_px_pb->Fill(m_bst_kal_px[1]);
  m_pp_py_pb->Fill(m_bst_kal_py[1]);
  m_pp_pz_pb->Fill(m_bst_kal_pz[1]);
  m_pp_p_pb->Fill(m_bst_kal_p[1]);
  m_pp_cos_pb->Fill(m_bst_kal_cos[1]);
  m_pp_emc_pb->Fill(m_e_emc[1]);
  m_pp_pidchidedx_pb->Fill(m_dedx_pid[1]);
  m_pp_pidchitof1_pb->Fill(m_tof1_pid[1]);
  m_pp_pidchitof2_pb->Fill(m_tof2_pid[1]);
 
  }
  //
  //    Test vertex fit
  //
 
  HepPoint3D vx(0., 0., 0.);
  HepSymMatrix Evx(3, 0);
  double bx = 1E+6;
  double by = 1E+6;
  double bz = 1E+6;
  Evx[0][0] = bx*bx;
  Evx[1][1] = by*by;
  Evx[2][2] = bz*bz;
 
  VertexParameter vxpar;
  vxpar.setVx(vx);
  vxpar.setEvx(Evx);
  
  VertexFit* vtxfit = VertexFit::instance();
  vtxfit->init();
  
  WTrackParameter wp(xmass[4], ppKalTrk->getZHelixP(), ppKalTrk->getZErrorP());
  WTrackParameter wpb(xmass[4], pmKalTrk->getZHelixP(), pmKalTrk->getZErrorP());
 
  vtxfit->AddTrack(0, wp);
  vtxfit->AddTrack(1, wpb);
  vtxfit->AddVertex(0, vxpar,0, 1);
  if(!vtxfit->Fit(0)) return SUCCESS;
  vtxfit->Swim(0);
 
  counter[4]++;
  
  wp  = vtxfit->wtrk(0);
  wpb = vtxfit->wtrk(1);
 
  //
  //  boosted 
  //
  HepLorentzVector p = wp.p();
  HepLorentzVector pb = wpb.p();
 
  p.boost(u_cms);
  pb.boost(u_cms);
  
  HepLorentzVector ptot = p + pb;
  
  for (int i = 0; i < 2; i++) {
    HepLorentzVector p_vtx; 
    if (m_charge[i] > 0 ) {
      p_vtx =  p;
      ii = 0; 
    }
    else { 
      p_vtx =  pb;
      ii = 1; 
    }
    
    m_vtx_px[ii] = p_vtx.px(); 
    m_vtx_py[ii] = p_vtx.py(); 
    m_vtx_pz[ii] = p_vtx.pz(); 
    m_vtx_p[ii]  = p_vtx.rho(); 
    m_vtx_cos[ii]= p_vtx.cosTheta(); 
  }
 
  m_vtx_m2p = (p + pb).m();
  m_vtx_angle = (p.vect()).angle(pb.vect()) * 180.0/(CLHEP::pi) ;
  
  counter[5]++;
  m_tuple1 -> write();
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode TestV::finalize

(

)

Definition at line 926 of file TestV.cxx.

                           {
 
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "in finalize()" << endmsg;
  
  std::cout << "************* TestV.cxx ****************" << std::endl;
  std::cout << "the totale events is      " << counter[0] << std::endl;
  std::cout << "select good charged track " << counter[1] << std::endl;
  std::cout << "particle ID               " << counter[2] << std::endl;
  std::cout << "inform. for charged track " << counter[3] << std::endl;
  std::cout << "vertex fit                " << counter[4] << std::endl;
  std::cout << "boosted information       " << counter[5] << std::endl;
  std::cout << "****************************************" << std::endl;
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TestV::initialize

(

)

Definition at line 85 of file TestV.cxx.

                            {
  MsgStream log(msgSvc(), name());
 
  log << MSG::INFO << "in initialize()" << endmsg;
  
  StatusCode status;
 
  status = service("THistSvc", m_thistsvc);
  if(status.isFailure() ){
    log << MSG::INFO << "Unable to retrieve pointer to THistSvc" << endreq;
    return status;
  }
 
  if(m_tagPPbar){
 
     m_pp_mass = new TH1F( "pp_mass", "pp_mass", 100,3.0,3.2 );
     status = m_thistsvc->regHist("/VAL/PHY/pp_mass", m_pp_mass);
     m_pp_angle = new TH1F( "pp_angle", "pp_angle", 100, 170, 180 );
     status = m_thistsvc->regHist("/VAL/PHY/pp_angle", m_pp_angle);
     m_pp_deltatof = new TH1F( "pp_deltatof", "pp_deltatof", 100, 0, 10 );
     status = m_thistsvc->regHist("/VAL/PHY/pp_deltatof", m_pp_deltatof);
 
     m_pp_x_pp = new TH1F( "pp_x_pp", "pp_x_pp", 100, -0.5, 0.5); 
     status = m_thistsvc->regHist("/VAL/PHY/pp_x_pp", m_pp_x_pp);
     m_pp_y_pp = new TH1F( "pp_y_pp", "pp_y_pp", 100, -0.5, 0.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_y_pp", m_pp_y_pp);
     m_pp_z_pp = new TH1F( "pp_z_pp", "pp_z_pp", 100, -10.0, 10.);
     status = m_thistsvc->regHist("/VAL/PHY/pp_z_pp", m_pp_z_pp);
     m_pp_r_pp = new TH1F( "pp_r_pp", "pp_r_pp", 100, 0.0, 0.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_r_pp", m_pp_r_pp);
     m_pp_px_pp = new TH1F( "pp_px_pp", "pp_px_pp", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_px_pp", m_pp_px_pp);
     m_pp_py_pp = new TH1F( "pp_py_pp", "pp_py_pp", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_py_pp", m_pp_py_pp);
     m_pp_pz_pp = new TH1F( "pp_pz_pp", "pp_pz_pp", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_pz_pp", m_pp_pz_pp);
     m_pp_p_pp = new TH1F( "pp_p_pp", "pp_p_pp", 100, 1.15, 1.35);
     status = m_thistsvc->regHist("/VAL/PHY/pp_p_pp", m_pp_p_pp);
     m_pp_cos_pp = new TH1F( "pp_cos_pp", "pp_cos_pp", 100, -1.0,1.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_cos_pp", m_pp_cos_pp);
     m_pp_emc_pp = new TH1F( "pp_emc_pp", "pp_emc_pp", 100, 0.0, 2.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_emc_pp", m_pp_emc_pp);
     m_pp_pidchidedx_pp = new TH1F( "pp_pidchidedx_pp", "pp_pidchidedx_pp", 100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_pidchidedx_pp", m_pp_pidchidedx_pp);
     m_pp_pidchitof1_pp = new TH1F( "pp_pidchitof1_pp", "pp_pidchitof1_pp", 100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_pidchitof1_pp", m_pp_pidchitof1_pp);
     m_pp_pidchitof2_pp = new TH1F( "pp_pidchitof2_pp", "pp_pidchitof2_pp", 100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_pidchitof2_pp", m_pp_pidchitof2_pp);
 
     m_pp_x_pb = new TH1F( "pp_x_pb", "pp_x_pb", 100, -0.5, 0.5); 
     status = m_thistsvc->regHist("/VAL/PHY/pp_x_pb", m_pp_x_pb);
     m_pp_y_pb = new TH1F( "pp_y_pb", "pp_y_pb", 100, -0.5, 0.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_y_pb", m_pp_y_pb);
     m_pp_z_pb = new TH1F( "pp_z_pb", "pp_z_pb", 100, -10.0, 10.);
     status = m_thistsvc->regHist("/VAL/PHY/pp_z_pb", m_pp_z_pb);
     m_pp_r_pb = new TH1F( "pp_r_pb", "pp_r_pb", 100, 0.0, 0.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_r_pb", m_pp_r_pb);
     m_pp_px_pb = new TH1F( "pp_px_pb", "pp_px_pb", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_px_pb", m_pp_px_pb);
     m_pp_py_pb = new TH1F( "pp_py_pb", "pp_py_pb", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_py_pb", m_pp_py_pb);
     m_pp_pz_pb = new TH1F( "pp_pz_pb", "pp_pz_pb", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/pp_pz_pb", m_pp_pz_pb);
     m_pp_p_pb = new TH1F( "pp_p_pb", "pp_p_pb", 100, 1.15, 1.35);
     status = m_thistsvc->regHist("/VAL/PHY/pp_p_pb", m_pp_p_pb);
     m_pp_cos_pb = new TH1F( "pp_cos_pb", "pp_cos_pb", 100, -1.0,1.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_cos_pb", m_pp_cos_pb);
     m_pp_emc_pb = new TH1F( "pp_emc_pb", "pp_emc_pb", 100, 0.0, 2.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_emc_pb", m_pp_emc_pb);
     m_pp_pidchidedx_pb = new TH1F( "pp_pidchidedx_pb", "pp_pidchidedx_pb", 100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_pidchidedx_pb", m_pp_pidchidedx_pb);
     m_pp_pidchitof1_pb = new TH1F( "pp_pidchitof1_pb", "pp_pidchitof1_pb", 100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_pidchitof1_pb", m_pp_pidchitof1_pb);
     m_pp_pidchitof2_pb = new TH1F( "pp_pidchitof2_pb", "pp_pidchitof2_pb", 100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/pp_pidchitof2_pb", m_pp_pidchitof2_pb);
  }
  
 
  NTuplePtr nt1(ntupleSvc(), "FILE1/testv");
  if ( nt1 ) m_tuple1 = nt1;
  else {
    m_tuple1 = ntupleSvc()->book ("FILE1/testv", CLID_ColumnWiseTuple, "N-Tuple");
    if ( m_tuple1 )    {
      status = m_tuple1->addItem ("irun",   m_run);
      status = m_tuple1->addItem ("ievent", m_event);
      status = m_tuple1->addItem ("Nchrg",  m_nchrg);
      status = m_tuple1->addItem ("Nneu",   m_nneu);
      status = m_tuple1->addItem ("NGch",   m_ngch, 0, 10);
 
      status = m_tuple1->addIndexedItem ("charge",m_ngch, m_charge);
      status = m_tuple1->addIndexedItem ("vx",    m_ngch, m_vx0);
      status = m_tuple1->addIndexedItem ("vy",    m_ngch, m_vy0);
      status = m_tuple1->addIndexedItem ("vz",    m_ngch, m_vz0);
      status = m_tuple1->addIndexedItem ("vr",    m_ngch, m_vr0);
      status = m_tuple1->addIndexedItem ("px",    m_ngch, m_px) ;
      status = m_tuple1->addIndexedItem ("py",    m_ngch, m_py) ;
      status = m_tuple1->addIndexedItem ("pz",    m_ngch, m_pz) ;
      status = m_tuple1->addIndexedItem ("p",     m_ngch, m_p)  ;
      status = m_tuple1->addIndexedItem ("cos",   m_ngch, m_cos);
 
      status = m_tuple1->addIndexedItem ("bst_px",    m_ngch, m_bst_px) ;
      status = m_tuple1->addIndexedItem ("bst_py",    m_ngch, m_bst_py) ;
      status = m_tuple1->addIndexedItem ("bst_pz",    m_ngch, m_bst_pz) ;
      status = m_tuple1->addIndexedItem ("bst_p",     m_ngch, m_bst_p)  ;
      status = m_tuple1->addIndexedItem ("bst_cos",   m_ngch, m_bst_cos);
 
      status = m_tuple1->addIndexedItem ("kal_vx",    m_ngch, m_kal_vx0);
      status = m_tuple1->addIndexedItem ("kal_vy",    m_ngch, m_kal_vy0);
      status = m_tuple1->addIndexedItem ("kal_vz",    m_ngch, m_kal_vz0);
      status = m_tuple1->addIndexedItem ("kal_vr",    m_ngch, m_kal_vr0);
 
      status = m_tuple1->addIndexedItem ("kal_px",    m_ngch, m_kal_px) ;
      status = m_tuple1->addIndexedItem ("kal_py",    m_ngch, m_kal_py) ;
      status = m_tuple1->addIndexedItem ("kal_pz",    m_ngch, m_kal_pz) ;
      status = m_tuple1->addIndexedItem ("kal_p",     m_ngch, m_kal_p)  ;
      status = m_tuple1->addIndexedItem ("kal_cos",   m_ngch, m_kal_cos);
 
      status = m_tuple1->addIndexedItem ("bst_kal_px",    m_ngch, m_bst_kal_px) ;
      status = m_tuple1->addIndexedItem ("bst_kal_py",    m_ngch, m_bst_kal_py) ;
      status = m_tuple1->addIndexedItem ("bst_kal_pz",    m_ngch, m_bst_kal_pz) ;
      status = m_tuple1->addIndexedItem ("bst_kal_p",     m_ngch, m_bst_kal_p)  ;
      status = m_tuple1->addIndexedItem ("bst_kal_cos",   m_ngch, m_bst_kal_cos);
 
      status = m_tuple1->addIndexedItem ("vtx_px",    m_ngch, m_vtx_px) ;
      status = m_tuple1->addIndexedItem ("vtx_py",    m_ngch, m_vtx_py) ;
      status = m_tuple1->addIndexedItem ("vtx_pz",    m_ngch, m_vtx_pz) ;
      status = m_tuple1->addIndexedItem ("vtx_p",     m_ngch, m_vtx_p)  ;
      status = m_tuple1->addIndexedItem ("vtx_cos",   m_ngch, m_vtx_cos);
 
      status = m_tuple1->addIndexedItem ("chie"   , m_ngch, m_chie)   ;
      status = m_tuple1->addIndexedItem ("chimu"  , m_ngch, m_chimu)  ;
      status = m_tuple1->addIndexedItem ("chipi"  , m_ngch, m_chipi)  ;
      status = m_tuple1->addIndexedItem ("chik"   , m_ngch, m_chik)   ;
      status = m_tuple1->addIndexedItem ("chip"   , m_ngch, m_chip)   ;
      status = m_tuple1->addIndexedItem ("ghit"   , m_ngch, m_ghit)   ;
      status = m_tuple1->addIndexedItem ("thit"   , m_ngch, m_thit)   ;
      status = m_tuple1->addIndexedItem ("probPH" , m_ngch, m_probPH) ;
      status = m_tuple1->addIndexedItem ("normPH" , m_ngch, m_normPH) ;
 
      status = m_tuple1->addIndexedItem ("e_emc"   , m_ngch, m_e_emc) ;
 
 
      status = m_tuple1->addIndexedItem ("clus_tof"    , m_ngch,   m_clus_tof     );
      status = m_tuple1->addIndexedItem ("clus_texp_e" , m_ngch,   m_clus_texp_e  );
      status = m_tuple1->addIndexedItem ("clus_texp_mu", m_ngch,   m_clus_texp_mu );
      status = m_tuple1->addIndexedItem ("clus_texp_pi", m_ngch,   m_clus_texp_pi );
      status = m_tuple1->addIndexedItem ("clus_texp_k" , m_ngch,   m_clus_texp_k  );
      status = m_tuple1->addIndexedItem ("clus_texp_p" , m_ngch,   m_clus_texp_p  );
      status = m_tuple1->addIndexedItem ("clus_toff_e" , m_ngch,   m_clus_toff_e  );
      status = m_tuple1->addIndexedItem ("clus_toff_mu", m_ngch,   m_clus_toff_mu );
      status = m_tuple1->addIndexedItem ("clus_toff_pi", m_ngch,   m_clus_toff_pi );
      status = m_tuple1->addIndexedItem ("clus_toff_k" , m_ngch,   m_clus_toff_k  );
      status = m_tuple1->addIndexedItem ("clus_toff_p" , m_ngch,   m_clus_toff_p  );
      status = m_tuple1->addIndexedItem ("clus_tsig_e" , m_ngch,   m_clus_tsig_e  );
      status = m_tuple1->addIndexedItem ("clus_tsig_mu", m_ngch,   m_clus_tsig_mu );
      status = m_tuple1->addIndexedItem ("clus_tsig_pi", m_ngch,   m_clus_tsig_pi );
      status = m_tuple1->addIndexedItem ("clus_tsig_k" , m_ngch,   m_clus_tsig_k  );
      status = m_tuple1->addIndexedItem ("clus_tsig_p" , m_ngch,   m_clus_tsig_p  );
      status = m_tuple1->addIndexedItem ("clus_path"   , m_ngch,   m_clus_path    );
      status = m_tuple1->addIndexedItem ("clus_zrhit"  , m_ngch,   m_clus_zrhit   );
      status = m_tuple1->addIndexedItem ("clus_ph"     , m_ngch,   m_clus_ph      );
      status = m_tuple1->addIndexedItem ("clus_beta"   , m_ngch,   m_clus_beta    );
      status = m_tuple1->addIndexedItem ("clus_qual"   , m_ngch,   m_clus_qual    );
      status = m_tuple1->addIndexedItem ("clus_t0"     , m_ngch,   m_clus_t0      );
 
      status = m_tuple1->addIndexedItem ("cntr_etof" , m_ngch,   m_cntr_etof  );
      status = m_tuple1->addIndexedItem ("ptot_etof" , m_ngch,   m_ptot_etof  );
      status = m_tuple1->addIndexedItem ("ph_etof"   , m_ngch,   m_ph_etof    );
      status = m_tuple1->addIndexedItem ("rhit_etof" , m_ngch,   m_rhit_etof  );
      status = m_tuple1->addIndexedItem ("qual_etof" , m_ngch,   m_qual_etof  );
      status = m_tuple1->addIndexedItem ("tof_etof"  , m_ngch,   m_tof_etof   );
      status = m_tuple1->addIndexedItem ("te_etof"   , m_ngch,   m_te_etof    );
      status = m_tuple1->addIndexedItem ("tmu_etof"  , m_ngch,   m_tmu_etof   );
      status = m_tuple1->addIndexedItem ("tpi_etof"  , m_ngch,   m_tpi_etof   );
      status = m_tuple1->addIndexedItem ("tk_etof"   , m_ngch,   m_tk_etof    );
      status = m_tuple1->addIndexedItem ("tp_etof"   , m_ngch,   m_tp_etof    );
 
      status = m_tuple1->addIndexedItem ("cntr_btof1", m_ngch,   m_cntr_btof1 );
      status = m_tuple1->addIndexedItem ("ptot_btof1", m_ngch,   m_ptot_btof1 );
      status = m_tuple1->addIndexedItem ("ph_btof1"  , m_ngch,   m_ph_btof1   );
      status = m_tuple1->addIndexedItem ("zhit_btof1", m_ngch,   m_zhit_btof1 );
      status = m_tuple1->addIndexedItem ("qual_btof1", m_ngch,   m_qual_btof1 );
      status = m_tuple1->addIndexedItem ("tof_btof1" , m_ngch,   m_tof_btof1  );
      status = m_tuple1->addIndexedItem ("te_btof1"  , m_ngch,   m_te_btof1   );
      status = m_tuple1->addIndexedItem ("tmu_btof1" , m_ngch,   m_tmu_btof1  );
      status = m_tuple1->addIndexedItem ("tpi_btof1" , m_ngch,   m_tpi_btof1  );
      status = m_tuple1->addIndexedItem ("tk_btof1"  , m_ngch,   m_tk_btof1   );
      status = m_tuple1->addIndexedItem ("tp_btof1"  , m_ngch,   m_tp_btof1   );
 
      status = m_tuple1->addIndexedItem ("cntr_btof2", m_ngch,   m_cntr_btof2 );
      status = m_tuple1->addIndexedItem ("ptot_btof2", m_ngch,   m_ptot_btof2 );
      status = m_tuple1->addIndexedItem ("ph_btof2"  , m_ngch,   m_ph_btof2   );
      status = m_tuple1->addIndexedItem ("zhit_btof2", m_ngch,   m_zhit_btof2 );
      status = m_tuple1->addIndexedItem ("qual_btof2", m_ngch,   m_qual_btof2 );
      status = m_tuple1->addIndexedItem ("tof_btof2" , m_ngch,   m_tof_btof2  );
      status = m_tuple1->addIndexedItem ("te_btof2"  , m_ngch,   m_te_btof2   );
      status = m_tuple1->addIndexedItem ("tmu_btof2" , m_ngch,   m_tmu_btof2  );
      status = m_tuple1->addIndexedItem ("tpi_btof2" , m_ngch,   m_tpi_btof2  );
      status = m_tuple1->addIndexedItem ("tk_btof2"  , m_ngch,   m_tk_btof2   );
      status = m_tuple1->addIndexedItem ("tp_btof2"  , m_ngch,   m_tp_btof2   );
 
      status = m_tuple1->addIndexedItem ("m_ptrk_pid", m_ngch,   m_ptrk_pid);
      status = m_tuple1->addIndexedItem ("m_cost_pid", m_ngch,   m_cost_pid);
      status = m_tuple1->addIndexedItem ("m_dedx_pid", m_ngch,   m_dedx_pid);
      status = m_tuple1->addIndexedItem ("m_tof1_pid", m_ngch,   m_tof1_pid);
      status = m_tuple1->addIndexedItem ("m_tof2_pid", m_ngch,   m_tof2_pid);
      status = m_tuple1->addIndexedItem ("m_prob_pi", m_ngch,   m_prob_pi  );
      status = m_tuple1->addIndexedItem ("m_prob_k",  m_ngch,   m_prob_k   );
      status = m_tuple1->addIndexedItem ("m_prob_p",  m_ngch,   m_prob_p   );
 
 
      status = m_tuple1->addItem ( "np",   m_np        );
      status = m_tuple1->addItem ( "npb",  m_npb       );
 
 
      status = m_tuple1->addItem ( "m2p",    m_m2p   );
      status = m_tuple1->addItem ( "angle",  m_angle );
      status = m_tuple1->addItem ( "deltatof", m_deltatof );
 
      status = m_tuple1->addItem ( "kal_m2p",    m_kal_m2p   );
      status = m_tuple1->addItem ( "kal_angle",  m_kal_angle );
 
      status = m_tuple1->addItem ( "vtx_m2p",    m_vtx_m2p   );
      status = m_tuple1->addItem ( "vtx_angle",  m_vtx_angle );
 
 
//
//      status = m_tuple1->addItem ( "Jpx",  m_Jpx   );
//      status = m_tuple1->addItem ( "Jpy",  m_Jpy   );
//      status = m_tuple1->addItem ( "Jpz",  m_Jpz   );
//      status = m_tuple1->addItem ( "Jpp",  m_Jpp   );
//      status = m_tuple1->addItem ( "m2p",  m_m2p  );
//
//      status = m_tuple1->addItem ( "p1pp",  m_p1pp  );
//      status = m_tuple1->addItem ( "p1px",  m_p1px  );
//      status = m_tuple1->addItem ( "p1py",  m_p1py  );
//      status = m_tuple1->addItem ( "p1pz",  m_p1pz  );
//      status = m_tuple1->addItem ( "p1cos", m_p1cos );
//
//      status = m_tuple1->addItem ( "p2pp", m_p2pp );
//      status = m_tuple1->addItem ( "p2px", m_p2px );
//      status = m_tuple1->addItem ( "p2py", m_p2py );
//      status = m_tuple1->addItem ( "p2pz", m_p2pz );
//      status = m_tuple1->addItem ( "p2cos",m_p2cos);
//
//      status = m_tuple1->addItem ( "angle",  m_angle );
//
    }
    else    { 
      log << MSG::ERROR << "    Cannot book N-tuple:" << long(m_tuple1) << endmsg;
      return StatusCode::FAILURE;
    }
  }
 
  //
  //--------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:

• TestV.h
• TestV.cxx