PPbar Class Reference

#include <PPbar.h>

Inheritance diagram for PPbar:

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

Detailed Description

Definition at line 10 of file PPbar.h.

Constructor & Destructor Documentation

PPbar()

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

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

Referenced by PPbar().

Member Function Documentation

execute()

StatusCode PPbar::execute

(

)

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

Definition at line 345 of file PPbar.cxx.

                          {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "in execute()" << endmsg;
 
  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" << endmsg;
  log << MSG::DEBUG << "ncharg, nneu, tottks = " << evtRecEvent->totalCharged() << " , "
      << evtRecEvent->totalNeutral() << " , " << evtRecEvent->totalTracks() << endmsg;
 
  //
  // 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 << endmsg;
  //
  // 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 = -1;
 
  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 StatusCode::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 " << endmsg;
    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 StatusCode::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 PPbar::finalize

(

)

Definition at line 939 of file PPbar.cxx.

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

(

)

Definition at line 82 of file PPbar.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_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:

• PPbar.h
• PPbar.cxx