]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG2/FLOW/AliFlowMaker.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
namespace added for constants
[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowMaker.cxx
CommitLineData
9777bfcb 1//////////////////////////////////////////////////////////////////////
2//
3// $Id$
4//
5// Author: Emanuele Simili
6//
7//////////////////////////////////////////////////////////////////////
8//_____________________________________________________________
9//
10// Description:
11// AliFlowMaker provides the method to create AliFlowEvent(s)
12// from AliESD(s). Very basic track cuts are applyed.
13// The present class can be used in a simple AliRoot macro or in a
14// more complex enviroment such as AliSelector or AliTask.
15//
16//////////////////////////////////////////////////////////////////////
17
18#ifndef ALIFLOWMAKER_CXX
19#define ALIFLOWMAKER_CXX
20
21// ROOT things
22#include <TROOT.h>
23#include <TFile.h>
9777bfcb 24#include <TString.h>
92016a03 25#include <TMath.h>
26#include "TClonesArray.h"
9777bfcb 27
28// AliRoot things
29#include "AliESD.h"
30#include "AliESDVertex.h"
31#include "AliESDtrack.h"
32#include "AliESDv0.h"
327288af 33//#include "AliKalmanTrack.h"
9777bfcb 34
35// Flow things
36#include "AliFlowEvent.h"
37#include "AliFlowTrack.h"
38#include "AliFlowV0.h"
39#include "AliFlowConstants.h"
40#include "AliFlowMaker.h"
41
42// ANSI things
9777bfcb 43#include <stdlib.h>
da5aa0a0 44#include <vector>
45
9777bfcb 46using namespace std; //required for resolving the 'cout' symbol
47
da4d7f17 48ClassImp(AliFlowMaker)
9777bfcb 49//-----------------------------------------------------------------------
4e566f2f 50AliFlowMaker::AliFlowMaker():
c1a88675 51 fEventNumber(0), fTrackNumber(0), fV0Number(0), fGoodTracks(0), fGoodV0s(0),
52 fGoodTracksEta(0), fPosiTracks(0), fNegaTracks(0), fUnconstrained(0),
da5aa0a0 53 fSumAll(0), fCutEvts(0), fCutTrks(0), fCutV0s(0), fCounter(0), fMovedTr(0x0),
54 fNewAli(kFALSE), fLoopTrks(kTRUE), fLoopV0s(kTRUE),
4e566f2f 55 fESD(0x0), fTrack(0x0), fV0(0x0), fVertex(0x0),
c1a88675 56 fRunID(0), fNumberOfEvents(0), fNumberOfTracks(0),
57 fNumberOfV0s(0), fMagField(0),
58 fFlowEvent(0x0), fFlowTrack(0x0), fFlowV0(0x0),
59 fNHits(0), fElow(0.001), fEup(1000.)
9777bfcb 60{
61 // default constructor
62 // resets counters , sets defaults
63
9777bfcb 64 for(Int_t bb=0;bb<5;bb++) { fBayesianAll[bb] = 0 ; } ;
9777bfcb 65
66 // trak cuts
9777bfcb 67 fLabel[0] = 0 ; fLabel[1] = -1 ;
68}
69//-----------------------------------------------------------------------
70AliFlowMaker::~AliFlowMaker()
71{
72 // default destructor (no actions)
73}
74//-----------------------------------------------------------------------
75
76//-----------------------------------------------------------------------
77AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
78{
79 // From the AliESD (input) fills the AliFlowEvent (output) .
80 // It loops on track & v0 and calls the methods to fill the arrays .
81 // ... .
82
da5aa0a0 83 fFlowEvent = new AliFlowEvent(10000) ; if(!fFlowEvent) { return 0 ; }
9777bfcb 84 //cout << " -evt- " << fFlowEvent << endl ;
85
86 fRunID = fESD->GetRunNumber() ;
92016a03 87 fEventNumber = -1 ;
88 // fEventNumber = fESD->GetEventNumber() ;
9777bfcb 89 fNumberOfTracks = fESD->GetNumberOfTracks() ;
90 fNumberOfV0s = fESD->GetNumberOfV0s() ;
91 //
92 cout << " *evt n. " << fEventNumber << " (run " << fRunID << ") - tracks: " << fNumberOfTracks << " , v0s " << fNumberOfV0s << endl ;
da5aa0a0 93
94 // Clean the vector of links esd-flowEvt
95 fMovedTr.clear(); // Remove all elements
9777bfcb 96
97 // Event id
98 fFlowEvent->SetRunID(fRunID) ;
99 fFlowEvent->SetEventID(fEventNumber) ;
100 fFlowEvent->SetOrigMult((UInt_t)fNumberOfTracks) ;
101
102 // Run information (fixed - ???)
103 fMagField = fESD->GetMagneticField() ; // cout << " *fMagField " << fMagField << endl ;
104 fFlowEvent->SetMagneticField(fMagField) ;
92016a03 105 fFlowEvent->SetCenterOfMassEnergy(AliFlowConstants::fgCenterOfMassEnergy) ;
106 fFlowEvent->SetBeamMassNumberEast(AliFlowConstants::fgBeamMassNumberEast) ;
107 fFlowEvent->SetBeamMassNumberWest(AliFlowConstants::fgBeamMassNumberWest) ;
9777bfcb 108
109 // Trigger information (now is: ULon64_t - some trigger mask)
110 fFlowEvent->SetL0TriggerWord((Int_t)fESD->GetTriggerMask());
111
112 // Get primary vertex position
113 fVertex = (AliESDVertex*)fESD->GetVertex() ;
114 Double_t position[3] ;
115 fVertex->GetXYZ(position) ;
116 fFlowEvent->SetVertexPos((Float_t)position[0],(Float_t)position[1],(Float_t)position[2]) ;
117
118 // Zero Degree Calorimeter information
119 Int_t zdcp = fESD->GetZDCParticipants() ;
120 Float_t zdce[3] ;
121 zdce[0] = fESD->GetZDCN1Energy() + fESD->GetZDCN2Energy();
122 zdce[1] = fESD->GetZDCP1Energy() + fESD->GetZDCP2Energy() ;
123 zdce[2] = fESD->GetZDCEMEnergy() ;
124 fFlowEvent->SetZDCpart(zdcp);
125 fFlowEvent->SetZDCenergy(zdce[0],zdce[1],zdce[2]);
126
127 // Track loop
128 if(fLoopTrks)
129 {
92016a03 130 Int_t badTrks = 0 ;
9777bfcb 131 for(fTrackNumber=0;fTrackNumber<fNumberOfTracks;fTrackNumber++)
132 {
133 fTrack = fESD->GetTrack(fTrackNumber) ;
134 if(CheckTrack(fTrack))
135 {
92016a03 136 FillFlowTrack(fTrack) ;
9777bfcb 137 fGoodTracks++ ;
da5aa0a0 138 fMovedTr.push_back(fFlowEvent->TrackCollection()->GetLast()) ;
9777bfcb 139 }
da5aa0a0 140 else { fMovedTr.push_back(-1) ; badTrks++ ; continue ; }
9777bfcb 141 }
142 fCutTrks += badTrks ;
92016a03 143 } // cout << " -track number- : " << fTrackNumber << endl ;
9777bfcb 144
145 // V0 loop
146 if(fLoopV0s)
147 {
148 Int_t badV0s = 0 ;
149 for(fV0Number=0;fV0Number<fNumberOfV0s;fV0Number++)
150 {
151 fV0 = fESD->GetV0(fV0Number) ;
152 if(CheckV0(fV0))
153 {
92016a03 154 FillFlowV0(fV0) ;
9777bfcb 155 fGoodV0s++ ;
156 }
157 else { badV0s++ ; continue ; }
158 }
159 fCutV0s += badV0s ;
92016a03 160 } // cout << " -v0 number- : " << fV0Number << endl ;
9777bfcb 161
162 // Evt setting stuff
163 fFlowEvent->SetCentrality();
164
165 fCounter++ ;
166 return fFlowEvent ;
167}
168//----------------------------------------------------------------------
169AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
170{
171 // From the AliESDtrack (input) fills the AliFlowTrack (output) .
172
173 TString name = "" ; name += fTrackNumber ;
92016a03 174 Int_t idx = fFlowEvent->TrackCollection()->GetEntries() ;
175 fFlowTrack = (AliFlowTrack*)(fFlowEvent->TrackCollection()->New(idx)) ;
176 fFlowTrack->SetName(name.Data()) ;
9777bfcb 177
92016a03 178 // cout << " -tr- " << name.Data() << "(" << idx << ")" << endl ;
179
9777bfcb 180 // ESD particle label (link: KineTree-ESD)
181 Int_t label = TMath::Abs(fTrack->GetLabel());
182 fFlowTrack->SetLabel(label) ;
183
184 // signed DCA from ESDtrack
185 Float_t xy = 0 ; Float_t z = 0 ;
186 fTrack->GetImpactParameters(xy,z) ;
187 fFlowTrack->SetDcaSigned(xy,z) ;
188
92016a03 189 // error on the DCA
190 Float_t dcaBis[2] ; Float_t dcaCov[3] ;
191 for(Int_t dd=0;dd<3;dd++) { dcaCov[dd] = 0. ; }
192 fTrack->GetImpactParameters(dcaBis, dcaCov) ;
193 fFlowTrack->SetDcaError(dcaCov[0],dcaCov[1],dcaCov[2]) ;
194
9777bfcb 195 // UnConstrained (global) first
196 Double_t gD[3] ;
197 fTrack->GetPxPyPz(gD) ;
198 // -
199 Float_t phiGl = (Float_t)Phi(gD) ;
200 if(phiGl<0) { phiGl += 2*TMath::Pi() ; }
201 fFlowTrack->SetPhiGlobal(phiGl) ;
92016a03 202 Float_t ptGl = (Float_t)Pt(gD) ; if(ptGl<=0) { cout << " !!! ptGlobal = " << ptGl << endl ; }
9777bfcb 203 fFlowTrack->SetPtGlobal(ptGl) ;
204 Float_t etaGl = (Float_t)Eta(gD) ;
205 fFlowTrack->SetEtaGlobal(etaGl) ;
206
207 // Constrained (NEW)
208 Double_t cD[3] ;
209 Double_t par1 ; Double_t par2 ; Double_t par3[3] ;
210 if(fTrack->GetConstrainedExternalParameters(par1,par2,par3))
211 {
212 fTrack->GetConstrainedPxPyPz(cD) ;
213 }
214 else { for(Int_t iii=0;iii<3;iii++) { cD[iii] =0 ; } }
215
216 if(Norm(cD)!=0.) // ConstrainedPxPyPz != 0 if ConstrainedChi2 < something ...
217 {
218 Float_t phi = (Float_t)Phi(cD) ;
219 if(phi<0) { phi += 2*TMath::Pi() ; }
220 fFlowTrack->SetPhi(phi) ;
92016a03 221 Float_t pt = (Float_t)Pt(cD) ; if(pt<=0) { cout << " !!! pt = " << pt << endl ; }
9777bfcb 222 fFlowTrack->SetPt(pt) ;
223 Float_t eta = (Float_t)Eta(cD) ;
224 fFlowTrack->SetEta(eta) ;
225
327288af 226 // number of constrainable tracks with |eta| < AliFlowConstants::fgEtaGood (0.9)
da5aa0a0 227 if(TMath::Abs(eta) < AliFlowConstants::fgEtaMid) { fGoodTracksEta++ ; }
9777bfcb 228 }
229 else // in case Constriction impossible for track, fill the UnConstrained (global)
230 {
231 fUnconstrained++ ;
232 fFlowTrack->SetPhi(0.) ;
233 fFlowTrack->SetPt(0.) ;
234 fFlowTrack->SetEta(0.) ;
235 }
236
237 // positive - negative tracks
327288af 238 Int_t trkSign = (Int_t)fTrack->GetSign() ;
239 fFlowTrack->SetCharge(trkSign) ;
240 if(trkSign>0) { fPosiTracks++ ; }
241 else if(trkSign<0) { fNegaTracks++ ; }
9777bfcb 242 else { return 0 ; }
243
244 // Tracking parameters (fit , TPC , ITS , dE/dx)
245 fFlowTrack->SetChi2(fTrack->GetConstrainedChi2()) ;
246 fFlowTrack->SetTrackLength(fTrack->GetIntegratedLength()) ;
247 // -
248 Int_t idXt[180] ; // used for Cluster Map ( see AliESDtrack::GetTPCclusters() ) // old: Int
249 Int_t idX[6] ; // used for Cluster Map ( see AliESDtrack::GetITSclusters() ) // old: UInt
250 Int_t idxr[130] ; // used for Cluster Map ( see AliESDtrack::GetTRDclusters() ) // old: UInt
251 Int_t nClus = 0 ;
252 Int_t fNFound = 0 ; // *!* fNFoundable (in AliTPCtrack) ... added by M.Ianov
4e566f2f 253 // -
254 Double_t detPid[5] ;
255 Float_t detPid6[AliFlowConstants::kPid] ;
256
9777bfcb 257 Double_t pVecAt[3] ;
258 for(Int_t gg=0;gg<3;gg++) { pVecAt[gg] = gD[gg] ; }
259 Bool_t boh ; Float_t pAt = 0 ; // to get p at each detector
260 // -
327288af 261 if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTPCx, fMagField, pVecAt) ; }
262 else { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTPCx, fMagField, pVecAt) ; }
9777bfcb 263 pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
264 nClus = fTrack->GetTPCclusters(idXt) ;
265 fNFound = fTrack->GetTPCNclsF() ; // was 160
4e566f2f 266 if( (fTrack->GetStatus() & AliESDtrack::kTPCpid) != 0 )
267 {
268 fTrack->GetTPCpid(detPid) ;
269 for(Int_t bb=0;bb<5;bb++) { detPid6[bb] = detPid[bb] ; } detPid6[5] = 0. ;
270 fFlowTrack->SetRespFunTPC(detPid6) ;
271 }
9777bfcb 272 fFlowTrack->SetMaxPtsTPC(fNFound) ;
273 fFlowTrack->SetFitPtsTPC(nClus) ;
274 fFlowTrack->SetDedxTPC(fTrack->GetTPCsignal()) ;
275 fFlowTrack->SetChi2TPC((Float_t)(fTrack->GetTPCchi2())) ;
276 fFlowTrack->SetPatTPC(pAt) ;
277 // -
327288af 278 if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgITSx, fMagField, pVecAt) ; }
279 else { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgITSx, fMagField, pVecAt) ; }
9777bfcb 280 pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
281 nClus = fTrack->GetITSclusters(idX) ;
4e566f2f 282 fNFound = 6 ; // ? fixed
283 if( (fTrack->GetStatus() & AliESDtrack::kITSpid) != 0 )
284 {
285 fTrack->GetITSpid(detPid) ;
286 for(Int_t bb=0;bb<5;bb++) { detPid6[bb] = detPid[bb] ; } detPid6[5] = 0. ;
287 fFlowTrack->SetRespFunITS(detPid6) ;
288 }
9777bfcb 289 fFlowTrack->SetMaxPtsITS(fNFound) ;
290 fFlowTrack->SetFitPtsITS(nClus) ;
291 fFlowTrack->SetDedxITS(fTrack->GetITSsignal()) ;
292 fFlowTrack->SetChi2ITS((Float_t)(fTrack->GetITSchi2())) ;
293 fFlowTrack->SetPatITS(pAt) ;
294 // -
327288af 295 if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTRDx, fMagField, pVecAt) ; }
296 else { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTRDx, fMagField, pVecAt) ; }
9777bfcb 297 pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
9777bfcb 298 nClus = fTrack->GetTRDclusters(idxr) ;
4e566f2f 299 fNFound = fTrack->GetTRDncls() ; // was 130
300 if( (fTrack->GetStatus() & AliESDtrack::kTRDpid) != 0 )
301 {
302 fTrack->GetTRDpid(detPid) ;
303 for(Int_t bb=0;bb<5;bb++) { detPid6[bb] = detPid[bb] ; } detPid6[5] = 0. ;
304 fFlowTrack->SetRespFunTRD(detPid6) ;
305 }
9777bfcb 306 fFlowTrack->SetMaxPtsTRD(fNFound) ;
307 fFlowTrack->SetNhitsTRD(nClus) ;
308 fFlowTrack->SetSigTRD(fTrack->GetTRDsignal()) ;
309 fFlowTrack->SetChi2TRD((Float_t)fTrack->GetTRDchi2()) ;
310 fFlowTrack->SetPatTRD(pAt) ;
311 // -
327288af 312 if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTOFx, fMagField, pVecAt) ; }
313 else { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTOFx, fMagField, pVecAt) ; }
9777bfcb 314 pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
9777bfcb 315 nClus = fTrack->GetTOFcluster() ;
4e566f2f 316 fNFound = 0 ; if(fTrack->GetTOFCalChannel() > 0) { fNFound = 1 ; }
317 if( (fTrack->GetStatus() & AliESDtrack::kTOFpid) != 0 )
318 {
319 fTrack->GetTOFpid(detPid) ;
320 for(Int_t bb=0;bb<5;bb++) { detPid6[bb] = detPid[bb] ; } detPid6[5] = 0. ;
321 fFlowTrack->SetRespFunTOF(detPid6) ;
322 }
9777bfcb 323 fFlowTrack->SetMaxPtsTOF(fNFound) ;
324 fFlowTrack->SetNhitsTOF(nClus) ;
325 fFlowTrack->SetTofTOF(fTrack->GetTOFsignal()) ;
326 fFlowTrack->SetChi2TOF(fTrack->GetTOFchi2()) ;
327 fFlowTrack->SetPatTOF(pAt) ;
328 // -
329 Double_t rIn[3] ; rIn[0] = 0. ; rIn[1] = 0. ; rIn[2] = 0. ;
330 Double_t rOut[3] ; rOut[0] = 0. ; rOut[1] = 0. ; rOut[2] = 0. ;
331 // -
332 fTrack->GetInnerXYZ(rIn) ;
333 fFlowTrack->SetZFirstPoint(rIn[2]) ;
327288af 334 //fTrack->GetXYZAt(AliFlowConstants::fgTPCx,fMagField,rOut) ;
9777bfcb 335 fTrack->GetOuterXYZ(rOut) ;
336 fFlowTrack->SetZLastPoint(rOut[2]) ;
337
338 // ESD-P.Id. = 5-vector of Best detectors probabilities for [e , mu , pi , K , p]
339 Double_t trkPid[5] ; fTrack->GetESDpid(trkPid) ;
327288af 340 Double_t trkPid6[AliFlowConstants::kPid] ;
9777bfcb 341 for(Int_t bb=0;bb<5;bb++) { trkPid6[bb] = trkPid[bb] ; }
342 trkPid6[5] = 0. ; // *!* implement P.Id. for Deuterim
343
344 // Bayesian P.Id. method (weighted probabilities for [e , mu , pi , K , p , d])
327288af 345 Double_t bsum = 0 ;
346 Double_t bayePid[AliFlowConstants::kPid] ; // normalized P.id
347 Double_t storedPid[AliFlowConstants::kPid] ; // stored P.id
348 for(Int_t nB=0;nB<AliFlowConstants::kPid;nB++) { bsum += trkPid6[nB]*AliFlowConstants::fgBayesian[nB] ; }
349 if(bsum)
9777bfcb 350 {
327288af 351 for(Int_t nB=0;nB<AliFlowConstants::kPid;nB++)
9777bfcb 352 {
327288af 353 bayePid[nB] = trkPid6[nB]*AliFlowConstants::fgBayesian[nB] / bsum ;
9777bfcb 354 storedPid[nB] = trkPid6[nB] ;
355 }
356 }
357 else { cout << " ERROR - Empty Bayesian Vector !!! " << endl ; }
358
359 fFlowTrack->SetElectronPositronProb(storedPid[0]);
360 fFlowTrack->SetMuonPlusMinusProb(storedPid[1]);
361 fFlowTrack->SetPionPlusMinusProb(storedPid[2]);
362 fFlowTrack->SetKaonPlusMinusProb(storedPid[3]);
363 fFlowTrack->SetProtonPbarProb(storedPid[4]);
364 fFlowTrack->SetDeuteriumAntiDeuteriumProb(storedPid[5]); // *!* implement P.Id. for Deuterim
365
366 // P.id. label given via the weighted prob.
327288af 367 const Int_t kCode[] = {11,13,211,321,2212,10010020} ;
9777bfcb 368 Int_t kkk = 2 ; // if No id. -> then is a Pi
327288af 369 Float_t pidMax = bayePid[2] ; // (if all equal, Pi probability get's the advantage to be the first)
9777bfcb 370 for(Int_t iii=0; iii<5; iii++)
371 {
327288af 372 if(bayePid[iii]>pidMax) { kkk = iii ; pidMax = bayePid[iii] ; } // !!! Bayesian as well !!!
9777bfcb 373 }
374 fBayesianAll[kkk]++ ; fSumAll++ ; // goes on filling the vector of observed abundance
375 //-
327288af 376 Int_t pdgCode = trkSign*kCode[kkk] ;
377 fFlowTrack->SetMostLikelihoodPID(pdgCode);
9777bfcb 378
379 return fFlowTrack ;
380}
381//-----------------------------------------------------------------------
382AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
383{
384 // From the AliESDv0 (input) fills the AliFlowV0 (output) .
385
386 TString name = "" ; name += fV0Number ;
92016a03 387 Int_t idx = fFlowEvent->V0Collection()->GetEntries() ;
388 fFlowV0 = (AliFlowV0*)(fFlowEvent->V0Collection()->New(idx)) ;
389 fFlowV0->SetName(name.Data()) ;
390
391 // cout << " -v0- " << name.Data() << "(" << idx << ")" << endl ;
392
393 // ESD particle label (link: KineTree-ESD)
394 Int_t label = -1 ; // TMath::Abs(fV0->GetLabel());
395 fFlowV0->SetLabel(label) ;
9777bfcb 396
92016a03 397 // reconstructed momentum of the V0
398 Double_t pxyz[3] ;
327288af 399 fV0->GetPxPyPz(pxyz[0],pxyz[1],pxyz[2]) ;
9777bfcb 400
327288af 401 Float_t phi = (Float_t)Phi(pxyz) ; if(phi<0) { phi += 2*TMath::Pi() ; }
9777bfcb 402 fFlowV0->SetPhi(phi) ;
327288af 403 Float_t pt = (Float_t)Pt(pxyz) ;
9777bfcb 404 fFlowV0->SetPt(pt) ;
327288af 405 Float_t eta = (Float_t)Eta(pxyz) ;
9777bfcb 406 fFlowV0->SetEta(eta) ;
407
92016a03 408 // reconstructed position of the V0
409 Double_t xyz[3] ;
9777bfcb 410 fV0->GetXYZ(xyz[0],xyz[1],xyz[2]) ;
411 fFlowV0->SetCrossPoint(xyz[0],xyz[1],xyz[2]) ;
412
92016a03 413 // V0's impact parameter & error (chi2 , DCA , sigma , pointing angle)
414 //fFlowV0->SetDca((Float_t)fV0->GetD()) ; // GetDistNorm
415 //fFlowV0->SetSigma((Float_t)fV0->GetDistSigma()) ;
416 //fFlowV0->SetCosPointingAngle((Float_t)fV0->GetV0CosineOfPointingAngle()) ;
4e566f2f 417 //fFlowV0->SetDaughtersDca(fV0->GetDcaV0Daughters()) ;
92016a03 418 //fFlowV0->SetChi2((Float_t)fV0->GetChi2V0()) ; // AliRoot v4-04-Release (December 2006)
419 //fFlowV0->SetChi2((Float_t)fV0->GetChi2()) ; // AliRoot v4-04-Release (old)
420 // ...when they'll stop changing the methods I'll enable the above lines. For now:
421 fFlowV0->SetDca(0.);
422 fFlowV0->SetSigma(0.1);
423 fFlowV0->SetCosPointingAngle(1.) ;
424 fFlowV0->SetDaughtersDca(0.) ;
9777bfcb 425 fFlowV0->SetChi2(1.) ;
9777bfcb 426
427 // P.id.
327288af 428 Int_t pdgCode = fV0->GetPdgCode() ;
429 fFlowV0->SetMostLikelihoodPID(pdgCode);
9777bfcb 430
431 // mass
432 fFlowV0->SetVmass((Float_t)fV0->GetEffMass()) ;
433
92016a03 434 // daughters
9777bfcb 435 Int_t pN = fV0->GetPindex() ;
436 Int_t nN = fV0->GetNindex() ;
da5aa0a0 437 fFlowV0->SetDaughters(fMovedTr[pN],fMovedTr[nN]) ;
9777bfcb 438
439 return fFlowV0 ;
440}
441//-----------------------------------------------------------------------
327288af 442Bool_t AliFlowMaker::CheckTrack(AliESDtrack* fTrack) const
9777bfcb 443{
327288af 444 // applies track cuts (pE , nHits , label)
9777bfcb 445
da5aa0a0 446 if(!fTrack) { return kFALSE ; }
447
9777bfcb 448 Int_t idXt[180] ; // used for Cluster Map ( see AliESDtrack::GetTPCclusters() )
449 Int_t nHits = fTrack->GetTPCclusters(idXt) ;
327288af 450 Float_t pE = fTrack->GetP() ;
9777bfcb 451 Int_t label = fTrack->GetLabel() ;
452
453 if(fNHits && (nHits<=fNHits)) { return kFALSE ; }
327288af 454 if((fElow < fEup) && ((pE<fElow) || (pE>fEup))) { return kFALSE ; }
9777bfcb 455 if((fLabel[0] < fLabel[1]) && ((label<fLabel[0]) || (label>fLabel[1]))) { return kFALSE ; }
456 //if(fPrimary && ...) { return kFALSE ; }
457
458 return kTRUE ;
459}
460//-----------------------------------------------------------------------
327288af 461Bool_t AliFlowMaker::CheckV0(AliESDv0* fV0) const
9777bfcb 462{
da5aa0a0 463 // applies v0 cuts (mass>fElow, daughters included in the tracks)
51a9b7d8 464
465 if(!fV0) { return kFALSE ; }
da5aa0a0 466
467 Int_t pN = fV0->GetPindex() ;
468 Int_t nN = fV0->GetNindex() ;
469 Float_t iMass = (Float_t)fV0->GetEffMass() ;
470
471 if(iMass < fElow) { return kFALSE ; }
472 if(fMovedTr[pN] < 0) { return kFALSE ; }
473 if(fMovedTr[nN] < 0) { return kFALSE ; }
9777bfcb 474
475 return kTRUE ;
476}
477//-----------------------------------------------------------------------
327288af 478Bool_t AliFlowMaker::CheckEvent(AliESD* fESD) const
9777bfcb 479{
480 // applies event cuts (dummy)
51a9b7d8 481
482 if(!fESD) { return kFALSE ; }
9777bfcb 483
484 return kTRUE ;
485}
486//-----------------------------------------------------------------------
487void AliFlowMaker::PrintCutList()
488{
489 // Prints the list of Cuts
490
491 cout << " * ESD cuts list * " << endl ;
492 if(fLabel[0]<fLabel[1])
493 {
494 cout << " Track Label [ " << fLabel[0] << " , " << fLabel[1] << " ] " << endl ;
495 }
496 if(fNHits)
497 {
498 cout << " TPC clusters > " << fNHits << endl ;
499 }
500 if(fElow<fEup)
501 {
502 cout << " Track Energy (P_total) [ " << fElow << " , " << fEup << " ] " << endl ;
503 }
da5aa0a0 504 if(fElow>0.)
505 {
506 cout << " V0 invariant mass > " << fElow << endl ;
507 }
9777bfcb 508 cout << " * * " << endl ;
509}
510//-----------------------------------------------------------------------
511
512//-----------------------------------------------------------------------
513//*** USEFULL METHODS for a 3-array of double (~ TVector3) ***
514//-----------------------------------------------------------------------
515Double_t AliFlowMaker::Norm(Double_t nu[3])
516{
517 // returns the norm of a double[3]
518
519 Double_t norm2 = nu[0]*nu[0] + nu[1]*nu[1] + nu[2]*nu[2] ;
520 return TMath::Sqrt(norm2) ;
521}
522//-----------------------------------------------------------------------
523Double_t AliFlowMaker::Phi(Double_t nu[3])
524{
525 // returns the azimuthal angle of a double[3]
526
527 if(nu[0]==0 && nu[1]==0) { return 0. ; }
528 else { return TMath::ATan2(nu[1],nu[0]) ; }
529}
530//-----------------------------------------------------------------------
531Double_t AliFlowMaker::Pt(Double_t nu[3])
532{
533 // returns the transvers momentum of a double[3]
534
535 Double_t trans = nu[0]*nu[0] + nu[1]*nu[1] ;
536 return TMath::Sqrt(trans) ;
537}
538//-----------------------------------------------------------------------
539Double_t AliFlowMaker::Eta(Double_t nu[3])
540{
541 // returns the PseudoRapidity of a double[3]
542 // if transvers momentum = 0 --> returns +/- 1.000
543
544 Double_t m = Norm(nu) ;
545 if(nu[0]!=0 || nu[1]!=0) { return 0.5*TMath::Log((m+nu[2])/(m-nu[2])) ; }
546 else { return TMath::Sign((Double_t)1000.,nu[2]) ; }
547}
548//-----------------------------------------------------------------------
549
550#endif