Signal Class Reference

#include <Signal.h>

Inheritance diagram for Signal:

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

Detailed Description

Definition at line 10 of file ValidKsKpiAlg/ValidKsKpiAlg-00-01-00/ValidKsKpiAlg/Signal.h.

Constructor & Destructor Documentation

Signal() [1/3]

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

Definition at line 63 of file ValidKsKpiAlg/ValidKsKpiAlg-00-01-00/src/Signal.cxx.

                                                              :
  Algorithm(name, pSvcLocator) {
  
  //Declare the properties  
  declareProperty("Vr0cut", m_vr0cut=5.0);
  declareProperty("Vz0cut", m_vz0cut=20.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("tagKsKpi",  m_tagKsKpi = false);
}

Signal() [2/3]

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

Signal() [3/3]

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

Member Function Documentation

execute() [1/3]

StatusCode Signal::execute

(

)

if(m_pidcode[ii]==3)mdcKalTrk->setPidType(RecMdcKalTrack::kaon); if(m_pidcode[ii]==4)mdcKalTrk->setPidType(RecMdcKalTrack::proton);

Definition at line 400 of file ValidKsKpiAlg/ValidKsKpiAlg-00-01-00/src/Signal.cxx.

                           {
  
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "in execute()" << endreq;
 
  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;
//  cout <<"ncharg, nneu, tottks = " 
//       << evtRecEvent->totalCharged() << " , "
//       << evtRecEvent->totalNeutral() << " , "
//       << evtRecEvent->totalTracks()  << endl ;
 
  counter[0]++;
 
  // 
  // Good charged track selection
  //
  Vint iGood; 
  iGood.clear();
 
  int nCharge = 0;
  Hep3Vector xorigin(0,0,0);
    
  //if (m_reader.isRunNumberValid(runNo)) {
  IVertexDbSvc*  vtxsvc;
  Gaudi::svcLocator()->service("VertexDbSvc", vtxsvc);
  if  (vtxsvc->isVertexValid()){
      double* dbv = vtxsvc->PrimaryVertex(); 
      double*  vv = vtxsvc->SigmaPrimaryVertex();  
      //    HepVector dbv = m_reader.PrimaryVertex(runNo);
      //    HepVector vv = m_reader.SigmaPrimaryVertex(runNo);
      xorigin.setX(dbv[0]);
      xorigin.setY(dbv[1]);
      xorigin.setZ(dbv[2]);
  }
  
  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
  //
  m_ngch = iGood.size();
  if((m_ngch != 4) || (nCharge != 0) ) {  return StatusCode::SUCCESS;  }
  //  std::cout << "ngood, totcharge = " << m_ngch << " , " << nCharge << std::endl;
 
  counter[1]++;
 
  //
  // Particle ID
  // 
  Vint ipip, ipim, ikp, ikm, ipp, ipm;
  ipip.clear();
  ipim.clear();
  ikp.clear();
  ikm.clear();
  ipp.clear();
  ipm.clear();
 
  Vp4 p_pip, p_pim, p_kp, p_km, p_pp, p_pm ;
  p_pip.clear();
  p_pim.clear();
  p_kp.clear();
  p_km.clear();
  p_pp.clear();
  p_pm.clear();
 
  ParticleID *pid = ParticleID::instance();
  for(int i = 0; i < m_ngch; i++) {
    EvtRecTrackIterator itTrk = evtRecTrkCol->begin() + iGood[i]; 
    //    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->usePidSys(pid->useDedx() | pid->useTof1() | pid->useTof2() | pid->useTofE() | pid->useTofQ()); // use PID sub-system
    pid->identify(pid->onlyPionKaonProton());                  // seperater Pion/Kaon/Proton
    //    pid->identify(pid->onlyPion() | pid->onlyKaon());    // seperater Pion/Kaon
    //    pid->identify(pid->onlyPion());
    //    pid->identify(pid->onlyKaon());
    pid->calculate();
    if(!(pid->IsPidInfoValid())) continue;
 
    RecMdcTrack* mdcTrk = (*itTrk)->mdcTrack();
    RecMdcKalTrack* mdcKalTrk = 0 ; 
    if((*itTrk)->isMdcKalTrackValid()) mdcKalTrk = (*itTrk)->mdcKalTrack(); 
 
    double  prob_pi = pid->probPion();
    double  prob_K  = pid->probKaon();
    double  prob_p  = pid->probProton();
    //    std::cout << "prob "<< prob_pi << ", "<< prob_K << ", "<< prob_p << std::endl; 
    HepLorentzVector ptrk;
    ptrk.setPx(mdcTrk->px()) ; 
    ptrk.setPy(mdcTrk->py()) ;
    ptrk.setPz(mdcTrk->pz()) ; 
    double p3 = ptrk.mag()   ; 
    
    if (prob_pi > prob_K && prob_pi > prob_p) {
      m_pidcode[i]=2;
      m_pidprob[i]=pid->prob(2);
      m_pidchiDedx[i]=pid->chiDedx(2);
      m_pidchiTof1[i]=pid->chiTof1(2);
      m_pidchiTof2[i]=pid->chiTof2(2);      
      ptrk.setE(sqrt(p3*p3 + xmass[2]*xmass[2])) ; 
      if(mdcTrk->charge() > 0) {
    ipip.push_back(iGood[i]);
    p_pip.push_back(ptrk);
      }
      if (mdcTrk->charge() < 0) {
    ipim.push_back(iGood[i]);
    p_pim.push_back(ptrk); 
      }
    }
 
    if (prob_K > prob_pi && prob_K > prob_p) {
      m_pidcode[i]=3;
      m_pidprob[i]=pid->prob(3);
      m_pidchiDedx[i]=pid->chiDedx(3);
      m_pidchiTof1[i]=pid->chiTof1(3);
      m_pidchiTof2[i]=pid->chiTof2(3);      
      ptrk.setE(sqrt(p3*p3 + xmass[3]*xmass[3])) ; 
      if(mdcTrk->charge() > 0) {
    ikp.push_back(iGood[i]);
    p_kp.push_back(ptrk);
      }
      if (mdcTrk->charge() < 0) {
    ikm.push_back(iGood[i]);
    p_km.push_back(ptrk); 
      }
    }
 
    if (prob_p > prob_pi && prob_p > prob_K) {
      m_pidcode[i]=4;
      m_pidprob[i]=pid->prob(4);
      m_pidchiDedx[i]=pid->chiDedx(4);
      m_pidchiTof1[i]=pid->chiTof1(4);
      m_pidchiTof2[i]=pid->chiTof2(4);      
      ptrk.setE(sqrt(p3*p3 + xmass[4]*xmass[4])) ; 
      if(mdcTrk->charge() > 0) {
    ipp.push_back(iGood[i]);
    p_pp.push_back(ptrk);
      }
      if (mdcTrk->charge() < 0) {
    ipm.push_back(iGood[i]);
    p_pm.push_back(ptrk); 
      }
    }
  }
  m_npip= ipip.size() ; 
  m_npim= ipim.size() ;
  m_nkp = ikp.size() ; 
  m_nkm = ikm.size() ;
  m_np  = ipp.size() ; 
  m_npb = ipm.size() ;
  
  if ( m_npip*m_npim != 2 )  {  return StatusCode::SUCCESS;  } 
  if ( m_nkp+m_nkm != 1 )  {  return StatusCode::SUCCESS;  }
 
  counter[2]++;
 
  //
  //    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);
 
//  HepPoint3D bvx(0., 0., 0.);
//  HepSymMatrix bEvx(3, 0);
//  bEvx[0][0] = 0.038*0.038;;
//  bEvx[1][1] = 0.00057*0.00057;
//  bEvx[2][2] = 1.5*1.5;
//  VertexParameter bs;
//  bs.setVx(bvx);
//  bs.setEvx(bEvx);
 
  VertexFit *vtxfit_s = VertexFit::instance(); // S second vertex 
  VertexFit *vtxfit_p = VertexFit::instance(); // P primary vertex 
  SecondVertexFit *vtxfit2 = SecondVertexFit::instance();
 
  RecMdcKalTrack *pi1KalTrk, *pi2KalTrk, *pi3KalTrk, *k1KalTrk; 
  RecMdcKalTrack *pipKalTrk, *pimKalTrk, *piKalTrk, *kKalTrk; 
  WTrackParameter wks,vwks; 
 
  double chi_temp = 999.0; 
  double mks_temp = 10.0 ; 
  bool okloop=false; 
  for(unsigned int i1 = 0; i1 < m_npip; i1++) {
    RecMdcKalTrack *pi1KalTrk = (*(evtRecTrkCol->begin()+ipip[i1]))-> mdcKalTrack();
    pi1KalTrk->setPidType(RecMdcKalTrack::pion);
    WTrackParameter wpi1trk(xmass[2], pi1KalTrk->getZHelix(), pi1KalTrk->getZError());
 
    for(unsigned int i2 = 0; i2 < m_npim; i2++) {
      RecMdcKalTrack *pi2KalTrk = (*(evtRecTrkCol->begin()+ipim[i2]))-> mdcKalTrack();
      pi2KalTrk->setPidType(RecMdcKalTrack::pion);
      WTrackParameter wpi2trk(xmass[2], pi2KalTrk->getZHelix(), pi2KalTrk->getZError());
   
      vtxfit_s->init();
      vtxfit_s->AddTrack(0, wpi1trk);
      vtxfit_s->AddTrack(1, wpi2trk);
      vtxfit_s->AddVertex(0, vxpar, 0, 1);
 
      if(!(vtxfit_s->Fit(0))) continue;
      vtxfit_s->BuildVirtualParticle(0);
      m_vfits_chi = vtxfit_s->chisq(0);
      WTrackParameter wkshort = vtxfit_s->wVirtualTrack(0);
      VertexParameter vparks  = vtxfit_s->vpar(0);
 
      m_vfits_vx = (vparks.Vx())[0]; 
      m_vfits_vy = (vparks.Vx())[1]; 
      m_vfits_vz = (vparks.Vx())[2]; 
      m_vfits_vr = sqrt(m_vfits_vx*m_vfits_vx + m_vfits_vy*m_vfits_vy) ;
 
      if ( m_npip == 2 ) {
    int j = i1 ;
    int jj =  ( i1 == 1 ) ? 0 : 1; 
    pi3KalTrk   = (*(evtRecTrkCol->begin()+ipip[jj]))->mdcKalTrack();
    k1KalTrk    = (*(evtRecTrkCol->begin()+ikm[0]))->mdcKalTrack();
      }
      if (m_npim == 2 ) {
    int j = i2 ;
    int jj =  ( i2 == 1 ) ? 0 : 1; 
    pi3KalTrk   = (*(evtRecTrkCol->begin()+ipim[jj]))->mdcKalTrack();
    k1KalTrk    = (*(evtRecTrkCol->begin()+ikp[0]))->mdcKalTrack();
      }
 
      pi3KalTrk->setPidType(RecMdcKalTrack::pion);
      WTrackParameter wpi3trk( xmass[2], pi3KalTrk->getZHelix(), pi3KalTrk->getZError());
      k1KalTrk->setPidType(RecMdcKalTrack::kaon);
      WTrackParameter wk1trk( xmass[3], k1KalTrk->getZHelixK(), k1KalTrk->getZErrorK());
   
      vtxfit_p->init();
//      vtxfit_p->AddTrack(0, wkshort);
      vtxfit_p->AddTrack(0, wpi3trk);
      vtxfit_p->AddTrack(1, wk1trk);
      vtxfit_p->AddVertex(0, vxpar, 0, 1);
      if(!(vtxfit_p->Fit(0))) continue;
 
      m_vfitp_chi = vtxfit_p->chisq(0) ; 
 
      VertexParameter primaryVpar = vtxfit_p->vpar(0);
      m_vfitp_vx = (primaryVpar.Vx())[0]; 
      m_vfitp_vy = (primaryVpar.Vx())[1]; 
      m_vfitp_vz = (primaryVpar.Vx())[2]; 
      m_vfitp_vr = sqrt(m_vfitp_vx*m_vfitp_vx + m_vfitp_vy*m_vfitp_vy); 
 
      vtxfit2->init();
      vtxfit2->setPrimaryVertex(vtxfit_p->vpar(0));
      vtxfit2->AddTrack(0, wkshort);
      vtxfit2->setVpar(vtxfit_s->vpar(0));
      if(!vtxfit2->Fit()) continue;
 
      if ( fabs(((vtxfit2->wpar()).p()).m()-mks0) < mks_temp ) {
    mks_temp = fabs(((vtxfit2->wpar()).p()).m()-mks0) ; 
      
    okloop = true; 
 
    wks = vtxfit2->wpar();
    m_vfit2_mks = (wks.p()).m(); 
    m_vfit2_chi = vtxfit2->chisq();
    m_vfit2_ct  = vtxfit2->ctau();
    m_vfit2_dl  = vtxfit2->decayLength();
    m_vfit2_dle = vtxfit2->decayLengthError();
 
    pipKalTrk = pi1KalTrk ; 
    pimKalTrk = pi2KalTrk ; 
    piKalTrk  = pi3KalTrk ; 
    kKalTrk   = k1KalTrk ; 
 
      }
    }
  }
  
  if (! okloop ) {  return StatusCode::SUCCESS;  }
 
  pipKalTrk->setPidType(RecMdcKalTrack::pion);
  pimKalTrk->setPidType(RecMdcKalTrack::pion);
  piKalTrk->setPidType(RecMdcKalTrack::pion);
  kKalTrk->setPidType(RecMdcKalTrack::kaon);
 
  WTrackParameter wpip(xmass[2], pipKalTrk->getZHelix(), pipKalTrk->getZError()); //pi+ from Ks
  WTrackParameter wpim(xmass[2], pimKalTrk->getZHelix(), pimKalTrk->getZError()); //pi- from Ks 
  WTrackParameter wpi(xmass[2], piKalTrk->getZHelix(), piKalTrk->getZError());
  WTrackParameter wk(xmass[3], kKalTrk->getZHelixK(), kKalTrk->getZErrorK());
 
  counter[3]++;
 
 
  //
  // check good charged track's infomation
  //
  int ii ;
  for(int i = 0; i < m_ngch; i++ ){
 
    EvtRecTrackIterator  itTrk = evtRecTrkCol->begin() + iGood[i];
    if(!(*itTrk)->isMdcTrackValid()) continue;  //  MDC information 
    RecMdcTrack* mdcTrk = (*itTrk)->mdcTrack();
    RecMdcKalTrack *mdcKalTrk = (*itTrk)->mdcKalTrack();
 
    if ( mdcKalTrk == pipKalTrk ) {
      ii = 0 ;
      mdcKalTrk->setPidType(RecMdcKalTrack::pion);
    }
    if ( mdcKalTrk == pimKalTrk ) {
      ii = 1 ;
      mdcKalTrk->setPidType(RecMdcKalTrack::pion);
    }  
    if ( mdcKalTrk == piKalTrk  ) {
      ii = 2 ;
      mdcKalTrk->setPidType(RecMdcKalTrack::pion);
    }  
    if ( mdcKalTrk == kKalTrk   ) {
      ii = 3 ;  
      mdcKalTrk->setPidType(RecMdcKalTrack::pion);
    }
 
    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 ;
    
    x0=mdcKalTrk->x();
    y0=mdcKalTrk->y();
    z0=mdcKalTrk->z();
    rv=(x0-xv)*cos(phi0)+(y0-yv)*sin(phi0);
    
    m_vx[ii] = x0-xv ;
    m_vy[ii] = y0-yv ;
    m_vz[ii] = z0-zv ;
    m_vr[ii] = rv ;
 
    m_px[ii]   = mdcKalTrk->px();
    m_py[ii]   = mdcKalTrk->py();
    m_pz[ii]   = mdcKalTrk->pz();
    m_p[ii]    = mdcKalTrk->p();
    m_cost[ii] = mdcKalTrk->pz()/mdcKalTrk->p();
      
    double ptrk = mdcKalTrk->p() ; 
    if((*itTrk)->isMdcDedxValid()) { // DEDX information 
      RecMdcDedx* dedxTrk = (*itTrk)->mdcDedx();
      m_probPH[ii]= dedxTrk->probPH();
      m_normPH[ii]= dedxTrk->normPH();
      
      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();
    }
      
    if((*itTrk)->isEmcShowerValid()) {
      RecEmcShower *emcTrk = (*itTrk)->emcShower();
      m_e_emc[ii] = emcTrk->energy();
    }
 
    if((*itTrk)->isTofTrackValid()) {  //TOF information
      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_qual_etof[ii]  = qual;
      m_tof_etof[ii]   = tof ; 
    }
        else {//barrel
          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_qual_btof1[ii]  = qual;
        m_tof_btof1[ii]   = tof ; 
          }
 
          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_qual_btof2[ii]  = qual;
        m_tof_btof2[ii]   = tof ; 
          } 
    }
      }
    }
  }
  counter[4]++;
  
 
  //////////
  //
  //  Apply Kinematic 4C fit
  // 
 
  KinematicFit * kmfit = KinematicFit::instance();
 
  if(m_test4C==1) {
    double ecms  = 3.097; 
    double chisq = 9999.;
    m_4c_chi2  = 9999.;
    m_4c_mks   = 10.0;
    m_4c_mkspi = 10.0;
    m_4c_mksk  = 10.0;
    m_4c_mkpi  = 10.0;
    m_4c_ks_px = 10.0;
    m_4c_ks_py = 10.0;
    m_4c_ks_pz = 10.0;
    m_4c_ks_p  = 10.0;
    m_4c_ks_cos= 10.0;
    
    kmfit->init();
    kmfit->AddTrack(0, wpi);
    kmfit->AddTrack(1, wk);
    kmfit->AddTrack(2, wks);
    kmfit->AddFourMomentum(0, p_cms);
    bool oksq = kmfit->Fit();
    if(oksq) {
      chisq = kmfit->chisq(); 
 
      HepLorentzVector pks   = kmfit->pfit(2);
      HepLorentzVector pkspi = kmfit->pfit(0) + kmfit->pfit(2);
      HepLorentzVector pksk  = kmfit->pfit(1) + kmfit->pfit(2);
      HepLorentzVector pkpi  = kmfit->pfit(0) + kmfit->pfit(1);
      
      pks.boost(u_cms); 
      pkspi.boost(u_cms); 
      pksk.boost(u_cms);
      pkpi.boost(u_cms); 
 
      m_4c_chi2  = chisq ; 
      m_4c_mks   = pks.m(); 
      m_4c_mkspi = pkspi.m(); 
      m_4c_mksk  = pksk.m(); 
      m_4c_mkpi  = pkpi.m(); 
      
      m_4c_ks_px = pks.px() ; 
      m_4c_ks_py = pks.py() ; 
      m_4c_ks_pz = pks.pz() ; 
      m_4c_ks_p = (pks.vect()).mag() ;
      m_4c_ks_cos = m_4c_ks_pz/m_4c_ks_p ;
 
    }
 
    chisq = 9999.;
    m_chi2_fs4c  = 9999.;
    m_mks_fs4c   = 10.0;
    m_mkspi_fs4c = 10.0;
    m_mksk_fs4c  = 10.0;
    m_mkpi_fs4c  = 10.0;
 
    kmfit->init();
    kmfit->AddTrack(0, wpip);
    kmfit->AddTrack(1, wpim);
    kmfit->AddTrack(2, wpi);
    kmfit->AddTrack(3, wk);
    kmfit->AddFourMomentum(0, p_cms);
    oksq = kmfit->Fit();
    if(oksq) {
      chisq =  kmfit->chisq();
 
      HepLorentzVector pks = kmfit->pfit(0) + kmfit->pfit(1);
      HepLorentzVector pkspi = pks  + kmfit->pfit(2);
      HepLorentzVector pksk  = pks  + kmfit->pfit(3);
      HepLorentzVector pkpi  = kmfit->pfit(2) + kmfit->pfit(3);
      
      pks.boost(u_cms); 
      pkspi.boost(u_cms); 
      pksk.boost(u_cms);
      pkpi.boost(u_cms); 
      
      m_chi2_fs4c  = chisq ;
      m_mks_fs4c   = pks.m(); 
      m_mkspi_fs4c = pkspi.m(); 
      m_mksk_fs4c  = pksk.m(); 
      m_mkpi_fs4c  = pkpi.m(); 
    }
 
  }
 
  counter[5]++;
  
  if (m_tagKsKpi) {
    m_kskpi_vx_pi1->Fill(m_vx[0]) ; 
    m_kskpi_vy_pi1->Fill(m_vy[0]) ; 
    m_kskpi_vz_pi1->Fill(m_vz[0]) ; 
    m_kskpi_vr_pi1->Fill(m_vr[0]) ; 
    m_kskpi_px_pi1->Fill(m_px[0]) ; 
    m_kskpi_py_pi1->Fill(m_py[0]) ; 
    m_kskpi_pz_pi1->Fill(m_pz[0]) ; 
    m_kskpi_pp_pi1->Fill(m_p[0]) ; 
    m_kskpi_cos_pi1->Fill(m_cost[0]) ; 
    m_kskpi_emc_pi1->Fill(m_e_emc[0]) ; 
 
    m_kskpi_vx_pi2->Fill(m_vx[1]) ; 
    m_kskpi_vy_pi2->Fill(m_vy[1]) ; 
    m_kskpi_vz_pi2->Fill(m_vz[1]) ; 
    m_kskpi_vr_pi2->Fill(m_vr[1]) ; 
    m_kskpi_px_pi2->Fill(m_px[1]) ; 
    m_kskpi_py_pi2->Fill(m_py[1]) ; 
    m_kskpi_pz_pi2->Fill(m_pz[1]) ; 
    m_kskpi_pp_pi2->Fill(m_p[1]) ; 
    m_kskpi_cos_pi2->Fill(m_cost[1]) ; 
    m_kskpi_emc_pi2->Fill(m_e_emc[1]) ; 
 
    m_kskpi_vx_pi->Fill(m_vx[2]) ; 
    m_kskpi_vy_pi->Fill(m_vy[2]) ; 
    m_kskpi_vz_pi->Fill(m_vz[2]) ; 
    m_kskpi_vr_pi->Fill(m_vr[2]) ; 
    m_kskpi_px_pi->Fill(m_px[2]) ; 
    m_kskpi_py_pi->Fill(m_py[2]) ; 
    m_kskpi_pz_pi->Fill(m_pz[2]) ; 
    m_kskpi_pp_pi->Fill(m_p[2]) ; 
    m_kskpi_cos_pi->Fill(m_cost[2]) ; 
    m_kskpi_emc_pi->Fill(m_e_emc[2]) ; 
 
    m_kskpi_vx_k->Fill(m_vx[3]) ; 
    m_kskpi_vy_k->Fill(m_vy[3]) ; 
    m_kskpi_vz_k->Fill(m_vz[3]) ; 
    m_kskpi_vr_k->Fill(m_vr[3]) ; 
    m_kskpi_px_k->Fill(m_px[3]) ; 
    m_kskpi_py_k->Fill(m_py[3]) ; 
    m_kskpi_pz_k->Fill(m_pz[3]) ; 
    m_kskpi_pp_k->Fill(m_p[3]) ; 
    m_kskpi_cos_k->Fill(m_cost[3]) ; 
    m_kskpi_emc_k->Fill(m_e_emc[3]) ; 
 
    
    m_kskpi_pidchidedx_1->Fill(m_pidchiDedx[0]);
    m_kskpi_pidchitof1_1->Fill(m_pidchiTof1[0]);
    m_kskpi_pidchitof2_1->Fill(m_pidchiTof2[0]);
    m_kskpi_pidchidedx_2->Fill(m_pidchiDedx[1]);
    m_kskpi_pidchitof1_2->Fill(m_pidchiTof1[1]);
    m_kskpi_pidchitof2_2->Fill(m_pidchiTof2[1]);
    m_kskpi_pidchidedx_3->Fill(m_pidchiDedx[2]);
    m_kskpi_pidchitof1_3->Fill(m_pidchiTof1[2]);
    m_kskpi_pidchitof2_3->Fill(m_pidchiTof2[2]);
    m_kskpi_pidchidedx_4->Fill(m_pidchiDedx[3]);
    m_kskpi_pidchitof1_4->Fill(m_pidchiTof1[3]);
    m_kskpi_pidchitof2_4->Fill(m_pidchiTof2[3]);
 
 
    m_kskpi_vfits_chi->Fill(m_vfits_chi)  ; 
    m_kskpi_vfits_vx->Fill(m_vfits_vx)  ; 
    m_kskpi_vfits_vy->Fill(m_vfits_vy)  ; 
    m_kskpi_vfits_vz->Fill(m_vfits_vz)  ; 
    m_kskpi_vfits_vr->Fill(m_vfits_vr)  ; 
 
    m_kskpi_vfitp_chi->Fill(m_vfitp_chi)  ; 
    m_kskpi_vfitp_vx->Fill(m_vfitp_vx)  ; 
    m_kskpi_vfitp_vy->Fill(m_vfitp_vy)  ; 
    m_kskpi_vfitp_vz->Fill(m_vfitp_vz)  ; 
    m_kskpi_vfitp_vr->Fill(m_vfitp_vr)  ; 
 
    m_kskpi_vfit2_chi->Fill(m_vfit2_chi)  ;
    m_kskpi_vfit2_mks->Fill(m_vfit2_mks)  ;
    m_kskpi_vfit2_ct->Fill(m_vfit2_ct)  ;
    m_kskpi_vfit2_dl->Fill(m_vfit2_dl)  ;
    m_kskpi_vfit2_dle->Fill(m_vfit2_dle)  ;
   
    m_kskpi_4c_ks_px->Fill(m_4c_ks_px) ; 
    m_kskpi_4c_ks_py->Fill(m_4c_ks_py) ; 
    m_kskpi_4c_ks_pz->Fill(m_4c_ks_pz) ; 
    m_kskpi_4c_ks_p->Fill(m_4c_ks_p)   ; 
    m_kskpi_4c_ks_cos->Fill(m_4c_ks_cos);
      
    m_kskpi_4c_chi->Fill(m_4c_chi2);
    m_kskpi_4c_mks->Fill(m_4c_mks);
    m_kskpi_4c_mksk->Fill(m_4c_mksk);
    m_kskpi_4c_mkspi->Fill(m_4c_mkspi);
    m_kskpi_4c_mkpi->Fill(m_4c_mkpi);
 
  }
 
  m_tuple1 -> write();
 
  return StatusCode::SUCCESS;
}

