Removing output of hit pointers in AliMUONTrack class. New switch in ALiMUONv1 for...
[u/mrichter/AliRoot.git] / MUON / AliMUONData.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 //Root includes
19 #include "TNamed.h"
20 //AliRoot include
21 #include "AliLoader.h" 
22 #include "AliMUONConstants.h"
23 #include "AliMUONData.h"
24 #include "AliMUONDigit.h"
25 #include "AliMUONHit.h"
26 #include "AliMUONLocalTrigger.h"
27 #include "AliMUONGlobalTrigger.h"
28 #include "AliMUONRawCluster.h"
29 #include "AliMUONTrack.h"
30
31 ClassImp(AliMUONData)
32  
33 //_____________________________________________________________________________
34 AliMUONData::AliMUONData():TNamed()
35 {
36   fLoader        = 0x0;
37   fHits          = 0x0;    // One event in treeH per primary track
38   fDigits        = 0x0;  // One event in treeH per detection plane
39   fNdigits       = 0x0;
40   fRawClusters   = 0x0; //One event in TreeR/RawclusterBranch per tracking detection plane
41   fGlobalTrigger = 0x0; //! List of Global Trigger 1st event in TreeR/GlobalTriggerBranch
42   fLocalTrigger  = 0x0;  //! List of Local Trigger, 1st event in TreeR/LocalTriggerBranch
43   fRecTracks     = 0x0;       
44   fSplitLevel    = 0;
45 //default constructor
46 }
47 //_____________________________________________________________________________
48 AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
49   TNamed(name,title)
50 {
51   fLoader        = loader;
52   fHits          = 0x0;    // One event in treeH per primary track
53   fDigits        = 0x0;  // One event in treeH per detection plane
54   fNdigits       = 0x0;
55   fRawClusters   = 0x0; //One event in TreeR/RawclusterBranch per tracking detection plane
56   fGlobalTrigger = 0x0; //! List of Global Trigger 1st event in TreeR/GlobalTriggerBranch
57   fLocalTrigger  = 0x0;  //! List of Local Trigger, 1st event in TreeR/LocalTriggerBranch
58   fRecTracks     = 0x0;    
59   fNhits         = 0;
60   fNglobaltrigger =0;
61   fNlocaltrigger = 0;
62   fNrectracks    = 0;  
63   fSplitLevel    = 0;
64 //   fHits          = new TClonesArray("AliMUONHit",1000);
65 //   fNhits         = 0;
66 //   fDigits        = new TObjArray(AliMUONConstants::NCh());
67 //   fNdigits       = new Int_t[AliMUONConstants::NCh()];
68 //   for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
69 //     fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),iDetectionPlane); 
70 //     fNdigits[iDetectionPlane]=0;
71 //   }
72 //   fRawClusters   = new TObjArray(AliMUONConstants::NTrackingCh());
73 //   fNrawclusters  = new Int_t[AliMUONConstants::NTrackingCh()];
74 //   for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NTrackingCh();iDetectionPlane++) {
75 //     fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),iDetectionPlane); 
76 //     fNrawclusters[iDetectionPlane]=0;
77 //   }
78 //   fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);    
79 //   fNglobaltrigger =0;
80 //   fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);   
81 //   fNlocaltrigger = 0;
82 //   fRecTracks     = new TClonesArray("AliMUONTrack", 100);
83 //   fNrectracks    = 0; // really needed or GetEntriesFast sufficient ????
84
85
86   //default constructor
87 }
88 //_____________________________________________________________________________
89 AliMUONData::AliMUONData(const AliMUONData& rMUONData):TNamed(rMUONData)
90 {
91   // Dummy copy constructor
92   ;
93 }
94 //_____________________________________________________________________________
95 AliMUONData::~AliMUONData()
96 {
97   if (fHits) {
98     fHits->Delete();
99     delete fHits;
100   }
101   if (fDigits) {
102     fDigits->Delete();
103     delete fDigits;
104   }
105   if (fRawClusters) {
106     fRawClusters->Delete();
107     delete fRawClusters;
108   }
109   if (fGlobalTrigger){
110     fGlobalTrigger->Delete();
111     delete fGlobalTrigger;
112   }  
113   if (fLocalTrigger){
114     fLocalTrigger->Delete();
115     delete fLocalTrigger;
116   }
117   if (fRecTracks){
118     fRecTracks->Delete();
119     delete fRecTracks;
120   }
121   //detructor 
122 }
123 //_____________________________________________________________________________
124 void AliMUONData::AddDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
125 {
126   //
127   // Add a MUON digit to the list of Digits of the detection plane id
128   //
129   TClonesArray &ldigits = * Digits(id) ; 
130   new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
131 }
132 //_____________________________________________________________________________
133 void AliMUONData::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
134                                    Int_t *singleUndef,
135                                    Int_t *pairUnlike, Int_t *pairLike)
136 {
137   // add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
138   TClonesArray &globalTrigger = *fGlobalTrigger;
139   new(globalTrigger[fNglobaltrigger++]) 
140     AliMUONGlobalTrigger(singlePlus, singleMinus,  singleUndef, pairUnlike, pairLike);
141 }
142 //_____________________________________________________________________________
143 void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber, 
144                          Int_t idpart, Float_t X, Float_t Y, Float_t Z, 
145                          Float_t tof, Float_t momentum, Float_t theta, 
146                          Float_t phi, Float_t length, Float_t destep)
147 {
148   TClonesArray &lhits = *fHits;
149   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber, 
150                                   idpart, X, Y, Z, 
151                                   tof, momentum, theta, 
152                                   phi, length, destep);
153 }
154 //____________________________________________________________________________
155 void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber, 
156                          Int_t idpart, Float_t X, Float_t Y, Float_t Z, 
157                          Float_t tof, Float_t momentum, Float_t theta, 
158                          Float_t phi, Float_t length, Float_t destep,
159                          Float_t Xref,Float_t Yref,Float_t Zref)
160 {
161   TClonesArray &lhits = *fHits;
162   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber, 
163                                   idpart, X, Y, Z, 
164                                   tof, momentum, theta, 
165                                   phi, length, destep,
166                                   Xref,Yref,Zref);
167 }
168 //____________________________________________________________________________
169 void AliMUONData::AddLocalTrigger(Int_t *localtr)
170 {
171   // add a MUON Local Trigger to the list
172   TClonesArray &localTrigger = *fLocalTrigger;
173   new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(localtr);
174 }
175 //_____________________________________________________________________________
176 void AliMUONData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
177 {
178   //
179   // Add a MUON rawcluster to the list in the detection plane id
180   //
181   TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
182   new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
183 }
184 //_____________________________________________________________________________
185 void AliMUONData::AddRecTrack(const AliMUONTrack& track)
186 {
187   //
188   // Add a MUON rectrack
189   //
190   TClonesArray &lrectracks = *fRecTracks;
191   new(lrectracks[fNrectracks++]) AliMUONTrack(track);
192 }
193 //____________________________________________________________________________
194 TClonesArray*  AliMUONData::Digits(Int_t DetectionPlane) 
195 {
196   if (fDigits)
197     return ( (TClonesArray*) fDigits->At(DetectionPlane) );
198   else
199     return NULL;
200 }
201 //____________________________________________________________________________
202 Bool_t   AliMUONData::IsRawClusterBranchesInTree()
203 {
204   if (TreeR()==0x0) {
205     Error("TreeR","No treeR in memory");
206     return kFALSE;
207   }
208   else {
209      char branchname[30];
210      sprintf(branchname,"%sRawClusters1",GetName());
211      TBranch * branch = 0x0;
212      branch = TreeR()->GetBranch(branchname);
213      if (branch)  return kTRUE;
214      else return kFALSE;    
215   }
216 }
217 //____________________________________________________________________________
218 Bool_t   AliMUONData::IsTriggerBranchesInTree()
219 {
220  if (TreeR()==0x0) {
221     Error("TreeR","No treeR in memory");
222     return kFALSE;
223   }
224   else {
225      char branchname[30];
226      sprintf(branchname,"%sLocalTrigger",GetName());
227      TBranch * branch = 0x0;
228      branch = TreeR()->GetBranch(branchname);
229      if (branch)  return kTRUE;
230      else return kFALSE;    
231   }
232 }
233 //____________________________________________________________________________
234 void AliMUONData::Fill(Option_t* option)
235 {
236   // Method to fill the trees
237   const char *cH   = strstr(option,"H");
238   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
239   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
240   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
241   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
242   //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
243   
244   char branchname[30];
245   TBranch * branch = 0x0;
246
247   //
248   // Filling TreeH
249   if ( TreeH() && cH ) {
250     TreeH()->Fill();
251   }  
252   //
253   // Filling TreeD
254   if ( TreeD() && cD) {
255     TreeD()->Fill();
256   }
257
258   //
259   // filling rawclusters
260   if ( TreeR()  && cRC ) {
261     if ( IsTriggerBranchesInTree() ) {
262       // Branch per branch filling
263       for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
264         sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
265         branch = TreeR()->GetBranch(branchname);
266         branch->Fill();
267       }
268     }
269     else  TreeR()->Fill();
270   }
271   
272  //
273   // filling trigger 
274   if ( TreeR()  && cGLT) {
275     if (IsRawClusterBranchesInTree()) {
276       // Branch per branch filling
277       sprintf(branchname,"%sLocalTrigger",GetName());
278       branch = TreeR()->GetBranch(branchname); 
279       branch->Fill();
280       sprintf(branchname,"%sGlobalTrigger",GetName());
281       branch = TreeR()->GetBranch(branchname);
282       branch->Fill();
283     }
284     else  TreeR()->Fill();
285   }
286   //
287   // filling tracks
288   if ( TreeT() && cRT ) {
289     sprintf(branchname,"%sTrack",GetName());  
290     TreeT()->Fill();
291   }
292 }
293 //_____________________________________________________________________________
294 void AliMUONData::MakeBranch(Option_t* option)
295 {
296   //
297   // Create Tree branches for the MUON.
298   //
299   const Int_t kBufferSize = 4000;
300   char branchname[30];
301   
302   const char *cH   = strstr(option,"H");
303   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
304   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
305   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
306   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
307   const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
308   
309   TBranch * branch = 0x0;
310   
311   // Creating Branches for Hits
312   if (TreeH() && cH) {
313     if (fHits == 0x0)  fHits = new TClonesArray("AliMUONHit",1000);
314     fNhits = 0;
315     sprintf(branchname,"%sHits",GetName());  
316     branch = TreeH()->GetBranch(branchname);
317     if (branch) {  
318       Info("MakeBranch","Branch %s is already in tree.",GetName());
319       return ;
320     }
321     branch = TreeH()->Branch(branchname,&fHits,kBufferSize,fSplitLevel);
322     Info("MakeBranch","Making Branch %s for hits \n",branchname);
323   }  
324   
325   //Creating Branches for Digits
326   if (TreeD() && cD ) {
327     // one branch for digits per chamber
328     if (fDigits  == 0x0) {
329       fDigits  = new TObjArray(AliMUONConstants::NCh());
330       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
331         fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),iDetectionPlane); 
332       }
333     }
334     if (fNdigits == 0x0) {
335       fNdigits = new Int_t[AliMUONConstants::NCh()];
336       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
337         fNdigits[iDetectionPlane]=0;
338       }
339     }
340     for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
341       sprintf(branchname,"%sDigits%d",GetName(),iDetectionPlane+1);
342       branch = 0x0;
343       branch = TreeD()->GetBranch(branchname);
344       if (branch) {  
345         Info("MakeBranch","Branch %s is already in tree.",GetName());
346         return;
347       }
348       TClonesArray * digits = Digits(iDetectionPlane); 
349       branch = TreeD()->Branch(branchname, &digits, kBufferSize,1);
350       Info("MakeBranch","Making Branch %s for digits in detection plane %d\n",branchname,iDetectionPlane+1);
351       }
352   }
353   
354   if (TreeR() && cRC ) {
355     //  one branch for raw clusters per tracking detection plane
356     //        
357     Int_t i;
358     if (fRawClusters == 0x0) {
359       fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
360       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
361         fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",1000),i); 
362       }
363     }
364
365     if (fNrawclusters == 0x0) {
366       fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
367       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
368         fNrawclusters[i]=0;
369       }
370     }
371     
372     for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
373       sprintf(branchname,"%sRawClusters%d",GetName(),i+1);      
374       branch = 0x0;
375       branch = TreeR()->GetBranch(branchname);
376       if (branch) {  
377         Info("MakeBranch","Branch %s is already in tree.",GetName());
378         return;
379       }
380       branch = TreeR()->Branch(branchname, &((*fRawClusters)[i]),kBufferSize,fSplitLevel);
381       Info("MakeBranch","Making Branch %s for rawcluster in detection plane %d\n",branchname,i+1);
382     }
383   }
384
385   if (TreeR() && cGLT ) {
386     //
387     // one branch for global trigger
388     //
389     sprintf(branchname,"%sGlobalTrigger",GetName());
390     branch = 0x0;
391     
392     if (fGlobalTrigger == 0x0) {
393       fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",fSplitLevel); 
394       fNglobaltrigger = 0;
395     }
396     branch = TreeR()->GetBranch(branchname);
397     if (branch) {  
398       Info("MakeBranch","Branch %s is already in tree.",GetName());
399       return ;
400     }
401     branch = TreeR()->Branch(branchname, &fGlobalTrigger, kBufferSize,fSplitLevel);
402     Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);
403     
404     //
405     // one branch for local trigger
406     //  
407     sprintf(branchname,"%sLocalTrigger",GetName());
408     branch = 0x0;
409     
410     if (fLocalTrigger == 0x0) {
411       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
412       fNlocaltrigger = 0;
413     }
414     branch = TreeR()->GetBranch(branchname);
415     if (branch) {  
416       Info("MakeBranch","Branch %s is already in tree.",GetName());
417       return;
418     }
419     branch = TreeR()->Branch(branchname, &fLocalTrigger, kBufferSize,fSplitLevel);
420     Info("MakeBranch", "Making Branch %s for Global Trigger\n",branchname);  
421   }
422   
423   if (TreeT() && cRT ) {
424     if (fRecTracks == 0x0)  fRecTracks = new TClonesArray("AliMUONTrack",100);
425     fNrectracks = 0;
426     sprintf(branchname,"%sTrack",GetName());  
427     branch = TreeT()->GetBranch(branchname);
428     if (branch) {  
429       Info("MakeBranch","Branch %s is already in tree.",GetName());
430       return ;
431     }
432     branch = TreeT()->Branch(branchname,&fRecTracks,kBufferSize);
433     Info("MakeBranch","Making Branch %s for tracks \n",branchname);
434   }  
435
436   if (TreeP() && cRP ) {
437     Info("MakeBranch","Making Branch for TreeP is not yet ready. \n");
438   }
439 }
440 //____________________________________________________________________________
441 TClonesArray*  AliMUONData::RawClusters(Int_t DetectionPlane)
442 {
443   if (fRawClusters) 
444     return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );
445   else
446     return NULL;
447 }
448 //____________________________________________________________________________
449 void AliMUONData::ResetDigits()
450 {
451     //
452     // Reset number of digits and the digits array for this detector
453     //
454     if (fDigits == 0x0) return;
455     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
456       if ((*fDigits)[i])    ((TClonesArray*)fDigits->At(i))->Clear();
457       if (fNdigits)  fNdigits[i]=0;
458     }
459 }
460 //______________________________________________________________________________
461 void AliMUONData::ResetHits()
462 {
463   // Reset number of clusters and the cluster array for this detector
464   fNhits   = 0;
465   if (fHits) fHits->Clear();
466 }
467 //_______________________________________________________________________________
468 void AliMUONData::ResetRawClusters()
469 {
470     // Reset number of raw clusters and the raw clust array for this detector
471     //
472   for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
473     if ((*fRawClusters)[i])    ((TClonesArray*)fRawClusters->At(i))->Clear();
474     if (fNrawclusters)  fNrawclusters[i]=0;
475   }
476 }
477 //_______________________________________________________________________________
478 void AliMUONData::ResetTrigger()
479 {
480   //  Reset Local and Global Trigger 
481   fNglobaltrigger = 0;
482   if (fGlobalTrigger) fGlobalTrigger->Clear();
483   fNlocaltrigger = 0;
484   if (fLocalTrigger) fLocalTrigger->Clear();
485 }
486 //____________________________________________________________________________
487 void AliMUONData::ResetRecTracks()
488 {
489   // Reset tracks information
490   fNrectracks = 0;
491   if (fRecTracks) fRecTracks->Clear();
492 }
493 //_____________________________________________________________________________
494 void AliMUONData::SetTreeAddress(Option_t* option)
495 {
496   const char *cH   = strstr(option,"H");
497   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
498   const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
499   const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
500   const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
501   //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
502   
503   // Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
504   char branchname[30];
505   TBranch * branch = 0x0;
506
507   //
508   // Branch address for hit tree
509   if ( TreeH() && cH ) {
510     if (fHits == 0x0) fHits     = new TClonesArray("AliMUONHit",1000);
511     fNhits =0;
512   } 
513   if (TreeH() && fHits && cH) {
514     sprintf(branchname,"%sHits",GetName());  
515     branch = TreeH()->GetBranch(branchname);
516     if (branch) {
517       //      Info("SetTreeAddress","(%s) Setting for Hits",GetName());
518       branch->SetAddress(&fHits);
519     }
520     else { //can be invoked before branch creation
521       Warning("SetTreeAddress","(%s) Failed for Hits. Can not find branch in tree.",GetName());
522     }
523   }
524   
525   //
526   // Branch address for digit tree
527   if ( TreeD() && cD) {
528     if (fDigits == 0x0) { 
529       fDigits = new TObjArray(AliMUONConstants::NCh());
530       fNdigits= new Int_t[AliMUONConstants::NCh()];
531       for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
532         fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
533         fNdigits[i]=0;
534       }
535     }
536   }
537
538   if (TreeD() && fDigits && cD) {
539     for (int i=0; i<AliMUONConstants::NCh(); i++) {
540       sprintf(branchname,"%sDigits%d",GetName(),i+1);
541       if (fDigits) {
542         branch = TreeD()->GetBranch(branchname);
543         TClonesArray * digits = Digits(i);
544         if (branch) branch->SetAddress( &digits );
545         else Warning("SetTreeAddress","(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i);
546       }
547     }
548   }
549   
550   //
551   // Branch address for rawclusters, globaltrigger and local trigger tree
552   if (TreeR() ) {
553     if (fRawClusters == 0x0 && cRC) {
554       fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
555       fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
556       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
557         fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
558         fNrawclusters[i]=0;
559       }
560     }
561     if (fLocalTrigger == 0x0 && cGLT) {
562       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
563     }
564     if (fGlobalTrigger== 0x0 && cGLT) {
565         fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1); 
566     }
567
568   }
569   if ( TreeR()  && fRawClusters && cRC) {
570     for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
571       sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
572       if (fRawClusters) {
573         branch = TreeR()->GetBranch(branchname);
574         if (branch) branch->SetAddress( &((*fRawClusters)[i]) );
575         else Warning("SetTreeAddress","(%s) Failed for RawClusters Detection plane %d. Can not find branch in tree.",GetName(),i);
576       }
577     }
578   }
579   if ( TreeR()  && fLocalTrigger && cGLT) {
580     sprintf(branchname,"%sLocalTrigger",GetName());
581     branch = TreeR()->GetBranch(branchname);
582     if (branch) branch->SetAddress(&fLocalTrigger);
583     else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
584   }
585   if ( TreeR() && fGlobalTrigger && cGLT) {
586     sprintf(branchname,"%sGlobalTrigger",GetName());
587     branch = TreeR()->GetBranch(branchname);
588     if (branch) branch->SetAddress(&fGlobalTrigger);
589     else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
590   }
591
592   if ( TreeT() ) {
593     if (fRecTracks == 0x0 && cRT )  {
594       fRecTracks  = new TClonesArray("AliMUONTrack",100);
595     }
596   }
597   if ( TreeT() && fRecTracks && cRT ) {
598     sprintf(branchname,"%sTrack",GetName());  
599     branch = TreeT()->GetBranch(branchname);
600     if (branch) branch->SetAddress(&fRecTracks);
601     else Warning("SetTreeAddress","(%s) Failed for Tracks. Can not find branch in tree.",GetName());
602   }
603 }
604 //_____________________________________________________________________________