KsKpi Class Reference

#include <KsKpi.h>

Inheritance diagram for KsKpi:

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

Detailed Description

Definition at line 9 of file KsKpi.h.

Constructor & Destructor Documentation

KsKpi()

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

Definition at line 61 of file KsKpi.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 );
}

Referenced by KsKpi().

Member Function Documentation

execute()

StatusCode KsKpi::execute

(

)

Definition at line 409 of file KsKpi.cxx.

                          {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in execute()" << endmsg;
 
  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" << endmsg;
  //  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 = nullptr, *pi2KalTrk = nullptr, *pi3KalTrk = nullptr, *k1KalTrk = nullptr;
  RecMdcKalTrack *pipKalTrk = nullptr, *pimKalTrk = nullptr, *piKalTrk = nullptr, *kKalTrk = nullptr;
  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 = -1;
  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;
}

finalize()

StatusCode KsKpi::finalize

(

)

Definition at line 1109 of file KsKpi.cxx.

                           {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in finalize()" << endmsg;
 
  std::cout << "************ for KsKpi *******************" << 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;
}

initialize()

StatusCode KsKpi::initialize

(

)

Definition at line 82 of file KsKpi.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" << endmsg;
    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;
}

---

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

• KsKpi.h
• KsKpi.cxx