PWGLF/RESONANCES/AliRsnValueDaughter.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, Daughter, 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 <Riostream.h>
  41 #include "AliVVertex.h"
  42 #include "AliMultiplicity.h"
  43 #include "AliESDtrackCuts.h"
  44 #include "AliESDpid.h"
  45 #include "AliAODPid.h"
  46 #include "AliCentrality.h"
  47 #include "AliESDUtils.h"
  48 #include "AliPIDResponse.h"
  49
  50 #include "AliRsnEvent.h"
  51 #include "AliRsnDaughter.h"
  52 #include "AliRsnMother.h"
  53 #include "AliRsnDaughterDef.h"
  54 #include "AliRsnDaughterDef.h"
  55
  56 #include "AliRsnValueDaughter.h"
  57
  58 ClassImp(AliRsnValueDaughter)
  59
  60 //_____________________________________________________________________________
  61 AliRsnValueDaughter::AliRsnValueDaughter(const char *name, EType type) :
  62    AliRsnValue(name, AliRsnTarget::kDaughter),
  63    fType(type)
  64 {
  65 //
  66 // Constructor
  67 //
  68 }
  69
  70 //_____________________________________________________________________________
  71 AliRsnValueDaughter::AliRsnValueDaughter(const AliRsnValueDaughter &copy) :
  72    AliRsnValue(copy),
  73    fType(copy.fType)
  74 {
  75 //
  76 // Copy constructor
  77 //
  78 }
  79
  80 //_____________________________________________________________________________
  81 AliRsnValueDaughter &AliRsnValueDaughter::operator=(const AliRsnValueDaughter &copy)
  82 {
  83 //
  84 // Assignment operator.
  85 // Works like copy constructor.
  86 //
  87
  88    AliRsnValue::operator=(copy);
  89    if (this == &copy)
  90       return *this;
  91    fType = copy.fType;
  92
  93    return (*this);
  94 }
  95
  96 //_____________________________________________________________________________
  97 const char *AliRsnValueDaughter::GetTypeName() const
  98 {
  99 //
 100 // This method returns a string to give a name to each possible
 101 // computation value.
 102 //
 103
 104    switch (fType) {
 105       case kP:                         return "SingleTrackPtot";
 106       case kPt:                        return "SingleTrackPt";
 107       case kPtpc:                      return "SingleTrackPtpc";
 108       case kEta:                       return "SingleTrackEta";
 109       case kY:                         return "SingleTrackY";
 110       case kMass:                      return "SingleTrackMass";
 111       case kITSsignal:                 return "SingleTrackITSsignal";
 112       case kTPCsignal:                  return "SingleTrackTPCsignal";
 113       case kTOFsignal:                  return "SingleTrackTOFsignal";
 114       case kTPCnsigmaPi:                return "SingleTrackTPCnsigmaPion";
 115       case kTPCnsigmaK:                 return "SingleTrackTPCnsigmaKaon";
 116       case kTPCnsigmaP:                 return "SingleTrackTPCnsigmaProton";
 117       case kTOFnsigmaPi:                return "SingleTrackTOFnsigmaPion";
 118       case kTOFnsigmaK:                 return "SingleTrackTOFnsigmaKaon";
 119       case kTOFnsigmaP:                 return "SingleTrackTOFnsigmaProton";
 120       case kTOFdeltaPi:                 return "SingleTrackTOFdeltaPion";
 121       case kTOFdeltaK:                  return "SingleTrackTOFdeltaKaon";
 122       case kTOFdeltaP:                  return "SingleTrackTOFdeltaProton";
 123       case kNITSclusters:               return "SingleTrackNITSclusters";
 124       case kNTPCclusters:               return "SingleTrackNTPCclusters";
 125       case kNTPCcrossedRows:            return "SingleTrackNTPCcrossedRows";
 126       case kNTPCcrossedRowsFclusters:   return "SingleTrackNTPCcrossedRowsFclusters";
 127       case kITSchi2:                    return "SingleTrackITSchi2";
 128       case kTPCchi2:                    return "SingleTrackTPCchi2";
 129       case kDCAXY:                      return "SingleTrackDCAz";
 130       case kDCAZ:                       return "SingleTrackDCAz";
 131       case kCharge:                     return "SingleTrackCharge";
 132       case kPhi:                        return "SingleTrackPhi";
 133       case kPhiOuterTPC:                return "SingleTrackPhiOuterTPC";
 134       case kV0DCA:                      return "V0DCAToPrimaryVertex";
 135       case kDaughterDCA:                return "V0DaughterDCA";
 136       case kCosPointAng:                return "V0CosineOfPointingAngle";
 137       case kLambdaProtonPIDCut:         return "V0LambdaProtonNsigma";
 138       case kAntiLambdaAntiProtonPIDCut: return "V0AntiLambdaAntiProtonNsigma";
 139       case kLambdaPionPIDCut:           return "V0LambdaPionNsigma";
 140       case kAntiLambdaAntiPionPIDCut:   return "V0AntiLambdaPionNsigma";
 141       default:                          return "Undefined";
 142    }
 143 }
 144
 145 //_____________________________________________________________________________
 146 Bool_t AliRsnValueDaughter::Eval(TObject *object)
 147 {
 148 //
 149 // Evaluation of the required value.
 150 // Checks that the passed object is of the right type
 151 // and if this check is successful, computes the required value.
 152 // The output of the function tells if computing was successful,
 153 // and the values must be taken with GetValue().
 154 //
 155
 156    // coherence check, which also casts object
 157    // to AliRsnTarget data members and returns kFALSE
 158    // in case the object is NULL
 159    if (!TargetOK(object)) return kFALSE;
 160
 161    // set a reference to the mother momentum
 162    AliVParticle   *ref   = fDaughter->GetRef();
 163    AliVParticle   *refMC = fDaughter->GetRefMC();
 164    AliVTrack      *track = fDaughter->Ref2Vtrack();
 165    AliESDv0       *v0esd = fDaughter->Ref2ESDv0();
 166    AliAODv0       *v0aod = fDaughter->Ref2AODv0();
 167    AliESDEvent    *lESDEvent = fEvent->GetRefESD();
 168
 169    Double_t xPrimaryVertex = -999.9;
 170    Double_t yPrimaryVertex = -999.9;
 171    Double_t zPrimaryVertex = -999.9;
 172
 173    if(lESDEvent){
 174
 175    xPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetX();
 176    yPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetY();
 177    zPrimaryVertex = lESDEvent->GetPrimaryVertex()->GetZ();
 178
 179    }
 180
 181    if (fUseMCInfo && !refMC) {
 182       AliError("No MC");
 183       return kFALSE;
 184    }
 185    if (!fUseMCInfo && !ref) {
 186       AliError("No DATA");
 187       return kFALSE;
 188    }
 189
 190    // compute value depending on types in the enumeration
 191    // if the type does not match any available choice, or if
 192    // the computation is not doable due to any problem
 193    // (not initialized support object, wrong values, risk of floating point errors)
 194    // the method returng kFALSE and sets the computed value to a meaningless number
 195    switch (fType) {
 196    case kP:
 197      fComputedValue = (fUseMCInfo ? refMC->P() : ref->P());
 198      return kTRUE;
 199
 200    case kPt:
 201      fComputedValue = (fUseMCInfo ? refMC->Pt() : ref->Pt());
 202      return kTRUE;
 203
 204    case kEta:
 205      fComputedValue = (fUseMCInfo ? refMC->Eta() : ref->Eta());
 206      return kTRUE;
 207
 208    case kY:
 209      fComputedValue = (fUseMCInfo ? refMC->Y() : ref->Y());
 210      return kTRUE;
 211
 212    case kMass:
 213      fComputedValue = (fUseMCInfo ? refMC->M() : ref->M());
 214      return kTRUE;
 215
 216    case kPtpc:
 217      if (track) {
 218        fComputedValue = track->GetTPCmomentum();
 219        return kTRUE;
 220      } else {
 221        AliWarning("Cannot get TPC momentum for non-track object");
 222        fComputedValue = 0.0;
 223        return kFALSE;
 224      }
 225
 226    case kITSsignal:
 227      if (track) {
 228        fComputedValue = track->GetITSsignal();
 229        return kTRUE;
 230      } else {
 231        AliWarning("Cannot get ITS signal for non-track object");
 232        fComputedValue = 0.0;
 233        return kFALSE;
 234      }
 235
 236    case kTPCsignal:
 237      if (track) {
 238        fComputedValue = track->GetTPCsignal();
 239        return kTRUE;
 240      } else {
 241        AliWarning("Cannot get TPC signal for non-track object");
 242        fComputedValue = 0.0;
 243        return kFALSE;
 244      }
 245
 246    case kTOFsignal:
 247      if (track) {
 248        fComputedValue = track->GetTOFsignal();
 249        return kTRUE;
 250      } else {
 251        AliWarning("Cannot get TOF signal for non-track object");
 252        fComputedValue = 0.0;
 253        return kFALSE;
 254      }
 255
 256    case kTPCnsigmaPi:
 257      if (track) {
 258        AliPIDResponse *pid = fEvent->GetPIDResponse();
 259        fComputedValue = pid->NumberOfSigmasTPC(track, AliPID::kPion);
 260        return kTRUE;
 261      } else {
 262        AliWarning("Cannot get TOF signal for non-track object");
 263        fComputedValue = 0.0;
 264        return kFALSE;
 265      }
 266
 267    case kTPCnsigmaK:
 268      if (track) {
 269        AliPIDResponse *pid = fEvent->GetPIDResponse();
 270        fComputedValue = pid->NumberOfSigmasTPC(track, AliPID::kKaon);
 271        return kTRUE;
 272      } else {
 273        AliWarning("Cannot get TOF signal for non-track object");
 274        fComputedValue = 0.0;
 275        return kFALSE;
 276      }
 277
 278    case kTPCnsigmaP:
 279      if (track) {
 280        AliPIDResponse *pid = fEvent->GetPIDResponse();
 281        fComputedValue = pid->NumberOfSigmasTPC(track, AliPID::kProton);
 282        return kTRUE;
 283      } else {
 284        AliWarning("Cannot get TOF signal for non-track object");
 285        fComputedValue = 0.0;
 286        return kFALSE;
 287      }
 288
 289    case kTOFnsigmaPi:
 290      if (track) {
 291        AliPIDResponse *pid = fEvent->GetPIDResponse();
 292        fComputedValue = pid->NumberOfSigmasTOF(track, AliPID::kPion);
 293        return kTRUE;
 294      } else {
 295        AliWarning("Cannot get TOF signal for non-track object");
 296        fComputedValue = 0.0;
 297        return kFALSE;
 298      }
 299
 300    case kTOFnsigmaK:
 301      if (track) {
 302        AliPIDResponse *pid = fEvent->GetPIDResponse();
 303        fComputedValue = pid->NumberOfSigmasTOF(track, AliPID::kKaon);
 304        return kTRUE;
 305      } else {
 306        AliWarning("Cannot get TOF signal for non-track object");
 307        fComputedValue = 0.0;
 308        return kFALSE;
 309      }
 310
 311    case kTOFnsigmaP:
 312      if (track) {
 313        AliPIDResponse *pid = fEvent->GetPIDResponse();
 314        fComputedValue = pid->NumberOfSigmasTOF(track, AliPID::kProton);
 315        return kTRUE;
 316      } else {
 317        AliWarning("Cannot get TOF signal for non-track object");
 318        fComputedValue = 0.0;
 319        return kFALSE;
 320      }
 321
 322    case kTOFdeltaPi:
 323      if (track) {
 324        AliPIDResponse *pid = fEvent->GetPIDResponse();
 325        pid->GetSignalDelta(AliPIDResponse::kTOF, track, AliPID::kPion, fComputedValue, kFALSE);//(==AliPIDResponse::kDetPidOk);
 326          return kTRUE;
 327      } else {
 328        AliWarning("Cannot get TOF delta for non-track object");
 329        fComputedValue = 0.0;
 330        return kFALSE;
 331      }
 332
 333    case kTOFdeltaK:
 334      if (track) {
 335        AliPIDResponse *pid = fEvent->GetPIDResponse();
 336        pid->GetSignalDelta(AliPIDResponse::kTOF, track, AliPID::kKaon, fComputedValue, kFALSE);//(==AliPIDResponse::kDetPidOk);
 337        return kTRUE;
 338      } else {
 339        AliWarning("Cannot get TOF delta for non-track object");
 340        fComputedValue = 0.0;
 341        return kFALSE;
 342      }
 343
 344    case kTOFdeltaP:
 345      if (track) {
 346        AliPIDResponse *pid = fEvent->GetPIDResponse();
 347        pid->GetSignalDelta(AliPIDResponse::kTOF, track, AliPID::kProton, fComputedValue, kFALSE);//(==AliPIDResponse::kDetPidOk);
 348        return kTRUE;
 349      } else {
 350        AliWarning("Cannot get TOF delta for non-track object");
 351        fComputedValue = 0.0;
 352        return kFALSE;
 353      }
 354
 355    case kNITSclusters:
 356      if (track) {
 357        AliESDtrack *trackESD = dynamic_cast<AliESDtrack *>(track);
 358        if (trackESD) {
 359          fComputedValue =  trackESD->GetITSclusters(0);
 360        } else {
 361          fComputedValue =  ((AliAODTrack *)track)->GetITSNcls();
 362        }
 363        return kTRUE;
 364      } else {
 365        AliWarning("Cannot get n ITS clusters for non-track object");
 366        fComputedValue = 0.0;
 367        return kFALSE;
 368      }
 369
 370    case kNTPCclusters:
 371      if (track) {
 372        AliESDtrack *trackESD = dynamic_cast<AliESDtrack *>(track);
 373        if (trackESD) {
 374          fComputedValue =  trackESD->GetTPCclusters(0);
 375        } else {
 376          fComputedValue =  ((AliAODTrack *)track)->GetTPCNcls();
 377        }
 378        return kTRUE;
 379      } else {
 380        AliWarning("Cannot get n TPC clusters for non-track object");
 381        fComputedValue = 0.0;
 382        return kFALSE;
 383      }
 384
 385    case kNTPCcrossedRows:
 386      if (track) {
 387        AliESDtrack *trackESD = dynamic_cast<AliESDtrack *>(track);
 388        if (trackESD) {
 389          fComputedValue =  trackESD->GetTPCCrossedRows();
 390        } else {
 391          fComputedValue =  ((AliAODTrack *)track)->GetTPCNCrossedRows();
 392        }
 393        return kTRUE;
 394      } else {
 395        AliWarning("Cannot get n TPC crossed rows for non-track object");
 396        fComputedValue = 0.0;
 397        return kFALSE;
 398      }
 399
 400    case kNTPCcrossedRowsFclusters:
 401      if (track) {
 402        AliESDtrack *trackESD = dynamic_cast<AliESDtrack *>(track);
 403        fComputedValue = 1.0;
 404        if (trackESD) {
 405          if (trackESD->GetTPCNclsF()>0) fComputedValue = trackESD->GetTPCCrossedRows() / trackESD->GetTPCNclsF();
 406        } else {
 407          Float_t nCrossedRows = ((AliAODTrack*) track)->GetTPCNCrossedRows();
 408          Float_t nFcls = ((AliAODTrack*) track)->GetTPCNclsF();
 409          if (nFcls>0) fComputedValue = nCrossedRows / nFcls;
 410        }
 411        return kTRUE;
 412      } else {
 413        AliWarning("Cannot get n TPC crossed rows/findable clusters for non-track object");
 414        fComputedValue = 0.0;
 415        return kFALSE;
 416      }
 417
 418    case kITSchi2:
 419      if (track) {
 420        AliESDtrack *trackESD = dynamic_cast<AliESDtrack *>(track);
 421        if (trackESD) {
 422          UShort_t nClustersITS = trackESD->GetITSclusters(0);
 423          fComputedValue =  trackESD->GetITSchi2()/Float_t(nClustersITS);
 424        } else {
 425          fComputedValue = ((AliAODTrack *)track)->Chi2perNDF();
 426        }
 427        return kTRUE;
 428      } else {
 429        AliWarning("Cannot get ITS chi^2 for non-track object");
 430        fComputedValue = 0.0;
 431        return kFALSE;
 432      }
 433    case kTPCchi2:
 434      if (track) {
 435        AliESDtrack *trackESD = dynamic_cast<AliESDtrack *>(track);
 436        if (trackESD) {
 437          UShort_t nClustersTPC = trackESD->GetTPCclusters(0);
 438          fComputedValue =  trackESD->GetTPCchi2()/Float_t(nClustersTPC);
 439        } else {
 440          fComputedValue = ((AliAODTrack *)track)->Chi2perNDF();
 441        }
 442        return kTRUE;
 443      } else {
 444        AliWarning("Cannot get TPC chi^2 for non-track object");
 445        fComputedValue = 0.0;
 446        return kFALSE;
 447      }
 448    case kDCAXY:
 449      if (track) {
 450        AliESDtrack *trackESD = dynamic_cast<AliESDtrack *>(track);
 451        if (trackESD) {
 452          Float_t b[2], bCov[3];
 453          trackESD->GetImpactParameters(b, bCov);
 454          fComputedValue =  b[0];
 455        } else {
 456          Double_t b[2]= {-999,-999}, cov[3];
 457          AliAODVertex *vertex = fEvent->GetRefAOD()->GetPrimaryVertex();
 458          if(vertex) {
 459            track->PropagateToDCA(vertex, fEvent->GetRefAOD()->GetMagneticField(),kVeryBig, b, cov);
 460            fComputedValue = b[0];
 461          } else {
 462            fComputedValue = -999;
 463          }
 464        }
 465        return kTRUE;
 466      } else {
 467        AliWarning("Cannot get TPC chi^2 for non-track object");
 468        fComputedValue = 0.0;
 469        return kFALSE;
 470      }
 471    case kDCAZ:
 472      if (track) {
 473        AliESDtrack *trackESD = dynamic_cast<AliESDtrack *>(track);
 474        if (trackESD) {
 475          Float_t b[2], bCov[3];
 476          trackESD->GetImpactParameters(b, bCov);
 477          fComputedValue =  b[1];
 478        } else {
 479          Double_t b[2]= {-999,-999}, cov[3];
 480          AliAODVertex *vertex = fEvent->GetRefAOD()->GetPrimaryVertex();
 481          if(vertex) {
 482            track->PropagateToDCA(vertex, fEvent->GetRefAOD()->GetMagneticField(),kVeryBig, b, cov);
 483            fComputedValue = b[1];
 484          } else {
 485            fComputedValue = -999;
 486          }
 487
 488        }
 489        return kTRUE;
 490      } else {
 491        AliWarning("Cannot get TPC chi^2 for non-track object");
 492        fComputedValue = 0.0;
 493        return kFALSE;
 494      }
 495
 496    case kCharge:
 497      fComputedValue = (fUseMCInfo ? refMC->Charge() : ref->Charge());
 498      return kTRUE;
 499
 500    case kPhi:
 501      fComputedValue = (fUseMCInfo ? (refMC->Phi()*TMath::RadToDeg()) : (ref->Phi()*TMath::RadToDeg()));
 502      return kTRUE;
 503
 504    case kPhiOuterTPC:
 505      if (track) {
 506        Double_t pos[3]={0.,0.,0.};
 507        Double_t phiOut = -999.0;
 508        Double_t radius = 278.;//TPC outer (vessel) = 278 cm, TOF radius (active surf.) = 378 cm;  ref. PPR.1
 509        AliExternalTrackParam etp; //thanks to Andrea and Cristina
 510        etp.CopyFromVTrack(track);
 511        if(etp.GetXYZAt(radius, 5., pos)){
 512          phiOut=TMath::ATan2(pos[1],pos[0])*TMath::RadToDeg();
 513          if (phiOut<0) phiOut+= (2*TMath::Pi()*TMath::RadToDeg());
 514        }
 515        fComputedValue = phiOut;
 516      } else {
 517        AliWarning("Cannot get phi at outer TPC radius for non-track object");
 518        fComputedValue = -99.0;
 519        return kFALSE;
 520      }
 521      return kTRUE;
 522
 523    case kV0DCA:
 524      if(v0esd) {
 525        AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
 526        fComputedValue = v0ESD->GetD(xPrimaryVertex,yPrimaryVertex,zPrimaryVertex);
 527        return kTRUE;
 528      }
 529      if(v0aod) {
 530        AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
 531        fComputedValue = v0AOD->DcaV0ToPrimVertex();
 532        return kTRUE;
 533      }
 534      else {
 535        fComputedValue = -999;
 536        return kFALSE;
 537      }
 538
 539    case kDaughterDCA:
 540      if(v0esd) {
 541        AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
 542        fComputedValue = v0ESD->GetDcaV0Daughters();
 543        return kTRUE;
 544      }
 545      if(v0aod) {
 546        AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
 547        fComputedValue = v0AOD->DcaV0Daughters();
 548        return kTRUE;
 549      }
 550      else {
 551        fComputedValue = -999;
 552        return kFALSE;
 553      }
 554
 555    case kCosPointAng:
 556      if(v0esd) {
 557        AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
 558        fComputedValue = v0ESD->GetV0CosineOfPointingAngle();
 559        return kTRUE;
 560      }
 561      if(v0aod) {
 562        AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
 563        fComputedValue = TMath::Cos(v0AOD->OpenAngleV0());
 564        return kTRUE;
 565      }
 566      else {
 567        fComputedValue = -999;
 568        return kFALSE;
 569      }
 570
 571    case kLambdaProtonPIDCut:
 572      if(v0esd && lESDEvent) {
 573        AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
 574        // retrieve the V0 daughters
 575        UInt_t lIdxPos      = (UInt_t) TMath::Abs(v0ESD->GetPindex());
 576        AliESDtrack *pTrack = lESDEvent->GetTrack(lIdxPos);
 577        AliPIDResponse *pid = fEvent->GetPIDResponse();
 578        fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, AliPID::kProton));
 579        return kTRUE;
 580      }
 581      if(v0aod) {
 582        AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
 583        AliAODTrack *pTrack = (AliAODTrack *) (v0AOD->GetSecondaryVtx()->GetDaughter(0));
 584        AliPIDResponse *pid = fEvent->GetPIDResponse();
 585        fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, AliPID::kProton));
 586        return kTRUE;
 587      }
 588      else {
 589        fComputedValue = -999;
 590        return kFALSE;
 591      }
 592
 593    case kAntiLambdaAntiProtonPIDCut:
 594      if(v0esd && lESDEvent) {
 595        AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
 596        // retrieve the V0 daughters
 597        UInt_t lIdxNeg      = (UInt_t) TMath::Abs(v0ESD->GetNindex());
 598        AliESDtrack *nTrack = lESDEvent->GetTrack(lIdxNeg);
 599        AliPIDResponse *pid = fEvent->GetPIDResponse();
 600        fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(nTrack, AliPID::kProton));
 601        return kTRUE;
 602      }
 603      if(v0aod) {
 604        AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
 605        AliAODTrack *nTrack = (AliAODTrack *) (v0AOD->GetSecondaryVtx()->GetDaughter(1));
 606        AliPIDResponse *pid = fEvent->GetPIDResponse();
 607        fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(nTrack, AliPID::kProton));
 608        return kTRUE;
 609      }
 610      else {
 611        fComputedValue = -999;
 612        return kFALSE;
 613      }
 614
 615    case kLambdaPionPIDCut:
 616      if(v0esd && lESDEvent) {
 617        AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
 618        // retrieve the V0 daughters
 619        UInt_t lIdxNeg      = (UInt_t) TMath::Abs(v0ESD->GetNindex());
 620        AliESDtrack *nTrack = lESDEvent->GetTrack(lIdxNeg);
 621        AliPIDResponse *pid = fEvent->GetPIDResponse();
 622        fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(nTrack, AliPID::kPion));
 623        return kTRUE;
 624      }
 625      if(v0aod) {
 626        AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
 627        AliAODTrack *nTrack = (AliAODTrack *) (v0AOD->GetSecondaryVtx()->GetDaughter(1));
 628        AliPIDResponse *pid = fEvent->GetPIDResponse();
 629        fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(nTrack, AliPID::kPion));
 630        return kTRUE;
 631      }
 632      else {
 633        fComputedValue = -999;
 634        return kFALSE;
 635      }
 636
 637    case kAntiLambdaAntiPionPIDCut:
 638      if(v0esd && lESDEvent) {
 639        AliESDv0 *v0ESD = dynamic_cast<AliESDv0 *>(v0esd);
 640        // retrieve the V0 daughters
 641        UInt_t lIdxPos      = (UInt_t) TMath::Abs(v0ESD->GetPindex());
 642        AliESDtrack *pTrack = lESDEvent->GetTrack(lIdxPos);
 643        AliPIDResponse *pid = fEvent->GetPIDResponse();
 644        fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, AliPID::kPion));
 645        return kTRUE;
 646      }
 647      if(v0aod) {
 648        AliAODv0 *v0AOD = dynamic_cast<AliAODv0 *>(v0aod);
 649        AliAODTrack *pTrack = (AliAODTrack *) (v0AOD->GetSecondaryVtx()->GetDaughter(0));
 650        AliPIDResponse *pid = fEvent->GetPIDResponse();
 651        fComputedValue = TMath::Abs(pid->NumberOfSigmasTPC(pTrack, AliPID::kPion));
 652        return kTRUE;
 653      }
 654      else {
 655        fComputedValue = -999;
 656        return kFALSE;
 657      }
 658
 659    default:
 660      AliError(Form("[%s] Invalid value type for this computation", GetName()));
 661      return kFALSE;
 662    }
 663 }