execute() [2/3]

StatusCode Signal::execute

(

)

execute() [3/3]

StatusCode Signal::execute

(

)

finalize() [1/3]

StatusCode Signal::finalize

(

)

Definition at line 1069 of file ValidKsKpiAlg/ValidKsKpiAlg-00-01-00/src/Signal.cxx.

                            {
 
  MsgStream log(msgSvc(), name());
  log << MSG::INFO << "in finalize()" << endmsg;
 
  std::cout << "************ for Signal *******************" << std::endl;
  std::cout << "*******************************************" << std::endl;
  std::cout << "the total events is          " << counter[0] << std::endl;
  std::cout << "Good charged tracks          " << counter[1] << std::endl;
  std::cout << "particle ID                  " << counter[2] << std::endl;
  std::cout << "resort tracks considering Ks " << counter[3] << std::endl;
  std::cout << "info. for good charged track " << counter[4] << std::endl;
  std::cout << "kinematic fit 4C             " << counter[5] << std::endl;
  std::cout << "kinematic fit 5C             " << counter[6] << std::endl;
  std::cout << "*******************************************" << std::endl;
 
  return StatusCode::SUCCESS;
}

finalize() [2/3]

StatusCode Signal::finalize

(

)

finalize() [3/3]

StatusCode Signal::finalize

