STEER/CreateAODfromKineTree.C

   1 #if !defined(__CINT__) || defined(__MAKECINT__)
   2
   3 #include <Riostream.h>
   4 #include <TFile.h>
   5 #include <TTree.h>
   6 #include <TMath.h>
   7
   8 #include "AliRun.h"
   9 #include "AliRunLoader.h"
  10 #include "AliHeader.h"
  11 #include "AliStack.h"
  12 #include "TParticle.h"
  13
  14 #include "AliAODEvent.h"
  15 #include "AliAODHeader.h"
  16 #include "AliAODVertex.h"
  17 #include "AliAODTrack.h"
  18 #include "AliAODCluster.h"
  19
  20 #endif
  21
  22 // function declarations
  23 void SetVertexType(TParticle *part, AliAODVertex *vertex);
  24 void SetChargeAndPID(Int_t pdgCode, AliAODTrack *track);
  25 Int_t LoopOverSecondaries(TParticle *mother);
  26 void CreateAODfromKineTree(const char *inFileName = "galice.root",
  27                            const char *outFileName = "AliAOD.root");
  28
  29 // global variables
  30 AliAODEvent *aod = NULL;
  31 AliStack *stack = NULL;
  32
  33 Int_t jVertices = 0;
  34 Int_t jTracks = 0;
  35 Int_t jKinks = 0;
  36 Int_t jV0s = 0;
  37 Int_t jCascades = 0;
  38 Int_t jMultis = 0;
  39 Int_t nPos = 0;
  40 Int_t nNeg = 0;
  41
  42 Int_t nGamma = 0;
  43 Int_t nElectron = 0;
  44 Int_t nPositron = 0;
  45 Int_t nMuon = 0;
  46 Int_t nAntiMuon = 0;
  47 Int_t nProton = 0;
  48 Int_t nAntiProton = 0;
  49 Int_t nNeutron = 0;
  50 Int_t nAntiNeutron = 0;
  51 Int_t nPi0 = 0;
  52 Int_t nPiMinus = 0;
  53 Int_t nPiPlus = 0;
  54 Int_t nK0 = 0;
  55 Int_t nKPlus = 0;
  56 Int_t nKMinus = 0;
  57
  58 void CreateAODfromKineTree(const char *inFileName,
  59                            const char *outFileName) {
  60   printf("This macro works only correctly in comiled mode!\n");
  61   /* This probem is due to CINT which gets confused if arrays are reused */
  62
  63   // create an AliAOD object
  64   aod = new AliAODEvent();
  65   aod->CreateStdContent();
  66
  67   // open the file
  68   TFile *outFile = TFile::Open(outFileName, "RECREATE");
  69
  70   // create the tree
  71   TTree *aodTree = new TTree("AOD", "AliAOD tree");
  72   aodTree->Branch(aod->GetList());
  73
  74   AliRunLoader *runLoader;
  75   delete gAlice;
  76   gAlice = NULL;
  77   runLoader = AliRunLoader::Open(inFileName);
  78   if (!runLoader) return;
  79
  80   runLoader->LoadHeader();
  81   runLoader->LoadKinematics();
  82
  83   Int_t nEvents = runLoader->GetNumberOfEvents();
  84
  85   // loop over events and fill them
  86   for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
  87
  88     cout << "Event " << iEvent+1 << "/" << nEvents;
  89     runLoader->GetEvent(iEvent);
  90
  91     AliHeader *aliHeader = runLoader->GetHeader();
  92     stack = runLoader->Stack();
  93     Int_t nTracks = stack->GetNtrack();
  94     Int_t nPrims = stack->GetNprimary();
  95
  96     nPos = 0;
  97     nNeg = 0;
  98
  99     nGamma = 0;
 100     nElectron = 0;
 101     nPositron = 0;
 102     nMuon = 0;
 103     nAntiMuon = 0;
 104     nProton = 0;
 105     nAntiProton = 0;
 106     nNeutron = 0;
 107     nAntiNeutron = 0;
 108     nPi0 = 0;
 109     nPiMinus = 0;
 110     nPiPlus = 0;
 111     nK0 = 0;
 112     nKPlus = 0;
 113     nKMinus = 0;
 114
 115     // create the header
 116     aod->AddHeader(new AliAODHeader(aliHeader->GetRun(),
 117                                     0, // bunchX number
 118                                     0, // orbit number
 119                                     nTracks,
 120                                     nPos,
 121                                     nNeg,
 122                                     -999, // mag. field
 123                                     -999., // muon mag. field
 124                                     -999., // centrality
 125                                     -999, // ZDCN1Energy
 126                                     -999, // ZDCP1Energy
 127                                     -999, // ZDCN2Energy
 128                                     -999, // ZDCP2Energy
 129                                     -999, // ZDCEMEnergy
 130                                     0, // TriggerMask
 131                                     0, // TriggerCluster
 132                                     0)); // EventType
 133
 134     // Access to the header
 135     AliAODHeader *header = aod->GetHeader();
 136
 137     // Access to the AOD container of vertices
 138     TClonesArray &vertices = *(aod->GetVertices());
 139     jVertices=0;
 140     jKinks=0;
 141     jV0s=0;
 142     jCascades=0;
 143     jMultis=0;
 144
 145     // Access to the AOD container of tracks
 146     TClonesArray &tracks = *(aod->GetTracks());
 147     jTracks=0;
 148
 149     aod->ResetStd(nTracks, 1);
 150
 151     Float_t p[3];
 152     Float_t x[3];
 153     Float_t *covTr = NULL;
 154     Float_t *pid = NULL;
 155     AliAODVertex *primary = NULL;
 156     AliAODTrack* currTrack = NULL;
 157     // track loop
 158     for (Int_t iTrack = 0; iTrack < nPrims; ++iTrack) {
 159
 160       TParticle *part = stack->Particle(iTrack);
 161
 162       //if (part->IsPrimary()) { // this will exclude 'funny' primaries, too
 163       if (kTRUE) { // this won't
 164         p[0] = part->Px(); p[1] = part->Py(); p[2] = part->Pz();
 165         x[0] = part->Vx(); x[1] = part->Vy(); x[2] = part->Vz();
 166
 167         if (iTrack == 0) {
 168           // add primary vertex
 169           primary = new(vertices[jVertices++])
 170             AliAODVertex(x, NULL, -999., NULL, AliAODVertex::kPrimary);
 171         }
 172
 173         // add primary tracks
 174         primary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID,
 175                                                                 0, // Label
 176                                                                 p,
 177                                                                 kTRUE,
 178                                                                 x,
 179                                                                 kFALSE,
 180                                                                 covTr,
 181                                                                 (Short_t)-99,
 182                                                                 0, // no ITSClusterMap
 183                                                                 pid,
 184                                                                 primary,
 185                                                                 kFALSE, // no fit preformed
 186                                                                 AliAODTrack::kPrimary));
 187         currTrack = (AliAODTrack*)tracks.Last();
 188         SetChargeAndPID(part->GetPdgCode(), currTrack);
 189         if (currTrack->Charge() != -99) {
 190           if (currTrack->Charge() > 0) {
 191             nPos++;
 192           } else if (currTrack->Charge() < 0) {
 193             nNeg++;
 194           }
 195         }
 196
 197         LoopOverSecondaries(part);
 198       }
 199     } // end of track loop
 200
 201     header->SetRefMultiplicityPos(nPos);
 202     header->SetRefMultiplicityNeg(nNeg);
 203
 204     cout << ":: primaries: " << nPrims << " secondaries: " << tracks.GetEntriesFast()-nPrims <<
 205       " (pos: " << nPos << ", neg: " << nNeg << "), vertices: " << vertices.GetEntriesFast() <<
 206       " (kinks: " << jKinks << ", V0: " << jV0s << ", cascades: " << jCascades <<
 207       ", multi: " << jMultis << ")" << endl;
 208     /*
 209     cout << "  gamma: " << nGamma << " e-: " << nElectron << " e+: " << nPositron << " p: " << nProton <<
 210       " pBar: " << nAntiProton << " n: " << nNeutron << " nBar: " << nAntiNeutron << " pi0: " << nPi0 <<
 211       " pi+: " << nPiPlus << " pi-: " << nPiMinus << " K0: " << nK0 << " K+: " << nKPlus <<
 212       " K-: " << nKMinus << endl;
 213     */
 214     // fill the tree for this event
 215     aodTree->Fill();
 216   } // end of event loop
 217
 218   aodTree->GetUserInfo()->Add(aod);
 219
 220   // write the tree to the specified file
 221   outFile = aodTree->GetCurrentFile();
 222   outFile->cd();
 223   aodTree->Write();
 224   outFile->Close();
 225
 226 }
 227
 228
 229 Int_t LoopOverSecondaries(TParticle *mother) {
 230
 231   if (mother->GetNDaughters() > 0) {
 232
 233     TClonesArray &vertices = *(aod->GetVertices());
 234     TClonesArray &tracks = *(aod->GetTracks());
 235
 236     Float_t pSec[3];
 237     Float_t xSec[3];
 238     Float_t *covSec = NULL;
 239     Float_t *pidSec = NULL;
 240     AliAODVertex *secondary = NULL;
 241     AliAODTrack* currTrackSec = NULL;
 242
 243     for (Int_t iDaughter = mother->GetFirstDaughter(); iDaughter <= mother->GetLastDaughter(); iDaughter++) {
 244       TParticle *partSec = stack->Particle(iDaughter);
 245
 246       pSec[0] = partSec->Px(); pSec[1] = partSec->Py(); pSec[2] = partSec->Pz();
 247       xSec[0] = partSec->Vx(); xSec[1] = partSec->Vy(); xSec[2] = partSec->Vz();
 248
 249       if (iDaughter == mother->GetFirstDaughter()) {
 250         // add secondary vertex
 251         secondary = new(vertices[jVertices++])
 252           AliAODVertex(xSec, NULL, -999., tracks.Last(), AliAODVertex::kUndef);
 253
 254         SetVertexType(partSec, secondary);
 255       }
 256
 257       // add secondary tracks
 258       secondary->AddDaughter(new(tracks[jTracks++]) AliAODTrack(0, // ID
 259                                                                 0, // label
 260                                                                 pSec,
 261                                                                 kTRUE,
 262                                                                 xSec,
 263                                                                 kFALSE,
 264                                                                 covSec,
 265                                                                 (Short_t)-99,
 266                                                                 0, // no cluster map available
 267                                                                 pidSec,
 268                                                                 secondary,
 269                                                                 kFALSE, // no fit performed
 270                                                                 AliAODTrack::kSecondary));
 271
 272       currTrackSec = (AliAODTrack*)tracks.Last();
 273       SetChargeAndPID(partSec->GetPdgCode(), currTrackSec);
 274       if (currTrackSec->Charge() != -99) {
 275         if (currTrackSec->Charge() > 0) {
 276           nPos++;
 277         } else if (currTrackSec->Charge() < 0) {
 278           nNeg++;
 279         }
 280       }
 281
 282       LoopOverSecondaries(partSec);
 283     }
 284     return 1;
 285   } else {
 286     return 0;
 287   }
 288 }
 289
 290
 291 void SetChargeAndPID(Int_t pdgCode, AliAODTrack *track) {
 292
 293   Float_t PID[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};
 294
 295   switch (pdgCode) {
 296
 297   case 22: // gamma
 298     track->SetCharge(0);
 299     PID[AliAODTrack::kUnknown] = 1.;
 300     track->SetPID(PID);
 301     nGamma++;
 302     break;
 303
 304   case 11: // e-
 305     track->SetCharge(-1);
 306     PID[AliAODTrack::kElectron] = 1.;
 307     track->SetPID(PID);
 308     nElectron++;
 309     break;
 310
 311   case -11: // e+
 312     track->SetCharge(+1);
 313     PID[AliAODTrack::kElectron] = 1.;
 314     track->SetPID(PID);
 315     nPositron++;
 316     break;
 317
 318   case 13: // mu-
 319     track->SetCharge(-1);
 320     PID[AliAODTrack::kMuon] = 1.;
 321     track->SetPID(PID);
 322     nMuon++;
 323     break;
 324
 325   case -13: // mu+
 326     track->SetCharge(+1);
 327     PID[AliAODTrack::kMuon] = 1.;
 328     track->SetPID(PID);
 329     nAntiMuon++;
 330     break;
 331
 332   case 111: // pi0
 333     track->SetCharge(0);
 334     PID[AliAODTrack::kUnknown] = 1.;
 335     track->SetPID(PID);
 336     nPi0++;
 337     break;
 338
 339   case 211: // pi+
 340     track->SetCharge(+1);
 341     PID[AliAODTrack::kPion] = 1.;
 342     track->SetPID(PID);
 343     nPiPlus++;
 344     break;
 345
 346   case -211: // pi-
 347     track->SetCharge(-1);
 348     PID[AliAODTrack::kPion] = 1.;
 349     track->SetPID(PID);
 350     nPiMinus++;
 351     break;
 352
 353   case 130: // K0L
 354     track->SetCharge(0);
 355     PID[AliAODTrack::kUnknown] = 1.;
 356     track->SetPID(PID);
 357     nK0++;
 358     break;
 359
 360   case 321: // K+
 361     track->SetCharge(+1);
 362     PID[AliAODTrack::kKaon] = 1.;
 363     track->SetPID(PID);
 364     nKPlus++;
 365     break;
 366
 367   case -321: // K-
 368     track->SetCharge(-1);
 369     PID[AliAODTrack::kKaon] = 1.;
 370     track->SetPID(PID);
 371     nKMinus++;
 372     break;
 373
 374   case 2112: // n
 375     track->SetCharge(0);
 376     PID[AliAODTrack::kUnknown] = 1.;
 377     track->SetPID(PID);
 378     nNeutron++;
 379     break;
 380
 381   case 2212: // p
 382     track->SetCharge(+1);
 383     PID[AliAODTrack::kProton] = 1.;
 384     track->SetPID(PID);
 385     nProton++;
 386     break;
 387
 388   case -2212: // anti-p
 389     track->SetCharge(-1);
 390     PID[AliAODTrack::kProton] = 1.;
 391     track->SetPID(PID);
 392     nAntiProton++;
 393     break;
 394
 395   case 310: // K0S
 396     track->SetCharge(0);
 397     PID[AliAODTrack::kUnknown] = 1.;
 398     track->SetPID(PID);
 399     nK0++;
 400     break;
 401
 402   case 311: // K0
 403     track->SetCharge(0);
 404     PID[AliAODTrack::kUnknown] = 1.;
 405     track->SetPID(PID);
 406     nK0++;
 407     break;
 408
 409   case -311: // anti-K0
 410     track->SetCharge(0);
 411     PID[AliAODTrack::kUnknown] = 1.;
 412     track->SetPID(PID);
 413     nK0++;
 414     break;
 415
 416   case 221: // eta
 417     track->SetCharge(0);
 418     PID[AliAODTrack::kUnknown] = 1.;
 419     track->SetPID(PID);
 420     break;
 421
 422   case 3122: // lambda
 423     track->SetCharge(0);
 424     PID[AliAODTrack::kUnknown] = 1.;
 425     track->SetPID(PID);
 426     break;
 427
 428   case 3222: // Sigma+
 429     track->SetCharge(+1);
 430     PID[AliAODTrack::kUnknown] = 1.;
 431     track->SetPID(PID);
 432     break;
 433
 434   case 3212: // Sigma0
 435     track->SetCharge(-1);
 436     PID[AliAODTrack::kUnknown] = 1.;
 437     track->SetPID(PID);
 438     break;
 439
 440   case 3112: // Sigma-
 441     track->SetCharge(-1);
 442     PID[AliAODTrack::kUnknown] = 1.;
 443     track->SetPID(PID);
 444     break;
 445
 446   case 3322: // Xi0
 447     track->SetCharge(0);
 448     PID[AliAODTrack::kUnknown] = 1.;
 449     track->SetPID(PID);
 450     break;
 451
 452   case 3312: // Xi-
 453     track->SetCharge(-1);
 454     PID[AliAODTrack::kUnknown] = 1.;
 455     track->SetPID(PID);
 456     break;
 457
 458   case 3334: // Omega-
 459     track->SetCharge(-1);
 460     PID[AliAODTrack::kUnknown] = 1.;
 461     track->SetPID(PID);
 462     break;
 463
 464   case -2112: // n-bar
 465     track->SetCharge(0);
 466     PID[AliAODTrack::kUnknown] = 1.;
 467     track->SetPID(PID);
 468     break;
 469
 470   case -3122: // anti-Lambda
 471     track->SetCharge(0);
 472     PID[AliAODTrack::kUnknown] = 1.;
 473     track->SetPID(PID);
 474     break;
 475
 476   case -3222: // anti-Sigma-
 477     track->SetCharge(-1);
 478     PID[AliAODTrack::kUnknown] = 1.;
 479     track->SetPID(PID);
 480     break;
 481
 482   case -3212: // anti-Sigma0
 483     track->SetCharge(0);
 484     PID[AliAODTrack::kUnknown] = 1.;
 485     track->SetPID(PID);
 486     break;
 487
 488   case -3112: // anti-Sigma+
 489     track->SetCharge(+1);
 490     PID[AliAODTrack::kUnknown] = 1.;
 491     track->SetPID(PID);
 492     break;
 493
 494   case -3322: // anti-Xi0
 495     track->SetCharge(0);
 496     PID[AliAODTrack::kUnknown] = 1.;
 497     track->SetPID(PID);
 498     break;
 499
 500   case -3312: // anti-Xi+
 501     track->SetCharge(+1);
 502     break;
 503
 504   case -3334: // anti-Omega+
 505     track->SetCharge(+1);
 506     PID[AliAODTrack::kUnknown] = 1.;
 507     track->SetPID(PID);
 508     break;
 509
 510   case 411: // D+
 511     track->SetCharge(+1);
 512     PID[AliAODTrack::kUnknown] = 1.;
 513     track->SetPID(PID);
 514     break;
 515
 516   case -411: // D-
 517     track->SetCharge(-1);
 518     PID[AliAODTrack::kUnknown] = 1.;
 519     track->SetPID(PID);
 520     break;
 521
 522   case 421: // D0
 523     track->SetCharge(0);
 524     PID[AliAODTrack::kUnknown] = 1.;
 525     track->SetPID(PID);
 526     break;
 527
 528   case -421: // anti-D0
 529     track->SetCharge(0);
 530     PID[AliAODTrack::kUnknown] = 1.;
 531     track->SetPID(PID);
 532     break;
 533
 534   default : // unknown
 535     track->SetCharge(-99);
 536     PID[AliAODTrack::kUnknown] = 1.;
 537     track->SetPID(PID);
 538  }
 539
 540   return;
 541 }
 542
 543
 544 void SetVertexType(TParticle *part, AliAODVertex *vertex) {
 545   // this whole thing doesn't make much sense. but anyhow...
 546
 547   TParticle *mother = stack->Particle(part->GetFirstMother());
 548   Int_t pdgMother = mother->GetPdgCode();
 549   Int_t pdgPart = part->GetPdgCode();
 550
 551   // kinks
 552   if (mother->GetNDaughters() == 2) {
 553     Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
 554     Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
 555
 556     if (!(pdgMother == 22 || pdgMother == 111 || pdgMother == 130 ||
 557           TMath::Abs(pdgMother) == 2112 || pdgMother == 310 || pdgMother == 221 ||
 558           TMath::Abs(pdgMother) == 3122 || TMath::Abs(pdgMother) == 3322 ||
 559           pdgMother == -3212 || TMath::Abs(pdgMother) == 421 ||
 560           TMath::Abs(pdgMother) == 311) // not neutral
 561         && (((firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 ||
 562               TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 ||
 563               firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 ||
 564               TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 ||
 565               TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // neutral
 566              && !(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 ||
 567                   TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 ||
 568                   lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 ||
 569                   TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 ||
 570                   TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311)) // not neutral
 571             || !((firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 ||
 572                   TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 ||
 573                   firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 ||
 574                   TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 ||
 575                   TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
 576                  && (lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 ||
 577                      TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 ||
 578                      lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 ||
 579                      TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 ||
 580                      TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311)))) { // neutral
 581
 582       vertex->SetType(AliAODVertex::kKink);
 583       jKinks++;
 584     }
 585   }
 586
 587   // V0
 588   else if (mother->GetNDaughters() == 2) {
 589     Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
 590     Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
 591
 592     if ((pdgMother == 22 || pdgMother == 111 || pdgMother == 130 ||
 593          TMath::Abs(pdgMother) == 2112 || pdgMother == 310 ||
 594          pdgMother == 221 || TMath::Abs(pdgMother) == 3122 ||
 595          TMath::Abs(pdgMother) == 3322 || pdgMother == -3212 ||
 596          TMath::Abs(pdgMother) == 421 || TMath::Abs(pdgMother) == 311) // neutral
 597         && !(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 ||
 598              TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 ||
 599              lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 ||
 600              TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 ||
 601              TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
 602         && !(firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 ||
 603              TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 ||
 604              firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 ||
 605              TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 ||
 606              TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311)) { // not neutral
 607
 608       vertex->SetType(AliAODVertex::kV0);
 609       jV0s++;
 610     }
 611   }
 612
 613   // Cascade
 614   else if (mother->GetNDaughters() == 2) {
 615     Int_t firstPdgCode = stack->Particle(mother->GetFirstDaughter())->GetPdgCode();
 616     Int_t lastPdgCode = stack->Particle(mother->GetLastDaughter())->GetPdgCode();
 617
 618     if ((TMath::Abs(pdgMother) == 3334 || TMath::Abs(pdgMother) == 3312 || TMath::Abs(pdgMother) == 3322) &&
 619         (TMath::Abs(pdgPart) == 3122 || TMath::Abs(pdgPart) == 211 || TMath::Abs(pdgPart) == 321)
 620         && ((!(firstPdgCode == 22 || firstPdgCode == 111 || firstPdgCode == 130 ||
 621                TMath::Abs(firstPdgCode) == 2112 || firstPdgCode == 310 ||
 622                firstPdgCode == 221 || TMath::Abs(firstPdgCode) == 3122 ||
 623                TMath::Abs(firstPdgCode) == 3322 || firstPdgCode == -3212 ||
 624                TMath::Abs(firstPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
 625              && TMath::Abs(lastPdgCode) == 3122) // labmda or anti-lambda
 626             || ((!(lastPdgCode == 22 || lastPdgCode == 111 || lastPdgCode == 130 ||
 627                    TMath::Abs(lastPdgCode) == 2112 || lastPdgCode == 310 ||
 628                    lastPdgCode == 221 || TMath::Abs(lastPdgCode) == 3122 ||
 629                    TMath::Abs(lastPdgCode) == 3322 || lastPdgCode == -3212 ||
 630                    TMath::Abs(lastPdgCode) == 421 || TMath::Abs(pdgMother) == 311) // not neutral
 631                  && TMath::Abs(firstPdgCode) == 3122)))) { // lambda or anti-lambda
 632       vertex->SetType(AliAODVertex::kCascade);
 633       jCascades++;
 634     }
 635   }
 636
 637   // Multi
 638   else if (mother->GetNDaughters() > 2) {
 639
 640     vertex->SetType(AliAODVertex::kMulti);
 641     jMultis++;
 642   }
 643
 644   else {
 645     vertex->SetType(AliAODVertex::kUndef);
 646   }
 647 }
 648 //  LocalWords:  SetCharge