PWG2/RESONANCES/AliRsnValueStd.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 //  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
  53 ClassImp(AliRsnValueStd)
  54
  55 //_____________________________________________________________________________
  56 AliRsnValueStd::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 //_____________________________________________________________________________
  70 AliRsnValueStd::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 //_____________________________________________________________________________
  93 AliRsnValueStd::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 //_____________________________________________________________________________
 111 AliRsnValueStd::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 //_____________________________________________________________________________
 128 AliRsnValueStd::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 //_____________________________________________________________________________
 140 AliRsnValueStd& 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 //_____________________________________________________________________________
 156 const 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 //_____________________________________________________________________________
 211 Bool_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 //_____________________________________________________________________________
 693 void 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 //_____________________________________________________________________________
 714 RSNTARGET 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 }