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