StRoot: StStrangeMuDstMaker/StV0I.hh Source File

00001 
00011 #ifndef StV0I_hh
00012 #define StV0I_hh
00013 #include "phys_constants.h"
00014 #include <math.h>
00015 #include "StStrangeEvMuDst.hh"
00016 #include "StDecayAngle.hh"
00017 
00018 #ifndef StTrackTopologyMap_hh
00019 #include "StEvent/StTrackTopologyMap.h"
00020 #endif
00021 
00022 class StStrangeEvMuDst;
00023 R__EXTERN StTrackTopologyMap* gFakeTopoPtr;
00024 static const Float_t M_LAMBDA_2 = ::pow(M_LAMBDA,2);
00025 static const Float_t M_KAON_0_SHORT_2 = ::pow(M_KAON_0_SHORT,2);
00026 static const Float_t M_PROTON_2 = ::pow(M_PROTON,2);
00027 static const Float_t M_ANTIPROTON_2 = ::pow(M_ANTIPROTON,2);
00028 static const Float_t M_PION_PLUS_2 = ::pow(M_PION_PLUS,2);
00029 static const Float_t M_PION_MINUS_2 = ::pow(M_PION_MINUS,2);
00030 
00031 class StV0I {
00032 public:
00033   StV0I() {}
00034   virtual ~StV0I() {}
00035 
00036 // ************************************************************************
00038 // ************************************************************************
00039 
00041   virtual void Clear();
00043           StStrangeEvMuDst* event();
00045   virtual void SetEvent(StStrangeEvMuDst*);
00047 
00049 
00050 
00051   virtual Float_t decayLengthV0() const;
00052   virtual Float_t decayVertexV0X() const=0;
00053   virtual Float_t decayVertexV0Y() const=0; 
00054   virtual Float_t decayVertexV0Z() const=0;
00055           Float_t alphaV0(); 
00056           Float_t ptArmV0();
00058           Float_t cTauLambda();
00060           Float_t cTauK0Short();
00062 
00064 
00065 
00066           TVector3 momPos();
00067   virtual Float_t momPosX() const=0;
00068   virtual Float_t momPosY() const=0; 
00069   virtual Float_t momPosZ() const=0;
00071           TVector3 momNeg();
00072   virtual Float_t momNegX() const=0;
00073   virtual Float_t momNegY() const=0; 
00074   virtual Float_t momNegZ() const=0;
00076           TVector3 momV0();
00077   virtual Float_t momV0X() const=0;
00078   virtual Float_t momV0Y() const=0; 
00079   virtual Float_t momV0Z() const=0;
00081           Float_t ptV0();
00083           Float_t ptPos();
00085           Float_t ptNeg();
00087           Float_t ptotV0();
00089           Float_t ptotPos();
00091           Float_t ptotNeg();
00093 
00095 
00096 
00097           Float_t eLambda();
00099           Float_t eK0Short();
00101           Float_t ePosProton();
00103           Float_t ePosPion();
00105           Float_t eNegProton();
00107           Float_t eNegPion();
00109           Float_t massLambda();
00111           Float_t massAntiLambda();
00113           Float_t massK0Short();
00115           Float_t rapLambda();
00117           Float_t rapK0Short();
00119 
00121 
00122 
00123           Float_t thetaV0();
00125           Float_t thetaPos();
00127           Float_t thetaNeg();
00129           Float_t pseudoRapV0();
00131           Float_t pseudoRapPos();
00133           Float_t pseudoRapNeg();
00135   
00137 
00138 
00139           Float_t mtLambda();
00141           Float_t mtK0Short();
00143           Float_t mtm0Lambda();
00145           Float_t mtm0K0Short();
00147   
00149 
00150 
00151           Float_t ePosHyp(Float_t mass);
00153           Float_t eNegHyp(Float_t mass);
00154           Float_t massHypV0(Float_t massPos, Float_t massNeg);
00155           Float_t eHypV0(Float_t mass);
00156           Float_t rapHypV0(Float_t mass);
00157           Float_t mtHypV0(Float_t mass);
00159           Float_t mtm0HypV0(Float_t mass);
00161 
00163 
00164           Float_t decayCosThetaK0Short();       // k-short    - pos. daughter
00165           Float_t decayCosThetaLambda();        // lambda     - pos. daughter
00166           Float_t decayCosThetaAntiLambda();    // antilambda - neg. daughter
00167           Float_t polCosThetaLambda();          // lambda     - pos. daughter
00168           Float_t polCosThetaAntiLambda();      // antilambda - neg. daughter
00169           Float_t decayCosThetaPosLambda();     // lambda     - pos. daughter
00170           Float_t decayCosThetaNegLambda();     // lambda     - neg. daughter
00171           Float_t decayCosThetaPosAntiLambda(); // antilambda - pos. daughter
00172           Float_t decayCosThetaNegAntiLambda(); // antilambda - neg. daughter
00174 
00175           Float_t dCTV0(Float_t m1, Float_t m2, StChargeSign charge);
00177 
00179 
00180           TVector3 momPosK0Short();             // k-short    - pos. daughter
00181           TVector3 momNegK0Short();             // k-short    - neg. daughter
00182           TVector3 momPosLambda();              // lambda     - neg. daughter
00183           TVector3 momNegLambda();              // lambda     - neg. daughter
00184           TVector3 momPosAntiLambda();          // antilambda - pos. daughter
00185           TVector3 momNegAntiLambda();          // antilambda - neg. daughter
00188 
00189           TVector3 momV0Frame(Float_t m1, Float_t m2, StChargeSign charge);
00191 
00192 // ************************************************************************
00194 // ************************************************************************
00195 
00197 
00198 
00199   virtual Int_t decayMode() const {return -1;}
00200   virtual Int_t geantIdParent() const   {return -1;}
00201   virtual Int_t geantIdPositive() const {return -1;}
00202   virtual Int_t geantIdNegative() const {return -1;}
00203   virtual Int_t positiveSimTpcHits() const    {return -1;}
00204   virtual Int_t positiveCommonTpcHits() const {return -1;}
00205   virtual Int_t negativeSimTpcHits() const    {return -1;}
00206   virtual Int_t negativeCommonTpcHits() const {return -1;}
00208 
00209 // ************************************************************************
00211 // ************************************************************************
00212 
00214 
00215   virtual Int_t keyPos() const {return 0;}
00217   virtual Int_t keyNeg() const {return 0;}
00219   virtual StTrackTopologyMap& topologyMapPos() {return (*gFakeTopoPtr);}
00221   virtual StTrackTopologyMap& topologyMapNeg() {return (*gFakeTopoPtr);}
00223   virtual Float_t dedxPos() const {return 0;}
00225   virtual Float_t dedxNeg() const {return 0;}
00227   virtual Float_t errDedxPos() const {return 0;}
00229   virtual Float_t errDedxNeg() const {return 0;}
00231   virtual UShort_t numDedxPos() const {return 0;}
00233   virtual UShort_t numDedxNeg() const {return 0;}
00235   virtual Float_t lenDedxPos() const {return 0;}
00237   virtual Float_t lenDedxNeg() const {return 0;}
00239 
00241 
00242 
00243   virtual Float_t dcaV0Daughters() const {return 0;}
00245   virtual Float_t dcaV0ToPrimVertex()  const {return -1;}
00247   virtual Float_t dcaPosToPrimVertex() const {return -1;}
00249   virtual Float_t dcaNegToPrimVertex() const {return -1;}
00251   
00253 
00254 
00255   virtual Float_t chi2V0()  const {return 0;}
00257   virtual Float_t clV0()    const {return 0;}
00259   virtual Float_t chi2Pos() const {return 0;}
00261   virtual Float_t clPos()   const {return 0;}
00263   virtual Float_t chi2Neg() const {return 0;}
00265   virtual Float_t clNeg()   const {return 0;}
00267   virtual Long_t  detectorIdV0() {return 0;}
00269   virtual Long_t detectorIdPars() {return 0;}
00271   virtual void setPosBad() {}
00273   virtual void setNegBad() {}
00275   virtual Bool_t bad() const {return (chi2Pos()<0 || chi2Neg()<0);}
00277 
00278 
00279 protected:
00280           Float_t Ptot2Pos();
00281           Float_t Ptot2Neg();
00282           Float_t Ptot2V0();
00283           Float_t Pt2V0();
00284           Float_t MomPosAlongV0();
00285           Float_t MomNegAlongV0();
00286 
00287   StStrangeEvMuDst *mEvent;       
00288 };
00289 
00290 inline void StV0I::SetEvent(StStrangeEvMuDst* ev) {
00291      mEvent = ev;
00292 }
00293 
00294 inline StStrangeEvMuDst *StV0I::event() {
00295      return mEvent;
00296 }
00297 
00298 inline Float_t StV0I::decayLengthV0() const {
00299      if (mEvent)
00300        return ::sqrt(::pow(decayVertexV0X() - mEvent->primaryVertexX(),2) +
00301                      ::pow(decayVertexV0Y() - mEvent->primaryVertexY(),2) +
00302                      ::pow(decayVertexV0Z() - mEvent->primaryVertexZ(),2));
00303      return 0.;
00304 }
00305 
00306 inline TVector3 StV0I::momPos() {
00307      return TVector3(momPosX(), momPosY(), momPosZ());
00308 }
00309 
00310 inline TVector3 StV0I::momNeg() {
00311      return TVector3(momNegX(), momNegY(), momNegZ());
00312 }
00313 
00314 inline TVector3 StV0I::momV0() {
00315      return TVector3(momV0X(), momV0Y(), momV0Z());
00316 }
00317 
00318 inline Float_t StV0I::Ptot2Pos() {
00319      return (::pow(momPosX(),2) + ::pow(momPosY(),2) + ::pow(momPosZ(),2));
00320 }
00321 
00322 inline Float_t StV0I::Ptot2Neg() {
00323      return (::pow(momNegX(),2) + ::pow(momNegY(),2) + ::pow(momNegZ(),2));
00324 }
00325 
00326 inline Float_t StV0I::Pt2V0() {
00327      return (::pow(momV0X(),2) + ::pow(momV0Y(),2));
00328 }
00329 
00330 inline Float_t StV0I::Ptot2V0() {
00331      return (Pt2V0() + ::pow(momV0Z(),2));
00332 }
00333 
00334 inline Float_t StV0I::MomPosAlongV0() {
00335      Float_t mPtot2V0 = Ptot2V0();
00336      if (mPtot2V0)
00337        return (momPosX()*momV0X() + 
00338                momPosY()*momV0Y() +
00339                momPosZ()*momV0Z()) / ::sqrt(mPtot2V0);
00340      return 0.;
00341 }
00342 
00343 inline Float_t StV0I::MomNegAlongV0() {
00344      Float_t mPtot2V0 = Ptot2V0();
00345      if (mPtot2V0)
00346        return (momNegX()*momV0X() + 
00347                momNegY()*momV0Y() +
00348                momNegZ()*momV0Z()) / ::sqrt(mPtot2V0);
00349      return 0.;
00350 }
00351 
00352 inline Float_t StV0I::alphaV0() {
00353   Float_t mMomPosAlongV0 = MomPosAlongV0();
00354   Float_t mMomNegAlongV0 = MomNegAlongV0();
00355   return (mMomPosAlongV0-mMomNegAlongV0)/
00356          (mMomPosAlongV0+mMomNegAlongV0);
00357 }
00358 
00359 inline Float_t StV0I::ptArmV0() {
00360   Float_t ptarmsq = Ptot2Pos() - ::pow(MomPosAlongV0(),2);
00361   return ((ptarmsq > 0.) ? ::sqrt(ptarmsq) : 0.);
00362 }
00363 
00364 inline Float_t StV0I::eHypV0(Float_t mass) {
00365   return ::sqrt(Ptot2V0()+::pow(mass,2));
00366 }
00367 
00368 inline Float_t StV0I::eLambda() {
00369   return ::sqrt(Ptot2V0()+M_LAMBDA_2);
00370 }
00371 
00372 inline Float_t StV0I::eK0Short() {
00373   return ::sqrt(Ptot2V0()+M_KAON_0_SHORT_2);
00374 }
00375 
00376 inline Float_t StV0I::ePosHyp(Float_t mass) {
00377   return ::sqrt(Ptot2Pos()+::pow(mass,2));
00378 }
00379 
00380 inline Float_t StV0I::eNegHyp(Float_t mass) {
00381   return ::sqrt(Ptot2Neg()+::pow(mass,2));
00382 }
00383 
00384 inline Float_t StV0I::ePosProton() {
00385   return ::sqrt(Ptot2Pos()+M_PROTON_2);
00386 }
00387 
00388 inline Float_t StV0I::eNegProton() {
00389   return ::sqrt(Ptot2Neg()+M_ANTIPROTON_2);
00390 }
00391 
00392 inline Float_t StV0I::ePosPion() {
00393   return ::sqrt(Ptot2Pos()+M_PION_PLUS_2);
00394 }
00395 
00396 inline Float_t StV0I::eNegPion() {
00397   return ::sqrt(Ptot2Neg()+M_PION_MINUS_2);
00398 }
00399 
00400 inline Float_t StV0I::massHypV0(Float_t massPos, Float_t massNeg) {
00401   Float_t msq = ::pow(ePosHyp(massPos)+eNegHyp(massNeg),2)-Ptot2V0();
00402   return ((msq > 0.) ? ::sqrt(msq) : 0.);
00403 }
00404 
00405 inline Float_t StV0I::massLambda() {
00406   return ::sqrt(::pow(ePosProton()+eNegPion(),2)-Ptot2V0());
00407 }
00408 
00409 inline Float_t StV0I::massAntiLambda() {
00410   return ::sqrt(::pow(eNegProton()+ePosPion(),2)-Ptot2V0());
00411 }
00412 
00413 inline Float_t StV0I::massK0Short() {
00414   return ::sqrt(::pow(ePosPion()+eNegPion(),2)-Ptot2V0());
00415 }
00416 
00417 inline Float_t StV0I::rapHypV0(Float_t mass) {
00418   Float_t ehyp = eHypV0(mass);
00419   Float_t mMomV0Z = momV0Z();
00420   return 0.5*::log((ehyp+mMomV0Z)/(ehyp-mMomV0Z));
00421 }
00422 
00423 inline Float_t StV0I::rapLambda() {
00424   Float_t ela = eLambda();
00425   Float_t mMomV0Z = momV0Z();
00426   return 0.5*::log((ela+mMomV0Z)/(ela-mMomV0Z));
00427 }
00428 
00429 inline Float_t StV0I::rapK0Short() {
00430   Float_t ek0 = eK0Short();
00431   Float_t mMomV0Z = momV0Z();
00432   return 0.5*::log((ek0+mMomV0Z)/(ek0-mMomV0Z));
00433 }
00434 
00435 inline Float_t StV0I::cTauLambda() {
00436   return M_LAMBDA*decayLengthV0()/::sqrt(Ptot2V0());
00437 }
00438 
00439 inline Float_t StV0I::cTauK0Short() {
00440   return M_KAON_0_SHORT*decayLengthV0()/::sqrt(Ptot2V0());
00441 }
00442 
00443 inline Float_t StV0I::ptPos() {
00444   return ::sqrt(Ptot2Pos()-::pow(momPosZ(),2));
00445 }
00446 
00447 inline Float_t StV0I::ptotPos() {
00448   return ::sqrt(Ptot2Pos());
00449 }
00450 
00451 inline Float_t StV0I::ptNeg() {
00452   return ::sqrt(Ptot2Neg()-::pow(momNegZ(),2));
00453 }
00454 
00455 inline Float_t StV0I::ptotNeg() {
00456   return ::sqrt(Ptot2Neg());
00457 }
00458 
00459 inline Float_t StV0I::ptV0() {
00460   return ::sqrt(Pt2V0());
00461 }
00462 
00463 inline Float_t StV0I::ptotV0() {
00464   return ::sqrt(Ptot2V0());
00465 }
00466 
00467 inline Float_t StV0I::thetaV0() {
00468   return acos(momV0Z()/ptotV0());
00469 }
00470 
00471 inline Float_t StV0I::pseudoRapV0() {
00472   return (-::log(tan(thetaV0()/2.)));
00473 }
00474 
00475 inline Float_t StV0I::thetaPos() {
00476   return acos(momPosZ()/ptotPos());
00477 }
00478 
00479 inline Float_t StV0I::pseudoRapPos() {
00480   return (-::log(tan(thetaPos()/2.)));
00481 }
00482 
00483 inline Float_t StV0I::thetaNeg() {
00484   return acos(momNegZ()/ptotNeg());
00485 }
00486 
00487 inline Float_t StV0I::pseudoRapNeg() {
00488   return (-::log(tan(thetaNeg()/2.)));
00489 }
00490 
00491 inline Float_t StV0I::mtHypV0(Float_t mass) {
00492   return ::sqrt(Pt2V0()+::pow(mass,2));
00493 }
00494 
00495 inline Float_t StV0I::mtLambda() {
00496   return ::sqrt(Pt2V0()+M_LAMBDA_2);
00497 }
00498 
00499 inline Float_t StV0I::mtK0Short() {
00500   return ::sqrt(Pt2V0()+M_KAON_0_SHORT_2);
00501 }
00502 
00503 inline Float_t StV0I::mtm0HypV0(Float_t mass) {
00504   return (mtHypV0(mass)-mass);
00505 }
00506 
00507 inline Float_t StV0I::mtm0Lambda() {
00508   return (mtK0Short()-M_LAMBDA);
00509 }
00510 
00511 inline Float_t StV0I::mtm0K0Short() {
00512   return (mtK0Short()-M_KAON_0_SHORT);
00513 }
00514 
00515 inline Float_t StV0I::decayCosThetaK0Short() {    // default: use pos. daughter
00516   return dCTV0(M_KAON_0_SHORT,M_PION_PLUS,positive);
00517 }
00518 
00519 inline Float_t StV0I::decayCosThetaLambda() {     // default: use pos. daughter
00520   return decayCosThetaPosLambda();
00521 }
00522 
00523 inline Float_t StV0I::decayCosThetaAntiLambda() { // default: use neg. daughter
00524   return decayCosThetaNegAntiLambda();
00525 }
00526 
00527 inline Float_t StV0I::polCosThetaLambda() {       // default: use pos. daughter
00528   return StDecayAngle::polarityCosTheta(
00529     momV0X(),momV0Y(),momV0Z(),M_LAMBDA,
00530     momPosX(),momPosY(),momPosZ(),M_PROTON);
00531 }
00532 
00533 inline Float_t StV0I::polCosThetaAntiLambda() {   // default: use neg. daughter
00534   return StDecayAngle::polarityCosTheta(
00535     momV0X(),momV0Y(),momV0Z(),M_LAMBDA,
00536     momNegX(),momNegY(),momNegZ(),M_PROTON);
00537 }
00538 
00539 inline Float_t StV0I::decayCosThetaPosLambda() {
00540   return dCTV0(M_LAMBDA,M_PROTON,positive);
00541 }
00542 
00543 inline Float_t StV0I::decayCosThetaNegLambda() {
00544   return dCTV0(M_LAMBDA,M_PION_MINUS,negative);
00545 }
00546 
00547 inline Float_t StV0I::decayCosThetaNegAntiLambda() {
00548   return dCTV0(M_ANTILAMBDA,M_ANTIPROTON,negative);
00549 }
00550 
00551 inline Float_t StV0I::decayCosThetaPosAntiLambda() {
00552   return dCTV0(M_ANTILAMBDA,M_PION_PLUS,positive);
00553 }
00554 
00555 inline Float_t StV0I::dCTV0(Float_t m1, Float_t m2, StChargeSign charge) {
00556   return ( (charge == positive) ?
00557     StDecayAngle::decayCosTheta(momV0X() ,momV0Y() ,momV0Z() ,m1,
00558                                 momPosX(),momPosY(),momPosZ(),m2) :
00559     StDecayAngle::decayCosTheta(momV0X() ,momV0Y() ,momV0Z() ,m1,
00560                                 momNegX(),momNegY(),momNegZ(),m2) );
00561 }
00562 
00563 inline TVector3 StV0I::momPosK0Short() {
00564   return momV0Frame(M_KAON_0_SHORT,M_PION_PLUS,positive);
00565 }
00566 
00567 inline TVector3 StV0I::momNegK0Short() {
00568   return momV0Frame(M_KAON_0_SHORT,M_PION_MINUS,negative);
00569 }
00570 
00571 inline TVector3 StV0I::momPosLambda() {
00572   return momV0Frame(M_LAMBDA,M_PROTON,positive);
00573 }
00574 
00575 inline TVector3 StV0I::momNegLambda() {
00576   return momV0Frame(M_LAMBDA,M_PION_MINUS,negative);
00577 }
00578 
00579 inline TVector3 StV0I::momPosAntiLambda() {
00580   return momV0Frame(M_ANTILAMBDA,M_PION_PLUS,positive);
00581 }
00582 
00583 inline TVector3 StV0I::momNegAntiLambda() {
00584   return momV0Frame(M_ANTILAMBDA,M_ANTIPROTON,negative);
00585 }
00586 
00587 inline TVector3 StV0I::momV0Frame(Float_t m1, Float_t m2, StChargeSign charge) {
00588   return ( (charge == positive) ?
00589     StDecayAngle::getShiftedDaughter(momV0X() ,momV0Y() ,momV0Z() ,m1,
00590                                      momPosX(),momPosY(),momPosZ(),m2) :
00591     StDecayAngle::getShiftedDaughter(momV0X() ,momV0Y() ,momV0Z() ,m1,
00592                                      momNegX(),momNegY(),momNegZ(),m2) );
00593 }
00594 
00595 inline void StV0I::Clear() {
00596   mEvent = 0;
00597 }
00598 
00599 #endif
00600 
00601 
00602 /***********************************************************************
00603  * $Id: StV0I.hh,v 3.13 2011/05/27 18:25:32 genevb Exp $
00604  * $Log: StV0I.hh,v $
00605  * Revision 3.13  2011/05/27 18:25:32  genevb
00606  * Propagate StTrack::key => Int_t to other codes
00607  *
00608  * Revision 3.12  2008/07/10 16:16:55  genevb
00609  * Allow for marking of bad tracks -> bad secondary vertices
00610  *
00611  * Revision 3.11  2003/10/26 06:06:01  genevb
00612  * Added checks for sqrt of neg. numbers
00613  *
00614  * Revision 3.10  2003/09/02 17:59:04  perev
00615  * gcc 3.2 updates + WarnOff
00616  *
00617  * Revision 3.9  2003/05/30 21:20:19  genevb
00618  * doxygen savvy, encoding of FTPC mults, change virtual funcs
00619  *
00620  * Revision 3.8  2003/02/10 15:47:14  genevb
00621  * Fixed mt calculations
00622  *
00623  * Revision 3.7  2002/07/30 20:07:52  genevb
00624  * Better cTau calcs
00625  *
00626  * Revision 3.6  2002/04/30 16:02:48  genevb
00627  * Common muDst, improved MC code, better kinks, StrangeCuts now a branch
00628  *
00629  * Revision 3.5  2002/02/10 15:29:09  genevb
00630  * Additional functions for momenta of decay daughters in CM frame
00631  *
00632  * Revision 3.4  2001/11/28 05:14:59  genevb
00633  * Additional decay angle functions
00634  *
00635  * Revision 3.3  2001/11/05 23:41:06  genevb
00636  * Add more dEdx, B field info, careful of changes to TTree unrolling
00637  *
00638  * Revision 3.2  2001/08/23 13:20:58  genevb
00639  * Many bug workarounds...
00640  *
00641  * Revision 3.1  2001/05/04 20:15:14  genevb
00642  * Common interfaces and reorganization of components, add MC event info
00643  *
00644  *
00645  ***********************************************************************/