CORRFW/AliCFPair.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16
  17 ////////////////////////////////////////////////
  18 // Class to handle pairs of tracks
  19 // Useful for resonance analysis
  20 // Derives from AliVParticle =>
  21 // usable in Correction Framework
  22 ////////////////////////////////////////////////
  23 // author : renaud.vernet@cern.ch
  24 ////////////////////////////////////////////////
  25
  26 #include "AliCFPair.h"
  27 #include "AliESDtrack.h"
  28 #include "AliESDv0.h"
  29 #include "AliESDEvent.h"
  30 #include "TMath.h"
  31 #include "AliAODv0.h"
  32
  33 ClassImp(AliCFPair)
  34
  35 AliCFPair::AliCFPair(AliVParticle* t1, AliVParticle* t2) :
  36   AliVParticle(),
  37   fIsV0(0),
  38   fTrackNeg(t1),
  39   fTrackPos(t2),
  40   fESDV0(0x0),
  41   fAODV0(0x0),
  42   fLabel(-1),
  43   fV0PDG(0),
  44   fMassNeg(0.),
  45   fMassPos(0.)
  46 {
  47   //
  48   // 2-track ctor
  49   //
  50 }
  51 AliCFPair::AliCFPair(AliESDv0* v0, AliESDEvent* esd) :
  52   AliVParticle(),
  53   fIsV0(1),
  54   fTrackNeg(esd->GetTrack(v0->GetNindex())),
  55   fTrackPos(esd->GetTrack(v0->GetPindex())),
  56   fESDV0(v0),
  57   fAODV0(0x0),
  58   fLabel(-1),
  59   fV0PDG(0),
  60   fMassNeg(0.),
  61   fMassPos(0.)
  62 {
  63   //
  64   // V0 ctor
  65   //
  66 }
  67 AliCFPair::AliCFPair(AliAODv0* v0) :
  68   AliVParticle(),
  69   fIsV0(1),
  70   fTrackNeg((AliVParticle*)v0->GetSecondaryVtx()->GetDaughter(1)),
  71   fTrackPos((AliVParticle*)v0->GetSecondaryVtx()->GetDaughter(0)),
  72   fESDV0(0x0),
  73   fAODV0(v0),
  74   fLabel(-1),
  75   fV0PDG(0),
  76   fMassNeg(0.),
  77   fMassPos(0.)
  78 {
  79   //
  80   // V0 ctor
  81   //
  82 }
  83 AliCFPair::AliCFPair(const AliCFPair& c) :
  84   AliVParticle(c),
  85   fIsV0(c.fIsV0),
  86   fTrackNeg(c.fTrackNeg),
  87   fTrackPos(c.fTrackPos),
  88   fESDV0(c.fESDV0),
  89   fAODV0(c.fAODV0),
  90   fLabel(c.fLabel),
  91   fV0PDG(c.fV0PDG),
  92   fMassNeg(c.fMassNeg),
  93   fMassPos(c.fMassPos)
  94 {
  95   //
  96   // Copy constructor.
  97   //
  98 }
  99 AliCFPair& AliCFPair::operator=(const AliCFPair& c) {
 100   //
 101   // assignment operator.
 102   //
 103
 104   if (this!=&c) {
 105     AliVParticle::operator=(c);
 106     fIsV0 = c.fIsV0;
 107     fTrackNeg = c.fTrackNeg ;
 108     fTrackPos = c.fTrackPos ;
 109     fESDV0 = c.fESDV0 ;
 110     fAODV0 = c.fAODV0 ;
 111     fLabel = c.fLabel ;
 112     fV0PDG = c.fV0PDG ;
 113     fMassNeg = c.fMassNeg ;
 114     fMassPos = c.fMassPos;
 115   }
 116   return *this;
 117 }
 118 Bool_t AliCFPair::PxPyPz(Double_t p[3]) const {
 119   //
 120   // sets pair total momentum in vector p
 121   //
 122   if (fIsV0) {
 123     if      (fESDV0) fESDV0->GetPxPyPz(p[0],p[1],p[2]);
 124     else if (fAODV0) fAODV0->PxPyPz(p);
 125     else Error("PxPyPz","Pointer to V0 not found");
 126   }
 127   else if (fTrackNeg && fTrackPos) {
 128     p[0]=fTrackNeg->Px()+fTrackPos->Px();
 129     p[1]=fTrackNeg->Py()+fTrackPos->Py();
 130     p[2]=fTrackNeg->Pz()+fTrackPos->Pz();
 131   }
 132   else Error("PxPyPz","Could not find V0 nor track pointers");
 133   return kTRUE;
 134 }
 135
 136 Double32_t AliCFPair::P() const {
 137   //
 138   // returns pair total momentum norm
 139   //
 140   Double32_t mom[3];
 141   PxPyPz(mom);
 142   return TMath::Sqrt(mom[0]*mom[0]+mom[1]*mom[1]+mom[2]*mom[2]);
 143 }
 144
 145 Double32_t AliCFPair::Px() const {
 146   //
 147   // returns pair X-projected momentum
 148   //
 149   Double32_t mom[3];
 150   PxPyPz(mom);
 151   return mom[0];
 152 }
 153 Double32_t AliCFPair::Py() const {
 154   //
 155   // returns pair Y-projected momentum
 156   //
 157   Double32_t mom[3];
 158   PxPyPz(mom);
 159   return mom[1];
 160 }
 161 Double32_t AliCFPair::Pz() const {
 162   //
 163   // returns pair Z-projected momentum
 164   //
 165   Double32_t mom[3];
 166   PxPyPz(mom);
 167   return mom[2];
 168 }
 169 Double32_t AliCFPair::Pt() const {
 170   //
 171   // returns pair transverse (XY) momentum
 172   //
 173   Double32_t mom[3];
 174   PxPyPz(mom);
 175   return sqrt(mom[0]*mom[0]+mom[1]*mom[1]);
 176 }
 177 Double32_t AliCFPair::E() const {
 178   //
 179   // returns pair total energy according to ESD-calculated mass
 180   //
 181   Double32_t mom[3];
 182   PxPyPz(mom);
 183   Double32_t mass=M() ;
 184   return TMath::Sqrt(mass*mass + mom[0]*mom[0]+ mom[1]*mom[1]+ mom[2]*mom[2]);
 185 }
 186 Bool_t AliCFPair::XvYvZv(Double_t x[3]) const {
 187   //
 188   // sets pair position to x
 189   // since this class is designed for resonances, the assumed pair position
 190   // should be the same for both tracks. neg track position is kept here
 191   //
 192
 193   if (fIsV0) {
 194     if      (fESDV0) fESDV0->GetXYZ(x[0],x[1],x[2]);
 195     else if (fAODV0) fAODV0->XvYvZv(x);
 196     else Error("PxPyPz","Pointer to V0 not found");
 197   }
 198   else if (fTrackNeg) fTrackNeg->PxPyPz(x);
 199   else Error("PxPyPz","Could not find V0 nor track pointers");
 200
 201   return kTRUE;
 202 }
 203 Double32_t AliCFPair::Xv() const {
 204   //
 205   // returns pair X-projected position
 206   //
 207   Double32_t pos[3];
 208   XvYvZv(pos);
 209   return pos[0];
 210 }
 211 Double32_t AliCFPair::Yv() const {
 212   //
 213   // returns pair Y-projected position
 214   //
 215   Double32_t pos[3];
 216   XvYvZv(pos);
 217   return pos[1];
 218 }
 219 Double32_t AliCFPair::Zv() const {
 220   //
 221   // returns pair Z-projected position
 222   //
 223   Double32_t pos[3];
 224   XvYvZv(pos);
 225   return pos[2];
 226 }
 227 Double32_t AliCFPair::Phi() const {
 228   //
 229   // returns pair phi angle (in transverse plane)
 230   //
 231   return TMath::Pi()+TMath::ATan2(-Py(),-Px());
 232 }
 233 Double32_t AliCFPair::Theta() const {
 234   //
 235   // returns pair theta angle (in YZ plane)
 236   //
 237   return (Pz()==0)?TMath::PiOver2():TMath::ACos(Pz()/P());
 238 }
 239 Double32_t AliCFPair::Eta() const {
 240   //
 241   // returns pair pseudo-rapidity
 242   //
 243   Double32_t pmom = P();
 244   Double32_t pz = Pz();
 245   if (pmom != TMath::Abs(pz)) return 0.5*TMath::Log((pmom+pz)/(pmom-pz));
 246   else                        return 999;
 247 }
 248 Double32_t AliCFPair::Y() const {
 249   //
 250   // returns pair rapidity
 251   //
 252   Double32_t e  = E();
 253   Double32_t pz = Pz();
 254
 255   if (e == pz || e == -pz) {
 256     printf("GetRapidity : ERROR : rapidity for 4-vector with E = Pz -- infinite result");
 257     return 999;
 258   }
 259   if (e < pz) {
 260     printf("GetRapidity : ERROR : rapidity for 4-vector with E = Pz -- infinite result");
 261     return 999;
 262   }
 263   Double32_t y = 0.5 * log((e + pz) / (e - pz));
 264   return y;
 265 }
 266 Double32_t AliCFPair::M() const {
 267   //
 268   // returns pair invariant mass
 269   // in case of a V0, returns the current mass hypothesis
 270   // otherwise returns ESD-calculated mass
 271   //
 272
 273   Double32_t minv = 0. ;
 274
 275   if (fIsV0) {
 276     if      (fESDV0) {
 277       fESDV0->ChangeMassHypothesis(fV0PDG);
 278       minv = (Double32_t)fESDV0->GetEffMass();
 279     }
 280     else if (fAODV0) {
 281       switch (fV0PDG) {
 282       case 310  : minv = fAODV0->MassK0Short()    ; break ;
 283       case 3122 : minv = fAODV0->MassLambda()     ; break ;
 284       case -3122: minv = fAODV0->MassAntiLambda() ; break ;
 285       default:    minv = -1.              ; break ;
 286       }
 287     }
 288     else Error("PxPyPz","Pointer to V0 not found");
 289   }
 290   else if (fTrackNeg && fTrackPos) {
 291     Double32_t p  = P() ;
 292     Double32_t e =0. ;
 293     if (fMassNeg==0. && fMassPos==0.) {
 294       e = fTrackNeg->E() + fTrackPos->E() ;
 295     }
 296     else {
 297       e =
 298         TMath::Sqrt(TMath::Power(fTrackNeg->P(),2)+TMath::Power(fMassNeg,2)) +
 299         TMath::Sqrt(TMath::Power(fTrackPos->P(),2)+TMath::Power(fMassPos,2)) ;
 300     }
 301     minv = TMath::Sqrt(e*e-p*p);
 302   }
 303   else Error("M","Could not find V0 nor track pointers");
 304
 305   return minv ;
 306 }