StRoot: StEmcUtil/projection/StEmcPosition.cxx Source File

00001 //******************************************************************************
00002 //                                                                            
00003 // StEmcPosition.cxx
00004 //
00005 // Authors: Marcia Maria de Moura
00006 //
00007 // Initial version: 2001/12/21
00008 //
00009 //******************************************************************************
00010 
00011 #include "StEmcPosition.h"
00012 #include <math.h>
00013 #include "SystemOfUnits.h"
00014 #include "PhysicalConstants.h"
00015 #include "StPhysicalHelixD.hh"
00016 
00017 #include "StMcEvent.hh"
00018 #include "StMcEventTypes.hh"
00019 #include "StMcEventMaker/StMcEventMaker.h"
00020 #include "StEvent.h"
00021 #include "StEventTypes.h"
00022 #include "StEmcUtil/geometry/StEmcGeom.h"
00023 
00024 //StMuDstMaker:
00025 #include "StMuDSTMaker/COMMON/StMuTrack.h"
00026 
00027 ClassImp(StEmcPosition)
00028 
00029 //------------------------------------------------------------------------------
00030 StEmcPosition::StEmcPosition():TObject()
00031 {  
00032   mGeom[0] = StEmcGeom::getEmcGeom("bemc");  
00033   mGeom[1] = StEmcGeom::getEmcGeom("bprs");  
00034   mGeom[2] = StEmcGeom::getEmcGeom("bsmde");  
00035   mGeom[3] = StEmcGeom::getEmcGeom("bsmdp");  
00036 }
00037 //------------------------------------------------------------------------------
00038 StEmcPosition::~StEmcPosition()
00039 {
00040 }
00041 //------------------------------------------------------------------------------
00042 Bool_t StEmcPosition::projTrack(StThreeVectorD* atFinal, StThreeVectorD* momentumAtFinal, 
00043                                                                 const StMuTrack* const track, double magField, double radius, int option) const
00044 {
00045     StThreeVectorD Zero(0,0,0);
00046     *atFinal=Zero;
00047     *momentumAtFinal=Zero;
00048         
00049     /* this was for StTrack
00050                 const StThreeVectorF& origin = track->geometry()->origin();
00051         const StThreeVectorF& momentum = track->geometry()->momentum();
00052         double charge = track->geometry()->charge();
00053         StPhysicalHelixD helix(momentum, origin, magField*tesla, charge);
00054     */
00055     StPhysicalHelixD helix = track->outerHelix();
00056     const StThreeVectorF momentum = track->momentum();
00057     pairD pathLength = helix.pathLength(radius);
00058     double charge = track->charge();
00059         
00060     double s,s1,s2; 
00061     s=0;
00062     s1 = pathLength.first;
00063     s2 = pathLength.second;
00064         
00065     Bool_t goProj;
00066     goProj = kFALSE;
00067         
00068     if (finite(s1) == 0 && finite(s2) == 0) { return kFALSE;} // Track couldn't be projected!
00069         
00070     if (option == 1)  // Selects positive path lenght to project track forwards along its helix relative to
00071                                           // first point of track. The smaller solution is taken when both are positive
00072         {
00073             if (s1 >= 0 && s2 >= 0) {s = s1; goProj = kTRUE; }
00074             if (s1 >= 0 && s2 < 0) { s = s1; goProj = kTRUE; }
00075             if (s1 < 0 && s2 >= 0) { s = s2; goProj = kTRUE; }
00076         }
00077         
00078     if (option == -1) // Selects negative path lenght to project track backwards along its helix relative to
00079                                           // first point of track. The smaller absolute solution is taken when both are negative 
00080         {
00081             if (s1 <= 0 && s2 <= 0) { s = s2; goProj = kTRUE; }
00082             if (s1 <= 0 && s2 > 0) { s = s1; goProj = kTRUE; }
00083             if (s1 > 0 && s2 <= 0) { s = s2; goProj = kTRUE; }
00084         }
00085         
00086     if (goProj) 
00087         {
00088             *atFinal = helix.at( s );
00089             *momentumAtFinal = helix.momentumAt( s, magField*tesla );
00090             if (charge == 0) *momentumAtFinal = momentum;
00091         }
00092     return goProj;
00093 }
00094 //------------------------------------------------------------------------------
00095 Bool_t StEmcPosition::projTrack(StThreeVectorD* atFinal, StThreeVectorD* momentumAtFinal, 
00096                             const StPhysicalHelixD* const helix, Double_t magField, Double_t radius, Int_t option) const
00097 {
00098   StThreeVectorD Zero(0,0,0);
00099   *atFinal=Zero;
00100   *momentumAtFinal=Zero;
00101 
00102   pairD pathLength = helix->pathLength(radius);
00103 
00104   Double_t s,s1,s2; 
00105   s=0;
00106   s1 = pathLength.first;
00107   s2 = pathLength.second;
00108 
00109   Bool_t goProj;
00110   goProj = kFALSE;
00111 
00112   if (finite(s1) == 0 && finite(s2) == 0) { return kFALSE;} // Track couldn't be projected!
00113 
00114   if (option == 1)  // Selects positive path lenght to project track forwards along its helix relative to
00115                     // first point of track. The smaller solution is taken when both are positive
00116   {
00117     if (s1 >= 0 && s2 >= 0) {s = s1; goProj = kTRUE; }
00118     if (s1 >= 0 && s2 < 0) { s = s1; goProj = kTRUE; }
00119     if (s1 < 0 && s2 >= 0) { s = s2; goProj = kTRUE; }
00120   }
00121   
00122   if (option == -1) // Selects negative path lenght to project track backwards along its helix relative to
00123                     // first point of track. The smaller absolute solution is taken when both are negative 
00124   {
00125     if (s1 <= 0 && s2 <= 0) { s = s2; goProj = kTRUE; }
00126     if (s1 <= 0 && s2 > 0) { s = s1; goProj = kTRUE; }
00127     if (s1 > 0 && s2 <= 0) { s = s2; goProj = kTRUE; }
00128   }
00129         
00130   if (goProj) 
00131   {
00132     *atFinal = helix->at( s );
00133     *momentumAtFinal = helix->momentumAt( s, magField*tesla );
00134   }
00135   return goProj;
00136 }
00137 
00138 //------------------------------------------------------------------------------
00139 Bool_t StEmcPosition::projTrack(StThreeVectorD* atFinal, StThreeVectorD* momentumAtFinal, 
00140                             const StTrack* const track, Double_t magField, Double_t radius, Int_t option) const 
00141 {
00142   StThreeVectorD Zero(0,0,0);
00143   *atFinal=Zero;
00144   *momentumAtFinal=Zero;
00145 
00146   const StThreeVectorF& origin = track->outerGeometry()->origin();
00147   const StThreeVectorF& momentum = track->outerGeometry()->momentum();
00148   Double_t charge = track->outerGeometry()->charge();
00149   StPhysicalHelixD helix(momentum, origin, magField*tesla, charge);
00150   pairD pathLength = helix.pathLength(radius);
00151 
00152   Double_t s,s1,s2; 
00153   s=0;
00154   s1 = pathLength.first;
00155   s2 = pathLength.second;
00156 
00157   Bool_t goProj;
00158   goProj = kFALSE;
00159 
00160   if (finite(s1) == 0 && finite(s2) == 0) { return kFALSE;} // Track couldn't be projected!
00161 
00162   if (option == 1)  // Selects positive path lenght to project track forwards along its helix relative to
00163                     // first point of track. The smaller solution is taken when both are positive
00164   {
00165     if (s1 >= 0 && s2 >= 0) {s = s1; goProj = kTRUE; }
00166     if (s1 >= 0 && s2 < 0) { s = s1; goProj = kTRUE; }
00167     if (s1 < 0 && s2 >= 0) { s = s2; goProj = kTRUE; }
00168   }
00169   
00170   if (option == -1) // Selects negative path lenght to project track backwards along its helix relative to
00171                     // first point of track. The smaller absolute solution is taken when both are negative 
00172   {
00173     if (s1 <= 0 && s2 <= 0) { s = s2; goProj = kTRUE; }
00174     if (s1 <= 0 && s2 > 0) { s = s1; goProj = kTRUE; }
00175     if (s1 > 0 && s2 <= 0) { s = s2; goProj = kTRUE; }
00176   }
00177         
00178   if (goProj) 
00179   {
00180     *atFinal = helix.at( s );
00181     *momentumAtFinal = helix.momentumAt( s, magField*tesla );
00182     if (charge == 0) *momentumAtFinal = momentum;
00183   }
00184   return goProj;
00185 }
00186 //------------------------------------------------------------------------------
00187 Bool_t StEmcPosition::projTrack(StThreeVectorD* atFinal, StThreeVectorD* momentumAtFinal, 
00188                             const StMcTrack* const mcTrack, Double_t magField, Double_t radius, Int_t option) const 
00189 {
00190   StThreeVectorD Zero(0,0,0);
00191   *atFinal=Zero;
00192   *momentumAtFinal=Zero;
00193 
00194   const StThreeVectorF& origin = mcTrack->startVertex()->position();
00195   const StThreeVectorF& momentum = mcTrack->momentum();
00196   Double_t charge = mcTrack->particleDefinition()->charge();
00197   StPhysicalHelixD helix(momentum, origin, magField*tesla, charge);
00198   pairD pathLength = helix.pathLength(radius);
00199 
00200   Double_t s,s1,s2;  
00201   s=0;
00202   s1 = pathLength.first;
00203   s2 = pathLength.second;
00204 
00205   Bool_t goProj;
00206   goProj = kFALSE;
00207 
00208   if (finite(s1) == 0 && finite(s2) == 0) { return kFALSE;} // Track couldn't be projected!
00209 
00210   if (option == 1)  // Selects positive path lenght to project track forwards along its helix relative to
00211                     // first point of track. The smaller solution is taken when both are positive
00212   {                 
00213     if (s1 >= 0 && s2 >= 0) { s = s1; goProj = kTRUE; }
00214     if (s1 >= 0 && s2 < 0) { s = s1; goProj = kTRUE; }
00215     if (s1 < 0 && s2 >= 0) { s = s2; goProj = kTRUE; }
00216   }
00217 
00218   if (option == -1) // Selects negative path lenght to project track backwards along its helix relative to
00219                     // first point of track. The smaller absolute solution is taken when both are negative 
00220   {
00221     if (s1 <= 0 && s2 <= 0) { s = s2; goProj = kTRUE; }
00222     if (s1 <= 0 && s2 > 0) { s = s1; goProj = kTRUE; }
00223     if (s1 > 0 && s2 <= 0) { s = s2; goProj = kTRUE; }
00224   }
00225 
00226         if (goProj) 
00227   {
00228     *atFinal = helix.at( s );
00229     *momentumAtFinal = helix.momentumAt( s, magField*tesla );
00230     if (charge == 0) *momentumAtFinal = momentum;
00231   }
00232   return goProj;
00233 }
00234 //------------------------------------------------------------------------------
00235 Bool_t StEmcPosition::trackOnEmc( StThreeVectorD* position, StThreeVectorD* momentum, const StMuTrack* const track, double magField, double emcRadius ) const
00236 {  
00237     // There's no check for primary or secondary tracks
00238         
00239     /* this was for StTrack
00240         if (!track->geometry()) return kFALSE;  
00241         const StThreeVectorD& origin = track->geometry()->origin();
00242     */
00243     StPhysicalHelixD helix = track->outerHelix();
00244     const StThreeVectorD& origin = helix.origin();
00245         
00246     
00247     float xO = origin.x();
00248     float yO = origin.y();
00249     float distToOrigin = ::sqrt( ::pow(xO, 2) + ::pow(yO, 2) );    
00250     if ( distToOrigin < emcRadius )
00251         {
00252                 //              LOG_DEBUG << "inside emcRadius" << endm;
00253             Bool_t projTrackOk = projTrack( position, momentum, track, magField, emcRadius );
00254             if ( projTrackOk )  
00255                 {
00256                         //                      LOG_DEBUG << "projTrackOk==1" << endm;
00257                     int m = 0, e = 0, s = 0;
00258                     float phi = position->phi();
00259                     float eta = position->pseudoRapidity();
00260                         //                      LOG_DEBUG << "eta,phi = "<<eta<<","<<phi<<endm;
00261                         //                      LOG_DEBUG << mGeom[0]->getBin(phi, eta, m, e, s) << endm;
00262                         //                      LOG_DEBUG <<"m:e:s = "<<m<<":"<<e<<":"<<s<<endm;
00263                     if ( mGeom[0]->getBin(phi, eta, m, e, s) == 0  && s != -1 ) return kTRUE;      
00264                 }
00265         } 
00266         
00267     return kFALSE;
00268 }
00269 //------------------------------------------------------------------------------
00270 Bool_t StEmcPosition::trackOnEmc( StThreeVectorD* position, StThreeVectorD* momentum,
00271                             const StTrack* const track, Double_t magField, Double_t emcRadius ) const
00272 {  
00273   // There's no check for primary or secondary tracks
00274   
00275   if (!track->outerGeometry()) return kFALSE;  
00276 
00277   const StThreeVectorD& origin = track->outerGeometry()->origin();
00278   Float_t xO = origin.x();
00279   Float_t yO = origin.y();
00280   Float_t distToOrigin = ::sqrt( ::pow(xO, 2) + ::pow(yO, 2) );    
00281   if ( distToOrigin < emcRadius )
00282   {
00283     Bool_t projTrackOk = projTrack( position, momentum, track, magField, emcRadius );
00284     if ( projTrackOk )  
00285     {
00286       Int_t m = 0, e = 0, s = 0;
00287       Float_t phi = position->phi();
00288       Float_t eta = position->pseudoRapidity();
00289       if ( mGeom[0]->getBin(phi, eta, m, e, s) == 0  && s != -1 ) return kTRUE;      
00290     }
00291   } 
00292 
00293   return kFALSE;
00294 }
00295 //------------------------------------------------------------------------------
00296 Bool_t StEmcPosition::trackOnEmc( StThreeVectorD* position, StThreeVectorD* momentum,
00297                             const StMcTrack* const mcTrack, Double_t magField, Double_t emcRadius ) const
00298 {  
00299   Float_t startVertexX = mcTrack->startVertex()->position().x();
00300   Float_t startVertexY = mcTrack->startVertex()->position().y();
00301   Float_t startVtxToOrigin = ::sqrt( ::pow( startVertexX, 2 ) + ::pow( startVertexY, 2 ) );
00302 
00303   if ( !mcTrack->stopVertex() && startVtxToOrigin < emcRadius )    
00304   {
00305    Bool_t projTrackOk = projTrack( position, momentum, mcTrack, magField, emcRadius );
00306    if ( projTrackOk )  
00307     {
00308       Int_t m = 0, e = 0, s = 0;
00309       Float_t phi = position->phi();
00310       Float_t eta = position->pseudoRapidity();
00311       if ( mGeom[0]->getBin(phi, eta, m, e, s) == 0 && s != -1 ) return kTRUE;
00312     }
00313   } 
00314 
00315   // Checking if stopVertex exists
00316   Float_t stopVtxToOrigin = -1;
00317   if ( mcTrack->stopVertex() )     
00318   {
00319     Float_t stopVertexX = mcTrack->stopVertex()->position().x();
00320     Float_t stopVertexY = mcTrack->stopVertex()->position().y();
00321     stopVtxToOrigin = ::sqrt( ::pow( stopVertexX,2 ) + ::pow(stopVertexY,2) );
00322   }
00323   
00324   if (stopVtxToOrigin >= emcRadius)
00325   {
00326     Bool_t projTrackOk = projTrack( position, momentum, mcTrack, magField, emcRadius );
00327     if ( projTrackOk )  
00328     {
00329       Int_t m = 0, e = 0, s = 0;
00330       Float_t phi = position->phi();
00331       Float_t eta = position->pseudoRapidity();
00332       if ( mGeom[0]->getBin(phi, eta, m, e, s) == 0 && s != -1 ) return kTRUE;
00333     }
00334   }  
00335 
00336   return kFALSE;
00337 }
00338 //------------------------------------------------------------------------------
00339 Int_t StEmcPosition::getTowerEtaPhi(const Double_t eta, const Double_t phi, 
00340                                   Float_t* towerEta, Float_t* towerPhi ) const
00341 {
00342   *towerEta = 0; *towerPhi = 0;
00343   Float_t tempTowerEta = 0, tempTowerPhi = 0;
00344   Int_t m = 0, e = 0, s = 0, towerId = -1;
00345   
00346   mGeom[0]->getBin(phi, eta, m, e, s);
00347   if (m==0) return -1;
00348   if (s<0) s=1;
00349   mGeom[0]->getId(m, e, s, towerId);
00350   mGeom[0]->getEtaPhi(towerId, tempTowerEta, tempTowerPhi);
00351   *towerEta = tempTowerEta;
00352   *towerPhi = tempTowerPhi;
00353   return 0;
00354 }
00355 //------------------------------------------------------------------------------
00356 Int_t StEmcPosition::getNextTowerId(const Float_t eta, const Float_t phi, const Int_t nTowersdEta, const Int_t nTowersdPhi) const
00357 {
00358   Int_t m,e,s;
00359   mGeom[0]->getBin( phi, eta, m, e, s );
00360         if(m>0 && m<=120)
00361         {
00362                 if(s<0) s=1;
00363                 return getNextTowerId(m,e,s,nTowersdEta,nTowersdPhi);
00364         }
00365         return 0;
00366 }
00367 //------------------------------------------------------------------------------
00368 Int_t StEmcPosition::getNextTowerId(const Int_t softId, const Int_t nTowersdEta, const Int_t nTowersdPhi) const
00369 {
00370         if(softId<1 || softId>4800) return 0;
00371         Int_t m,e,s;
00372         mGeom[0]->getBin(softId,m,e,s);
00373         return getNextTowerId(m,e,s,nTowersdEta,nTowersdPhi);
00374 }
00375 //------------------------------------------------------------------------------
00376 Int_t StEmcPosition::getNextTowerId(const Int_t m, const Int_t e, const Int_t s, const Int_t nTowersdEta, const Int_t nTowersdPhi) const
00377 {
00378         if(m<1 || m>120) return 0;
00379         if(e<1 || e>20) return 0;
00380         if(s<1 || s>2) return 0;
00381         return getNextId(1,m,e,s,nTowersdEta,nTowersdPhi);
00382 }
00383 //------------------------------------------------------------------------------
00384 Int_t StEmcPosition::getNextId(const Int_t det, const Int_t m, const Int_t e, const Int_t s, const Int_t nEta, const Int_t nPhi) const
00385 {
00386         if(det<1 || det>4) return 0;
00387         if(m<1 || m>120) return 0;
00388         if(s<1 || s>mGeom[det-1]->NSub()) return 0;
00389         if(e<1 || e>mGeom[det-1]->NEta()) return 0;
00390         
00391         Int_t ef=e+nEta;
00392         Int_t sf=s+nPhi;
00393         Int_t mf=m;
00394         
00395         Int_t NE=mGeom[det-1]->NEta();
00396         Int_t NS=mGeom[det-1]->NSub();
00397         
00398         if(abs(ef)>NE) return 0;
00399         
00400   do
00401         {
00402                 if(sf<=0)
00403                 {
00404                         sf += NS;
00405                         mf--;
00406                         if(mf==60) mf  = 120;
00407                         if(mf==0)  mf  = 60;
00408                 }
00409                 if(sf>NS)
00410                 {
00411                         sf -= NS;
00412                         mf++;
00413                         if(mf==61)  mf = 1;
00414                         if(mf==121) mf = 61;
00415                 }
00416         } while(sf<=0 || sf>NS);
00417         
00418         if(ef<=0)
00419         {
00420                 ef = 1-ef;
00421                 sf = NS-sf+1;
00422                 if(ef>NE) return 0;
00423           Int_t rid,etmp,stmp;
00424           Float_t eta,phi;
00425           mGeom[det-1]->getId(mf, ef, sf, rid);
00426     mGeom[det-1]->getEtaPhi(rid, eta, phi);
00427                 mGeom[det-1]->getBin(phi,-eta,mf,etmp,stmp);
00428         }
00429         
00430         Int_t rid;
00431         if(mf<1 || mf>120) return 0;
00432         if(ef<1 || ef>NE) return 0;
00433         if(sf<1 || sf>NS) return 0;
00434         mGeom[det-1]->getId(mf, ef, sf, rid);
00435         return rid;
00436 
00437 }
00438 //------------------------------------------------------------------------------
00439 Int_t StEmcPosition::getNextId(const Int_t det, const Int_t softId, const Int_t nEta, const Int_t nPhi)const
00440 {
00441   if(det<1 || det>4) return 0;
00442   Int_t m,e,s;
00443   if(softId<1)return 0;
00444   if((det == 1 || det == 2) && softId > 4800)return 0;
00445   if((det == 3 || det == 4) && softId > 18000)return 0;
00446   mGeom[det-1]->getBin(softId,m,e,s);
00447   if(m>0 && m<=120)
00448     {
00449       if(s<0) s=1;
00450       return getNextId(det,m,e,s,nEta,nPhi);
00451     }
00452   return 0;
00453 }
00454 //------------------------------------------------------------------------------
00455 Float_t StEmcPosition::getDistTowerToTrack( Double_t trackEta, Double_t trackPhi, 
00456                                          Int_t nTowersdEta, Int_t nTowersdPhi ) const
00457 
00458 {     
00459   Int_t towerId = 0;
00460   Float_t towerEta = 0, towerToTrackdEta = 0; 
00461   Float_t towerPhi = 0, towerToTrackdPhi = 0; 
00462   Float_t mdistTowerToTrack = 0;
00463 
00464   towerId = getNextTowerId( trackEta, trackPhi, nTowersdEta, nTowersdPhi );
00465   if (towerId != 0)
00466   {
00467     // Getting eta and phi of neighbour tower
00468     mGeom[0]->getEtaPhi(towerId, towerEta, towerPhi);
00469     towerToTrackdEta = towerEta-trackEta;
00470     towerToTrackdPhi = towerPhi-trackPhi;
00471       
00472     mdistTowerToTrack = ::sqrt( ::pow(towerToTrackdEta, 2) + ::pow(towerToTrackdPhi, 2) );
00473   
00474     return mdistTowerToTrack;
00475   }
00476   else
00477     return -1;
00478 }
00479 //------------------------------------------------------------------------------
00480 StThreeVectorF StEmcPosition::getPosFromVertex( const StVertex* const vertex,Int_t TowerId ) const
00481 {
00482   StThreeVectorF Zero(0,0,0);
00483   if(TowerId<1 || TowerId>4800) return Zero;
00484   
00485   Float_t xTower,yTower,zTower;
00486   StThreeVectorF position = vertex->position();
00487   mGeom[0]->getXYZ(TowerId, xTower, yTower, zTower);
00488   StThreeVectorF towerPosition(xTower, yTower, zTower);
00489   StThreeVectorF PositionFromVertex = towerPosition - position;
00490   
00491   return PositionFromVertex;
00492 }
00493 //------------------------------------------------------------------------------
00494 StThreeVectorF StEmcPosition::getPosFromVertex( const StThreeVectorF& position,int TowerId ) const
00495 {
00496     StThreeVectorF Zero(0,0,0);
00497     if(TowerId<1 || TowerId>4800) return Zero;
00498         
00499     float xTower,yTower,zTower;
00500     //StThreeVectorF position = vertex->position(); //modified to work with StMuDst instead of StEvent
00501     mGeom[0]->getXYZ(TowerId, xTower, yTower, zTower);
00502     StThreeVectorF towerPosition(xTower, yTower, zTower);
00503     StThreeVectorF PositionFromVertex = towerPosition - position;
00504         
00505     return PositionFromVertex;
00506 }
00507 //------------------------------------------------------------------------------
00508 StThreeVectorF StEmcPosition::getPosFromVertex( const StMcVertex* const vertex,Int_t TowerId ) const
00509 {
00510   StThreeVectorF Zero(0,0,0);
00511   if(TowerId<1 || TowerId>4800) return Zero;
00512   
00513   Float_t xTower,yTower,zTower;
00514   StThreeVectorF position = vertex->position();
00515   mGeom[0]->getXYZ(TowerId, xTower, yTower, zTower);
00516   StThreeVectorF towerPosition(xTower, yTower, zTower);
00517   StThreeVectorF PositionFromVertex = towerPosition - position;
00518   
00519   return PositionFromVertex;
00520 }
00521 //------------------------------------------------------------------------------
00522 Float_t StEmcPosition::getThetaFromVertex( const StVertex* const vertex,Int_t TowerId ) const
00523 {
00524   StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00525   return p.theta();
00526 }
00527 //------------------------------------------------------------------------------
00528 Float_t StEmcPosition::getThetaFromVertex( const StThreeVectorF& vertex,int TowerId ) const
00529 {
00530     StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00531     return p.theta();
00532 }
00533 //------------------------------------------------------------------------------
00534 Float_t StEmcPosition::getThetaFromVertex( const StMcVertex* const vertex,Int_t TowerId ) const
00535 {
00536   StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00537   return p.theta();
00538 }
00539 //------------------------------------------------------------------------------
00540 Float_t StEmcPosition::getEtaFromVertex( const StVertex* const vertex,Int_t TowerId ) const
00541 {
00542   StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00543   return p.pseudoRapidity();
00544 }
00545 //------------------------------------------------------------------------------
00546 Float_t StEmcPosition::getEtaFromVertex( const StThreeVectorF& vertex,int TowerId ) const
00547 {
00548     StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00549     return p.pseudoRapidity();
00550 }
00551 //------------------------------------------------------------------------------
00552 Float_t StEmcPosition::getEtaFromVertex( const StMcVertex* const vertex,Int_t TowerId ) const
00553 {
00554   StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00555   return p.pseudoRapidity();
00556 }
00557 //------------------------------------------------------------------------------
00558 Float_t StEmcPosition::getPhiFromVertex( const StVertex* const vertex,Int_t TowerId ) const
00559 {
00560   StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00561   return p.phi();
00562 }
00563 //------------------------------------------------------------------------------
00564 Float_t StEmcPosition::getPhiFromVertex( const StThreeVectorF& vertex,int TowerId ) const
00565 {
00566     StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00567     return p.phi();
00568 }
00569 //------------------------------------------------------------------------------
00570 Float_t StEmcPosition::getPhiFromVertex( const StMcVertex* const vertex,Int_t TowerId ) const
00571 {
00572   StThreeVectorF p=getPosFromVertex(vertex,TowerId );
00573   return p.phi();
00574 }