PWG/muon/AliAnalysisMuonUtility.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2007, 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 /* $Id: AliAnalysisMuonUtility.cxx 47782 2011-02-24 18:37:31Z martinez $ */
  17
  18 //-----------------------------------------------------------------------------
  19 /// \class AliAnalysisMuonUtility
  20 /// Static tilities for muon analysis
  21 /// The class allows to treat AODs and ESDs
  22 /// as well as MC AODs and MC in a transparent way
  23 ///
  24 /// \author Diego Stocco
  25 //-----------------------------------------------------------------------------
  26
  27 #include "AliAnalysisMuonUtility.h"
  28
  29 // ROOT includes
  30 #include "TAxis.h"
  31 #include "TMath.h"
  32 #include "TLorentzVector.h"
  33 #include "TFile.h"
  34
  35 // STEER includes
  36 #include "AliAODEvent.h"
  37 #include "AliAODHeader.h"
  38 #include "AliAODMCHeader.h"
  39 #include "AliAODMCParticle.h"
  40 #include "AliAODTrack.h"
  41 #include "AliAODTZERO.h"
  42 #include "AliESDEvent.h"
  43 #include "AliESDMuonTrack.h"
  44 #include "AliESDTZERO.h"
  45 #include "AliInputEventHandler.h"
  46 #include "AliLog.h"
  47 #include "AliMCEvent.h"
  48 #include "AliMCParticle.h"
  49 #include "AliVVertex.h"
  50 #include "AliStack.h"
  51
  52 // CORRFW includes
  53 #include "AliCFGridSparse.h"
  54
  55 /// \cond CLASSIMP
  56 ClassImp(AliAnalysisMuonUtility) // Class implementation in ROOT context
  57 /// \endcond
  58
  59
  60 //________________________________________________________________________
  61 Bool_t AliAnalysisMuonUtility::IsAODEvent ( const AliVEvent* event )
  62 {
  63   /// Check if event is from ESD or AOD
  64   return ( event->IsA() == AliAODEvent::Class() );
  65 }
  66
  67 //________________________________________________________________________
  68 Bool_t AliAnalysisMuonUtility::IsAODTrack ( const AliVParticle* track )
  69 {
  70   /// Check if track is from ESD or AOD
  71   return ( track->IsA() == AliAODTrack::Class() );
  72 }
  73
  74 //________________________________________________________________________
  75 Bool_t AliAnalysisMuonUtility::IsMuonTrack ( const AliVParticle* track )
  76 {
  77   /// Check if track has muon tracker info
  78   return ( IsAODTrack(track) ) ? static_cast<const AliAODTrack*>(track)->IsMuonTrack() : static_cast<const AliESDMuonTrack*>(track)->ContainTrackerData();
  79 }
  80
  81 //________________________________________________________________________
  82 Bool_t AliAnalysisMuonUtility::IsMuonGhost ( const AliVParticle* track )
  83 {
  84   /// Check if track has trigger info
  85   return ( IsAODTrack(track) ) ? kFALSE : ( ! static_cast<const AliESDMuonTrack*>(track)->ContainTrackerData() );
  86 }
  87
  88 //________________________________________________________________________
  89 Double_t AliAnalysisMuonUtility::GetRabs ( const AliVParticle* track )
  90 {
  91   /// Get Rabs
  92   return ( IsAODTrack(track) ) ? static_cast<const AliAODTrack*>(track)->GetRAtAbsorberEnd() : static_cast<const AliESDMuonTrack*>(track)->GetRAtAbsorberEnd();
  93 }
  94
  95 //________________________________________________________________________
  96 Double_t AliAnalysisMuonUtility::GetThetaAbsDeg ( const AliVParticle* track )
  97 {
  98   /// Get Theta at absorber end (in deg)
  99   return TMath::ATan( GetRabs(track) / 505. ) * TMath::RadToDeg();
 100 }
 101
 102 //________________________________________________________________________
 103 Int_t AliAnalysisMuonUtility::GetMatchTrigger ( const AliVParticle* track )
 104 {
 105   /// Get match trigger
 106   return IsAODTrack(track) ? static_cast<const AliAODTrack*>(track)->GetMatchTrigger() : static_cast<const AliESDMuonTrack*>(track)->GetMatchTrigger();
 107 }
 108
 109 //________________________________________________________________________
 110 Double_t AliAnalysisMuonUtility::GetChi2perNDFtracker ( const AliVParticle* track )
 111 {
 112   /// Get the normalized chi2 of the tracker track
 113   return IsAODTrack(track) ? static_cast<const AliAODTrack*>(track)->Chi2perNDF() : static_cast<const AliESDMuonTrack*>(track)->GetNormalizedChi2();
 114 }
 115
 116 //________________________________________________________________________
 117 Double_t AliAnalysisMuonUtility::GetChi2MatchTrigger ( const AliVParticle* track )
 118 {
 119   /// Get the normalized chi2 of the tracker-trigger track matching
 120   return IsAODTrack(track) ? static_cast<const AliAODTrack*>(track)->GetChi2MatchTrigger() : static_cast<const AliESDMuonTrack*>(track)->GetChi2MatchTrigger();
 121 }
 122
 123 //________________________________________________________________________
 124 Double_t AliAnalysisMuonUtility::GetXatVertex ( const AliVParticle* track )
 125 {
 126   /// Get X at vertex
 127   Double_t coor = 0.;
 128   if ( IsAODTrack(track) ) {
 129     Double_t vtxPos[3];
 130     static_cast<const AliAODTrack*>(track)->GetXYZ(vtxPos);
 131     coor = vtxPos[0];
 132   }
 133   else coor = static_cast<const AliESDMuonTrack*>(track)->GetNonBendingCoor();
 134
 135   return coor;
 136 }
 137
 138 //________________________________________________________________________
 139 Double_t AliAnalysisMuonUtility::GetYatVertex ( const AliVParticle* track )
 140 {
 141   /// Get Y at vertex
 142   Double_t coor = 0.;
 143   if ( IsAODTrack(track) ) {
 144     Double_t vtxPos[3];
 145     static_cast<const AliAODTrack*>(track)->GetXYZ(vtxPos);
 146     coor = vtxPos[1];
 147   }
 148   else coor = static_cast<const AliESDMuonTrack*>(track)->GetBendingCoor();
 149
 150   return coor;
 151 }
 152
 153 //________________________________________________________________________
 154 Double_t AliAnalysisMuonUtility::GetZatVertex ( const AliVParticle* track )
 155 {
 156   /// Get Z at vertex
 157   Double_t coor = 0.;
 158   if ( IsAODTrack(track) ) {
 159     Double_t vtxPos[3];
 160     static_cast<const AliAODTrack*>(track)->GetXYZ(vtxPos);
 161     coor = vtxPos[2];
 162   }
 163   else coor = static_cast<const AliESDMuonTrack*>(track)->GetZ();
 164
 165   return coor;
 166 }
 167
 168 //________________________________________________________________________
 169 Double_t AliAnalysisMuonUtility::GetXatDCA ( const AliVParticle* track )
 170 {
 171   /// Get X at DCA
 172   return IsAODTrack(track) ? static_cast<const AliAODTrack*>(track)->XAtDCA() : static_cast<const AliESDMuonTrack*>(track)->GetNonBendingCoorAtDCA();
 173 }
 174
 175 //________________________________________________________________________
 176 Double_t AliAnalysisMuonUtility::GetYatDCA ( const AliVParticle* track )
 177 {
 178   /// Get Y at DCA
 179   return IsAODTrack(track) ? static_cast<const AliAODTrack*>(track)->YAtDCA() : static_cast<const AliESDMuonTrack*>(track)->GetBendingCoorAtDCA();
 180 }
 181
 182 //________________________________________________________________________
 183 Bool_t AliAnalysisMuonUtility::IsTrkChamberHit( Int_t chamber, const AliVParticle* track )
 184 {
 185   /// Check if the given tracking chamber has been fired
 186   if (chamber < 0 || chamber > 9) return kFALSE;
 187   return IsAODTrack(track) ? static_cast<const AliAODTrack*>(track)->HitsMuonChamber(chamber) : static_cast<const AliESDMuonTrack*>(track)->IsInMuonClusterMap(chamber);
 188 }
 189
 190 //________________________________________________________________________
 191 UInt_t AliAnalysisMuonUtility::GetMUONTrigHitsMapTrk ( const AliVParticle* track )
 192 {
 193   /// Get hit pattern in trigger chambers from tracker track extrapolation
 194   return ( IsAODTrack(track) ) ? const_cast<AliAODTrack*>(static_cast<const AliAODTrack*>(track))->GetMUONTrigHitsMapTrk() : static_cast<const AliESDMuonTrack*>(track)->GetHitsPatternInTrigChTrk();
 195 }
 196
 197 //________________________________________________________________________
 198 UInt_t AliAnalysisMuonUtility::GetMUONTrigHitsMapTrg ( const AliVParticle* track )
 199 {
 200   /// Get hit pattern in trigger chambers from tracker track extrapolation
 201   return ( IsAODTrack(track) ) ? const_cast<AliAODTrack*>(static_cast<const AliAODTrack*>(track))->GetMUONTrigHitsMapTrg() : static_cast<const AliESDMuonTrack*>(track)->GetHitsPatternInTrigCh();
 202 }
 203
 204 //________________________________________________________________________
 205 Int_t AliAnalysisMuonUtility::GetLoCircuit ( const AliVParticle* track )
 206 {
 207   /// Get local board
 208   Int_t loCircuit = 0;
 209   if ( IsAODTrack (track) ) {
 210     UInt_t pattern = const_cast<AliAODTrack*>(static_cast<const AliAODTrack*>(track))->GetMUONTrigHitsMapTrg();
 211     loCircuit = AliESDMuonTrack::GetCrossedBoard(pattern);
 212   }
 213   else loCircuit = static_cast<const AliESDMuonTrack*>(track)->LoCircuit();
 214
 215   return loCircuit;
 216 }
 217
 218 //________________________________________________________________________
 219 TString AliAnalysisMuonUtility::GetFiredTriggerClasses ( const AliVEvent* event )
 220 {
 221   /// Check if track is from ESD or AOD
 222   return ( IsAODEvent(event) ) ? static_cast<const AliAODEvent*>(event)->GetFiredTriggerClasses() : static_cast<const AliESDEvent*>(event)->GetFiredTriggerClasses();
 223 }
 224
 225 //________________________________________________________________________
 226 Int_t AliAnalysisMuonUtility::GetNTracks ( const AliVEvent* event )
 227 {
 228   //
 229   /// Return the number of tracks in event
 230   //
 231   return ( IsAODEvent(event) ) ? static_cast<const AliAODEvent*>(event)->GetNTracks() : static_cast<const AliESDEvent*>(event)->GetNumberOfMuonTracks();
 232 }
 233
 234 //________________________________________________________________________
 235 UInt_t AliAnalysisMuonUtility::GetL0TriggerInputs ( const AliVEvent* event )
 236 {
 237   //
 238   /// Return the L0 trigger inputs
 239   //
 240   return ( IsAODEvent(event) ) ? static_cast<const AliAODEvent*>(event)->GetHeader()->GetL0TriggerInputs() : static_cast<const AliESDEvent*>(event)->GetHeader()->GetL0TriggerInputs();
 241 }
 242
 243 //________________________________________________________________________
 244 UInt_t AliAnalysisMuonUtility::GetL1TriggerInputs ( const AliVEvent* event )
 245 {
 246   //
 247   /// Return the L1 trigger inputs
 248   //
 249   return ( IsAODEvent(event) ) ? static_cast<const AliAODEvent*>(event)->GetHeader()->GetL1TriggerInputs() : static_cast<const AliESDEvent*>(event)->GetHeader()->GetL1TriggerInputs();
 250 }
 251
 252 //________________________________________________________________________
 253 UInt_t AliAnalysisMuonUtility::GetL2TriggerInputs ( const AliVEvent* event )
 254 {
 255   //
 256   /// Return the L2 trigger inputs
 257   //
 258   return ( IsAODEvent(event) ) ? static_cast<const AliAODEvent*>(event)->GetHeader()->GetL2TriggerInputs() : static_cast<const AliESDEvent*>(event)->GetHeader()->GetL2TriggerInputs();
 259 }
 260
 261 //________________________________________________________________________
 262 AliVParticle* AliAnalysisMuonUtility::GetTrack ( Int_t itrack, const AliVEvent* event )
 263 {
 264   //
 265   /// Get the current track
 266   //
 267   AliVParticle* track = 0x0;
 268   if ( IsAODEvent(event) ) track = static_cast<const AliAODEvent*>(event)->GetTrack(itrack);
 269   else {
 270     AliESDEvent* esdEvent = const_cast<AliESDEvent*>(static_cast<const AliESDEvent*> (event));
 271     track = esdEvent->GetMuonTrack(itrack);
 272   }
 273   return track;
 274 }
 275
 276 //________________________________________________________________________
 277 Double_t AliAnalysisMuonUtility::MuonMass2()
 278 {
 279   /// A usefull constant
 280   return 1.11636129640000012e-02;
 281 }
 282
 283 //________________________________________________________________________
 284 TLorentzVector AliAnalysisMuonUtility::GetTrackPair ( const AliVParticle* track1, const AliVParticle* track2 )
 285 {
 286   //
 287   /// Get track pair
 288   //
 289   const AliVParticle* tracks[2] = {track1, track2};
 290
 291   TLorentzVector vec[2];
 292   for ( Int_t itrack=0; itrack<2; ++itrack ) {
 293     Double_t trackP = tracks[itrack]->P();
 294     Double_t energy = TMath::Sqrt(trackP*trackP + MuonMass2());
 295     vec[itrack].SetPxPyPzE(tracks[itrack]->Px(), tracks[itrack]->Py(), tracks[itrack]->Pz(), energy);
 296   }
 297
 298   TLorentzVector vecPair = vec[0] + vec[1];
 299   return vecPair;
 300 }
 301
 302
 303 //________________________________________________________________________
 304 Bool_t AliAnalysisMuonUtility::IsAODMCTrack( const AliVParticle* mcParticle )
 305 {
 306   /// Check if track is from AOD MC
 307   return ( mcParticle->IsA() == AliAODMCParticle::Class() );
 308 }
 309
 310 //________________________________________________________________________
 311 Bool_t AliAnalysisMuonUtility::IsMCTrack( const AliVParticle* mcParticle )
 312 {
 313   /// Check if track is MC track
 314   return ( mcParticle->IsA() == AliAODMCParticle::Class() || mcParticle->IsA() == AliMCParticle::Class() );
 315 }
 316
 317
 318 //________________________________________________________________________
 319 Double_t AliAnalysisMuonUtility::GetMCVertexZ ( const AliVEvent* event, const AliMCEvent* mcEvent )
 320 {
 321   /// Get MC vertex Z
 322   Double_t vz = 0.;
 323   if ( IsAODEvent(event) ) {
 324     AliAODMCHeader* aodMCHeader = static_cast<AliAODMCHeader*> (static_cast<const AliAODEvent*>(event)->FindListObject(AliAODMCHeader::StdBranchName()));
 325     vz = aodMCHeader->GetVtxZ();
 326   }
 327   else if ( mcEvent ) vz = mcEvent->GetPrimaryVertex()->GetZ();
 328   else AliErrorClass("No MC event found");
 329   return vz;
 330 }
 331
 332 //________________________________________________________________________
 333 Int_t AliAnalysisMuonUtility::GetMotherIndex ( const AliVParticle* mcParticle )
 334 {
 335   //
 336   /// Return the mother index
 337   //
 338   return ( IsAODMCTrack(mcParticle) ) ? static_cast<const AliAODMCParticle*>(mcParticle)->GetMother() : static_cast<const AliMCParticle*>(mcParticle)->GetMother();
 339 }
 340
 341 //________________________________________________________________________
 342 Int_t AliAnalysisMuonUtility::GetDaughterIndex ( const AliVParticle* mcParticle, Int_t idaughter )
 343 {
 344   //
 345   /// Return the daughter index
 346   /// idaughter can be:
 347   /// 0 -> first daughter
 348   /// 1 -> last daughter
 349   //
 350   if ( idaughter < 0 || idaughter > 1 ) {
 351     AliErrorClass(Form("Requested daughter %i Daughter index can be either 0 (first) or 1 (last)", idaughter));
 352     return -1;
 353   }
 354
 355   if ( IsAODMCTrack(mcParticle) ) return static_cast<const AliAODMCParticle*>(mcParticle)->GetDaughter(idaughter);
 356
 357   if ( idaughter == 0 ) return static_cast<const AliMCParticle*>(mcParticle)->GetFirstDaughter();
 358   else return static_cast<const AliMCParticle*>(mcParticle)->GetLastDaughter();
 359 }
 360
 361 //________________________________________________________________________
 362 Bool_t AliAnalysisMuonUtility::IsPrimary ( const AliVParticle* mcParticle, const AliMCEvent* mcEvent )
 363 {
 364   /// Check if the particle is primary
 365
 366   Bool_t isPrimary = kFALSE;
 367   if ( IsAODMCTrack(mcParticle) ) isPrimary = static_cast<const AliAODMCParticle*>(mcParticle)->IsPrimary();
 368   else if ( mcEvent ) {
 369     // First get the index of the current particle in the stack.
 370     // For this: get the mother, and get its daughter.
 371     // Since the mother can have many daughters, you can come up to a "sister"
 372     // of the particle. Nevertheless, if it is primary, then also the particle itself should be.
 373     Int_t imother = static_cast<const AliMCParticle*> (mcParticle)->GetMother();
 374     if ( imother < 0 ) isPrimary = kTRUE;
 375     else if ( static_cast<const AliMCParticle*>(mcEvent->GetTrack(imother))->GetFirstDaughter() < const_cast<AliMCEvent*>(mcEvent)->GetNumberOfPrimaries() ) isPrimary = kTRUE;
 376   }
 377   else AliWarningClass("There is no MC info");
 378   return isPrimary;
 379 }
 380
 381 //________________________________________________________________________
 382 UInt_t AliAnalysisMuonUtility::GetMCProcess ( const AliVParticle* mcParticle )
 383 {
 384   /// Get MC process
 385   /// WARNING: the method may fail when running on AODs for old MC production,
 386   /// the information was propagated to the AOD level only recently
 387   UInt_t mcProcess = 0;
 388   if ( IsAODMCTrack(mcParticle) ) {
 389     mcProcess = const_cast<AliAODMCParticle*>(static_cast<const AliAODMCParticle*>(mcParticle))->GetMCProcessCode();
 390   }
 391   else if ( mcParticle->IsA() == AliMCParticle::Class() ) {
 392     mcProcess = static_cast<const AliMCParticle*>(mcParticle)->Particle()->GetUniqueID();
 393   }
 394   else AliWarningClass("There is no MC info");
 395   return mcProcess;
 396 }
 397
 398 //________________________________________________________________________
 399 UInt_t AliAnalysisMuonUtility::GetStatusCode ( const AliVParticle* mcParticle )
 400 {
 401   /// Get particle status code
 402   UInt_t statusCode = 0;
 403   if ( IsAODMCTrack(mcParticle) ) {
 404     statusCode = static_cast<const AliAODMCParticle*>(mcParticle)->GetStatus();
 405   }
 406   else if ( mcParticle->IsA() == AliMCParticle::Class() ) {
 407     statusCode = static_cast<const AliMCParticle*>(mcParticle)->Particle()->GetStatusCode();
 408   }
 409   else AliWarningClass("There is no MC info");
 410   return statusCode;
 411 }
 412
 413 //________________________________________________________________________
 414 AliVVertex* AliAnalysisMuonUtility::GetVertexSPD ( const AliVEvent* event )
 415 {
 416   //
 417   /// Get vertex SPD
 418   //
 419
 420   AliVVertex* primaryVertex = ( IsAODEvent(event) ) ? (AliVVertex*)static_cast<const AliAODEvent*>(event)->GetPrimaryVertexSPD() : (AliVVertex*)static_cast<const AliESDEvent*>(event)->GetPrimaryVertexSPD();
 421   return primaryVertex;
 422 }
 423
 424
 425 //________________________________________________________________________
 426 TString AliAnalysisMuonUtility::GetPassName ( const AliInputEventHandler* eventHandler )
 427 {
 428   /// Get pass name from event
 429
 430   // At present there is no straightforward way to get the pass name.
 431   // The pass name is usually written in the path to the ESDs/AODs
 432   // but this won't work for:
 433   // - MC data (no pass info available)
 434   // - local ESDs/AODs
 435
 436   TString filePath = "";
 437   const AliVEvent* event = eventHandler->GetEvent();
 438   if ( IsAODEvent(event) ) {
 439     // In AODs, the header contains the path to the input ESD event
 440     // However, sometimes there is not the FULL path of the ESDs.
 441     // In that case we cannot extract the pass number.
 442     // To increase the possibility of getting the pass number,
 443     // try first to find the info in the AOD header
 444     // (which is a priori safer because it works even on local copies of AODs)
 445     // and if it does not work, directly check the path to the AOD
 446     filePath = static_cast<const AliAODEvent*> (event)->GetHeader()->GetESDFileName();
 447     TString passName = GetPassName(filePath.Data());
 448     if ( passName.IsNull() ) AliWarningClass("Check again with the AOD path");
 449     else return passName;
 450   }
 451
 452   filePath = eventHandler->GetTree()->GetCurrentFile()->GetName();
 453   return GetPassName(filePath.Data());
 454 }
 455
 456
 457 //________________________________________________________________________
 458 Int_t AliAnalysisMuonUtility::GetPassNumber ( const AliInputEventHandler* eventHandler )
 459 {
 460   /// Get pass number from event
 461
 462   // At present there is no straightforward way to get the pass number.
 463   // The pass number is usually written in the path to the ESDs/AODs
 464   // but this won't work for:
 465   // - MC data (no pass info available)
 466   // - local ESDs/AODs
 467
 468   TString passName = GetPassName(eventHandler);
 469   return GetPassNumber(passName);
 470 }
 471
 472
 473 //________________________________________________________________________
 474 TString AliAnalysisMuonUtility::GetPassName ( const char* str )
 475 {
 476   //
 477   /// Get pass name from string
 478   //
 479
 480   TString currName(str);
 481   TObjArray* array = currName.Tokenize("/");
 482
 483   TString passName = "";
 484   for ( Int_t ientry=0; ientry<array->GetEntries(); ientry++ ) {
 485     TString currToken = static_cast<TObjString*>(array->At(ientry))->GetString();
 486     TString checkToken(currToken);
 487     checkToken.ToUpper();
 488     if ( checkToken.Contains("PASS") || checkToken.Contains("MUON_CALO") ) {
 489       passName = currToken;
 490       break;
 491     }
 492   }
 493
 494   delete array;
 495
 496   if ( passName.IsNull() ) AliWarningClass(Form("Cannot find pass name in: %s", str));
 497
 498   return passName;
 499 }
 500
 501 //________________________________________________________________________
 502 Int_t AliAnalysisMuonUtility::GetPassNumber ( const char* str )
 503 {
 504   //
 505   /// Get pass number from string
 506   //
 507
 508   TString currName(str);
 509   currName.ToUpper();
 510   Int_t idx = currName.Index("PASS");
 511   if ( idx >= 0 ) {
 512     // Remove all of the words before PASS (and remove the word PASS itself)
 513     currName.Remove(0,idx+4);
 514     // Cut the word from the end untill only the digits are left
 515     // (In this way we can extract the pass number even if it has more than one digit)
 516     while ( ! currName.IsDigit() && currName.Length() > 0 ) {
 517       currName.Remove(currName.Length()-1);
 518     }
 519
 520     if ( currName.Length() > 0 ) return currName.Atoi();
 521   }
 522
 523   AliWarningClass(Form("Cannot find pass number in: %s", str));
 524   return -1;
 525 }
 526
 527 //________________________________________________________________________
 528 TString AliAnalysisMuonUtility::GetTrackHistory ( const AliVParticle* track, const AliMCEvent* mcEvent, Bool_t verbose )
 529 {
 530   //
 531   /// Get string containing particle history
 532   /// Useful when debugging MC
 533   //
 534   TString trackHistory = "";
 535   if ( ! mcEvent ) return trackHistory;
 536   Int_t fakeMother = 999999999;
 537   Int_t imother = IsMCTrack(track) ? fakeMother : track->GetLabel();
 538
 539   while ( imother >= 0 ) {
 540     const AliVParticle* part = ( imother == fakeMother ) ? track : mcEvent->GetTrack(imother);
 541     if ( ! part ) break; // In principle not needed...but for some old MC it breaks sometimes
 542     TParticlePDG* partPdg = TDatabasePDG::Instance()->GetParticle(part->PdgCode());
 543     TString pname = ( partPdg ) ? partPdg->GetName() : Form("%i",part->PdgCode());
 544     if ( ! trackHistory.IsNull() ) trackHistory.Append(" <- ");
 545     if ( imother != fakeMother ) trackHistory.Append(Form("%i ", imother));
 546     trackHistory.Append(Form("(%s)", pname.Data()));
 547     if ( verbose ) trackHistory.Append(Form(" [vz %g  mc %i]", part->Zv(), GetMCProcess(part)));
 548     imother = AliAnalysisMuonUtility::GetMotherIndex(part);
 549   }
 550   return trackHistory;
 551 }
 552
 553 //________________________________________________________________________
 554 Bool_t AliAnalysisMuonUtility::EAGetTZEROFlags(const AliVEvent* event, Bool_t& backgroundFlag, Bool_t& pileupFlag, Bool_t& satelliteFlag)
 555 {
 556   // get the TZERO decisions
 557   // return false if there's no tzero information in this event
 558
 559   Bool_t rv(kFALSE);
 560
 561   if ( event->IsA() == AliESDEvent::Class() )
 562   {
 563     const AliESDTZERO* tzero = static_cast<AliESDEvent*>(const_cast<AliVEvent*>(event))->GetESDTZERO();
 564     if ( tzero )
 565     {
 566       backgroundFlag = tzero->GetBackgroundFlag();
 567       pileupFlag = tzero->GetPileupFlag();
 568       satelliteFlag = tzero->GetSatellite();
 569       rv = kTRUE;
 570     }
 571   }
 572   else if ( event->IsA() == AliAODEvent::Class() )
 573   {
 574     AliAODTZERO* tzero = static_cast<const AliAODEvent*>(event)->GetTZEROData();
 575     if ( tzero )
 576     {
 577       backgroundFlag = tzero->GetBackgroundFlag();
 578       pileupFlag = tzero->GetPileupFlag();
 579       satelliteFlag = tzero->GetSatellite();
 580       rv = kTRUE;
 581     }
 582   }
 583   else
 584   {
 585     AliErrorClass(Form("Unknown class for the event = %s",event->ClassName()));
 586   }
 587
 588   return rv;
 589 }
 590
 591 //_______________________________________________________________________
 592 Bool_t AliAnalysisMuonUtility::SetSparseRange(AliCFGridSparse* gridSparse,
 593                                         Int_t ivar, TString labelName,
 594                                         Double_t varMin, Double_t varMax,
 595                                         TString option)
 596 {
 597   //
 598   /// Set range in a smart way.
 599   /// Allows to select a bin from the label.
 600   /// Check the bin limits.
 601   //
 602
 603   option.ToUpper();
 604   Int_t minVarBin = -1, maxVarBin = -1;
 605   TAxis* axis = gridSparse->GetAxis(ivar);
 606
 607   if ( ! axis ) {
 608     printf("Warning: Axis %i not found in %s", ivar, gridSparse->GetName());
 609     return kFALSE;
 610   }
 611
 612   if ( ! labelName.IsNull() ) {
 613     minVarBin = axis->FindBin(labelName.Data());
 614     maxVarBin = minVarBin;
 615     if ( minVarBin < 1 ) {
 616       printf("Warning: %s: label %s not found. Nothing done", gridSparse->GetName(), labelName.Data());
 617       return kFALSE;
 618     }
 619   }
 620   else if ( option.Contains( "USEBIN" ) ) {
 621     minVarBin = (Int_t)varMin;
 622     maxVarBin = (Int_t)varMax;
 623   }
 624   else {
 625     minVarBin = axis->FindBin(varMin);
 626     maxVarBin = axis->FindBin(varMax);
 627   }
 628
 629   if ( axis->GetFirst() == minVarBin && axis->GetLast() == maxVarBin ) return kFALSE;
 630
 631   gridSparse->SetRangeUser(ivar, axis->GetBinCenter(minVarBin), axis->GetBinCenter(maxVarBin));
 632
 633   return kTRUE;
 634 }