MUON/AliMUONDataInterface.cxx

   1
   2 // Author: Artur Szostak
   3 //  email: artur@alice.phy.uct.ac.za
   4
   5 #include <TError.h>
   6 #include <TParticle.h>
   7
   8 #include "AliRunLoader.h"
   9 #include "AliLoader.h"
  10
  11 #include "AliMUONDataInterface.h"
  12 #include "AliMUONLocalTrigger.h"
  13 #include "AliMUONHit.h"
  14 #include "AliMUONDigit.h"
  15 #include "AliMUONRawCluster.h"
  16 #include "AliLog.h"
  17
  18
  19 ClassImp(AliMUONDataInterface)
  20
  21
  22 AliMUONDataInterface::AliMUONDataInterface()
  23         : TObject(), fData(NULL, "MUON", "MUON")
  24 {
  25 // Set all internal pointers to NULL and indices to -1.
  26
  27         Reset();
  28 }
  29
  30 AliMUONDataInterface::AliMUONDataInterface(const AliMUONDataInterface& rhs)
  31   : TObject(rhs)
  32 {
  33 // Protected copy constructor
  34
  35   AliFatal("Not implemented.");
  36 }
  37
  38 AliMUONDataInterface::~AliMUONDataInterface()
  39 {
  40 // Delete the runloader when done.
  41 // If the runloader is not to be deleted then call Reset just before
  42 // the destructor is called.
  43
  44         if (fRunloader != NULL)
  45                 delete fRunloader;
  46 }
  47
  48 AliMUONDataInterface&
  49 AliMUONDataInterface::operator=(const AliMUONDataInterface& rhs)
  50 {
  51 // Protected assignement operator
  52
  53   if (this == &rhs) return *this;
  54
  55   AliFatal("Not implemented.");
  56
  57   return *this;
  58 }
  59
  60
  61 void AliMUONDataInterface::Reset()
  62 {
  63 // Sets all internal pointers to NULL and indices to -1.
  64 // Note: No resources are released!
  65 // Specificaly AliRunLoader is not deleted.
  66
  67         fRunloader = NULL;
  68         fMuonloader = NULL;
  69         fEventnumber = -1;
  70         fTrack = -1;
  71         fSCathode = -1;
  72         fCathode = -1;
  73         fHitAddressSet = kFALSE;
  74         fSDigitAddressSet = kFALSE;
  75         fDigitAddressSet = kFALSE;
  76         fClusterAddressSet = kFALSE;
  77         fTriggerAddressSet = kFALSE;
  78 }
  79
  80
  81 Bool_t AliMUONDataInterface::LoadLoaders(TString filename, TString foldername)
  82 {
  83 // Load the run and muon loaders from the specified file and folder.
  84 // kTRUE is returned on success and kFALSE on failure.
  85
  86         fRunloader = AliRunLoader::Open(filename, foldername, "READ");
  87         if (fRunloader == NULL)
  88         {
  89                 AliError(Form("Could not find or load the run loader for the file: %s and folder: %s",
  90                         (const char*)filename, (const char*)foldername));
  91                 return kFALSE;
  92         }
  93         fMuonloader = fRunloader->GetLoader("MUONLoader");
  94         if (fMuonloader == NULL)
  95         {
  96                 AliError(Form("Could not find the MUON loader in file: %s and folder: %s",
  97                         (const char*)filename, (const char*)foldername));
  98                 fRunloader = NULL;
  99                 return kFALSE;
 100         }
 101
 102         // Need to connect the muon loader to the AliMUONData object,
 103         // else class to fData will return NULL.
 104         fData.SetLoader(fMuonloader);
 105
 106         fFilename = filename;
 107         fFoldername = foldername;
 108         fEventnumber = -1;  // Reset the event number to force the event to be loaded.
 109         return kTRUE;
 110 }
 111
 112
 113 Bool_t AliMUONDataInterface::FetchLoaders(TString filename, TString foldername)
 114 {
 115 // Fetch the run loader and muon loader objects from memory if they already exist,
 116 // or from memory if they do not.
 117 // If the currently loaded run loader (if any) is not refering to the file and folder
 118 // we are interested in then it is deleted and reopened with the required file and
 119 // folder names.
 120
 121         if (fRunloader == NULL)
 122         {
 123                 fRunloader = AliRunLoader::GetRunLoader();
 124                 if (fRunloader == NULL)
 125                         return LoadLoaders(filename, foldername);
 126
 127                 // Fetch the current file and folder names.
 128                 fFilename = fRunloader->GetFileName();
 129                 fFoldername = fRunloader->GetEventFolder()->GetName();
 130         }
 131
 132         // If filename or foldername are not the same as the ones currently selected then
 133         // reopen the file.
 134         if ( filename.CompareTo(fFilename) != 0 || foldername.CompareTo(fFoldername) != 0 )
 135         {
 136                 delete fRunloader;
 137                 return LoadLoaders(filename, foldername);
 138         }
 139         return kTRUE;
 140 }
 141
 142
 143 Bool_t AliMUONDataInterface::FetchEvent(Int_t event)
 144 {
 145 // Fetch the specified event from the runloader and reset all the track, cathode
 146 // and address flags to force them to be reloaded.
 147
 148         if (fEventnumber < 0)
 149         {
 150                 fEventnumber = fRunloader->GetEventNumber();
 151                 fTrack = -1;
 152                 fSCathode = -1;
 153                 fCathode = -1;
 154                 fHitAddressSet = kFALSE;
 155                 fSDigitAddressSet = kFALSE;
 156                 fDigitAddressSet = kFALSE;
 157                 fClusterAddressSet = kFALSE;
 158                 fTriggerAddressSet = kFALSE;
 159         }
 160         if ( event != fEventnumber )
 161         {
 162                 if ( fRunloader->GetEvent(event) < 0 ) return kFALSE;
 163                 fEventnumber = event;
 164                 fTrack = -1;
 165                 fSCathode = -1;
 166                 fCathode = -1;
 167                 fHitAddressSet = kFALSE;
 168                 fSDigitAddressSet = kFALSE;
 169                 fDigitAddressSet = kFALSE;
 170                 fClusterAddressSet = kFALSE;
 171                 fTriggerAddressSet = kFALSE;
 172         }
 173         return kTRUE;
 174 }
 175
 176
 177 Bool_t AliMUONDataInterface::FetchTreeK()
 178 {
 179 // Fetch the Kine tree from the current run loader.
 180
 181         if (fRunloader->TreeK() == NULL)
 182         {
 183                 fRunloader->LoadKinematics("READ");
 184                 if (fRunloader->TreeK() == NULL)
 185                 {
 186                         AliError("Could not load TreeK.");
 187                         return kFALSE;
 188                 }
 189         }
 190         return kTRUE;
 191 }
 192
 193
 194 Bool_t AliMUONDataInterface::FetchTreeH()
 195 {
 196 // Fetch the Hits tree from the current muon loader.
 197 // Set all the required addresses etc...
 198
 199         if (fMuonloader->TreeH() == NULL)
 200         {
 201                 fMuonloader->LoadHits("READ");
 202                 if (fMuonloader->TreeH() == NULL)
 203                 {
 204                         AliError("Could not load TreeH.");
 205                         return kFALSE;
 206                 }
 207                 fData.SetTreeAddress("H");
 208                 fHitAddressSet = kTRUE;
 209         }
 210         else if ( ! fHitAddressSet )
 211         {
 212                 fData.SetTreeAddress("H");
 213                 fHitAddressSet = kTRUE;
 214         }
 215         return kTRUE;
 216 }
 217
 218
 219 Bool_t AliMUONDataInterface::FetchTreeS()
 220 {
 221 // Fetch the S-Digits tree from the current muon loader.
 222 // Set all the required addresses etc...
 223
 224         if (fMuonloader->TreeS() == NULL)
 225         {
 226                 fMuonloader->LoadSDigits("READ");
 227                 if (fMuonloader->TreeS() == NULL)
 228                 {
 229                         AliError("Could not load TreeS.");
 230                         return kFALSE;
 231                 }
 232                 fData.SetTreeAddress("S");
 233                 fSDigitAddressSet = kTRUE;
 234         }
 235         else if ( ! fSDigitAddressSet )
 236         {
 237                 fData.SetTreeAddress("S");
 238                 fSDigitAddressSet = kTRUE;
 239         }
 240         return kTRUE;
 241 }
 242
 243
 244 Bool_t AliMUONDataInterface::FetchTreeD()
 245 {
 246 // Fetch the digits tree from the current muon loader.
 247 // Set all the required addresses etc...
 248
 249         if (fMuonloader->TreeD() == NULL)
 250         {
 251                 fMuonloader->LoadDigits("READ");
 252                 if (fMuonloader->TreeD() == NULL)
 253                 {
 254                         AliError("Could not load TreeD.");
 255                         return kFALSE;
 256                 }
 257                 fData.SetTreeAddress("D");
 258                 fDigitAddressSet = kTRUE;
 259         }
 260         else if ( ! fDigitAddressSet )
 261         {
 262                 fData.SetTreeAddress("D");
 263                 fDigitAddressSet = kTRUE;
 264         }
 265         return kTRUE;
 266 }
 267
 268
 269 Bool_t AliMUONDataInterface::FetchTreeR()
 270 {
 271 // Fetch the reconstructed objects tree from the current muon loader.
 272 // Note: The addresses must still be set.
 273
 274         if (fMuonloader->TreeR() == NULL)
 275         {
 276                 fMuonloader->LoadRecPoints("READ");
 277                 if (fMuonloader->TreeR() == NULL)
 278                 {
 279                         AliError("Could not load TreeR.");
 280                         return kFALSE;
 281                 }
 282
 283                 // Need to reset these flags so that the cluster and trigger address
 284                 // gets reset after this method.
 285                 fClusterAddressSet = kFALSE;
 286                 fTriggerAddressSet = kFALSE;
 287         }
 288         return kTRUE;
 289 }
 290
 291
 292 Int_t AliMUONDataInterface::NumberOfEvents(TString filename, TString foldername)
 293 {
 294 // Returns the number of events in the specified file/folder, and -1 on error.
 295
 296         if ( ! FetchLoaders(filename, foldername) ) return -1;
 297         return fRunloader->GetNumberOfEvents();
 298 }
 299
 300
 301 Int_t AliMUONDataInterface::NumberOfParticles(TString filename, TString foldername, Int_t event)
 302 {
 303 // Returns the number of events in the specified file/folder, and -1 on error.
 304
 305         if ( ! FetchLoaders(filename, foldername) ) return -1;
 306         if ( ! FetchEvent(event) ) return -1;
 307         if ( ! FetchTreeK() ) return -1;
 308         return (Int_t) fRunloader->TreeK()->GetEntriesFast();
 309 }
 310
 311
 312 TParticle* AliMUONDataInterface::Particle(
 313                 TString filename, TString foldername, Int_t event, Int_t particle
 314         )
 315 {
 316 // Returns the specified particle in the given file, folder and event.
 317 // NULL is returned on error.
 318
 319         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 320         if ( ! FetchEvent(event) ) return NULL;
 321         if ( ! FetchTreeK() ) return NULL;
 322
 323         TTree* treeK = fRunloader->TreeK();
 324         TParticle* p = NULL;
 325         treeK->GetBranch("Particles")->SetAddress(&p);
 326         treeK->GetEvent(particle);
 327         return p;
 328 }
 329
 330
 331 Int_t AliMUONDataInterface::NumberOfTracks(TString filename, TString foldername, Int_t event)
 332 {
 333 // Returns the number of tracks in the specified file/folder and event.
 334 // -1 is returned on error.
 335
 336         if ( ! FetchLoaders(filename, foldername) ) return -1;
 337         if ( ! FetchEvent(event) ) return -1;
 338         if ( ! FetchTreeH() ) return -1;
 339         return fData.GetNtracks();
 340 }
 341
 342
 343 Int_t AliMUONDataInterface::NumberOfHits(
 344                 TString filename, TString foldername, Int_t event, Int_t track
 345         )
 346 {
 347 // Returns the number of hits in the specified file/folder, event and track.
 348 // -1 is returned on error.
 349
 350         if ( ! FetchLoaders(filename, foldername) ) return -1;
 351         if ( ! FetchEvent(event) ) return -1;
 352         if ( ! FetchTreeH() ) return -1;
 353
 354         if (fTrack < 0 || fTrack != track)
 355         {
 356                 fData.ResetHits();
 357                 fData.GetTrack(track);
 358                 fTrack = track;
 359         }
 360         return fData.Hits()->GetEntriesFast();
 361 }
 362
 363
 364 AliMUONHit* AliMUONDataInterface::Hit(
 365                 TString filename, TString foldername, Int_t event,
 366                 Int_t track, Int_t hit
 367         )
 368 {
 369 // Returns the specified hit in the given file, folder, event and track.
 370 // NULL is returned on error.
 371
 372         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 373         if ( ! FetchEvent(event) ) return NULL;
 374         if ( ! FetchTreeH() ) return NULL;
 375
 376         if (fTrack < 0 || fTrack != track)
 377         {
 378                 fData.ResetHits();
 379                 fData.GetTrack(track);
 380                 fTrack = track;
 381         }
 382         return static_cast<AliMUONHit*>( fData.Hits()->At(hit) );
 383 }
 384
 385
 386 Int_t AliMUONDataInterface::NumberOfSDigits(
 387                 TString filename, TString foldername, Int_t event,
 388                 Int_t chamber, Int_t cathode
 389         )
 390 {
 391 // Returns the number of s-digits in the given file, folder, event,
 392 // chamber and cathode. -1 is returned on error.
 393
 394         Assert( 0 <= chamber && chamber <= 13 );
 395         Assert( 0 <= cathode && cathode <= 1 );
 396
 397         if ( ! FetchLoaders(filename, foldername) ) return -1;
 398         if ( ! FetchEvent(event) ) return -1;
 399         if ( ! FetchTreeS() ) return -1;
 400
 401         if ( fSCathode != cathode )
 402         {
 403                 fData.ResetSDigits();
 404                 fData.GetCathodeS(cathode);
 405                 fSCathode = cathode;
 406         }
 407         return fData.SDigits(chamber)->GetEntriesFast();
 408 }
 409
 410
 411 AliMUONDigit* AliMUONDataInterface::SDigit(
 412                 TString filename, TString foldername, Int_t event,
 413                 Int_t chamber, Int_t cathode, Int_t sdigit
 414         )
 415 {
 416 // Returns the specified s-digit in the given file, folder, event,
 417 // chamber and cathode. NULL is returned on error.
 418
 419         Assert( 0 <= chamber && chamber <= 13 );
 420         Assert( 0 <= cathode && cathode <= 1 );
 421
 422         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 423         if ( ! FetchEvent(event) ) return NULL;
 424         if ( ! FetchTreeS() ) return NULL;
 425
 426         if ( fSCathode != cathode )
 427         {
 428                 fData.ResetSDigits();
 429                 fData.GetCathodeS(cathode);
 430                 fSCathode = cathode;
 431         }
 432         return static_cast<AliMUONDigit*>( fData.SDigits(chamber)->At(sdigit) );
 433 }
 434
 435
 436 Int_t AliMUONDataInterface::NumberOfDigits(
 437                 TString filename, TString foldername, Int_t event,
 438                 Int_t chamber, Int_t cathode
 439         )
 440 {
 441 // Returns the number of digits in the given file, folder, event,
 442 // chamber and cathode. -1 is returned on error.
 443         Assert( 0 <= chamber && chamber <= 13 );
 444         Assert( 0 <= cathode && cathode <= 1 );
 445
 446         if ( ! FetchLoaders(filename, foldername) ) return -1;
 447         if ( ! FetchEvent(event) ) return -1;
 448         if ( ! FetchTreeD() ) return -1;
 449
 450         if ( fCathode != cathode )
 451         {
 452                 fData.ResetDigits();
 453                 fData.GetCathode(cathode);
 454                 fCathode = cathode;
 455         }
 456         return fData.Digits(chamber)->GetEntriesFast();
 457 }
 458
 459
 460 AliMUONDigit* AliMUONDataInterface::Digit(
 461                 TString filename, TString foldername, Int_t event,
 462                 Int_t chamber, Int_t cathode, Int_t digit
 463         )
 464 {
 465 // Returns the specified digit in the given file, folder, event,
 466 // chamber and cathode. NULL is returned on error.
 467
 468         Assert( 0 <= chamber && chamber <= 13 );
 469         Assert( 0 <= cathode && cathode <= 1 );
 470
 471         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 472         if ( ! FetchEvent(event) ) return NULL;
 473         if ( ! FetchTreeD() ) return NULL;
 474
 475         if ( fCathode != cathode )
 476         {
 477                 fData.ResetDigits();
 478                 fData.GetCathode(cathode);
 479                 fCathode = cathode;
 480         }
 481         return static_cast<AliMUONDigit*>( fData.Digits(chamber)->At(digit) );
 482 }
 483
 484
 485 Int_t AliMUONDataInterface::NumberOfRawClusters(
 486                 TString filename, TString foldername, Int_t event, Int_t chamber
 487         )
 488 {
 489 // Returns the number of raw clusters in the specified file, folder, event and chamber.
 490 // -1 is returned or error.
 491
 492         Assert( 0 <= chamber && chamber <= 13 );
 493         if ( ! FetchLoaders(filename, foldername) ) return -1;
 494         if ( ! FetchEvent(event) ) return -1;
 495         if ( ! FetchTreeR() ) return -1;
 496         if ( ! fClusterAddressSet )
 497         {
 498                 // If the raw cluster address in TreeR is not set yet then set it now.
 499                 fData.SetTreeAddress("RC");
 500                 fData.ResetRawClusters();
 501                 fData.GetRawClusters();
 502                 fClusterAddressSet = kTRUE;
 503         }
 504         return fData.RawClusters(chamber)->GetEntriesFast();
 505 }
 506
 507
 508 AliMUONRawCluster* AliMUONDataInterface::RawCluster(
 509                 TString filename, TString foldername, Int_t event,
 510                 Int_t chamber, Int_t cluster
 511         )
 512 {
 513 // Fetch the specified raw cluster from the given file, folder, event and chamber number.
 514 // NULL is returned on error.
 515
 516         Assert( 0 <= chamber && chamber <= 13 );
 517         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 518         if ( ! FetchEvent(event) ) return NULL;
 519         if ( ! FetchTreeR() ) return NULL;
 520         if ( ! fClusterAddressSet )
 521         {
 522                 // If the raw cluster address in TreeR is not set yet then set it now.
 523                 fData.SetTreeAddress("RC");
 524                 fData.ResetRawClusters();
 525                 fData.GetRawClusters();
 526                 fClusterAddressSet = kTRUE;
 527         }
 528         return static_cast<AliMUONRawCluster*>( fData.RawClusters(chamber)->At(cluster) );
 529 }
 530
 531
 532 Int_t AliMUONDataInterface::NumberOfLocalTriggers(TString filename, TString foldername, Int_t event)
 533 {
 534 // Return the number of local trigger objects in the specified file, folder and
 535 // event number. -1 is returned on error.
 536
 537         if ( ! FetchLoaders(filename, foldername) ) return -1;
 538         if ( ! FetchEvent(event) ) return -1;
 539         if ( ! FetchTreeD() ) return -1;
 540         if ( ! fTriggerAddressSet )
 541         {
 542                 // If the local trigger address in TreeD is not set yet then set it now.
 543                 fData.SetTreeAddress("GLT");
 544                 fData.ResetTrigger();
 545                 fData.GetTriggerD();
 546                 fTriggerAddressSet = kTRUE;
 547         }
 548         return fData.LocalTrigger()->GetEntriesFast();
 549 }
 550
 551
 552 AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(
 553                 TString filename, TString foldername, Int_t event, Int_t trigger
 554         )
 555 {
 556 // Fetch the specified local trigger object from the given file, folder and event number.
 557 // NULL is returned on error.
 558
 559         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 560         if ( ! FetchEvent(event) ) return NULL;
 561         if ( ! FetchTreeD() ) return NULL;
 562         if ( ! fTriggerAddressSet )
 563         {
 564                 // If the local trigger address in TreeD is not set yet then set it now.
 565                 fData.SetTreeAddress("GLT");
 566                 fData.ResetTrigger();
 567                 fData.GetTriggerD();
 568                 fTriggerAddressSet = kTRUE;
 569         }
 570         return static_cast<AliMUONLocalTrigger*>( fData.LocalTrigger()->At(trigger) );
 571 }
 572
 573
 574 Bool_t AliMUONDataInterface::SetFile(TString filename, TString foldername)
 575 {
 576 // Set the current file and folder from which to fetch data.
 577 // kTRUE is returned if the run and muon loaders were found, else kFALSE.
 578
 579         return FetchLoaders(filename, foldername);
 580 }
 581
 582
 583 Bool_t AliMUONDataInterface::GetEvent(Int_t event)
 584 {
 585 // Select the current event from which to fetch data.
 586 // kTRUE is returned if the event was found, else kFALSE is returned.
 587
 588         if (fRunloader == NULL)
 589         {
 590                 AliError("File not set.");
 591                 return kFALSE;
 592         }
 593         else
 594                 return FetchEvent(event);
 595 }
 596
 597
 598 Int_t AliMUONDataInterface::NumberOfEvents()
 599 {
 600 // Get the number of events in the currently selected file.
 601 // -1 is returned on error.
 602
 603         if (fRunloader == NULL)
 604         {
 605                 AliError("File not set.");
 606                 return -1;
 607         }
 608         return fRunloader->GetNumberOfEvents();
 609 }
 610
 611
 612 Int_t AliMUONDataInterface::NumberOfParticles()
 613 {
 614 // Get the number of particles in the current event.
 615 // -1 is returned on error.
 616
 617         if (fRunloader == NULL)
 618         {
 619                 AliError("File not set.");
 620                 return -1;
 621         }
 622         if ( ! FetchTreeK() ) return -1;
 623         return (Int_t) fRunloader->TreeK()->GetEntriesFast();
 624 }
 625
 626
 627 TParticle* AliMUONDataInterface::Particle(Int_t particle)
 628 {
 629 // Fetch the specified particle from the current event.
 630 // NULL is returned on error.
 631
 632         if (fRunloader == NULL)
 633         {
 634                 AliError("File not set.");
 635                 return NULL;
 636         }
 637         if (fEventnumber < 0)
 638         {
 639                 AliError("Event not chosen.");
 640                 return NULL;
 641         }
 642         if ( ! FetchTreeK() ) return NULL;
 643         TTree* treeK = fRunloader->TreeK();
 644         TParticle* p = NULL;
 645         treeK->GetBranch("Particles")->SetAddress(&p);
 646         treeK->GetEvent(particle);
 647         return p;
 648 }
 649
 650
 651 Int_t AliMUONDataInterface::NumberOfTracks()
 652 {
 653 // Get the number of tracks in the current event.
 654 // -1 is returned on error.
 655
 656         if (fRunloader == NULL)
 657         {
 658                 AliError("File not set.");
 659                 return -1;
 660         }
 661         if (fEventnumber < 0)
 662         {
 663                 AliError( "Event not chosen.");
 664                 return -1;
 665         }
 666         if ( ! FetchTreeH() ) return -1;
 667         return fData.GetNtracks();
 668 }
 669
 670
 671 Int_t AliMUONDataInterface::NumberOfHits(Int_t track)
 672 {
 673 // Get the number of hits for the given track in the current event.
 674 // -1 is returned on error.
 675
 676         if (fRunloader == NULL)
 677         {
 678                 AliError("File not set.");
 679                 return -1;
 680         }
 681         if (fEventnumber < 0)
 682         {
 683                 AliError("Event not chosen.");
 684                 return -1;
 685         }
 686         if ( ! FetchTreeH() ) return -1;
 687         if (fTrack < 0 || fTrack != track)
 688         {
 689                 fData.ResetHits();
 690                 fData.GetTrack(track);
 691                 fTrack = track;
 692         }
 693         return fData.Hits()->GetEntriesFast();
 694 }
 695
 696
 697 AliMUONHit* AliMUONDataInterface::Hit(Int_t track, Int_t hit)
 698 {
 699 // Fetch the specified hit from the current event.
 700 // NULL is returned on error.
 701
 702         if (fRunloader == NULL)
 703         {
 704                 AliError("File not set.");
 705                 return NULL;
 706         }
 707         if (fEventnumber < 0)
 708         {
 709                 AliError("Event not chosen.");
 710                 return NULL;
 711         }
 712         if ( ! FetchTreeH() ) return NULL;
 713         if (fTrack < 0 || fTrack != track)
 714         {
 715                 fData.ResetHits();
 716                 fData.GetTrack(track);
 717                 fTrack = track;
 718         }
 719         return static_cast<AliMUONHit*>( fData.Hits()->At(hit) );
 720 }
 721
 722
 723 Int_t AliMUONDataInterface::NumberOfSDigits(Int_t chamber, Int_t cathode)
 724 {
 725 // Get the number of s-digits on the chamber, cathode in the current event.
 726 // -1 is returned on error.
 727
 728         Assert( 0 <= chamber && chamber <= 13 );
 729         Assert( 0 <= cathode && cathode <= 1 );
 730
 731         if (fRunloader == NULL)
 732         {
 733                 AliError("File not set.");
 734                 return -1;
 735         }
 736         if (fEventnumber < 0)
 737         {
 738                 AliError("Event not chosen.");
 739                 return -1;
 740         }
 741
 742         if ( ! FetchTreeS() ) return -1;
 743         if ( fSCathode != cathode )
 744         {
 745                 fData.ResetSDigits();
 746                 fData.GetCathodeS(cathode);
 747                 fSCathode = cathode;
 748         }
 749         return fData.SDigits(chamber)->GetEntriesFast();
 750 }
 751
 752
 753 AliMUONDigit* AliMUONDataInterface::SDigit(Int_t chamber, Int_t cathode, Int_t sdigit)
 754 {
 755 // Fetch the specified s-digits on the chamber, cathode from the current event.
 756 // NULL is returned on error.
 757
 758         Assert( 0 <= chamber && chamber <= 13 );
 759         Assert( 0 <= cathode && cathode <= 1 );
 760
 761         if (fRunloader == NULL)
 762         {
 763                 AliError("File not set.");
 764                 return NULL;
 765         }
 766         if (fEventnumber < 0)
 767         {
 768                 AliError("Event not chosen.");
 769                 return NULL;
 770         }
 771
 772         if ( ! FetchTreeS() ) return NULL;
 773         if ( fSCathode != cathode )
 774         {
 775                 fData.ResetSDigits();
 776                 fData.GetCathodeS(cathode);
 777                 fSCathode = cathode;
 778         }
 779         return static_cast<AliMUONDigit*>( fData.SDigits(chamber)->At(sdigit) );
 780 }
 781
 782
 783 Int_t AliMUONDataInterface::NumberOfDigits(Int_t chamber, Int_t cathode)
 784 {
 785 // Get the number of digits on the chamber, cathode in the current event.
 786 // -1 is returned on error.
 787
 788         Assert( 0 <= chamber && chamber <= 13 );
 789         Assert( 0 <= cathode && cathode <= 1 );
 790
 791         if (fRunloader == NULL)
 792         {
 793                 AliError("File not set.");
 794                 return -1;
 795         }
 796         if (fEventnumber < 0)
 797         {
 798                 AliError("Event not chosen.");
 799                 return -1;
 800         }
 801
 802         if ( ! FetchTreeD() ) return -1;
 803         if ( fCathode != cathode )
 804         {
 805                 fData.ResetDigits();
 806                 fData.GetCathode(cathode);
 807                 fCathode = cathode;
 808         }
 809         return fData.Digits(chamber)->GetEntriesFast();
 810 }
 811
 812
 813 AliMUONDigit* AliMUONDataInterface::Digit(Int_t chamber, Int_t cathode, Int_t digit)
 814 {
 815 // Fetch the specified digits on the chamber, cathode from the current event.
 816 // NULL is returned on error.
 817
 818         Assert( 0 <= chamber && chamber <= 13 );
 819         Assert( 0 <= cathode && cathode <= 1 );
 820
 821         if (fRunloader == NULL)
 822         {
 823                 AliError("File not set.");
 824                 return NULL;
 825         }
 826         if (fEventnumber < 0)
 827         {
 828                 AliError("Event not chosen.");
 829                 return NULL;
 830         }
 831
 832         if ( ! FetchTreeD() ) return NULL;
 833         if ( fCathode != cathode )
 834         {
 835                 fData.ResetDigits();
 836                 fData.GetCathode(cathode);
 837                 fCathode = cathode;
 838         }
 839         return static_cast<AliMUONDigit*>( fData.Digits(chamber)->At(digit) );
 840 }
 841
 842
 843 Int_t AliMUONDataInterface::NumberOfRawClusters(Int_t chamber)
 844 {
 845 // Get the number of raw clusters on the given chamber in the current event.
 846 // -1 is returned on error.
 847
 848         Assert( 0 <= chamber && chamber <= 13 );
 849
 850         if (fRunloader == NULL)
 851         {
 852                 AliError("File not set.");
 853                 return -1;
 854         }
 855         if (fEventnumber < 0)
 856         {
 857                 AliError("Event not chosen.");
 858                 return -1;
 859         }
 860
 861         if ( ! FetchTreeR() ) return -1;
 862         if ( ! fClusterAddressSet )
 863         {
 864                 fData.SetTreeAddress("RC");
 865                 fData.ResetRawClusters();
 866                 fData.GetRawClusters();
 867                 fClusterAddressSet = kTRUE;
 868         }
 869         return fData.RawClusters(chamber)->GetEntriesFast();
 870 }
 871
 872
 873 AliMUONRawCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t cluster)
 874 {
 875 // Fetch the specified raw cluster on the given chamber from the current event.
 876 // NULL is returned on error.
 877
 878         Assert( 0 <= chamber && chamber <= 13 );
 879
 880         if (fRunloader == NULL)
 881         {
 882                 AliError("File not set.");
 883                 return NULL;
 884         }
 885         if (fEventnumber < 0)
 886         {
 887                 AliError("Event not chosen.");
 888                 return NULL;
 889         }
 890
 891         if ( ! FetchTreeR() ) return NULL;
 892         if ( ! fClusterAddressSet )
 893         {
 894                 fData.SetTreeAddress("RC");
 895                 fData.ResetRawClusters();
 896                 fData.GetRawClusters();
 897                 fClusterAddressSet = kTRUE;
 898         }
 899         return static_cast<AliMUONRawCluster*>( fData.RawClusters(chamber)->At(cluster) );
 900 }
 901
 902
 903 Int_t AliMUONDataInterface::NumberOfLocalTriggers()
 904 {
 905 // Get the number of local trigger objects in the current event.
 906 // -1 is returned on error.
 907
 908         if (fRunloader == NULL)
 909         {
 910                 AliError("File not set.");
 911                 return -1;
 912         }
 913         if (fEventnumber < 0)
 914         {
 915                 AliError("Event not chosen.");
 916                 return -1;
 917         }
 918
 919         if ( ! FetchTreeD() ) return -1;
 920         if ( ! fTriggerAddressSet )
 921         {
 922                 fData.SetTreeAddress("GLT");
 923                 fData.ResetTrigger();
 924                 fData.GetTriggerD();
 925                 fTriggerAddressSet = kTRUE;
 926         }
 927         return fData.LocalTrigger()->GetEntriesFast();
 928 }
 929
 930
 931 AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(Int_t trigger)
 932 {
 933 // Fetch the specified local trigger object from the current event.
 934 // NULL is returned on error.
 935
 936         if (fRunloader == NULL)
 937         {
 938                 AliError("File not set.");
 939                 return NULL;
 940         }
 941         if (fEventnumber < 0)
 942         {
 943                 AliError( "Event not chosen.");
 944                 return NULL;
 945         }
 946
 947         if ( ! FetchTreeD() ) return NULL;
 948         if ( ! fTriggerAddressSet )
 949         {
 950                 fData.SetTreeAddress("GLT");
 951                 fData.ResetTrigger();
 952                 fData.GetTriggerD();
 953                 fTriggerAddressSet = kTRUE;
 954         }
 955         return static_cast<AliMUONLocalTrigger*>( fData.LocalTrigger()->At(trigger) );
 956 }