STEER/STEERBase/AliEventplane.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2008, 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 //   Class AliEventplane
  18 //   author: Alberica Toia, Johanna Gramling
  19 //*****************************************************
  20 /// A container for the event plane stored in AOD in ESD
  21
  22 #include "AliLog.h"
  23 #include "AliEventplane.h"
  24 #include "TVector2.h"
  25 #include "AliVTrack.h"
  26 #include "TObjArray.h"
  27 #include "TArrayF.h"
  28 #include "AliVEvent.h"
  29 #include "AliVVZERO.h"
  30
  31 ClassImp(AliEventplane)
  32
  33 AliEventplane::AliEventplane() : TNamed("Eventplane", "Eventplane"),
  34   fQVector(0),
  35   fQContributionX(0),
  36   fQContributionY(0),
  37   fQContributionXsub1(0),
  38   fQContributionYsub1(0),
  39   fQContributionXsub2(0),
  40   fQContributionYsub2(0),
  41   fEventplaneQ(-1),
  42   fQsub1(0),
  43   fQsub2(0),
  44   fQsubRes(0)
  45 {
  46   /// constructor
  47   fQContributionX = new TArrayF(0);
  48   fQContributionY = new TArrayF(0);
  49   fQContributionXsub1 = new TArrayF(0);
  50   fQContributionYsub1 = new TArrayF(0);
  51   fQContributionXsub2 = new TArrayF(0);
  52   fQContributionYsub2 = new TArrayF(0);
  53 }
  54
  55 AliEventplane::AliEventplane(const AliEventplane& ep) :
  56   TNamed(),
  57   fQVector(0),
  58   fQContributionX(0),
  59   fQContributionY(0),
  60   fQContributionXsub1(0),
  61   fQContributionYsub1(0),
  62   fQContributionXsub2(0),
  63   fQContributionYsub2(0),
  64   fEventplaneQ(0),
  65   fQsub1(0),
  66   fQsub2(0),
  67   fQsubRes(0)
  68 {
  69   /// Copy constructor
  70   ((AliEventplane &) ep).CopyEP(*this);
  71 }
  72
  73 AliEventplane& AliEventplane::operator=(const AliEventplane& ep)
  74 {
  75   /// Assignment operator
  76   if (this!=&ep)
  77     ((AliEventplane &) ep).CopyEP(*this);
  78
  79   return *this;
  80 }
  81
  82 void AliEventplane::CopyEP(AliEventplane& ep) const
  83 { // copy function
  84
  85   AliEventplane& target = (AliEventplane &) ep;
  86   if (fQContributionX)
  87       target.fQContributionX = fQContributionX;
  88   if (fQContributionY)
  89       target.fQContributionY = fQContributionY;
  90   if (fQContributionXsub1)
  91       target.fQContributionXsub1 = fQContributionXsub1;
  92   if (fQContributionYsub1)
  93       target.fQContributionYsub1 = fQContributionYsub1;
  94   if (fQContributionXsub2)
  95       target.fQContributionXsub2 = fQContributionXsub2;
  96   if (fQContributionYsub2)
  97       target.fQContributionYsub2 = fQContributionYsub2;
  98   if (fEventplaneQ)
  99       target.fEventplaneQ = fEventplaneQ;
 100   if (fQVector)
 101       target.fQVector = dynamic_cast<TVector2*> (fQVector->Clone());
 102   if (fQsub1)
 103       target.fQsub1 = dynamic_cast<TVector2*> (fQsub1->Clone());
 104   if (fQsub2)
 105       target.fQsub2 = dynamic_cast<TVector2*> (fQsub2->Clone());
 106   if (fQsubRes)
 107       target.fQsubRes = fQsubRes;
 108 }
 109
 110 AliEventplane::~AliEventplane()
 111 {
 112   /// destructor
 113   if (fQContributionX){
 114       delete fQContributionX;
 115       fQContributionX = 0;
 116   }
 117   if (fQContributionY){
 118       delete fQContributionY;
 119       fQContributionY = 0;
 120   }
 121   if (fQContributionXsub1){
 122       delete fQContributionXsub1;
 123       fQContributionXsub1 = 0;
 124   }
 125   if (fQContributionYsub1){
 126       delete fQContributionYsub1;
 127       fQContributionYsub1 = 0;
 128   }
 129   if (fQContributionXsub2){
 130       delete fQContributionXsub2;
 131       fQContributionXsub2 = 0;
 132   }
 133   if (fQContributionYsub2){
 134       delete fQContributionYsub2;
 135       fQContributionYsub2 = 0;
 136   }
 137   if (fQVector){
 138       delete fQVector;
 139       fQVector = 0;
 140   }
 141   if (fQsub1){
 142       delete fQsub1;
 143       fQsub1 = 0;
 144   }
 145     if (fQsub2){
 146       delete fQsub2;
 147       fQsub2 = 0;
 148   }
 149 }
 150
 151 TVector2* AliEventplane::GetQVector()
 152 {
 153   return fQVector;
 154 }
 155
 156 Double_t AliEventplane::GetEventplane(const char *x, const AliVEvent *event, Int_t harmonic) const
 157 {
 158   TString method = x;
 159   if(method.CompareTo("Q")==0)      return fEventplaneQ;
 160   else if(method.CompareTo("V0A")==0) return CalculateVZEROEventPlane(event, 4, 7, harmonic);
 161   else if(method.CompareTo("V0C")==0) return CalculateVZEROEventPlane(event, 0, 3, harmonic);
 162   else if(method.CompareTo("V0")==0)  return CalculateVZEROEventPlane(event, 0, 7, harmonic);
 163
 164   return -1000.;
 165 }
 166
 167 Double_t AliEventplane::CalculateVZEROEventPlane(const AliVEvent *  event, Int_t firstRing, Int_t lastRing, Int_t harmonic) const
 168 {
 169   if(!event) {
 170     AliError("No Event received");
 171     return -1000.;
 172   }
 173   AliVVZERO *vzeroData = event->GetVZEROData();
 174   if(!vzeroData) {
 175     AliError("Enable to get VZERO Data");
 176     return -1000.;
 177   }
 178   if(harmonic <= 0) {
 179     AliError("Required harmonic is less or equal to 0");
 180     return -1000.;
 181   }
 182
 183   Double_t qx=0., qy=0.;
 184   for(Int_t iCh = firstRing*8; iCh < (lastRing+1)*8; ++iCh) {
 185     if(iCh<32) {
 186       if(!vzeroData->BBTriggerV0C(iCh)) continue;
 187     }
 188     else {
 189       if(!vzeroData->BBTriggerV0A(iCh)) continue;
 190     }
 191     Double_t phi = TMath::Pi()/8. + (iCh%8) * TMath::Pi()/4.;
 192
 193     Double_t mult = event->GetVZEROEqMultiplicity(iCh);
 194
 195     qx += mult*TMath::Cos(harmonic*phi);
 196     qy += mult*TMath::Sin(harmonic*phi);
 197   }
 198   return (TMath::ATan2(qy,qx)/harmonic);
 199 }
 200
 201
 202 TVector2* AliEventplane::GetQsub1()
 203 {
 204   return fQsub1;
 205 }
 206
 207 TVector2* AliEventplane::GetQsub2()
 208 {
 209   return fQsub2;
 210 }
 211
 212 Double_t AliEventplane::GetQsubRes()
 213 {
 214   return fQsubRes;
 215 }
 216
 217 Bool_t AliEventplane::IsEventInEventplaneClass(Double_t a, Double_t b, const char *x)
 218 {
 219   TString method = x;
 220   if ((method.CompareTo("Q")==0) && (fEventplaneQ >=a && fEventplaneQ < b)) return kTRUE;
 221   else return kFALSE;
 222 }
 223
 224 Double_t AliEventplane::GetQContributionX(AliVTrack* track)
 225 {
 226   return fQContributionX->GetAt(track->GetID());
 227 }
 228
 229 Double_t AliEventplane::GetQContributionY(AliVTrack* track)
 230 {
 231   return fQContributionY->GetAt(track->GetID());
 232 }
 233
 234 Double_t AliEventplane::GetQContributionXsub1(AliVTrack* track)
 235 {
 236   return fQContributionXsub1->GetAt(track->GetID());
 237 }
 238
 239 Double_t AliEventplane::GetQContributionYsub1(AliVTrack* track)
 240 {
 241   return fQContributionYsub1->GetAt(track->GetID());
 242 }
 243
 244 Double_t AliEventplane::GetQContributionXsub2(AliVTrack* track)
 245 {
 246   return fQContributionXsub2->GetAt(track->GetID());
 247 }
 248
 249 Double_t AliEventplane::GetQContributionYsub2(AliVTrack* track)
 250 {
 251   return fQContributionYsub2->GetAt(track->GetID());
 252 }
 253
 254 void AliEventplane::Reset()
 255 {
 256   delete fQVector; fQVector=0;
 257   fQContributionX->Reset();
 258   fQContributionY->Reset();
 259   fQContributionXsub1->Reset();
 260   fQContributionYsub1->Reset();
 261   fQContributionXsub2->Reset();
 262   fQContributionYsub2->Reset();
 263   fEventplaneQ = -1;
 264   delete fQsub1; fQsub1=0;
 265   delete fQsub2; fQsub2=0;
 266   fQsubRes = 0;
 267 }