StRoot: StPeCMaker/StPeCEvent.cxx Source File

00001 
00002 //
00003 // $Id: StPeCEvent.cxx,v 1.17 2005/08/24 20:58:00 jeromel Exp $
00004 // $Log: StPeCEvent.cxx,v $
00005 // Revision 1.17  2005/08/24 20:58:00  jeromel
00006 // TClone to TObj fix
00007 //
00008 // Revision 1.16  2003/11/25 01:54:26  meissner
00009 // correct several bugs: eta cut for tracks, charge sorting, add counting of FTPC and TPC primary tracks, Add bbc information
00010 //
00011 // Revision 1.15  2003/09/02 17:58:46  perev
00012 // gcc 3.2 updates + WarnOff
00013 //
00014 // Revision 1.14  2003/03/20 20:10:58  yepes
00015 // double counting of tracks corrected
00016 //
00017 // Revision 1.13  2003/03/18 21:20:28  yepes
00018 // correcting problem with bField
00019 //
00020 // Revision 1.12  2003/02/11 20:45:39  yepes
00021 // Events without a vertex in MuDst should vertex parameters to -9999
00022 //
00023 // Revision 1.11  2003/02/05 17:14:05  yepes
00024 // Adding bField and pPairs.psi to tree
00025 //
00026 // Revision 1.10  2002/12/19 18:09:53  yepes
00027 // MuDST input added
00028 //
00029 // Revision 1.9  2002/03/19 22:23:26  meissner
00030 // New variables: zdc unatt., Trigger word, MC tree if Geant Branch, DCA  for primary pairs, all tracks for secondary pairs (Test)
00031 //
00032 // Revision 1.8  2001/04/23 21:44:30  meissner
00033 // add dEdx z variable to tree, setFormat(1) for tree, use private BetheBloch (temp solution)
00034 //
00035 // Revision 1.7  2001/02/21 20:41:58  yepes
00036 // Add ctb signals to tree
00037 //
00038 // Revision 1.6  2001/02/13 17:54:40  yepes
00039 // still problems on differnt platforms
00040 //
00041 // Revision 1.5  2001/02/12 22:33:51  yepes
00042 // avoid printing
00043 //
00044 // Revision 1.4  2001/02/12 21:15:42  yepes
00045 // New version of StPeCMaker, lots of changes
00046 //
00047 // Revision 1.3  2000/04/24 19:15:27  nystrand
00048 // Fix of a possible memory leak
00049 //
00050 // Revision 1.2  2000/04/21 19:10:30  nystrand
00051 // Include StPeCPair class
00052 //
00053 // Revision 1.1  2000/03/24 22:37:06  nystrand
00054 // First version of StPeCEvent
00055 //
00056 // Revision 1.0  2000/03/20 23:28:50  nystrand
00057 //
00059 // TODO: 
00060 //  Understand what the redifinition of the TClone Array does
00061 //   -> dereferencing the pointer to get  just the array 
00062 //  Place the cut on  track->flag() in a unuque place (Internal track array?)
00063 //  Understand the dublication of StPeCTrack  (does a tree work with pointers)
00064 // ///////////////////////////////////////////////////////////////////
00065 #include <Stiostream.h>
00066 #include "StPeCEvent.h"
00067 #include "StEventTypes.h"
00068 #include "StPeCEnumerations.h"
00069 #include "StMuDSTMaker/COMMON/StMuEvent.h"
00070 #include "StMuDSTMaker/COMMON/StMuTrack.h"
00071 
00072 
00073 ClassImp(StPeCEvent)
00074 
00075 StPeCEvent::StPeCEvent() {
00076   // StPeCMaxTracks ..... looks more like Fortran......
00077   pPairs  = new TClonesArray ("StPeCPair", StPeCnMaxTracks);
00078   sPairs  = new TClonesArray ("StPeCPair", StPeCnMaxTracks);
00079   tracks  = new TClonesArray ("StPeCTrack",StPeCnMaxTracks);
00080   nPPairs  = 0 ;
00081   nSPairs  = 0 ;
00082   nTracks  = 0 ;
00083   eventP   = 0 ;
00084 }
00085 
00086 StPeCEvent::~StPeCEvent() {
00087   clear() ;
00088   delete pPairs ;
00089   delete sPairs ;
00090   delete tracks ;
00091 }
00092 
00093 
00094 void  StPeCEvent::clear ( ) {
00095    eventN = 0 ;
00096    runN   = 0 ;
00097    nTot   = 0 ;
00098    nPrim  = 0 ;
00099    qTot   = 0 ;
00100    pt     = 0 ;
00101    xVertex = 0 ;
00102    yVertex = 0 ;
00103    zVertex = 0 ;
00104    rVertex = 0 ;
00105    nPPairs = 0 ;
00106    nSPairs = 0 ;
00107    nTracks = 0 ;
00108 
00109 
00110    pPairs->Clear();
00111    sPairs->Clear();
00112    tracks->Clear();
00113 }
00114 
00115 // The counting of FTPC tracks is not yet debugged
00116 Int_t StPeCEvent::fill ( StEvent *event ) {
00117   
00118   eventP = event ;
00119 
00120   // Set Run and Event Number
00121   eventN = event->id() ;
00122   runN   = event->runId(); 
00123   cout << "StEvent Run ID: " << runN << endl;
00124   cout << "StEvent ID: " << eventN << endl;
00125 
00126   bField = event->summary()->magneticField();
00127 
00128   //get trigger info
00129 
00130   Int_t   NGlobal=0; 
00131   Int_t   NPrimaries=0; 
00132   Int_t   SumQ=0; 
00133   Float_t SumPx=0.0; 
00134   Float_t SumPy=0.0;  
00135   // separate TPC and FTPC 
00136   nPrimaryTPC=0;
00137   nPrimaryFTPC=0;
00138 
00139   // Get the track nodes
00140   StSPtrVecTrackNode& exnode = event->trackNodes();
00141   Int_t nnode=exnode.size();
00142 
00143   // local pointer array for track needed for cuts
00144   for( Int_t in=0; in<nnode; in++ ) {
00145         UInt_t nprim = exnode[in]->entries(primary);
00146         UInt_t nglob = exnode[in]->entries(global);
00147         
00148         if( nprim>1 || nglob>1 ){
00149            cout<<"There could be a problem! nprim= "<<nprim<<"  nglob= "<<nglob<<endl;
00150            
00151     }
00152     if( nprim==1 ){
00153       StTrack *tp = exnode[in]->track(primary);
00154       // DANGER THAT SHOULD BE DONE IN A PROPPER WAY, CHECK 4 PLACES !
00155       if (! (tp->flag()>0)) continue;
00156       // -----------------------------------------------------------
00157       NPrimaries++;
00158       float px = tp->geometry()->momentum().x();
00159       float py = tp->geometry()->momentum().y();
00160       SumPx = SumPx + px; SumPy = SumPy + py;
00161       SumQ  = SumQ  + tp->geometry()->charge();
00162       // 
00163       // need to dereference the Array pointer first 
00164       //new((*tracks)[nTracks++]) StPeCTrack(1,tp) ;
00165       
00166       if(fabs(tp->geometry()->momentum().pseudoRapidity())<2.0) {
00167         nPrimaryTPC++;
00168       } else {
00169         nPrimaryFTPC++;
00170       }      
00171     }
00172     if( nglob==1 ){
00173       StTrack *tnp = exnode[in]->track(global);
00174       // DANGER THAT SHOULD BE DONE IN A PROPPER WAY, CHECK 4 PLACES !
00175       if (! (tnp->flag()>0)) continue;
00176       if ( tnp->detectorInfo()->numberOfPoints() < 11 ) continue ;
00177       NGlobal++; 
00178 //       Do not store tracks in tree any longer PPY 11/5/02
00179 //    new((*tracks)[nTracks++]) StPeCTrack(0,tnp) ;
00180     }
00181   }
00182   // nGlobals not a good UPC criteria any more 
00183   if ( NGlobal > StPeCnMaxTracks ) return 1 ; 
00184   cout << "Number of primary  TPC  tracks: " << nPrimaryTPC << " FTPC tracks " << nPrimaryFTPC;    
00185   
00186   if (( nPrimaryTPC > 0 ||  nPrimaryFTPC>0 ) &&   // at least one track in either FTPC or TPC
00187       ( nPrimaryTPC < StPeCnMaxTracks && nPrimaryFTPC< StPeCnMaxTracks ) &&( nPrimaryFTPC+nPrimaryTPC>=2 ) ) {
00188     cout << " analyze event !" << endl;
00189   } else {
00190     cout << " reject  event !" << endl;
00191     return 1; 
00192   } 
00193   
00194   nPrim             = NPrimaries ;
00195   nTot              = NGlobal  ;
00196   qTot = SumQ ;
00197   pt   = ::sqrt( SumPx*SumPx + SumPy*SumPy );
00198   
00199   nGlobalTracks=  NPrimaries;
00200   nPrimaryTracks= NGlobal;
00201 
00202   
00203   //cout << "Number of Primary Vertices " << event->numberOfPrimaryVertices() << endl;
00204   StPrimaryVertex* vtx = event->primaryVertex();
00205   if(vtx) {
00206     //cout << "Vertex flag " << vtx->flag() << endl;    
00207     xVertex = vtx->position().x();
00208     yVertex = vtx->position().y();
00209     zVertex = vtx->position().z();
00210     rVertex = ::sqrt(xVertex*xVertex + yVertex*yVertex);
00211     
00212     if ( infoLevel > 1 ) {
00213       cout << "StPeCEvent : primary vertex x:" << xVertex << " y: "  <<  yVertex  << " z: " << zVertex << " r: " << rVertex <<endl;
00214     }
00215   }   else {
00216     xVertex = -9999. ;
00217     yVertex = -9999. ;
00218     zVertex = -9999. ;
00219     rVertex = -9999. ;
00220     cout<<"StPeCEvent: There was no primary vertex!"<<endl;
00221   }
00222  
00223   // HERE  flag must  be tested. 
00224   StPeCPair* lPair ; 
00225   nPPairs = 0 ;
00226   StTrack *trk1, *trk2 ;
00227   for( Int_t i1=0; i1<nnode-1; i1++ ) {
00228      if( exnode[i1]->entries(primary) !=1 ) continue ;
00229      trk1 = exnode[i1]->track(primary);
00230      if ( trk1->detectorInfo()->numberOfPoints() < 11 ) continue ;
00231      for( Int_t i2=i1+1; i2<nnode; i2++ ) {
00232         if( exnode[i2]->entries(primary) !=1 ) continue ;
00233         trk2 = exnode[i2]->track(primary);
00234         if ( trk2->detectorInfo()->numberOfPoints() < 11 ) continue ;
00235         // DANGER 
00236         if (! (trk1->flag()>0)) continue;
00237         if (! (trk2->flag()>0)) continue;
00238         // --------
00239         // get pointer to memebr ?
00240         // TClonesArray &ppairs = *pPairs;
00241         // lPair = new(ppairs[nPPairs++]) StPeCPair(trk1,trk2,1,event) ;
00242         lPair = new((*pPairs)[nPPairs++]) StPeCPair(trk1,trk2,1,event) ;
00243 #ifdef PECPRINT
00244         cout << "StPeCEvent : Primary Pair : " 
00245            << "  sumQ = " << lPair->getSumCharge()
00246            << "  sumPt = " << lPair->getSumPt()
00247            << "  mInv = " << lPair->getMInv(pion)
00248            << "  opening angle = " << lPair->getOpeningAngle()
00249            << "  cos(theta*) = " << lPair->getCosThetaStar(pion) << endl;
00250 #endif     
00251      }
00252   }
00253 
00254 #ifdef SPAIRS
00255   //
00256   //   Look for V0
00257   //   Do not skip the primaries here for the time being.....
00258   // 
00259   // HERE must flag be tested. 
00260   for( Int_t i=0; i<nnode-1; i++ ) {
00261     // if ( exnode[i]->entries(primary)  ) continue ; 
00262     if ( exnode[i]->entries(global)  !=1 ) continue ;
00263     for( Int_t j=i+1; j<nnode; j++ ) {
00264       //if ( exnode[j]->entries(primary)     ) continue ; 
00265       if ( exnode[j]->entries(global)  !=1 ) continue ;
00266       StTrack *trk1 = exnode[i]->track(global);
00267       StTrack *trk2 = exnode[j]->track(global);
00268       
00269       // DANGER 
00270       if (! (trk1->flag()>0)) continue;
00271       if (! (trk2->flag()>0)) continue;
00272       // --------
00273       StPhysicalHelixD h1 = trk1->geometry()->helix() ;
00274       StPhysicalHelixD h2 = trk2->geometry()->helix() ;
00275       
00276        pairD dcaLengths = h1.pathLengths(h2);
00277        StThreeVectorD x1 = h1.at(dcaLengths.first);
00278        StThreeVectorD x2 = h2.at(dcaLengths.second);
00279        StThreeVectorD x = (x1-x2) ;
00280         if ( x.mag() > 10 ) continue ; // Hardwire cut
00281 
00282         // TClonesArray &spairs = *sPairs;
00283         // lPair = new(spairs[nSPairs++]) StPeCPair(trk1,trk2,0,event) ;
00284         // 
00285         lPair = new((*sPairs)[nSPairs++]) StPeCPair(trk1,trk2,0,event) ;
00286 #ifdef PECPRINT
00287         cout << "StPeCEvent : Secondary Pair : " 
00288            << "  sumQ = " << lPair->getSumCharge()
00289            << "  sumPt = " << lPair->getSumPt()
00290            << "  mInv = " << lPair->getMInv(pion)
00291            << "  opening angle = " << lPair->getOpeningAngle()
00292            << "  cos(theta*) = " << lPair->getCosThetaStar(pion) << endl;
00293 #endif     
00294      }
00295   }
00296 #endif
00297   return 0 ;
00298 }
00299 
00300 //===========================================================================================
00301 Int_t StPeCEvent::fill(StMuDst *mudst) {
00302    //cout << "Entering StPeCEvent::fill(StMuDst *mudst)" << endl;
00303   // Int_t nGlobals = 0, SumQ = 0; 
00304   // Float_t SumPx = 0.0, SumPy = 0.0;  
00305   // float px, py;
00306   TObjArray* muTracks = 0;
00307   StMuEvent* event = 0;
00308   StMuTrack *tp = 0;
00309   
00310    //Save the event reference
00311    muDst = mudst;
00312    event = muDst->event();
00313 
00314    //Set Run and Event Number
00315    eventN = event->eventInfo().id();
00316    
00317    runN = event->eventInfo().runId(); 
00318    cout << "StMuEvent Run ID: " << runN << endl;
00319    cout << "StMuEvent ID: " << eventN << endl;
00320    
00321    bField = event->eventSummary().magneticField();
00322    
00323    // number of vertices not a good number anymore ! FLK 07/03
00324    // if ( event->eventSummary().numberOfVertices() ) {
00325    
00326    StThreeVectorF vtx = event->primaryVertexPosition();
00327    // vertex is set to 0,0,0 of no prim vertex found  FLK 07/03
00328    if(vtx.x() !=0 && vtx.y()!=0 && vtx.z()!=0) {
00329      xVertex = vtx.x();
00330      yVertex = vtx.y();
00331      zVertex = vtx.z();
00332      rVertex = ::sqrt(xVertex*xVertex + yVertex*yVertex);
00333    }
00334    else {
00335      xVertex = -9999.;
00336      yVertex = -9999.;
00337      zVertex = -9999.;
00338      rVertex = -9999.;
00339    }
00340    
00341    // directly from StEvent Summary 
00342    nGlobalTracks= event->eventSummary().numberOfGoodTracks();
00343    nPrimaryTracks= event->eventSummary().numberOfGoodPrimaryTracks();
00344    nPrimaryTPC=0;
00345    nPrimaryFTPC=0;
00346    
00347    //Retrieve the primary tracks
00348    muTracks = muDst->primaryTracks();
00349    // nPrim    = muTracks->GetLast() + 1; // this ignores quality check FLK
00350    // backwards compatibility, FLK
00351    nPrim    = nPrimaryTracks; 
00352    nTot     = nGlobalTracks;
00353    
00354    for(int i = 0; i <= muTracks->GetLast(); i++) {
00355      tp = (StMuTrack*)muTracks->UncheckedAt(i);
00356      if (! (tp->flag()>0)) continue; // Quality check on the track
00357      
00358      // in 2003 this doesnt tell much anymore with the FTPC tracks....FLK
00359      // cout << "id " << i << " mom.x " <<  tp->momentum().x() << " mom.y "<< tp->momentum().y() << endl;
00360      //    px = tp->momentum().x();
00361      //    py = tp->momentum().y();
00362      //    SumPx += px;
00363      //    SumPy += py;
00364      //    SumQ += tp->charge();
00365      
00366      if(fabs(tp->eta())<2.0) {
00367        nPrimaryTPC++;
00368      } else {
00369        nPrimaryFTPC++;
00370      }
00371      
00372      // do not fill track list for now to save space 
00373      // nTracks should be the same as nPrim afterwards
00374      // new((*tracks)[nTracks++])StPeCTrack(0, tp);
00375    }
00376 
00377    // We do not fill track list, so can skip this loop FLK 11/03
00378    //    //Retrieve the global tracks
00379    //    muTracks = muDst->globalTracks();
00380    //    for(int i = 0; i <= muTracks->GetLast(); i++) {
00381    //       tp = (StMuTrack*)muTracks->UncheckedAt(i);
00382    //       if ( tp->nHits() < 11 ) continue ;
00383    // // No track structure: trying to make trees smaller
00384    // //    new((*tracks)[i])StPeCTrack(0, tp);
00385    //       nGlobals++;
00386    //    }
00387    // nTot = nGlobals ;  get this from above 
00388    // qTot = SumQ;
00389    // pt = sqrt(SumPx * SumPx + SumPy * SumPy );
00390    
00391    // nGlobals not a goof UPC criteria any more 
00392    // if ( nGlobals > StPeCnMaxTracks ) return 1 ; 
00393    cout << "Number of primary  TPC  tracks: " << nPrimaryTPC << " FTPC tracks " << nPrimaryFTPC;    
00394    
00395    if (( nPrimaryTPC > 0 ||  nPrimaryFTPC>0 ) &&   // at least one track in either FTPC or TPC
00396        ( nPrimaryTPC < StPeCnMaxTracks && nPrimaryFTPC< StPeCnMaxTracks )&& (nPrimaryFTPC+nPrimaryTPC>=2)) {
00397      cout << " analyze event !" << endl;
00398    } else {
00399      cout << " reject  event !" << endl;
00400      return 1; 
00401    } 
00402        
00403    nPPairs = 0 ;
00404    StPeCPair* lPair ; 
00405    StMuTrack *trk1, *trk2 ;
00406    muTracks = muDst->primaryTracks();
00407    for(int i1 = 0; i1  <= muTracks->GetLast(); i1++) {
00408      trk1 = (StMuTrack*)muTracks->UncheckedAt(i1);
00409      for(int i2 = i1+1; i2  <= muTracks->GetLast(); i2++) {
00410        trk2 = (StMuTrack*)muTracks->UncheckedAt(i2);
00411        // cout << " id1 " << i1 << " p_x " << trk1->momentum().x() << endl;
00412        // cout << " id2 " << i2 << " p_x " << trk2->momentum().x() << endl;
00413        
00414        // DANGER 
00415        if (! (trk1->flag()>0)) continue;
00416        if (! (trk2->flag()>0)) continue;
00417        // --------
00418        // get pointer to memebr ?
00419        // TClonesArray &ppairs = *pPairs;
00420        lPair = new((*pPairs)[nPPairs++]) StPeCPair(trk1,trk2,1,event) ;
00421 #ifdef PECPRINT
00422        cout << "StPeCEvent : Primary Pair : " 
00423             << "  sumQ = " << lPair->getSumCharge()
00424             << "  sumPt = " << lPair->getSumPt()
00425             << "  mInv = " << lPair->getMInv(pion)
00426             << "  opening angle = " << lPair->getOpeningAngle()
00427             << "  cos(theta*) = " << lPair->getCosThetaStar(pion) << endl;
00428 #endif     
00429       }
00430    }
00431    
00432 #ifdef SPAIRS
00433    // HERE  flag must  be tested. 
00434    nSPairs = 0 ;
00435    StMuTrack *muTrk1, *muTrk2 ;
00436    muTracks = muDst->globalTracks();
00437 
00438    for(int i1 = 0; i1 < nTot; i1++) {
00439      muTrk1 = (StMuTrack*)muTracks->UncheckedAt(i1);
00440      for(int i2 = i1+1; i2 < nTot; i2++) {
00441        muTrk2 = (StMuTrack*)muTracks->UncheckedAt(i2);
00442          // DANGER 
00443        if (! (muTrk1->flag()>0)) continue;
00444        if (! (muTrk2->flag()>0)) continue;
00445        // --------
00446        // get pointer to memebr ?
00447        // TClonesArray &ppairs = *pPairs;
00448        lPair = new((*sPairs)[nSPairs++]) StPeCPair(muTrk1,muTrk2,0,event) ;
00449 #ifdef PECPRINT
00450        cout << "StPeCEvent : Primary Pair : " 
00451             << "  sumQ = " << lPair->getSumCharge()
00452             << "  sumPt = " << lPair->getSumPt()
00453             << "  mInv = " << lPair->getMInv(pion)
00454             << "  opening angle = " << lPair->getOpeningAngle()
00455             << "  cos(theta*) = " << lPair->getCosThetaStar(pion) << endl;
00456 #endif     
00457      }
00458    }
00459 #endif
00460    //cout << "Exiting StPeCEvent::fill(StMuDst *mudst)" << endl;
00461    return 0;
00462 }
00463 
00464 StPeCPair* StPeCEvent::getPriPair ( Int_t i ) {
00465    if ( i < 0 || i >= nPPairs ) return 0 ;
00466    TClonesArray &pairs = *pPairs;
00467    return (StPeCPair *)pairs[i] ;
00468 }
00469 
00470 StPeCPair* StPeCEvent::getSecPair ( Int_t i ) {
00471    if ( i < 0 || i >= nSPairs ) return 0 ;
00472    TClonesArray &pairs = *sPairs;
00473    return (StPeCPair *)pairs[i] ;
00474 }
00475 
00476 void StPeCEvent::reset() { 
00477    delete pPairs ;
00478    delete sPairs ;
00479    delete tracks ;
00480    pPairs  = 0 ;
00481    sPairs  = 0 ;
00482    nPPairs  = 0 ;
00483    nSPairs  = 0 ;
00484    tracks = 0 ;
00485    nTracks = 0 ;
00486 }
00487 
00488 Long_t  StPeCEvent::eventNumber() const{ return eventN; }
00489 Long_t  StPeCEvent::runNumber() const{ return runN; }
00490 Int_t   StPeCEvent::getNTot() const{ return nTot; }
00491 Int_t   StPeCEvent::getNPrim() const{ return nPrim; }
00492 Int_t   StPeCEvent::getQTot() const{ return qTot; }
00493 Float_t StPeCEvent::getPt() const{ return pt; }
00494 Float_t StPeCEvent::getXVertex() const{ return xVertex; }
00495 Float_t StPeCEvent::getYVertex() const{ return yVertex; }
00496 Float_t StPeCEvent::getZVertex() const{ return zVertex; }
00497 #ifndef __CINT__
00498 
00499 
00500 StLorentzVectorF StPeCEvent::getEvent4Momentum(StPeCSpecies pid) const{
00501   Float_t mptcle=0.0;
00502   if(pid==pion){
00503     mptcle = pion_plus_mass_c2;
00504   }
00505   if(pid==kaon){
00506     mptcle = 493.677*MeV;
00507   }
00508   if(pid==proton){
00509     mptcle = proton_mass_c2;
00510   }
00511   if(pid==electron){
00512     mptcle = electron_mass_c2;
00513   }
00514   if(pid==muon){
00515     mptcle = 105.6584*MeV; 
00516   }
00517   StLorentzVectorF p4event(0.0,0.0,0.0,0.0);
00518 
00519   StSPtrVecTrackNode& exnode = eventP->trackNodes();
00520   if ( !eventP ) {
00521      printf ( "StPeCEvent::getEvent4Momentum eventP null \n" ) ;
00522      return p4event ;
00523   }
00524   Int_t nnode=exnode.size();
00525 
00526   for( Int_t in=0; in<nnode; in++ ) {
00527     if( exnode[in]->entries(global) != 1 ) continue ;
00528     StTrack* trk = exnode[in]->track(primary);
00529     StThreeVectorF p = trk->geometry()->momentum();
00530     Float_t energy = p.massHypothesis(mptcle);
00531     StLorentzVectorF pfour(energy,p);
00532     p4event = p4event + pfour;
00533   }
00534 
00535   return p4event;
00536 }
00537 #endif /*__CINT__*/
00538 
00539 Float_t StPeCEvent::mInv(StPeCSpecies pid) const{
00540 
00541   StLorentzVectorF p4event = getEvent4Momentum(pid);
00542 
00543   return p4event.m();
00544 }
00545 
00546 Float_t StPeCEvent::yRap(StPeCSpecies pid) const{
00547  
00548 
00549   StLorentzVectorF p4event = getEvent4Momentum(pid);
00550 
00551   return p4event.rapidity();
00552 }
00553