(

)

initialize() [1/3]

StatusCode Signal::initialize

(

)

Definition at line 84 of file ValidKsKpiAlg/ValidKsKpiAlg-00-01-00/src/Signal.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_tagKsKpi){
 
     m_kskpi_vx_pi1  = new TH1F( "kskpi_vx_pi1", "kskpi_vx_pi1", 100,-5.0, 5.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vx_pi1", m_kskpi_vx_pi1);
     m_kskpi_vy_pi1  = new TH1F( "kskpi_vy_pi1", "kskpi_vy_pi1", 100,-5.0, 5.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vy_pi1", m_kskpi_vy_pi1);
     m_kskpi_vz_pi1  = new TH1F( "kskpi_vz_pi1", "kskpi_vz_pi1", 100, -20.0, 20.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vz_pi1", m_kskpi_vz_pi1);
     m_kskpi_vr_pi1  = new TH1F( "kskpi_vr_pi1", "kskpi_vr_pi1", 100,0.0, 5.0 );
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vr_pi1", m_kskpi_vr_pi1);
     m_kskpi_px_pi1  = new TH1F( "kskpi_px_pi1", "kskpi_px_pi1", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_px_pi1", m_kskpi_px_pi1);
     m_kskpi_py_pi1  = new TH1F( "kskpi_py_pi1", "kskpi_py_pi1", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_py_pi1", m_kskpi_py_pi1);
     m_kskpi_pz_pi1  = new TH1F( "kskpi_pz_pi1", "kskpi_pz_pi1", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pz_pi1", m_kskpi_pz_pi1);
     m_kskpi_pp_pi1  = new TH1F( "kskpi_pp_pi1", "kskpi_pp_pi1", 100, 0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pp_pi1", m_kskpi_pp_pi1);
     m_kskpi_cos_pi1  = new TH1F( "kskpi_cos_pi1", "kskpi_cos_pi1", 100, -1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_cos_pi1", m_kskpi_cos_pi1);
     m_kskpi_emc_pi1  = new TH1F( "kskpi_emc_pi1", "kskpi_emc_pi1", 100, 0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_emc_pi1", m_kskpi_emc_pi1);
 
     m_kskpi_vx_pi2  = new TH1F( "kskpi_vx_pi2", "kskpi_vx_pi2", 100,-5.0, 5.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vx_pi2", m_kskpi_vx_pi2);
     m_kskpi_vy_pi2  = new TH1F( "kskpi_vy_pi2", "kskpi_vy_pi2", 100,-5.0, 5.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vy_pi2", m_kskpi_vy_pi2);
     m_kskpi_vz_pi2  = new TH1F( "kskpi_vz_pi2", "kskpi_vz_pi2", 100, -20.0, 20.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vz_pi2", m_kskpi_vz_pi2);
     m_kskpi_vr_pi2  = new TH1F( "kskpi_vr_pi2", "kskpi_vr_pi2", 100,0.0, 5.0 );
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vr_pi2", m_kskpi_vr_pi2);
     m_kskpi_px_pi2  = new TH1F( "kskpi_px_pi2", "kskpi_px_pi2", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_px_pi2", m_kskpi_px_pi2);
     m_kskpi_py_pi2  = new TH1F( "kskpi_py_pi2", "kskpi_py_pi2", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_py_pi2", m_kskpi_py_pi2);
     m_kskpi_pz_pi2  = new TH1F( "kskpi_pz_pi2", "kskpi_pz_pi2", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pz_pi2", m_kskpi_pz_pi2);
     m_kskpi_pp_pi2  = new TH1F( "kskpi_pp_pi2", "kskpi_pp_pi2", 100, 0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pp_pi2", m_kskpi_pp_pi2);
     m_kskpi_cos_pi2  = new TH1F( "kskpi_cos_pi2", "kskpi_cos_pi2", 100, -1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_cos_pi2", m_kskpi_cos_pi2);
     m_kskpi_emc_pi2  = new TH1F( "kskpi_emc_pi2", "kskpi_emc_pi2", 100, 0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_emc_pi2", m_kskpi_emc_pi2);
 
     m_kskpi_vx_pi  = new TH1F( "kskpi_vx_pi", "kskpi_vx_pi", 100,-1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vx_pi", m_kskpi_vx_pi);
     m_kskpi_vy_pi  = new TH1F( "kskpi_vy_pi", "kskpi_vy_pi", 100,-1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vy_pi", m_kskpi_vy_pi);
     m_kskpi_vz_pi  = new TH1F( "kskpi_vz_pi", "kskpi_vz_pi", 100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vz_pi", m_kskpi_vz_pi);
     m_kskpi_vr_pi  = new TH1F( "kskpi_vr_pi", "kskpi_vr_pi", 100,0.0, 1.0 );
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vr_pi", m_kskpi_vr_pi);
     m_kskpi_px_pi  = new TH1F( "kskpi_px_pi", "kskpi_px_pi", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_px_pi", m_kskpi_px_pi);
     m_kskpi_py_pi  = new TH1F( "kskpi_py_pi", "kskpi_py_pi", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_py_pi", m_kskpi_py_pi);
     m_kskpi_pz_pi  = new TH1F( "kskpi_pz_pi", "kskpi_pz_pi", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pz_pi", m_kskpi_pz_pi);
     m_kskpi_pp_pi  = new TH1F( "kskpi_pp_pi", "kskpi_pp_pi", 100, 0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pp_pi", m_kskpi_pp_pi);
     m_kskpi_cos_pi  = new TH1F( "kskpi_cos_pi", "kskpi_cos_pi", 100, -1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_cos_pi", m_kskpi_cos_pi);
     m_kskpi_emc_pi  = new TH1F( "kskpi_emc_pi", "kskpi_emc_pi", 100, 0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_emc_pi", m_kskpi_emc_pi);
 
     m_kskpi_vx_k = new TH1F( "kskpi_vx_k", "kskpi_vx_k", 100,-1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vx_k", m_kskpi_vx_k);
     m_kskpi_vy_k = new TH1F( "kskpi_vy_k", "kskpi_vy_k", 100,-1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vy_k", m_kskpi_vy_k);
     m_kskpi_vz_k = new TH1F( "kskpi_vz_k", "kskpi_vz_k", 100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vz_k", m_kskpi_vz_k);
     m_kskpi_vr_k = new TH1F( "kskpi_vr_k", "kskpi_vr_k", 100,0.0, 1.0 );
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vr_k", m_kskpi_vr_k);
     m_kskpi_px_k = new TH1F( "kskpi_px_k", "kskpi_px_k", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_px_k", m_kskpi_px_k);
     m_kskpi_py_k = new TH1F( "kskpi_py_k", "kskpi_py_k", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_py_k", m_kskpi_py_k);
     m_kskpi_pz_k = new TH1F( "kskpi_pz_k", "kskpi_pz_k", 100, -1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pz_k", m_kskpi_pz_k);
     m_kskpi_pp_k = new TH1F( "kskpi_pp_k", "kskpi_pp_k", 100, 0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pp_k", m_kskpi_pp_k);
     m_kskpi_cos_k = new TH1F( "kskpi_cos_k", "kskpi_cos_k", 100, -1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_cos_k", m_kskpi_cos_k);
     m_kskpi_emc_k = new TH1F( "kskpi_emc_k", "kskpi_emc_k", 100, 0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_emc_k", m_kskpi_emc_k);
 
     m_kskpi_pidchidedx_1 = new TH1F( "kskpi_pidchidedx_1", "kskpi_pidchidedx_1", 100, -10.0, 10.0); 
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchidedx_1", m_kskpi_pidchidedx_1);
     m_kskpi_pidchitof1_1 = new TH1F( "kskpi_pidchitof1_1", "kskpi_pidchitof1_1", 100, -10.0, 10.0); 
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchitof1_1", m_kskpi_pidchitof1_1);
     m_kskpi_pidchitof2_1 = new TH1F( "kskpi_pidchitof2_1", "kskpi_pidchitof2_1", 100, -10.0, 10.0); 
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchitof2_1", m_kskpi_pidchitof2_1);
 
     m_kskpi_pidchidedx_2 = new TH1F( "kskpi_pidchidedx_2", "kskpi_pidchidedx_2", 100, -10.0, 10.0); 
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchidedx_2", m_kskpi_pidchidedx_2);
     m_kskpi_pidchitof1_2 = new TH1F( "kskpi_pidchitof1_2", "kskpi_pidchitof1_2", 100, -10.0, 10.0); 
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchitof1_2", m_kskpi_pidchitof1_2);
     m_kskpi_pidchitof2_2 = new TH1F( "kskpi_pidchitof2_2", "kskpi_pidchitof2_2", 100, -10.0, 10.0); 
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchitof2_2", m_kskpi_pidchitof2_2);
 
     m_kskpi_pidchidedx_3 = new TH1F( "kskpi_pidchidedx_3", "kskpi_pidchidedx_3",  100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchidedx_3", m_kskpi_pidchidedx_3);
     m_kskpi_pidchitof1_3 = new TH1F( "kskpi_pidchitof1_3", "kskpi_pidchitof1_3",  100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchitof1_3", m_kskpi_pidchitof1_3);
     m_kskpi_pidchitof2_3 = new TH1F( "kskpi_pidchitof2_3", "kskpi_pidchitof2_3",  100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchitof2_3", m_kskpi_pidchitof2_3);
 
     m_kskpi_pidchidedx_4 = new TH1F( "kskpi_pidchidedx_4", "kskpi_pidchidedx_4",  100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchidedx_4", m_kskpi_pidchidedx_4);
     m_kskpi_pidchitof1_4 = new TH1F( "kskpi_pidchitof1_4", "kskpi_pidchitof1_4",  100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchitof1_4", m_kskpi_pidchitof1_4);
     m_kskpi_pidchitof2_4 = new TH1F( "kskpi_pidchitof2_4", "kskpi_pidchitof2_4",  100, -10.0, 10.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_pidchitof2_4", m_kskpi_pidchitof2_4);
 
     m_kskpi_vfits_chi = new TH1F( "kskpi_vfits_chi", "kskpi_vfits_chi", 100,0.0, 20.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfits_chi", m_kskpi_vfits_chi);
     m_kskpi_vfits_vx = new TH1F( "kskpi_vfits_vx", "kskpi_vfits_vx", 100,-20.0, 20.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfits_vx", m_kskpi_vfits_vx);
     m_kskpi_vfits_vy = new TH1F( "kskpi_vfits_vy", "kskpi_vfits_vy", 100,-20.0, 20.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfits_vy", m_kskpi_vfits_vy);
     m_kskpi_vfits_vz = new TH1F( "kskpi_vfits_vz", "kskpi_vfits_vz", 100,-20.0, 20.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfits_vz", m_kskpi_vfits_vz);
     m_kskpi_vfits_vr = new TH1F( "kskpi_vfits_vr", "kskpi_vfits_vr", 100,0.0, 20.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfits_vr", m_kskpi_vfits_vr);
 
     m_kskpi_vfitp_chi = new TH1F( "kskpi_vfitp_chi", "kskpi_vfitp_chi", 100,0.0, 50.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfitp_chi", m_kskpi_vfitp_chi);
     m_kskpi_vfitp_vx = new TH1F( "kskpi_vfitp_vx", "kskpi_vfitp_vx", 100,-1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfitp_vx", m_kskpi_vfitp_vx);
     m_kskpi_vfitp_vy = new TH1F( "kskpi_vfitp_vy", "kskpi_vfitp_vy", 100,-1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfitp_vy", m_kskpi_vfitp_vy);
     m_kskpi_vfitp_vz = new TH1F( "kskpi_vfitp_vz", "kskpi_vfitp_vz", 100,-5.0, 5.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfitp_vz", m_kskpi_vfitp_vz);
     m_kskpi_vfitp_vr = new TH1F( "kskpi_vfitp_vr", "kskpi_vfitp_vr", 100,0.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfitp_vr", m_kskpi_vfitp_vr);
 
     m_kskpi_vfit2_chi = new TH1F( "kskpi_vfit2_chi", "kskpi_vfit2_chi", 100,0.0, 20.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfit2_chi", m_kskpi_vfit2_chi);
     m_kskpi_vfit2_mks = new TH1F( "kskpi_vfit2_mks", "kskpi_vfit2_mks", 100,0.4, 0.6);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfit2_mks", m_kskpi_vfit2_mks);
     m_kskpi_vfit2_ct = new TH1F( "kskpi_vfit2_ct", "kskpi_vfit2_ct", 100,-3.0, 13.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfit2_ct", m_kskpi_vfit2_ct);
     m_kskpi_vfit2_dl = new TH1F( "kskpi_vfit2_dl", "kskpi_vfit2_dl", 100,-5.0, 25.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfit2_dl", m_kskpi_vfit2_dl);
     m_kskpi_vfit2_dle = new TH1F( "kskpi_vfit2_dle", "kskpi_vfit2_dle", 100,0.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_vfit2_dle", m_kskpi_vfit2_dle);
 
     m_kskpi_4c_chi = new TH1F( "kskpi_4c_chi", "kskpi_4c_chi", 100,0.0, 50);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_chi", m_kskpi_4c_chi);
     m_kskpi_4c_mks = new TH1F( "kskpi_4c_mks", "kskpi_4c_mks", 100,0.4, 0.6);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_mks", m_kskpi_4c_mks);
     m_kskpi_4c_mksk = new TH1F( "kskpi_4c_mksk", "kskpi_4c_mksk", 100,1.0, 3.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_mksk", m_kskpi_4c_mksk);
     m_kskpi_4c_mkspi = new TH1F( "kskpi_4c_mkspi", "kskpi_4c_mkspi", 100,0.6, 2.6);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_mkspi", m_kskpi_4c_mkspi);
     m_kskpi_4c_mkpi = new TH1F( "kskpi_4c_mkpi", "kskpi_4c_mkpi", 100,1.0, 3.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_mkpi", m_kskpi_4c_mkpi);
     m_kskpi_4c_ks_px = new TH1F( "kskpi_4c_ks_px", "kskpi_4c_ks_px", 100,-1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_ks_px", m_kskpi_4c_ks_px);
     m_kskpi_4c_ks_py = new TH1F( "kskpi_4c_ks_py", "kskpi_4c_ks_py", 100,-1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_ks_py", m_kskpi_4c_ks_py);
     m_kskpi_4c_ks_pz = new TH1F( "kskpi_4c_ks_pz", "kskpi_4c_ks_pz", 100,-1.5, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_ks_pz", m_kskpi_4c_ks_pz);
     m_kskpi_4c_ks_p = new TH1F( "kskpi_4c_ks_p", "kskpi_4c_ks_p", 100,0.0, 1.5);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_ks_p", m_kskpi_4c_ks_p);
     m_kskpi_4c_ks_cos = new TH1F( "kskpi_4c_ks_cos", "kskpi_4c_ks_cos", 100,-1.0, 1.0);
     status = m_thistsvc->regHist("/VAL/PHY/kskpi_4c_ks_cos", m_kskpi_4c_ks_cos);
 
  }
 
  NTuplePtr nt1(ntupleSvc(), "FILE1/signal");
  if ( nt1 ) m_tuple1 = nt1;
  else {
    m_tuple1 = ntupleSvc()->book ("FILE1/signal", 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 ("pidcode"  , m_ngch,       m_pidcode);
      status = m_tuple1->addIndexedItem ("pidprob"  , m_ngch,       m_pidprob);
      status = m_tuple1->addIndexedItem ("pidchiDedx"  , m_ngch,       m_pidchiDedx);
      status = m_tuple1->addIndexedItem ("pidchiTof1"  , m_ngch,       m_pidchiTof1);
      status = m_tuple1->addIndexedItem ("pidchiTof2"  , m_ngch,       m_pidchiTof2); 
 
      status = m_tuple1->addItem ( "npip", m_npip );
      status = m_tuple1->addItem ( "npim", m_npim );
      status = m_tuple1->addItem ( "nkp",  m_nkp );
      status = m_tuple1->addItem ( "nkm",  m_nkm );
      status = m_tuple1->addItem ( "np",   m_np   );
      status = m_tuple1->addItem ( "npb",  m_npb  );
 
      status = m_tuple1->addItem ( "vfits_chi"   ,  m_vfits_chi    ); 
      status = m_tuple1->addItem ( "vfits_vx"   ,  m_vfits_vx     ); 
      status = m_tuple1->addItem ( "vfits_vy"   ,  m_vfits_vy     ); 
      status = m_tuple1->addItem ( "vfits_vz"   ,  m_vfits_vz     ); 
      status = m_tuple1->addItem ( "vfits_vr"   ,  m_vfits_vr     ); 
 
      status = m_tuple1->addItem ( "vfitp_chi"   ,  m_vfitp_chi    );
      status = m_tuple1->addItem ( "vfitp_vx"   ,  m_vfitp_vx     ); 
      status = m_tuple1->addItem ( "vfitp_vy"   ,  m_vfitp_vy     ); 
      status = m_tuple1->addItem ( "vfitp_vz"   ,  m_vfitp_vz     ); 
      status = m_tuple1->addItem ( "vfitp_vr"   ,  m_vfitp_vr     ); 
 
      status = m_tuple1->addItem ( "vfit2_chi"   ,  m_vfit2_chi    );
      status = m_tuple1->addItem ( "vfit2_mks"   ,  m_vfit2_mks    );
      status = m_tuple1->addItem ( "vfit2_ct"    ,  m_vfit2_ct     );
      status = m_tuple1->addItem ( "vfit2_dl"    ,  m_vfit2_dl     );
      status = m_tuple1->addItem ( "vfit2_dle"   ,  m_vfit2_dle    );   
 
      status = m_tuple1->addIndexedItem("charge", m_ngch, m_charge);
      status = m_tuple1->addIndexedItem ("vx0",    m_ngch, m_vx0);
      status = m_tuple1->addIndexedItem ("vy0",    m_ngch, m_vy0);
      status = m_tuple1->addIndexedItem ("vz0",    m_ngch, m_vz0);
      status = m_tuple1->addIndexedItem ("vr0",    m_ngch, m_vr0);
 
      status = m_tuple1->addIndexedItem ("vx",    m_ngch, m_vx);
      status = m_tuple1->addIndexedItem ("vy",    m_ngch, m_vy);
      status = m_tuple1->addIndexedItem ("vz",    m_ngch, m_vz);
      status = m_tuple1->addIndexedItem ("vr",    m_ngch, m_vr);
 
      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 ("cost",  m_ngch, m_cost);
 
      status = m_tuple1->addIndexedItem ("probPH" , m_ngch, m_probPH) ;
      status = m_tuple1->addIndexedItem ("normPH" , m_ngch, m_normPH) ;
      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 ("e_emc"   , m_ngch, m_e_emc)   ;
 
      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 ("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 ("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->addItem ( "chi2_fs4c", m_chi2_fs4c);
      status = m_tuple1->addItem ( "mks_fs4c",  m_mks_fs4c);
      status = m_tuple1->addItem ( "mkspi_fs4c",m_mkspi_fs4c);
      status = m_tuple1->addItem ( "mksk_fs4c", m_mksk_fs4c);
      status = m_tuple1->addItem ( "mkpi_fs4c", m_mkpi_fs4c);
 
      status = m_tuple1->addItem ( "4c_chi2",    m_4c_chi2);
      status = m_tuple1->addItem ( "4c_mks",     m_4c_mks);
      status = m_tuple1->addItem ( "4c_mkspi",   m_4c_mkspi);
      status = m_tuple1->addItem ( "4c_mksk",    m_4c_mksk);
      status = m_tuple1->addItem ( "4c_mkpi",    m_4c_mkpi);
      status = m_tuple1->addItem ( "4c_ks_px",   m_4c_ks_px);
      status = m_tuple1->addItem ( "4c_ks_py",   m_4c_ks_py);
      status = m_tuple1->addItem ( "4c_ks_pz",   m_4c_ks_pz);
      status = m_tuple1->addItem ( "4c_ks_p",    m_4c_ks_p);
      status = m_tuple1->addItem ( "4c_ks_cos",  m_4c_ks_cos);
 
 
    }
    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;
 
}

initialize() [2/3]

StatusCode Signal::initialize

(

)

initialize() [3/3]

StatusCode Signal::initialize

(

)

---

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

• ValidKsKpiAlg/ValidKsKpiAlg-00-01-00/ValidKsKpiAlg/Signal.h
• ValidPhyJPsill/ValidPhyJPsill-00-01-00/ValidPhyJPsill/Signal.h
• ValidPPbarAlg/ValidPPbarAlg-00-01-00/ValidPPbarAlg/Signal.h
• ValidKsKpiAlg/ValidKsKpiAlg-00-01-00/src/Signal.cxx
• ValidPhyJPsill/ValidPhyJPsill-00-01-00/src/Signal.cxx