MUON/AliMUONDataInterface.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 /* $Id$ */
  17
  18 #include <TError.h>
  19 #include <TParticle.h>
  20
  21 #include "AliRunLoader.h"
  22 #include "AliLoader.h"
  23
  24 #include "AliMUONDataInterface.h"
  25 #include "AliMUONLocalTrigger.h"
  26 #include "AliMUONGlobalTrigger.h"
  27 #include "AliMUONHit.h"
  28 #include "AliMUONDigit.h"
  29 #include "AliMUONRawCluster.h"
  30 #include "AliMUONTrack.h"
  31 #include "AliLog.h"
  32
  33 #include <iostream>
  34 using std::endl;
  35 using std::cout;
  36
  37 ///
  38 /// \class AliMUONDataInterface
  39 ///
  40 /// An easy to use interface to the MUON module data stored in
  41 /// TreeK, TreeH, TreeS, TreeD and TreeR
  42 /// One can fetch any of the data objects with all the calls to runloader,
  43 /// muon loader and AliMUONData done behind the scenes and automatically.
  44 ///
  45 /// This interface in not necessarily the fastest way to fetch the data but
  46 /// it is the easiest.
  47 /// Note: If independant calls to the run loader, muon loader or
  48 /// AliMUONData objects are interspersed with calls to the
  49 /// AliMUONDataInterface to fetch data, one might need to call the Reset
  50 /// method between these method calls at some point to prevent
  51 /// AliMUONDataInterface from getting confused.
  52 /// This is necessary since this object assumes the state of runloader,
  53 /// muon loader nor AliMUONData has not changed between calls.
  54 /// If the state has changes then one must call Reset so that
  55 /// AliMUONDataInterface refreshes what it knows about the state
  56 /// of the loader and AliMUONData objects.
  57 ///
  58 /// \deprecated We have to revisit all this AliMUONData stuff anyway,
  59 /// and probably make a real AliMUONLoader instead...
  60 ///
  61 /// \author Artur Szostak
  62 /// email: artur@alice.phy.uct.ac.za
  63
  64
  65 /// \cond CLASSIMP
  66 ClassImp(AliMUONDataInterface)
  67 /// \endcond
  68
  69 AliMUONDataInterface::AliMUONDataInterface()
  70         : TObject(),
  71           fCreatedRunLoader(kFALSE),
  72           fHitAddressSet(kFALSE),
  73           fSDigitAddressSet(kFALSE),
  74           fDigitAddressSet(kFALSE),
  75           fClusterAddressSet(kFALSE),
  76           fTriggerAddressSet(kFALSE),
  77           fRecTracksAddressSet(kFALSE),
  78           fRunloader(0x0),
  79           fMuonloader(0x0),
  80           fData(0x0, "MUON", "MUON"),
  81           fFilename(),
  82           fFoldername(),
  83           fEventnumber(-1),
  84           fTrack(-1),
  85           fSCathode(-1),
  86           fCathode(-1)
  87 {
  88 /// Set all internal pointers to 0x0 and indices to -1.
  89
  90         Reset();
  91 }
  92
  93 AliMUONDataInterface::~AliMUONDataInterface()
  94 {
  95 /// Delete the runloader if we created it.
  96 /// If the runloader is not to be deleted then call Reset just before
  97 /// the destructor is called.
  98
  99         if (fRunloader != NULL && fCreatedRunLoader)
 100                 delete fRunloader;
 101 }
 102
 103 void AliMUONDataInterface::Reset()
 104 {
 105 /// Sets all internal pointers to NULL and indices to -1.
 106 /// Note: No resources are released!
 107 /// Specificaly AliRunLoader is not deleted.
 108
 109         fCreatedRunLoader = kFALSE;
 110         fRunloader = NULL;
 111         fMuonloader = NULL;
 112         fEventnumber = -1;
 113         fTrack = -1;
 114         fSCathode = -1;
 115         fCathode = -1;
 116         fHitAddressSet = kFALSE;
 117         fSDigitAddressSet = kFALSE;
 118         fDigitAddressSet = kFALSE;
 119         fClusterAddressSet = kFALSE;
 120         fTriggerAddressSet = kFALSE;
 121         fRecTracksAddressSet = kFALSE;
 122 }
 123
 124
 125 Bool_t AliMUONDataInterface::UseCurrentRunLoader()
 126 {
 127 /// Tries to fetch the current runloader with AliRunLoader::GetRunLoader. If nothing is
 128 /// currently loaded then kFALSE is returned and AliMUONDataInterface is reset.
 129
 130         Reset();
 131         fRunloader = AliRunLoader::GetRunLoader();
 132         if (fRunloader == NULL) return kFALSE;
 133         // Fetch the current file name, folder name and event number.
 134         fFilename = fRunloader->GetFileName();
 135         fFoldername = fRunloader->GetEventFolder()->GetName();
 136         fEventnumber = fRunloader->GetEventNumber();
 137
 138         if ( ! FetchMuonLoader(fFilename.Data(), fFoldername.Data()) )
 139         {
 140                 Reset();
 141                 return kFALSE;
 142         }
 143
 144         return kTRUE;
 145 }
 146
 147
 148 Bool_t AliMUONDataInterface::FetchMuonLoader(TString filename, TString foldername)
 149 {
 150 /// Fetches the muon loader for the given filename/foldername
 151
 152         fMuonloader = fRunloader->GetLoader("MUONLoader");
 153         if (fMuonloader == NULL)
 154         {
 155                 AliError(Form("Could not find the MUON loader in file: %s and folder: %s",
 156                         (const char*)filename, (const char*)foldername));
 157                 return kFALSE;
 158         }
 159
 160         // Need to connect the muon loader to the AliMUONData object,
 161         // else class to fData will return NULL.
 162         fData.SetLoader(fMuonloader);
 163         return kTRUE;
 164 }
 165
 166
 167 Bool_t AliMUONDataInterface::LoadLoaders(TString filename, TString foldername)
 168 {
 169 /// Load the run and muon loaders from the specified file and folder.
 170 /// kTRUE is returned on success and kFALSE on failure.
 171
 172         fRunloader = AliRunLoader::Open(filename, foldername, "READ");
 173         if (fRunloader == NULL)
 174         {
 175                 AliError(Form("Could not find or load the run loader for the file: %s and folder: %s",
 176                         (const char*)filename, (const char*)foldername));
 177                 return kFALSE;
 178         }
 179         fCreatedRunLoader = kTRUE;
 180         if ( ! FetchMuonLoader(filename, foldername) )
 181         {
 182                 fRunloader = NULL;
 183                 return kFALSE;
 184         }
 185
 186         fFilename = filename;
 187         fFoldername = foldername;
 188         fEventnumber = -1;  // Reset the event number to force the event to be loaded.
 189         return kTRUE;
 190 }
 191
 192
 193 Bool_t AliMUONDataInterface::FetchLoaders(TString filename, TString foldername)
 194 {
 195 /// Fetch the run loader and muon loader objects from memory if they already exist,
 196 /// or from memory if they do not.
 197 /// If the currently loaded run loader (if any) is not refering to the file and folder
 198 /// we are interested in then it is deleted and reopened with the required file and
 199 /// folder names.
 200
 201         if (fRunloader == NULL)
 202         {
 203                 fRunloader = AliRunLoader::GetRunLoader();
 204                 if (fRunloader == NULL)
 205                         return LoadLoaders(filename, foldername);
 206                 else
 207                 {
 208                         if (fMuonloader == NULL)
 209                         {
 210                                 if ( ! FetchMuonLoader(filename, foldername) )
 211                                 {
 212                                         fRunloader = NULL;
 213                                         return kFALSE;
 214                                 }
 215                         }
 216                 }
 217
 218                 // Fetch the current file and folder names.
 219                 fFilename = fRunloader->GetFileName();
 220                 fFoldername = fRunloader->GetEventFolder()->GetName();
 221         }
 222
 223         // If filename or foldername are not the same as the ones currently selected then
 224         // reopen the file.
 225         if ( filename.CompareTo(fFilename) != 0 || foldername.CompareTo(fFoldername) != 0 )
 226         {
 227                 delete fRunloader;
 228                 return LoadLoaders(filename, foldername);
 229         }
 230         return kTRUE;
 231 }
 232
 233
 234 Bool_t AliMUONDataInterface::FetchEvent(Int_t event)
 235 {
 236 /// Fetch the specified event from the runloader and reset all the track, cathode
 237 /// and address flags to force them to be reloaded.
 238 /// If a negative event number is specified then the current runloader event
 239 /// number is used.
 240
 241         if (fEventnumber < 0)
 242         {
 243                 fEventnumber = fRunloader->GetEventNumber();
 244                 fTrack = -1;
 245                 fSCathode = -1;
 246                 fCathode = -1;
 247                 fHitAddressSet = kFALSE;
 248                 fSDigitAddressSet = kFALSE;
 249                 fDigitAddressSet = kFALSE;
 250                 fClusterAddressSet = kFALSE;
 251                 fTriggerAddressSet = kFALSE;
 252                 fRecTracksAddressSet = kFALSE;
 253         }
 254         if ( event != fEventnumber )
 255         {
 256                 if ( fRunloader->GetEvent(event) < 0 ) return kFALSE;
 257                 fEventnumber = event;
 258                 fTrack = -1;
 259                 fSCathode = -1;
 260                 fCathode = -1;
 261                 fHitAddressSet = kFALSE;
 262                 fSDigitAddressSet = kFALSE;
 263                 fDigitAddressSet = kFALSE;
 264                 fClusterAddressSet = kFALSE;
 265                 fTriggerAddressSet = kFALSE;
 266                 fRecTracksAddressSet = kFALSE;
 267         }
 268         return kTRUE;
 269 }
 270
 271
 272 Bool_t AliMUONDataInterface::FetchTreeK()
 273 {
 274 /// Fetch the Kine tree from the current run loader.
 275
 276         if (fRunloader->TreeK() == NULL)
 277         {
 278                 fRunloader->LoadKinematics("READ");
 279                 if (fRunloader->TreeK() == NULL)
 280                 {
 281                         AliError("Could not load TreeK.");
 282                         return kFALSE;
 283                 }
 284         }
 285         return kTRUE;
 286 }
 287
 288
 289 Bool_t AliMUONDataInterface::FetchTreeH()
 290 {
 291 /// Fetch the Hits tree from the current muon loader.
 292 /// Set all the required addresses etc...
 293
 294         if (fMuonloader->TreeH() == NULL)
 295         {
 296                 fMuonloader->LoadHits("READ");
 297                 if (fMuonloader->TreeH() == NULL)
 298                 {
 299                         AliError("Could not load TreeH.");
 300                         return kFALSE;
 301                 }
 302                 fData.SetTreeAddress("H");
 303                 fHitAddressSet = kTRUE;
 304         }
 305         else if ( ! fHitAddressSet )
 306         {
 307                 fData.SetTreeAddress("H");
 308                 fHitAddressSet = kTRUE;
 309         }
 310         return kTRUE;
 311 }
 312
 313
 314 Bool_t AliMUONDataInterface::FetchTreeS()
 315 {
 316 /// Fetch the S-Digits tree from the current muon loader.
 317 /// Set all the required addresses etc...
 318
 319         if (fMuonloader->TreeS() == NULL)
 320         {
 321                 fMuonloader->LoadSDigits("READ");
 322                 if (fMuonloader->TreeS() == NULL)
 323                 {
 324                         AliError("Could not load TreeS.");
 325                         return kFALSE;
 326                 }
 327                 fData.SetTreeAddress("S");
 328                 fSDigitAddressSet = kTRUE;
 329         }
 330         else if ( ! fSDigitAddressSet )
 331         {
 332                 fData.SetTreeAddress("S");
 333                 fSDigitAddressSet = kTRUE;
 334         }
 335         return kTRUE;
 336 }
 337
 338
 339 Bool_t AliMUONDataInterface::FetchTreeD()
 340 {
 341 /// Fetch the digits tree from the current muon loader.
 342 /// Set all the required addresses etc...
 343
 344         if (fMuonloader->TreeD() == NULL)
 345         {
 346                 fMuonloader->LoadDigits("READ");
 347                 if (fMuonloader->TreeD() == NULL)
 348                 {
 349                         AliError("Could not load TreeD.");
 350                         return kFALSE;
 351                 }
 352                 fData.SetTreeAddress("D");
 353                 fDigitAddressSet = kTRUE;
 354         }
 355         else if ( ! fDigitAddressSet )
 356         {
 357                 fData.SetTreeAddress("D");
 358                 fDigitAddressSet = kTRUE;
 359         }
 360         return kTRUE;
 361 }
 362
 363
 364 Bool_t AliMUONDataInterface::FetchTreeR()
 365 {
 366 /// Fetch the reconstructed objects tree from the current muon loader.
 367 /// Note: The addresses must still be set.
 368
 369   if (fMuonloader->TreeR() == NULL)
 370     {
 371       fMuonloader->LoadRecPoints("READ");
 372       if (fMuonloader->TreeR() == NULL)
 373         {
 374           AliError("Could not load TreeR.");
 375           return kFALSE;
 376         }
 377
 378       // Need to reset these flags so that the cluster and trigger address
 379       // gets reset after this method.
 380       fClusterAddressSet = kFALSE;
 381       fTriggerAddressSet = kFALSE;
 382     }
 383   return kTRUE;
 384 }
 385
 386 Bool_t AliMUONDataInterface::FetchTreeT()
 387 {
 388 /// fetch the reconstructed tracks tree from the current muon loader
 389 /// note : the addresses must still be set.
 390   if (fMuonloader->TreeT() == NULL)
 391     {
 392       fMuonloader->LoadTracks("READ");
 393       if (fMuonloader->TreeT() == NULL)
 394         {
 395           AliError("Could not load TreeT.");
 396           return kFALSE;
 397         }
 398
 399       // Need to reset these flags so that the rec tracks address
 400       // gets reset after this method.
 401       fRecTracksAddressSet = kFALSE;
 402     }
 403   return kTRUE;
 404 }
 405
 406 Int_t AliMUONDataInterface::NumberOfEvents(TString filename, TString foldername)
 407 {
 408 /// Returns the number of events in the specified file/folder, and -1 on error.
 409
 410         if ( ! FetchLoaders(filename, foldername) ) return -1;
 411         return fRunloader->GetNumberOfEvents();
 412 }
 413
 414
 415 Int_t AliMUONDataInterface::NumberOfParticles(TString filename, TString foldername, Int_t event)
 416 {
 417 /// Returns the number of events in the specified file/folder, and -1 on error.
 418
 419         if ( ! FetchLoaders(filename, foldername) ) return -1;
 420         if ( ! FetchEvent(event) ) return -1;
 421         if ( ! FetchTreeK() ) return -1;
 422         return (Int_t) fRunloader->TreeK()->GetEntriesFast();
 423 }
 424
 425
 426 TParticle* AliMUONDataInterface::Particle(
 427                 TString filename, TString foldername, Int_t event, Int_t particle
 428         )
 429 {
 430 /// Returns the specified particle in the given file, folder and event.
 431 /// NULL is returned on error.
 432
 433         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 434         if ( ! FetchEvent(event) ) return NULL;
 435         if ( ! FetchTreeK() ) return NULL;
 436
 437         TTree* treeK = fRunloader->TreeK();
 438         TParticle* p = NULL;
 439         treeK->GetBranch("Particles")->SetAddress(&p);
 440         treeK->GetEvent(particle);
 441         return p;
 442 }
 443
 444
 445 Int_t AliMUONDataInterface::NumberOfTracks(TString filename, TString foldername, Int_t event)
 446 {
 447 /// Returns the number of tracks in the specified file/folder and event.
 448 /// -1 is returned on error.
 449
 450         if ( ! FetchLoaders(filename, foldername) ) return -1;
 451         if ( ! FetchEvent(event) ) return -1;
 452         if ( ! FetchTreeH() ) return -1;
 453         return fData.GetNtracks();
 454 }
 455
 456
 457 Int_t AliMUONDataInterface::NumberOfHits(
 458                 TString filename, TString foldername, Int_t event, Int_t track
 459         )
 460 {
 461 /// Returns the number of hits in the specified file/folder, event and track.
 462 /// -1 is returned on error.
 463
 464         if ( ! FetchLoaders(filename, foldername) ) return -1;
 465         if ( ! FetchEvent(event) ) return -1;
 466         if ( ! FetchTreeH() ) return -1;
 467
 468         if (fTrack < 0 || fTrack != track)
 469         {
 470                 fData.ResetHits();
 471                 fData.GetTrack(track);
 472                 fTrack = track;
 473         }
 474         return fData.Hits()->GetEntriesFast();
 475 }
 476
 477
 478 AliMUONHit* AliMUONDataInterface::Hit(
 479                 TString filename, TString foldername, Int_t event,
 480                 Int_t track, Int_t hit
 481         )
 482 {
 483 /// Returns the specified hit in the given file, folder, event and track.
 484 /// NULL is returned on error.
 485
 486         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 487         if ( ! FetchEvent(event) ) return NULL;
 488         if ( ! FetchTreeH() ) return NULL;
 489
 490         if (fTrack < 0 || fTrack != track)
 491         {
 492                 fData.ResetHits();
 493                 fData.GetTrack(track);
 494                 fTrack = track;
 495         }
 496         return static_cast<AliMUONHit*>( fData.Hits()->At(hit) );
 497 }
 498
 499
 500 Int_t AliMUONDataInterface::NumberOfSDigits(
 501                 TString filename, TString foldername, Int_t event,
 502                 Int_t chamber, Int_t cathode
 503         )
 504 {
 505 /// Returns the number of s-digits in the given file, folder, event,
 506 /// chamber and cathode. -1 is returned on error.
 507
 508         Assert( 0 <= chamber && chamber <= 13 );
 509         Assert( 0 <= cathode && cathode <= 1 );
 510
 511         if ( ! FetchLoaders(filename, foldername) ) return -1;
 512         if ( ! FetchEvent(event) ) return -1;
 513         if ( ! FetchTreeS() ) return -1;
 514
 515         if ( fSCathode != cathode )
 516         {
 517                 fData.ResetSDigits();
 518                 fData.GetSDigits();
 519                 fSCathode = cathode;
 520         }
 521         return fData.SDigits(chamber)->GetEntriesFast();
 522 }
 523
 524
 525 AliMUONDigit* AliMUONDataInterface::SDigit(
 526                 TString filename, TString foldername, Int_t event,
 527                 Int_t chamber, Int_t cathode, Int_t sdigit
 528         )
 529 {
 530 /// Returns the specified s-digit in the given file, folder, event,
 531 /// chamber and cathode. NULL is returned on error.
 532
 533         Assert( 0 <= chamber && chamber <= 13 );
 534         Assert( 0 <= cathode && cathode <= 1 );
 535
 536         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 537         if ( ! FetchEvent(event) ) return NULL;
 538         if ( ! FetchTreeS() ) return NULL;
 539
 540         if ( fSCathode != cathode )
 541         {
 542                 fData.ResetSDigits();
 543                 fData.GetSDigits();
 544                 fSCathode = cathode;
 545         }
 546         return static_cast<AliMUONDigit*>( fData.SDigits(chamber)->At(sdigit) );
 547 }
 548
 549
 550 Int_t AliMUONDataInterface::NumberOfDigits(
 551                 TString filename, TString foldername, Int_t event,
 552                 Int_t chamber, Int_t cathode
 553         )
 554 {
 555 /// Returns the number of digits in the given file, folder, event,
 556 /// chamber and cathode. -1 is returned on error.
 557         Assert( 0 <= chamber && chamber <= 13 );
 558         Assert( 0 <= cathode && cathode <= 1 );
 559
 560         if ( ! FetchLoaders(filename, foldername) ) return -1;
 561         if ( ! FetchEvent(event) ) return -1;
 562         if ( ! FetchTreeD() ) return -1;
 563
 564         if ( fCathode != cathode )
 565         {
 566                 fData.ResetDigits();
 567                 fData.GetDigits();
 568                 fCathode = cathode;
 569         }
 570         return fData.Digits(chamber)->GetEntriesFast();
 571 }
 572
 573
 574 AliMUONDigit* AliMUONDataInterface::Digit(
 575                 TString filename, TString foldername, Int_t event,
 576                 Int_t chamber, Int_t cathode, Int_t digit
 577         )
 578 {
 579 /// Returns the specified digit in the given file, folder, event,
 580 /// chamber and cathode. NULL is returned on error.
 581
 582         Assert( 0 <= chamber && chamber <= 13 );
 583         Assert( 0 <= cathode && cathode <= 1 );
 584
 585         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 586         if ( ! FetchEvent(event) ) return NULL;
 587         if ( ! FetchTreeD() ) return NULL;
 588
 589         if ( fCathode != cathode )
 590         {
 591                 fData.ResetDigits();
 592                 fData.GetDigits();
 593                 fCathode = cathode;
 594         }
 595         return static_cast<AliMUONDigit*>( fData.Digits(chamber)->At(digit) );
 596 }
 597
 598
 599 Int_t AliMUONDataInterface::NumberOfRawClusters(
 600                 TString filename, TString foldername, Int_t event, Int_t chamber
 601         )
 602 {
 603 /// Returns the number of raw clusters in the specified file, folder, event and chamber.
 604 /// -1 is returned or error.
 605
 606         Assert( 0 <= chamber && chamber <= 13 );
 607         if ( ! FetchLoaders(filename, foldername) ) return -1;
 608         if ( ! FetchEvent(event) ) return -1;
 609         if ( ! FetchTreeR() ) return -1;
 610         if ( ! fClusterAddressSet )
 611         {
 612                 // If the raw cluster address in TreeR is not set yet then set it now.
 613                 fData.SetTreeAddress("RC");
 614                 fData.ResetRawClusters();
 615                 fData.GetRawClusters();
 616                 fClusterAddressSet = kTRUE;
 617         }
 618         return fData.RawClusters(chamber)->GetEntriesFast();
 619 }
 620
 621
 622 AliMUONRawCluster* AliMUONDataInterface::RawCluster(
 623                 TString filename, TString foldername, Int_t event,
 624                 Int_t chamber, Int_t cluster
 625         )
 626 {
 627 /// Fetch the specified raw cluster from the given file, folder, event and chamber number.
 628 /// NULL is returned on error.
 629
 630         Assert( 0 <= chamber && chamber <= 13 );
 631         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 632         if ( ! FetchEvent(event) ) return NULL;
 633         if ( ! FetchTreeR() ) return NULL;
 634         if ( ! fClusterAddressSet )
 635         {
 636                 // If the raw cluster address in TreeR is not set yet then set it now.
 637                 fData.SetTreeAddress("RC");
 638                 fData.ResetRawClusters();
 639                 fData.GetRawClusters();
 640                 fClusterAddressSet = kTRUE;
 641         }
 642         return static_cast<AliMUONRawCluster*>( fData.RawClusters(chamber)->At(cluster) );
 643 }
 644
 645
 646 Int_t AliMUONDataInterface::NumberOfLocalTriggers(TString filename, TString foldername, Int_t event)
 647 {
 648 /// Return the number of local trigger objects in the specified file, folder and
 649 /// event number. -1 is returned on error.
 650
 651         if ( ! FetchLoaders(filename, foldername) ) return -1;
 652         if ( ! FetchEvent(event) ) return -1;
 653         if ( ! FetchTreeD() ) return -1;
 654         if ( ! fTriggerAddressSet )
 655         {
 656                 // If the local trigger address in TreeR is not set yet then set it now.
 657                 fData.SetTreeAddress("GLT");
 658                 fData.ResetTrigger();
 659                 fData.GetTriggerD();
 660                 fTriggerAddressSet = kTRUE;
 661         }
 662         return fData.LocalTrigger()->GetEntriesFast();
 663 }
 664
 665
 666 AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(
 667                 TString filename, TString foldername, Int_t event, Int_t trigger
 668         )
 669 {
 670 /// Fetch the specified local trigger object from the given file, folder and event number.
 671 /// NULL is returned on error.
 672
 673         if ( ! FetchLoaders(filename, foldername) ) return NULL;
 674         if ( ! FetchEvent(event) ) return NULL;
 675         if ( ! FetchTreeD() ) return NULL;
 676         if ( ! fTriggerAddressSet )
 677         {
 678                 // If the local trigger address in TreeR is not set yet then set it now.
 679                 fData.SetTreeAddress("GLT");
 680                 fData.ResetTrigger();
 681                 fData.GetTriggerD();
 682                 fTriggerAddressSet = kTRUE;
 683         }
 684         return static_cast<AliMUONLocalTrigger*>( fData.LocalTrigger()->At(trigger) );
 685 }
 686
 687 Bool_t AliMUONDataInterface::SetFile(TString filename, TString foldername)
 688 {
 689 /// Set the current file and folder from which to fetch data.
 690 /// kTRUE is returned if the run and muon loaders were found, else kFALSE.
 691
 692         return FetchLoaders(filename, foldername);
 693 }
 694
 695
 696 Bool_t AliMUONDataInterface::GetEvent(Int_t event)
 697 {
 698 /// Select the current event from which to fetch data.
 699 /// kTRUE is returned if the event was found, else kFALSE is returned.
 700
 701         if (fRunloader == NULL)
 702         {
 703                 AliError("File not set.");
 704                 return kFALSE;
 705         }
 706         else
 707                 return FetchEvent(event);
 708 }
 709
 710
 711 Int_t AliMUONDataInterface::NumberOfEvents()
 712 {
 713 /// Get the number of events in the currently selected file.
 714 /// -1 is returned on error.
 715
 716         if (fRunloader == NULL)
 717         {
 718                 AliError("File not set.");
 719                 return -1;
 720         }
 721         return fRunloader->GetNumberOfEvents();
 722 }
 723
 724
 725 Int_t AliMUONDataInterface::NumberOfParticles()
 726 {
 727 /// Get the number of particles in the current event.
 728 /// -1 is returned on error.
 729
 730         if (fRunloader == NULL)
 731         {
 732                 AliError("File not set.");
 733                 return -1;
 734         }
 735         if ( ! FetchTreeK() ) return -1;
 736         return (Int_t) fRunloader->TreeK()->GetEntriesFast();
 737 }
 738
 739
 740 TParticle* AliMUONDataInterface::Particle(Int_t particle)
 741 {
 742 /// Fetch the specified particle from the current event.
 743 /// NULL is returned on error.
 744
 745         if (fRunloader == NULL)
 746         {
 747                 AliError("File not set.");
 748                 return NULL;
 749         }
 750         if (fEventnumber < 0)
 751         {
 752                 AliError("Event not chosen.");
 753                 return NULL;
 754         }
 755         if ( ! FetchTreeK() ) return NULL;
 756         TTree* treeK = fRunloader->TreeK();
 757         TParticle* p = NULL;
 758         treeK->GetBranch("Particles")->SetAddress(&p);
 759         treeK->GetEvent(particle);
 760         return p;
 761 }
 762
 763
 764 Int_t AliMUONDataInterface::NumberOfTracks()
 765 {
 766 /// Get the number of tracks in the current event.
 767 /// -1 is returned on error.
 768
 769         if (fRunloader == NULL)
 770         {
 771                 AliError("File not set.");
 772                 return -1;
 773         }
 774         if (fEventnumber < 0)
 775         {
 776                 AliError( "Event not chosen.");
 777                 return -1;
 778         }
 779         if ( ! FetchTreeH() ) return -1;
 780         return fData.GetNtracks();
 781 }
 782
 783
 784 Int_t AliMUONDataInterface::NumberOfHits(Int_t track)
 785 {
 786 /// Get the number of hits for the given track in the current event.
 787 /// -1 is returned on error.
 788
 789         if (fRunloader == NULL)
 790         {
 791                 AliError("File not set.");
 792                 return -1;
 793         }
 794         if (fEventnumber < 0)
 795         {
 796                 AliError("Event not chosen.");
 797                 return -1;
 798         }
 799         if ( ! FetchTreeH() ) return -1;
 800         if (fTrack < 0 || fTrack != track)
 801         {
 802                 fData.ResetHits();
 803                 fData.GetTrack(track);
 804                 fTrack = track;
 805         }
 806         return fData.Hits()->GetEntriesFast();
 807 }
 808
 809
 810 AliMUONHit* AliMUONDataInterface::Hit(Int_t track, Int_t hit)
 811 {
 812 /// Fetch the specified hit from the current event.
 813 /// NULL is returned on error.
 814
 815         if (fRunloader == NULL)
 816         {
 817                 AliError("File not set.");
 818                 return NULL;
 819         }
 820         if (fEventnumber < 0)
 821         {
 822                 AliError("Event not chosen.");
 823                 return NULL;
 824         }
 825         if ( ! FetchTreeH() ) return NULL;
 826         if (fTrack < 0 || fTrack != track)
 827         {
 828                 fData.ResetHits();
 829                 fData.GetTrack(track);
 830                 fTrack = track;
 831         }
 832         return static_cast<AliMUONHit*>( fData.Hits()->At(hit) );
 833 }
 834
 835
 836 Int_t AliMUONDataInterface::NumberOfSDigits(Int_t chamber, Int_t cathode)
 837 {
 838 /// Get the number of s-digits on the chamber, cathode in the current event.
 839 /// -1 is returned on error.
 840
 841         Assert( 0 <= chamber && chamber <= 13 );
 842         Assert( 0 <= cathode && cathode <= 1 );
 843
 844         if (fRunloader == NULL)
 845         {
 846                 AliError("File not set.");
 847                 return -1;
 848         }
 849         if (fEventnumber < 0)
 850         {
 851                 AliError("Event not chosen.");
 852                 return -1;
 853         }
 854
 855         if ( ! FetchTreeS() ) return -1;
 856         if ( fSCathode != cathode )
 857         {
 858                 fData.ResetSDigits();
 859                 fData.GetSDigits();
 860                 fSCathode = cathode;
 861         }
 862         return fData.SDigits(chamber)->GetEntriesFast();
 863 }
 864
 865
 866 AliMUONDigit* AliMUONDataInterface::SDigit(Int_t chamber, Int_t cathode, Int_t sdigit)
 867 {
 868 /// Fetch the specified s-digits on the chamber, cathode from the current event.
 869 /// NULL is returned on error.
 870
 871         Assert( 0 <= chamber && chamber <= 13 );
 872         Assert( 0 <= cathode && cathode <= 1 );
 873
 874         if (fRunloader == NULL)
 875         {
 876                 AliError("File not set.");
 877                 return NULL;
 878         }
 879         if (fEventnumber < 0)
 880         {
 881                 AliError("Event not chosen.");
 882                 return NULL;
 883         }
 884
 885         if ( ! FetchTreeS() ) return NULL;
 886         if ( fSCathode != cathode )
 887         {
 888                 fData.ResetSDigits();
 889                 fData.GetSDigits();
 890                 fSCathode = cathode;
 891         }
 892         return static_cast<AliMUONDigit*>( fData.SDigits(chamber)->At(sdigit) );
 893 }
 894
 895
 896 Int_t AliMUONDataInterface::NumberOfDigits(Int_t chamber, Int_t cathode)
 897 {
 898 /// Get the number of digits on the chamber, cathode in the current event.
 899 /// -1 is returned on error.
 900
 901         Assert( 0 <= chamber && chamber <= 13 );
 902         Assert( 0 <= cathode && cathode <= 1 );
 903
 904         if (fRunloader == NULL)
 905         {
 906                 AliError("File not set.");
 907                 return -1;
 908         }
 909         if (fEventnumber < 0)
 910         {
 911                 AliError("Event not chosen.");
 912                 return -1;
 913         }
 914
 915         if ( ! FetchTreeD() ) return -1;
 916         if ( fCathode != cathode )
 917         {
 918                 fData.ResetDigits();
 919                 fData.GetDigits();
 920                 fCathode = cathode;
 921         }
 922         return fData.Digits(chamber)->GetEntriesFast();
 923 }
 924
 925
 926 AliMUONDigit* AliMUONDataInterface::Digit(Int_t chamber, Int_t cathode, Int_t digit)
 927 {
 928 /// Fetch the specified digits on the chamber, cathode from the current event.
 929 /// NULL is returned on error.
 930
 931         Assert( 0 <= chamber && chamber <= 13 );
 932         Assert( 0 <= cathode && cathode <= 1 );
 933
 934         if (fRunloader == NULL)
 935         {
 936                 AliError("File not set.");
 937                 return NULL;
 938         }
 939         if (fEventnumber < 0)
 940         {
 941                 AliError("Event not chosen.");
 942                 return NULL;
 943         }
 944
 945         if ( ! FetchTreeD() ) return NULL;
 946         if ( fCathode != cathode )
 947         {
 948                 fData.ResetDigits();
 949                 fData.GetDigits();
 950                 fCathode = cathode;
 951         }
 952         return static_cast<AliMUONDigit*>( fData.Digits(chamber)->At(digit) );
 953 }
 954
 955
 956 Int_t AliMUONDataInterface::NumberOfRawClusters(Int_t chamber)
 957 {
 958 /// Get the number of raw clusters on the given chamber in the current event.
 959 /// -1 is returned on error.
 960
 961         Assert( 0 <= chamber && chamber <= 13 );
 962
 963         if (fRunloader == NULL)
 964         {
 965                 AliError("File not set.");
 966                 return -1;
 967         }
 968         if (fEventnumber < 0)
 969         {
 970                 AliError("Event not chosen.");
 971                 return -1;
 972         }
 973
 974         if ( ! FetchTreeR() ) return -1;
 975         if ( ! fClusterAddressSet )
 976         {
 977                 fData.SetTreeAddress("RC");
 978                 fData.ResetRawClusters();
 979                 fData.GetRawClusters();
 980                 fClusterAddressSet = kTRUE;
 981         }
 982         return fData.RawClusters(chamber)->GetEntriesFast();
 983 }
 984
 985
 986 AliMUONRawCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t cluster)
 987 {
 988 /// Fetch the specified raw cluster on the given chamber from the current event.
 989 /// NULL is returned on error.
 990
 991         Assert( 0 <= chamber && chamber <= 13 );
 992
 993         if (fRunloader == NULL)
 994         {
 995                 AliError("File not set.");
 996                 return NULL;
 997         }
 998         if (fEventnumber < 0)
 999         {
1000                 AliError("Event not chosen.");
1001                 return NULL;
1002         }
1003
1004         if ( ! FetchTreeR() ) return NULL;
1005         if ( ! fClusterAddressSet )
1006         {
1007                 fData.SetTreeAddress("RC");
1008                 fData.ResetRawClusters();
1009                 fData.GetRawClusters();
1010                 fClusterAddressSet = kTRUE;
1011         }
1012         return static_cast<AliMUONRawCluster*>( fData.RawClusters(chamber)->At(cluster) );
1013 }
1014
1015
1016 Int_t AliMUONDataInterface::NumberOfLocalTriggers()
1017 {
1018 /// Get the number of local trigger objects in the current event.
1019 /// -1 is returned on error.
1020
1021         if (fRunloader == NULL)
1022         {
1023                 AliError("File not set.");
1024                 return -1;
1025         }
1026         if (fEventnumber < 0)
1027         {
1028                 AliError("Event not chosen.");
1029                 return -1;
1030         }
1031
1032         if ( ! FetchTreeD() ) return -1;
1033         if ( ! fTriggerAddressSet )
1034         {
1035                 fData.SetTreeAddress("GLT");
1036                 fData.ResetTrigger();
1037                 fData.GetTriggerD();
1038                 fTriggerAddressSet = kTRUE;
1039         }
1040         return fData.LocalTrigger()->GetEntriesFast();
1041 }
1042
1043
1044 AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(Int_t trigger)
1045 {
1046 /// Fetch the specified local trigger object from the current event.
1047 /// NULL is returned on error.
1048
1049         if (fRunloader == NULL)
1050         {
1051                 AliError("File not set.");
1052                 return NULL;
1053         }
1054         if (fEventnumber < 0)
1055         {
1056                 AliError( "Event not chosen.");
1057                 return NULL;
1058         }
1059
1060         if ( ! FetchTreeD() ) return NULL;
1061         if ( ! fTriggerAddressSet )
1062         {
1063                 fData.SetTreeAddress("GLT");
1064                 fData.ResetTrigger();
1065                 fData.GetTriggerD();
1066                 fTriggerAddressSet = kTRUE;
1067         }
1068         return static_cast<AliMUONLocalTrigger*>( fData.LocalTrigger()->At(trigger) );
1069 }
1070
1071 Int_t AliMUONDataInterface::NumberOfGlobalTriggers()
1072 {
1073 /// Get the number of local trigger objects in the current event.
1074 /// -1 is returned on error.
1075
1076   if (fRunloader == NULL)
1077     {
1078       AliError("File not set.");
1079       return -1;
1080     }
1081   if (fEventnumber < 0)
1082     {
1083       AliError("Event not chosen.");
1084       return -1;
1085     }
1086
1087   if ( ! FetchTreeD() ) return -1;
1088   if ( ! fTriggerAddressSet )
1089     {
1090       fData.SetTreeAddress("GLT");
1091       fData.ResetTrigger();
1092       fData.GetTriggerD();
1093       fTriggerAddressSet = kTRUE;
1094     }
1095   return fData.GlobalTrigger()->GetEntriesFast();
1096 }
1097
1098 AliMUONGlobalTrigger* AliMUONDataInterface::GlobalTrigger(Int_t trigger)
1099 {
1100 /// Fetch the specified local trigger object from the current event.
1101 /// NULL is returned on error.
1102
1103   if (fRunloader == NULL)
1104     {
1105       AliError("File not set.");
1106       return NULL;
1107     }
1108   if (fEventnumber < 0)
1109     {
1110       AliError( "Event not chosen.");
1111       return NULL;
1112     }
1113
1114   if ( ! FetchTreeD() ) return NULL;
1115   if ( ! fTriggerAddressSet )
1116     {
1117       fData.SetTreeAddress("GLT");
1118       fData.ResetTrigger();
1119       fData.GetTriggerD();
1120       fTriggerAddressSet = kTRUE;
1121     }
1122   return static_cast<AliMUONGlobalTrigger*>( fData.GlobalTrigger()->At(trigger) );
1123 }
1124
1125 Int_t AliMUONDataInterface::NumberOfRecTracks()
1126 {
1127 /// Fetch the number of reconstructed tracks from the current event.
1128 /// NULL is returned on error.
1129
1130   if (fRunloader == NULL)
1131     {
1132       AliError("File not set.");
1133       return -1;
1134     }
1135   if (fEventnumber < 0)
1136     {
1137       AliError( "Event not chosen.");
1138       return -1;
1139     }
1140
1141   if ( ! FetchTreeT() ) return -1;
1142   if ( ! fRecTracksAddressSet )
1143     {
1144       fData.SetTreeAddress("RT");
1145       fData.ResetRecTracks();
1146       fData.GetRecTracks();
1147       fRecTracksAddressSet = kTRUE;
1148     }
1149   return fData.RecTracks()->GetEntriesFast();
1150 }
1151
1152 AliMUONTrack* AliMUONDataInterface::RecTrack(Int_t rectrack)
1153 {
1154 /// Fetch the specified reconstructed track object from the current event.
1155 /// NULL is returned on error.
1156
1157   if (fRunloader == NULL)
1158     {
1159       AliError("File not set.");
1160       return NULL;
1161     }
1162   if (fEventnumber < 0)
1163     {
1164       AliError( "Event not chosen.");
1165       return NULL;
1166     }
1167
1168   if ( ! FetchTreeT() ) return NULL;
1169   if ( ! fRecTracksAddressSet )
1170     {
1171       fData.SetTreeAddress("RT");
1172       fData.ResetRecTracks();
1173       fData.GetRecTracks();
1174       fRecTracksAddressSet = kTRUE;
1175     }
1176   return static_cast<AliMUONTrack*>( fData.RecTracks()->At(rectrack) );
1177   // return (AliMUONTrack*)(fData.RecTracks()->At(rectrack));
1178 }