]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG2/RESONANCES/AliRsnValueStd.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Implementation of all needed changes in the package in order to speed-up the executio...
[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnValueStd.cxx
CommitLineData
c865cb1d 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// This class contains all code which is used to compute any of the values
19// which can be of interest within a resonance analysis. Besides the obvious
20// invariant mass, it allows to compute other utility values on all possible
21// targets, in order to allow a wide spectrum of binning and checks.
22// When needed, this object can also define a binning in the variable which
23// it is required to compute, which is used for initializing axes of output
24// histograms (see AliRsnFunction).
25// The value computation requires this object to be passed the object whose
26// informations will be used. This object can be of any allowed input type
27// (track, pair, event), then this class must inherit from AliRsnTarget.
28// Then, when value computation is attempted, a check on target type is done
29// and computation is successful only if expected target matches that of the
30// passed object.
31// In some cases, the value computation can require a support external object,
32// which must then be passed to this class. It can be of any type inheriting
33// from TObject.
34//
35// authors: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
36// M. Vala (martin.vala@cern.ch)
37//
38////////////////////////////////////////////////////////////////////////////////
39
40#include "AliESDtrackCuts.h"
41#include "AliESDpid.h"
42#include "AliAODPid.h"
43#include "AliCentrality.h"
44
45#include "AliRsnEvent.h"
46#include "AliRsnDaughter.h"
47#include "AliRsnMother.h"
48#include "AliRsnPairDef.h"
49#include "AliRsnDaughterDef.h"
50
51#include "AliRsnValueStd.h"
52
53ClassImp(AliRsnValueStd)
54
55//_____________________________________________________________________________
56AliRsnValueStd::AliRsnValueStd() :
57 AliRsnValue(),
58 fValueType(kValueTypes),
59 fSupportObject(0x0)
60{
61//
62// Default constructor without arguments.
63// Initialize data members to meaningless values.
64// This method is provided for ROOT streaming,
65// but should never be used directly by a user.
66//
67}
68
69//_____________________________________________________________________________
70AliRsnValueStd::AliRsnValueStd
71(const char *name, EValueType type, Int_t nbins, Double_t min, Double_t max) :
72 AliRsnValue(name),
73 fValueType(type),
74 fSupportObject(0x0)
75{
76//
77// Main constructor (version 1).
78// This constructor defines in meaningful way all data members,
79// and defined a fixed binnings, subdividing the specified interval
80// into that many bins as specified in the integer argument.
81// ---
82// This method is also the entry point for all instances
83// of this class which don't need to do binning (e.g.: TNtuple inputs),
84// since arguments 3 to 5 have default values which don't create any
85// binning array, in order not to allocate memory when this is useless.
86//
87
88 SetTargetType(TargetType(type));
89 SetBins(nbins, min, max);
90}
91
92//_____________________________________________________________________________
93AliRsnValueStd::AliRsnValueStd
94(const char *name, EValueType type, Double_t min, Double_t max, Double_t step) :
95 AliRsnValue(name),
96 fValueType(type),
97 fSupportObject(0x0)
98{
99//
100// Main constructor (version 2).
101// This constructor defines in meaningful way all data members
102// and creates enough equal bins of the specified size to cover
103// the required interval.
104//
105
106 SetTargetType(TargetType(type));
107 SetBins(min, max, step);
108}
109
110//_____________________________________________________________________________
111AliRsnValueStd::AliRsnValueStd
112(const char *name, EValueType type, Int_t nbins, Double_t *array) :
113 AliRsnValue(name),
114 fValueType(type),
115 fSupportObject(0x0)
116{
117//
118// Main constructor (version 3).
119// This constructor defines in meaningful way all data members
120// and creates a set of variable bins delimited by the passed array.
121//
122
123 SetTargetType(TargetType(type));
124 SetBins(nbins, array);
125}
126
127//_____________________________________________________________________________
128AliRsnValueStd::AliRsnValueStd(const AliRsnValueStd& copy) :
129 AliRsnValue(copy),
130 fValueType(copy.fValueType),
131 fSupportObject(copy.fSupportObject)
132{
133//
134// Copy constructor.
135// Duplicates the binning array and copies all settings.
136//
137}
138
139//_____________________________________________________________________________
140AliRsnValueStd& AliRsnValueStd::operator=(const AliRsnValueStd& copy)
141{
142//
143// Assignment operator.
144// Works like copy constructor.
145//
146
147 AliRsnValue::operator=(copy);
148
149 fSupportObject = copy.fSupportObject;
150 fValueType = copy.fValueType;
151
152 return (*this);
153}
154
155//_____________________________________________________________________________
156const char* AliRsnValueStd::GetValueTypeName() const
157{
158//
159// This method returns a string to give a name to each possible
160// computation value.
161//
162
163 switch (fValueType) {
164 case kTrackP: return "SingleTrackPtot";
165 case kTrackPt: return "SingleTrackPt";
166 case kTrackPtpc: return "SingleTrackPtpc";
167 case kTrackEta: return "SingleTrackEta";
168 case kTrackY: return "SingleTrackRapidity";
169 case kTrackITSsignal: return "SingleTrackITSsignal";
170 case kTrackTPCsignal: return "SingleTrackTPCsignal";
171 case kTrackTOFsignal: return "SingleTrackTOFsignal";
172 case kTrackTOFbeta: return "SingleTrackTOFbeta";
173 case kTrackLength: return "SingleTrackLength";
174
175 case kPairP1: return "PairPtotDaughter1";
176 case kPairP2: return "PairPtotDaughter2";
177 case kPairP1t: return "PairPtDaughter1";
178 case kPairP2t: return "PairPtDaughter2";
179 case kPairP1z: return "PairPzDaughter1";
180 case kPairP2z: return "PairPzDaughter2";
181 case kPairInvMass: return "PairInvMass";
182 case kPairInvMassMC: return "PairInvMassMC";
183 case kPairInvMassRes: return "PairInvMassResolution";
184 case kPairPt: return "PairPt";
185 case kPairPz: return "PairPz";
186 case kPairEta: return "PairEta";
187 case kPairMt: return "PairMt";
188 case kPairY: return "PairY";
189 case kPairPhi: return "PairPhi";
190 case kPairPhiMC: return "PairPhiMC";
191 case kPairPtRatio: return "PairPtRatio";
192 case kPairDipAngle: return "PairDipAngle";
193 case kPairCosThetaStar: return "PairCosThetaStar";
194 case kPairQInv: return "PairQInv";
195 case kPairAngleToLeading: return "PairAngleToLeading";
196
197 case kEventLeadingPt: return "EventLeadingPt";
198 case kEventMult: return "EventMult";
199 case kEventMultMC: return "EventMultMC";
200 case kEventMultESDCuts: return "EventMultESDCuts";
201 case kEventMultSPD: return "EventMultSPD";
202 case kEventVz: return "EventVz";
203 case kEventCentralityV0: return "EventCentralityV0";
204 case kEventCentralityTrack: return "EventCentralityTrack";
205 case kEventCentralityCL1: return "EventCentralityCL1";
206 default: return "Undefined";
207 }
208}
209
210//_____________________________________________________________________________
211Bool_t AliRsnValueStd::Eval(TObject *object, Bool_t useMC)
212{
213//
214// Evaluation of the required value.
215// Checks that the passed object is of the right type
216// and if this check is successful, computes the required value.
217// The output of the function tells if computing was successful,
218// and the values must be taken with GetValue().
219//
220
221 // utility variables
222 Bool_t success;
223 const Double_t fgkVeryBig = 1E20;
224 Double_t time;
225 Int_t leadingID = -1;
226 ULong_t status = 0x0;
227
228 // coherence check, which also casts object
229 // to AliRsnTarget data members and returns kFALSE
230 // in case the object is NULL
231 if (!TargetOK(object)) return kFALSE;
232
233 // these variables are initialized
234 // from the target object, once it
235 // is casted to one of the expected
236 // types (daughter/mother/event)
237 // -- not all are initialized always
238 TLorentzVector pRec; // 4-momentum for single track or pair sum (reco)
239 TLorentzVector pSim; // 4-momentum for single track or pair sum (MC)
240 TLorentzVector pRec0; // 4-momentum of first daughter (reco)
241 TLorentzVector pSim0; // 4-momentum of first daughter (MC)
242 TLorentzVector pRec1; // 4-momentum of second daughter (reco)
243 TLorentzVector pSim1; // 4-momentum of second daughter (MC)
244 AliESDEvent *esdev = 0x0; // reference ESD event
245 AliAODEvent *aodev = 0x0; // reference AOD event
246 AliESDtrack *esdt = 0x0; // reference ESD track
247 AliAODTrack *aodt = 0x0; // reference AOD track
248 AliAODPid *pidObj = 0x0; // reference AOD PID object
249
250 // initialize the above 4-vectors according to the
251 // expected target type (which has been checked above)
252 // in particular, the 'fEvent' data member of base AliRsnTarget
253 // will be *always* well initialized if the TargetOK() returns kTRUE
254 switch (fTargetType) {
255 case AliRsnTarget::kDaughter:
256 pRec = fDaughter->Prec();
257 pSim = fDaughter->Psim();
258 esdt = fDaughter->GetRefESDtrack();
259 aodt = fDaughter->GetRefAODtrack();
260 if (aodt) pidObj = aodt->GetDetPid();
261 break;
262 case AliRsnTarget::kMother:
263 pRec = fMother->Sum();
264 pSim = fMother->SumMC();
265 pRec0 = fMother->GetDaughter(0)->Prec();
266 pRec1 = fMother->GetDaughter(1)->Prec();
267 pSim0 = fMother->GetDaughter(0)->Psim();
268 pSim1 = fMother->GetDaughter(1)->Psim();
269 break;
270 case AliRsnTarget::kEvent:
271 break;
272 default:
273 AliError(Form("[%s] Wrong type", GetName()));
274 return kFALSE;
275 }
276 leadingID = fEvent->GetLeadingParticleID();
277 esdev = fEvent->GetRefESD();
278 aodev = fEvent->GetRefAOD();
279
280 // if leading index is negative, assume that leading particle was not searched
281 // and then searches for it
282 if (leadingID < 0) {
283 fEvent->SelectLeadingParticle();
284 leadingID = fEvent->GetLeadingParticleID();
285 }
286
287 if (esdt) status = esdt->GetStatus();
288 if (aodt) status = aodt->GetStatus();
289
290 // these objects are all types of supports
291 // which could be needed for some values
292 AliRsnPairDef *pairDef = 0x0;
293 AliRsnDaughterDef *daughterDef = 0x0;
294 AliESDpid *esdPID = 0x0;
295 if (fSupportObject) {
296 if (fSupportObject->InheritsFrom(AliRsnPairDef ::Class())) pairDef = static_cast<AliRsnPairDef*>(fSupportObject);
297 if (fSupportObject->InheritsFrom(AliRsnDaughterDef::Class())) daughterDef = static_cast<AliRsnDaughterDef*>(fSupportObject);
298 if (fSupportObject->InheritsFrom(AliESDpid ::Class())) esdPID = static_cast<AliESDpid*>(fSupportObject);
299 }
300
301 // compute value depending on types in the enumeration
302 // if the type does not match any available choice, or if
303 // the computation is not doable due to any problem
304 // (not initialized support object, wrong values, risk of floating point errors)
305 // the method returng kFALSE and sets the computed value to a meaningless number
306 switch (fValueType) {
307 case kTrackP:
308 // single track:
309 // total momentum
310 fComputedValue = useMC ? pSim.Vect().Mag() : pRec.Vect().Mag();
311 return kTRUE;
312 case kTrackPt:
313 // single track:
314 // transverse momentum
315 fComputedValue = useMC ? pSim.Perp() : pRec.Perp();
316 return kTRUE;
317 case kTrackPtpc:
318 // single track:
319 // transverse momentum
320 if (esdt) {
321 if (esdt->GetInnerParam()) {
322 fComputedValue = esdt->GetInnerParam()->P();
323 return kTRUE;
324 } else {
325 AliError(Form("[%s] TPC inner param is not initialized", GetName()));
326 return kFALSE;
327 }
328 }
329 else if (aodt && pidObj) {
330 fComputedValue = pidObj->GetTPCmomentum();
331 return kTRUE;
332 } else {
333 AliError(Form("[%s] Cannot retrieve TPC momentum", GetName()));
334 return kFALSE;
335 }
336 case kTrackEta:
337 // single track:
338 // pseudo-rapidity
339 fComputedValue = useMC ? pSim.Eta() : pRec.Eta();
340 return kTRUE;
341 case kTrackY:
342 // single track:
343 // rapidity (requires an AliRsnDaughterDef support)
344 if (daughterDef) {
345 pRec.SetXYZM(pRec.X(), pRec.Y(), pRec.Z(), daughterDef->GetMass());
346 pSim.SetXYZM(pSim.X(), pSim.Y(), pSim.Z(), daughterDef->GetMass());
347 fComputedValue = useMC ? pSim.Rapidity() : pRec.Rapidity();
348 return kTRUE;
349 }
350 else {
351 AliError(Form("[%s] Required a correctly initialized AliRsnDaughterDef support object to compute this value", GetName()));
352 fComputedValue = fgkVeryBig;
353 return kFALSE;
354 }
355 case kTrackITSsignal:
356 // single track:
357 // ITS signal (successful only for tracks)
358 // works only if the status is OK
359 if ((status & AliESDtrack::kITSin) == 0) {
360 AliDebug(AliLog::kDebug + 2, "Rejecting non-ITS track");
361 return kFALSE;
362 }
363 if (esdt) {
364 fComputedValue = esdt->GetITSsignal();
365 return kTRUE;
366 }
367 else if (aodt && pidObj) {
368 fComputedValue = pidObj->GetITSsignal();
369 return kTRUE;
370 }
371 else {
372 AliError(Form("[%s] Detector signals can be computed only on reconstructed tracks", GetName()));
373 fComputedValue = fgkVeryBig;
374 return kFALSE;
375 }
376 case kTrackTPCsignal:
377 // single track:
378 // TPC signal (successful only for tracks)
379 // works only if the status is OK
380 if ((status & AliESDtrack::kTPCin) == 0) {
381 AliDebug(AliLog::kDebug + 2, "Rejecting non-TPC track");
382 return kFALSE;
383 }
384 if (esdt) {
385 fComputedValue = esdt->GetTPCsignal();
386 return kTRUE;
387 }
388 else if (aodt && pidObj) {
389 fComputedValue = pidObj->GetTPCsignal();
390 return kTRUE;
391 }
392 else {
393 AliError(Form("[%s] Detector signals can be computed only on reconstructed tracks", GetName()));
394 fComputedValue = fgkVeryBig;
395 return kFALSE;
396 }
397 case kTrackTOFsignal:
398 // single track:
399 // TOF signal (successful only for tracks, for ESD requires an AliESDpid support)
400 // works only if the status is OK
401 if ((status & AliESDtrack::kTOFout) == 0 || (status & AliESDtrack::kTIME) == 0) {
402 AliDebug(AliLog::kDebug + 2, "Rejecting non-TOF track");
403 return kFALSE;
404 }
405 if (esdt) {
406 if (!esdPID || !esdev) {
407 AliError(Form("[%s] Required a correctly initialized AliRsnEvent and AliESDpid support object to compute this value with ESDs", GetName()));
408 fComputedValue = fgkVeryBig;
409 return kFALSE;
410 }
411 else {
412 esdPID->SetTOFResponse(esdev, AliESDpid::kTOF_T0);
413 fComputedValue = (esdt->GetTOFsignal() - esdPID->GetTOFResponse().GetStartTime(esdt->P()));
414 return kTRUE;
415 }
416 }
417 else if (aodt && pidObj) {
418 fComputedValue = pidObj->GetTOFsignal();
419 return kTRUE;
420 }
421 else {
422 AliError(Form("[%s] Detector signals can be computed only on reconstructed tracks", GetName()));
423 fComputedValue = fgkVeryBig;
424 return kFALSE;
425 }
426 case kTrackTOFbeta:
427 // single track:
428 // TOF beta (successful only for tracks, for ESD requires an AliESDpid support)
429 if (esdt) {
430 if (!esdPID) {
431 AliError(Form("[%s] Required a correctly initialized AliESDpid support object to compute this value with ESDs", GetName()));
432 fComputedValue = fgkVeryBig;
433 return kFALSE;
434 }
435 else if (!esdev) {
436 AliError(Form("[%s] Required a correctly initialized AliESDEvent to compute this value with ESDs", GetName()));
437 fComputedValue = fgkVeryBig;
438 return kFALSE;
439 }
440 else {
441 esdPID->SetTOFResponse(esdev, AliESDpid::kTOF_T0);
442 fComputedValue = esdt->GetIntegratedLength();
443 time = (esdt->GetTOFsignal() - esdPID->GetTOFResponse().GetStartTime(esdt->P()));
444 if (time > 0.0) {
445 fComputedValue /= time;
446 fComputedValue /= 2.99792458E-2;
447 return kTRUE;
448 } else {
449 fComputedValue = fgkVeryBig;
450 return kFALSE;
451 }
452 }
453 }
454 else {
455 AliError(Form("[%s] Length information not available in AODs", GetName()));
456 fComputedValue = fgkVeryBig;
457 return kFALSE;
458 }
459 case kTrackLength:
460 // single tracks:
461 // integrated length (computed only on ESDs)
462 if (esdt) {
463 fComputedValue = esdt->GetIntegratedLength();
464 return kTRUE;
465 }
466 else {
467 AliError(Form("[%s] Length information not available in AODs", GetName()));
468 fComputedValue = fgkVeryBig;
469 return kFALSE;
470 }
471 //---------------------------------------------------------------------------------------------------------------------
472 case kPairP1:
473 // pair:
474 // momentum of first daughter (which matches definition #1 in pairDef)
475 fComputedValue = useMC ? pSim0.Mag() : pRec0.Mag();
476 return kTRUE;
477 case kPairP2:
478 // pair:
479 // momentum of second daughter (which matches definition #2 in pairDef)
480 fComputedValue = useMC ? pSim1.Mag() : pRec1.Mag();
481 return kTRUE;
482 case kPairP1t:
483 // pair:
484 // transverse momentum of first daughter
485 fComputedValue = useMC ? pSim0.Perp() : pRec0.Perp();
486 return kTRUE;
487 case kPairP2t:
488 // pair:
489 // transverse momentum of second daughter
490 fComputedValue = useMC ? pSim1.Perp() : pRec1.Perp();
491 return kTRUE;
492 case kPairP1z:
493 // pair:
494 // longitudinal momentum of first daughter
495 fComputedValue = useMC ? pSim0.Z() : pRec0.Z();
496 return kTRUE;
497 case kPairP2z:
498 // pair:
499 // longitudinal momentum of second daughter
500 fComputedValue = useMC ? pSim1.Z() : pRec1.Z();
501 return kTRUE;
502 case kPairInvMass:
503 // pair:
504 // invariant mass
505 fComputedValue = useMC ? pSim.M() : pRec.M();
506 return kTRUE;
507 case kPairInvMassRes:
508 // pair:
509 // invariant mass resolution (requires MC)
510 if (TMath::Abs(pSim.M()) > 0.0) {
511 fComputedValue = (pSim.M() - pRec.M()) / pSim.M();
512 return kTRUE;
513 }
514 else {
515 AliError(Form("[%s] Caught a null MC mass", GetName()));
516 return kFALSE;
517 }
518 case kPairPt:
519 // pair:
520 // total transverse momentum
521 fComputedValue = useMC ? pSim.Perp() : pRec.Perp();
522 return kTRUE;
523 case kPairEta:
524 // pair:
525 // pseudo-rapidiry
526 fComputedValue = useMC ? pSim.Eta() : pRec.Eta();
527 return kTRUE;
528 case kPairMt:
529 // pair:
530 // transverse mass (requires an AliRsnPairDef to get mass hypothesis)
531 if (pairDef) {
532 pRec.SetXYZM(pRec.X(), pRec.Y(), pRec.Z(), pairDef->GetMotherMass());
533 pSim.SetXYZM(pSim.X(), pSim.Y(), pSim.Z(), pairDef->GetMotherMass());
534 fComputedValue = useMC ? pSim.Mt() : pRec.Mt();
535 return kTRUE;
536 }
537 else {
538 AliError(Form("[%s] Required a correctly initialized AliRsnPairDef support object to compute this value", GetName()));
539 fComputedValue = fgkVeryBig;
540 return kFALSE;
541 }
542 case kPairY:
543 // pair:
544 // rapidity (requires an AliRsnPairDef to get mass hypothesis)
545 if (pairDef) {
546 pRec.SetXYZM(pRec.X(), pRec.Y(), pRec.Z(), pairDef->GetMotherMass());
547 pSim.SetXYZM(pSim.X(), pSim.Y(), pSim.Z(), pairDef->GetMotherMass());
548 fComputedValue = useMC ? pSim.Rapidity() : pRec.Rapidity();
549 return kTRUE;
550 }
551 else {
552 AliError(Form("[%s] Required a correctly initialized AliRsnPairDef support object to compute this value", GetName()));
553 fComputedValue = fgkVeryBig;
554 return kFALSE;
555 }
556 case kPairPhi:
557 // pair:
558 // phi angle of total momentum
559 fComputedValue = useMC ? pSim.Phi() : pRec.Phi();
560 return kTRUE;
561 case kPairPtRatio:
562 // pair:
563 // ratio of relative sum and difference of daughter transverse momenta
564 if (useMC) {
565 fComputedValue = TMath::Abs(pSim0.Perp() - pSim1.Perp());
566 fComputedValue /= TMath::Abs(pSim0.Perp() + pSim1.Perp());
567 } else {
568 fComputedValue = TMath::Abs(pRec0.Perp() - pRec1.Perp());
569 fComputedValue /= TMath::Abs(pRec0.Perp() + pRec1.Perp());
570 }
571 return kTRUE;
572 case kPairDipAngle:
573 // pair:
574 // dip-angle in the transverse-Z plane
575 // (used to check conversion electrons)
576 if (useMC) {
577 fComputedValue = pSim0.Perp() * pSim1.Perp() + pSim0.Z() * pSim1.Z();
578 fComputedValue /= pSim0.Mag() * pSim1.Mag();
579 } else {
580 fComputedValue = pRec0.Perp() * pRec1.Perp() + pRec0.Z() * pRec1.Z();
581 fComputedValue /= pRec0.Mag() * pRec1.Mag();
582 }
583 fComputedValue = TMath::Abs(TMath::ACos(fComputedValue));
584 return kTRUE;
585 case kPairCosThetaStar:
586 // pair:
587 // cosine of theta star angle
588 // (= angle of first daughter to the total momentum, in resonance rest frame)
589 fComputedValue = fMother->CosThetaStar(useMC);
590 return kTRUE;
591 case kPairQInv:
592 // pair:
593 // Q-invariant
594 pSim0 -= pSim1;
595 pRec0 -= pRec1;
596 fComputedValue = useMC ? pSim0.M() : pRec0.M();
597 return kTRUE;
598 case kPairAngleToLeading:
599 // pair:
600 // angle w.r. to leading particle (if any)
601 fComputedValue = fMother->AngleToLeading(success);
602 return success;
603 //---------------------------------------------------------------------------------------------------------------------
604 case kEventMult:
605 // event:
606 // multiplicity of tracks
607 fComputedValue = (Double_t)fEvent->GetMultiplicityFromTracks();
608 return (fComputedValue >= 0);
609 case kEventMultMC:
610 // event:
611 // multiplicity of MC tracks
612 fComputedValue = (Double_t)fEvent->GetMultiplicityFromMC();
613 return (fComputedValue >= 0);
614 case kEventMultESDCuts:
615 // event:
616 // multiplicity of good quality tracks
617 fComputedValue = fEvent->GetMultiplicityFromESDCuts();
618 return (fComputedValue >= 0);
619 case kEventMultSPD:
620 // event:
621 // multiplicity of good quality tracks
622 fComputedValue = fEvent->GetMultiplicityFromSPD();
623 return (fComputedValue >= 0);
624 case kEventLeadingPt:
625 // event:
626 // transverse momentum of leading particle
627 if (leadingID >= 0) {
628 AliRsnDaughter leadingPart = fEvent->GetDaughter(leadingID);
629 AliVParticle *ref = leadingPart.GetRef();
630 fComputedValue = ref->Pt();
631 return kTRUE;
632 } else {
633 AliError(Form("[%s] Leading ID has bad value (%d)", GetName(), leadingID));
634 return kFALSE;
635 }
636 case kEventVz:
637 // event:
638 // Z position of primary vertex
639 fComputedValue = fEvent->GetRef()->GetPrimaryVertex()->GetZ();
640 return kTRUE;
641 case kEventCentralityV0:
642 // event:
643 // centrality using V0 method
644 if (esdev) {
645 AliCentrality *centrality = esdev->GetCentrality();
646 fComputedValue = centrality->GetCentralityPercentile("V0M");
647 return kTRUE;
648 } else if (aodev) {
649 AliCentrality *centrality = aodev->GetCentrality();
650 fComputedValue = centrality->GetCentralityPercentile("V0M");
651 return kTRUE;
652 } else {
653 AliError(Form("[%s] Neither the ESD nor the AOD events are initialized", GetName()));
654 return kFALSE;
655 }
656 case kEventCentralityTrack:
657 // event:
658 // centrality using tracks method
659 if (esdev) {
660 AliCentrality *centrality = esdev->GetCentrality();
661 fComputedValue = centrality->GetCentralityPercentile("TRK");
662 return kTRUE;
663 } else if (aodev) {
664 AliCentrality *centrality = aodev->GetCentrality();
665 fComputedValue = centrality->GetCentralityPercentile("TRK");
666 return kTRUE;
667 } else {
668 AliError(Form("[%s] Neither the ESD nor the AOD events are initialized", GetName()));
669 return kFALSE;
670 }
671 case kEventCentralityCL1:
672 // event:
673 // centrality using CL1 method
674 if (esdev) {
675 AliCentrality *centrality = esdev->GetCentrality();
676 fComputedValue = centrality->GetCentralityPercentile("CL1");
677 return kTRUE;
678 } else if (aodev) {
679 AliCentrality *centrality = aodev->GetCentrality();
680 fComputedValue = centrality->GetCentralityPercentile("CL1");
681 return kTRUE;
682 } else {
683 AliError(Form("[%s] Neither the ESD nor the AOD events are initialized", GetName()));
684 return kFALSE;
685 }
686 default:
687 AliError(Form("[%s] Invalid value type for this computation", GetName()));
688 return kFALSE;
689 }
690}
691
692//_____________________________________________________________________________
693void AliRsnValueStd::Print(Option_t *option) const
694{
695//
696// Print informations about this object
697//
698
699 AliInfo("=== VALUE INFO =================================================");
700 AliInfo(Form(" Name : %s", GetName()));
701 AliInfo(Form(" Type : %s", GetValueTypeName()));
702 AliInfo(Form(" Current computed value: %f", fComputedValue));
703 if (!strcmp(option, "BINS")) {
704 Int_t i;
705 for (i = 0; i < fBinArray.GetSize(); i++) {
706 AliInfo(Form(" Bin limit #%03d = %f", i, fBinArray[i]));
707 }
708 }
709 AliInfo(Form(" Support object : %s", (fSupportObject ? fSupportObject->ClassName() : " NO SUPPORT")));
710 AliInfo("=== END VALUE INFO =============================================");
711}
712
713//_____________________________________________________________________________
714RSNTARGET AliRsnValueStd::TargetType(EValueType type)
715{
716//
717// This method assigns the target to be expected by this object
718// in the computation, depending on its type chosen in the enum.
719//
720
721 if (type < kTrackValues)
722 return AliRsnTarget::kDaughter;
723 else if (type < kPairValues)
724 return AliRsnTarget::kMother;
725 else
726 return AliRsnTarget::kEvent;
727}