Adding new AddHit function
[u/mrichter/AliRoot.git] / MUON / AliMUON.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 $Log$
17 Revision 1.59  2002/11/21 17:01:56  alibrary
18 Removing AliMCProcess and AliMC
19
20 Revision 1.58  2002/10/21 09:01:33  alibrary
21 Getting rid of unused variable
22
23 Revision 1.57  2002/10/14 14:57:29  hristov
24 Merging the VirtualMC branch to the main development branch (HEAD)
25
26 Revision 1.56.6.2  2002/07/24 10:07:20  alibrary
27 Updating VirtualMC
28
29 Revision 1.56.6.1  2002/06/10 15:10:14  hristov
30 Merged with v3-08-02
31
32 Revision 1.56  2001/11/22 11:26:28  jchudoba
33 Proper deletion of arrays, deletion of unused variables (thanks to Rene Brun)
34
35 Revision 1.55  2001/09/07 08:38:30  hristov
36 Pointers initialised to 0 in the default constructors
37
38 Revision 1.54  2001/08/30 09:52:12  hristov
39 The operator[] is replaced by At() or AddAt() in case of TObjArray.
40
41 Revision 1.53  2001/07/20 10:03:13  morsch
42 Changes needed to work with Root 3.01 (substitute lhs [] operator). (Jiri Chudoba)
43
44 Revision 1.52  2001/06/14 13:49:22  hristov
45 Write a TreeD in SDigits2Digits method (needed to be compatible with alirun script)
46
47 Revision 1.51  2001/05/31 10:19:52  morsch
48 Fix for new AliRun::RunReco().
49
50 Revision 1.50  2001/05/16 14:57:17  alibrary
51 New files for folders and Stack
52
53 Revision 1.49  2001/03/12 17:45:48  hristov
54 Changes needed on Sun with CC 5.0
55
56 Revision 1.48  2001/03/06 00:01:36  morsch
57 Add  Digits2Reco() and FindClusters()
58 Adapt call of cluster finder to new STEER.
59
60 Revision 1.47  2001/03/05 08:38:36  morsch
61 Digitization related methods moved to AliMUONMerger.
62
63 Revision 1.46  2001/01/26 21:34:59  morsch
64 Use access functions for AliMUONHit, AliMUONDigit and AliMUONPadHit data members.
65
66 Revision 1.45  2001/01/26 20:00:49  hristov
67 Major upgrade of AliRoot code
68
69 Revision 1.44  2001/01/25 17:39:09  morsch
70 Pass size of fNdch and fNrawch to CINT.
71
72 Revision 1.43  2001/01/23 18:58:19  hristov
73 Initialisation of some pointers
74
75 Revision 1.42  2001/01/17 20:53:40  hristov
76 Destructors corrected to avoid memory leaks
77
78 Revision 1.41  2000/12/21 22:12:40  morsch
79 Clean-up of coding rule violations,
80
81 Revision 1.40  2000/11/29 20:32:26  gosset
82 Digitize:
83 1. correction for array index out of bounds
84 2. one printout commented
85
86 Revision 1.39  2000/11/12 17:17:03  pcrochet
87 BuildGeometry of AliMUON for trigger chambers delegated to AliMUONSegmentationTriggerX (same strategy as for tracking chambers)
88
89 Revision 1.38  2000/11/06 09:20:43  morsch
90 AliMUON delegates part of BuildGeometry() to AliMUONSegmentation using the
91 Draw() method. This avoids code and parameter replication.
92
93 Revision 1.37  2000/10/26 09:53:37  pcrochet
94 put back trigger chambers in the display (there was a problem in buildgeometry)
95
96 Revision 1.36  2000/10/25 19:51:18  morsch
97 Correct x-position of chambers.
98
99 Revision 1.35  2000/10/24 19:46:21  morsch
100 BuildGeometry updated for slats in station 3-4.
101
102 Revision 1.34  2000/10/18 11:42:06  morsch
103 - AliMUONRawCluster contains z-position.
104 - Some clean-up of useless print statements during initialisations.
105
106 Revision 1.33  2000/10/09 14:01:57  morsch
107 Unused variables removed.
108
109 Revision 1.32  2000/10/06 09:08:10  morsch
110 Built geometry includes slat geometry for event display.
111
112 Revision 1.31  2000/10/02 21:28:08  fca
113 Removal of useless dependecies via forward declarations
114
115 Revision 1.30  2000/10/02 16:58:29  egangler
116 Cleaning of the code :
117 -> coding conventions
118 -> void Streamers
119 -> some useless includes removed or replaced by "class" statement
120
121 Revision 1.29  2000/07/28 13:49:38  morsch
122 SetAcceptance defines inner and outer chamber radii according to angular acceptance.
123 Can be used for simple acceptance studies.
124
125 Revision 1.28  2000/07/22 16:43:15  morsch
126 Same comment as before, but now done correctly I hope (sorry it's Saturday evening)
127
128 Revision 1.27  2000/07/22 16:36:50  morsch
129 Change order of indices in creation (new) of xhit and yhit
130
131 Revision 1.26  2000/07/03 11:54:57  morsch
132 AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
133 The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
134
135 Revision 1.25  2000/06/29 12:34:09  morsch
136 AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
137 it usable with any other geometry class. The link to the object to which it belongs is
138 established via an index. This assumes that there exists a global geometry manager
139 from which the pointer to the parent object can be obtained (in our case gAlice).
140
141 Revision 1.24  2000/06/28 15:16:35  morsch
142 (1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
143 to allow development of slat-muon chamber simulation and reconstruction code in the MUON
144 framework. The changes should have no side effects (mostly dummy arguments).
145 (2) Hit disintegration uses 3-dim hit coordinates to allow simulation
146 of chambers with overlapping modules (MakePadHits, Disintegration).
147
148 Revision 1.23  2000/06/28 12:19:17  morsch
149 More consequent seperation of global input data services (AliMUONClusterInput singleton) and the
150 cluster and hit reconstruction algorithms in AliMUONClusterFindRawinderVS.
151 AliMUONClusterFinderVS becomes the base class for clustering and hit reconstruction.
152 It requires two cathode planes. Small modifications in the code will make it usable for
153 one cathode plane and, hence, more general (for test beam data).
154 AliMUONClusterFinder is now obsolete.
155
156 Revision 1.22  2000/06/28 08:06:10  morsch
157 Avoid global variables in AliMUONClusterFinderVS by seperating the input data for the fit from the
158 algorithmic part of the class. Input data resides inside the AliMUONClusterInput singleton.
159 It also naturally takes care of the TMinuit instance.
160
161 Revision 1.21  2000/06/27 08:54:41  morsch
162 Problems with on constant array sizes (in hitMap, nmuon, xhit, yhit) corrected.
163
164 Revision 1.20  2000/06/26 14:02:38  morsch
165 Add class AliMUONConstants with MUON specific constants using static memeber data and access methods.
166
167 Revision 1.19  2000/06/22 13:40:51  morsch
168 scope problem on HP, "i" declared once
169 pow changed to TMath::Power (PH, AM)
170
171 Revision 1.18  2000/06/15 07:58:48  morsch
172 Code from MUON-dev joined
173
174 Revision 1.14.4.17  2000/06/14 14:36:46  morsch
175 - add TriggerCircuit (PC)
176 - add GlobalTrigger and LocalTrigger and specific methods (PC)
177
178 Revision 1.14.4.16  2000/06/09 21:20:28  morsch
179 Most coding rule violations corrected
180
181 Revision 1.14.4.15  2000/05/02 09:54:32  morsch
182 RULE RN17 violations corrected
183
184 Revision 1.14.4.12  2000/04/26 12:25:02  morsch
185 Code revised by P. Crochet:
186 - Z position of TriggerChamber changed according to A.Tournaire Priv.Comm.
187 - ToF included in the method MakePadHits
188 - inner radius of flange between beam shielding and trigger corrected
189 - Trigger global volume updated (according to the new geometry)
190
191 Revision 1.14.4.11  2000/04/19 19:42:08  morsch
192 Some changes of variable names curing viols and methods concerning
193 correlated clusters removed.
194
195 Revision 1.14.4.10  2000/03/22 16:44:07  gosset
196 Memory leak suppressed in function Digitise:
197 p_adr->Delete() instead of Clear (I.Chevrot and A.Baldisseri)
198
199 Revision 1.14.4.9  2000/03/20 18:15:25  morsch
200 Positions of trigger chambers corrected (P.C.)
201
202 Revision 1.14.4.8  2000/02/21 15:38:01  morsch
203 Call to AddHitList introduced to make this version compatible with head.
204
205 Revision 1.14.4.7  2000/02/20 07:45:53  morsch
206 Bugs in Trigger part of BuildGeomemetry corrected (P.C)
207
208 Revision 1.14.4.6  2000/02/17 14:28:54  morsch
209 Trigger included into initialization and digitization
210
211 Revision 1.14.4.5  2000/02/15 10:02:58  morsch
212 Log messages of previous revisions added
213
214 Revision 1.14.4.2  2000/02/04 10:57:34  gosset
215 Z position of the chambers:
216 it was the Z position of the stations;
217 it is now really the Z position of the chambers.
218    !!!! WARNING: THE CALLS TO "AliMUONChamber::SetZPOS"
219    !!!!                   AND "AliMUONChamber::ZPosition"
220    !!!! HAVE TO BE CHANGED TO "AliMUONChamber::"SetZ"
221    !!!!                   AND "AliMUONChamber::Z"
222
223 Revision 1.14.4.3  2000/02/04 16:19:04  gosset
224 Correction for mis-spelling of NCH 
225
226 Revision 1.14.4.4  2000/02/15 09:43:38  morsch
227 Log message added
228
229 */
230
231
232 ///////////////////////////////////////////////
233 //  Manager and hits classes for set:MUON     //
234 ////////////////////////////////////////////////
235
236 #include <TTUBE.h>
237 #include <TBRIK.h>
238 #include <TRotMatrix.h>
239 #include <TGeometry.h>
240 #include <TNode.h> 
241 #include <TTree.h> 
242 #include <TRandom.h> 
243 #include <TObject.h>
244 #include <TVector.h>
245 #include <TObjArray.h>
246 #include <TMinuit.h>
247 #include <TParticle.h>
248 #include <TROOT.h>
249 #include <TFile.h>
250 #include <TNtuple.h>
251 #include <TCanvas.h>
252 #include <TPad.h>
253 #include <TDirectory.h>
254 #include <TObjectTable.h>
255 #include <AliPDG.h>
256 #include <TTUBE.h>
257
258 #include "AliMUON.h"
259 #include "AliMUONHit.h"
260 #include "AliMUONPadHit.h"
261 #include "AliMUONDigit.h"
262 #include "AliMUONTransientDigit.h"
263 #include "AliMUONRawCluster.h"
264 #include "AliMUONLocalTrigger.h"
265 #include "AliMUONGlobalTrigger.h"
266 #include "AliMUONTriggerCircuit.h"
267 #include "AliHitMap.h"
268 #include "AliMUONHitMapA1.h"
269 #include "AliMUONChamberTrigger.h"
270 #include "AliMUONConstants.h"
271 #include "AliMUONClusterFinderVS.h"
272 #include "AliMUONTriggerDecision.h"
273 #include "AliRun.h"
274 #include "AliHeader.h"
275 #include "AliMUONClusterInput.h"
276 #include "AliMUONMerger.h"      
277 #include "Riostream.h"
278 #include "AliConst.h" 
279
280 // Defaults parameters for Z positions of chambers
281 // taken from values for "stations" in AliMUON::AliMUON
282 //     const Float_t zch[7]={528, 690., 975., 1249., 1449., 1610, 1710.};
283 // and from array "dstation" in AliMUONv1::CreateGeometry
284 //          Float_t dstation[5]={20., 20., 20, 20., 20.};
285 //     for tracking chambers,
286 //          according to (Z1 = zch - dstation) and  (Z2 = zch + dstation)
287 //          for the first and second chambers in the station, respectively,
288 // and from "DTPLANES" in AliMUONv1::CreateGeometry
289 //           const Float_t DTPLANES = 15.;
290 //     for trigger chambers,
291 //          according to (Z1 = zch) and  (Z2 = zch + DTPLANES)
292 //          for the first and second chambers in the station, respectively
293
294 ClassImp(AliMUON)
295 //___________________________________________
296 AliMUON::AliMUON()
297 {
298 // Default Constructor
299 //
300     fNCh             = 0;
301     fNTrackingCh     = 0;
302     fIshunt          = 0;
303     fPadHits         = 0;
304     fNPadHits        = 0;
305     fChambers        = 0;
306     fDchambers       = 0;
307     fTriggerCircuits = 0;  
308     fNdch            = 0;
309     fRawClusters     = 0;
310     fNrawch          = 0;
311     fGlobalTrigger   = 0;
312     fNLocalTrigger   = 0;
313     fLocalTrigger    = 0;
314     fNLocalTrigger   = 0;
315     fAccMin          = 0.;
316     fAccMax          = 0.;   
317     fAccCut          = kFALSE;
318     fMerger          = 0;
319     fFileName        = 0;
320 }
321  
322 //___________________________________________
323 AliMUON::AliMUON(const char *name, const char *title)
324        : AliDetector(name,title)
325 {
326 //Begin_Html
327 /*
328 <img src="gif/alimuon.gif">
329 */
330 //End_Html
331
332    fHits     = new TClonesArray("AliMUONHit",1000);
333    gAlice->AddHitList(fHits);
334    fPadHits = new TClonesArray("AliMUONPadHit",10000);
335    fNPadHits  =  0;
336    fIshunt     =  0;
337
338    fNCh             = AliMUONConstants::NCh(); 
339    fNTrackingCh     = AliMUONConstants::NTrackingCh();
340    fNdch            = new Int_t[fNCh];
341
342    fDchambers = new TObjArray(AliMUONConstants::NCh());
343
344    Int_t i;
345    
346    for (i=0; i<AliMUONConstants::NCh() ;i++) {
347        fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
348        fNdch[i]=0;
349    }
350
351    fNrawch      = new Int_t[fNTrackingCh];
352
353    fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
354
355    for (i=0; i<AliMUONConstants::NTrackingCh();i++) {
356        fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
357        fNrawch[i]=0;
358    }
359
360    fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);    
361    fNGlobalTrigger = 0;
362    fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);    
363    fNLocalTrigger = 0;
364
365    SetMarkerColor(kRed);
366 //
367 //
368 //
369 //
370
371     Int_t ch;
372
373     fChambers = new TObjArray(AliMUONConstants::NCh());
374
375     // Loop over stations
376     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
377       // Loop over 2 chambers in the station
378         for (Int_t stCH = 0; stCH < 2; stCH++) {
379 //
380 //    
381 //    Default Parameters for Muon Tracking Stations
382
383
384             ch = 2 * st + stCH;
385 //
386             if (ch < AliMUONConstants::NTrackingCh()) {
387               fChambers->AddAt(new AliMUONChamber(ch),ch);
388             } else {
389               fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
390             }
391             
392         //PH        AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
393             AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
394             
395             chamber->SetGid(0);
396             // Default values for Z of chambers
397             chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
398 //
399             chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
400 //          Set chamber inner and outer radius to default
401             chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
402             chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
403 //
404         } // Chamber stCH (0, 1) in 
405     }     // Station st (0...)
406 //    fChambers->SetLast(AliMUONConstants::NCh());
407     fMaxStepGas=0.01; 
408     fMaxStepAlu=0.1; 
409     fMaxDestepGas=-1;
410     fMaxDestepAlu=-1;
411 //
412    fMaxIterPad   = 0;
413    fCurIterPad   = 0;
414 //
415    fAccMin          = 0.;
416    fAccMax          = 0.;   
417    fAccCut          = kFALSE;
418
419    // cp new design of AliMUONTriggerDecision
420    fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
421    for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
422      fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);     
423
424    }
425      fMerger = 0;
426 }
427  
428 //___________________________________________
429 AliMUON::AliMUON(const AliMUON& rMUON)
430 {
431 // Dummy copy constructor
432     ;
433     
434 }
435
436 AliMUON::~AliMUON()
437 {
438 // Destructor
439     if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
440     
441     fIshunt  = 0;
442  
443     // Delete TObjArrays
444  
445     if (fChambers){
446       fChambers->Delete();
447       delete fChambers;
448     }
449  
450     if (fTriggerCircuits){
451       fTriggerCircuits->Delete();
452       delete fTriggerCircuits;
453     }
454  
455     if (fDchambers){
456       fDchambers->Delete();
457       delete fDchambers;
458     }
459  
460     if (fRawClusters){
461       fRawClusters->Delete();
462       delete fRawClusters;
463     }
464
465     if (fNrawch) delete [] fNrawch;
466  
467     // Delete TClonesArrays
468  
469     if (fPadHits){
470       fPadHits->Delete();
471       delete fPadHits;
472     }
473  
474     if (fGlobalTrigger){
475       fGlobalTrigger->Delete();
476       delete fGlobalTrigger;
477     }
478     fNGlobalTrigger = 0;
479     
480     if (fLocalTrigger){
481       fLocalTrigger->Delete();
482       delete fLocalTrigger;
483     }
484     fNLocalTrigger = 0;
485
486     if (fHits) {
487       fHits->Delete();
488       delete fHits;
489     }
490
491     if (fMerger) delete fMerger;
492     if (fNdch) delete [] fNdch;
493
494 }
495  
496 //___________________________________________
497 void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
498 {
499   TClonesArray &lhits = *fHits;
500   new(lhits[fNhits++]) AliMUONHit(fIshunt,track,vol,hits);
501 }
502 //___________________________________________
503 void AliMUON::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber, 
504               Int_t idpart, Float_t X, Float_t Y, Float_t Z, 
505               Float_t tof, Float_t momentum, Float_t theta, 
506               Float_t phi, Float_t length, Float_t destep)
507 {
508   TClonesArray &lhits = *fHits;
509   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber, 
510                idpart, X, Y, Z, 
511                tof, momentum, theta, 
512                phi, length, destep);
513 }
514 //___________________________________________
515 void AliMUON::AddPadHit(Int_t *clhits)  // To be removed
516 {
517    TClonesArray &lclusters = *fPadHits;
518    new(lclusters[fNPadHits++]) AliMUONPadHit(clhits);
519 }
520 //_____________________________________________________________________________
521 void AliMUON::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
522 {
523     //
524     // Add a MUON digit to the list
525     //
526
527   //PH    TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
528     TClonesArray &ldigits = *((TClonesArray*)fDchambers->At(id));
529     new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
530 }
531
532 //_____________________________________________________________________________
533 void AliMUON::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
534 {
535     //
536     // Add a MUON digit to the list
537     //
538
539   //PH    TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
540     TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
541     new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
542 }
543
544 //___________________________________________
545 void AliMUON::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
546                                Int_t *singleUndef,
547                                Int_t *pairUnlike, Int_t *pairLike)
548 {
549 // add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
550   TClonesArray &globalTrigger = *fGlobalTrigger;
551   new(globalTrigger[fNGlobalTrigger++]) 
552     AliMUONGlobalTrigger(singlePlus, singleMinus,  singleUndef, pairUnlike, 
553                          pairLike);
554 }
555 //___________________________________________
556 void AliMUON::AddLocalTrigger(Int_t *localtr)
557 {
558 // add a MUON Local Trigger to the list
559   TClonesArray &localTrigger = *fLocalTrigger;
560   new(localTrigger[fNLocalTrigger++]) AliMUONLocalTrigger(localtr);
561 }
562
563 //___________________________________________
564 void AliMUON::BuildGeometry()
565 {
566 // Geometry for event display
567   for (Int_t i=0; i<7; i++) {
568     for (Int_t j=0; j<2; j++) {
569       Int_t id=2*i+j+1;
570       this->Chamber(id-1).SegmentationModel(1)->Draw("eventdisplay");
571     }
572   }
573 }
574
575 //___________________________________________
576 Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
577 {
578    return 9999;
579 }
580
581 //___________________________________________
582 void AliMUON::MakeBranch(Option_t* option, const char *file)
583 {
584     //
585     // Create Tree branches for the MUON.
586     //
587     const Int_t kBufferSize = 4000;
588     char branchname[30];
589     sprintf(branchname,"%sCluster",GetName());
590     
591     AliDetector::MakeBranch(option,file);
592     
593     const char *cD = strstr(option,"D");
594     const char *cR = strstr(option,"R");
595     const char *cH = strstr(option,"H");
596
597     // PadHits to be removed
598     if (fPadHits   && gAlice->TreeH() && cH) {
599       MakeBranchInTree(gAlice->TreeH(), 
600                        branchname, &fPadHits, kBufferSize, file);
601     }
602     
603     if (cD) {
604       //
605       // one branch for digits per chamber
606       // 
607       Int_t i;
608     
609       for (i=0; i<AliMUONConstants::NCh() ;i++) {
610             sprintf(branchname,"%sDigits%d",GetName(),i+1);     
611             if (fDchambers   && gAlice->TreeD()) {
612             MakeBranchInTree(gAlice->TreeD(), 
613                              branchname, &((*fDchambers)[i]), kBufferSize, file);
614               printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
615         }
616           }     
617     }
618     
619     if (cR) {
620       //     
621       // one branch for raw clusters per chamber
622       //  
623       printf("Make Branch - TreeR address %p\n",gAlice->TreeR());
624       
625       Int_t i;
626
627       for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
628             sprintf(branchname,"%sRawClusters%d",GetName(),i+1);        
629             if (fRawClusters   && gAlice->TreeR()) {
630               MakeBranchInTree(gAlice->TreeR(), 
631                                branchname, &((*fRawClusters)[i]), kBufferSize, file);
632               printf("Making Branch %s for raw clusters in chamber %d\n",branchname,i+1);
633             }   
634       }
635       //
636       // one branch for global trigger
637       //
638       sprintf(branchname,"%sGlobalTrigger",GetName());
639       if (fGlobalTrigger && gAlice->TreeR()) {  
640           MakeBranchInTree(gAlice->TreeR(), 
641                            branchname, &fGlobalTrigger, kBufferSize, file);
642             printf("Making Branch %s for Global Trigger\n",branchname);
643       }
644       //
645       // one branch for local trigger
646       //  
647       sprintf(branchname,"%sLocalTrigger",GetName());
648       if (fLocalTrigger && gAlice->TreeR()) {  
649           MakeBranchInTree(gAlice->TreeR(), 
650                            branchname, &fLocalTrigger, kBufferSize, file);
651             printf("Making Branch %s for Local Trigger\n",branchname);
652       }
653    }
654 }
655
656 //___________________________________________
657 void AliMUON::SetTreeAddress()
658 {
659   // Set branch address for the Hits and Digits Tree.
660   char branchname[30];
661   AliDetector::SetTreeAddress();
662
663   TBranch *branch;
664   TTree *treeH = gAlice->TreeH();
665   TTree *treeD = gAlice->TreeD();
666   TTree *treeR = gAlice->TreeR();
667
668   if (treeH) {
669     if (fPadHits) {
670       branch = treeH->GetBranch("MUONCluster");
671       if (branch) branch->SetAddress(&fPadHits);
672     }
673   }
674
675   if (treeD) {
676       for (int i=0; i<AliMUONConstants::NCh(); i++) {
677           sprintf(branchname,"%sDigits%d",GetName(),i+1);
678           if (fDchambers) {
679               branch = treeD->GetBranch(branchname);
680               if (branch) branch->SetAddress(&((*fDchambers)[i]));
681           }
682       }
683   }
684
685   // printf("SetTreeAddress --- treeR address  %p \n",treeR);
686
687   if (treeR) {
688       for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
689           sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
690           if (fRawClusters) {
691               branch = treeR->GetBranch(branchname);
692               if (branch) branch->SetAddress(&((*fRawClusters)[i]));
693           }
694       }
695
696       if (fLocalTrigger) {
697         branch = treeR->GetBranch("MUONLocalTrigger");
698         if (branch) branch->SetAddress(&fLocalTrigger);
699       }
700       if (fGlobalTrigger) {
701         branch = treeR->GetBranch("MUONGlobalTrigger");
702         if (branch) branch->SetAddress(&fGlobalTrigger);
703       }
704   }
705 }
706 //___________________________________________
707 void AliMUON::ResetHits()
708 {
709   // Reset number of clusters and the cluster array for this detector
710   AliDetector::ResetHits();
711   fNPadHits = 0;
712   if (fPadHits) fPadHits->Clear();
713 }
714
715 //____________________________________________
716 void AliMUON::ResetDigits()
717 {
718     //
719     // Reset number of digits and the digits array for this detector
720     //
721     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
722       //PH      if ((*fDchambers)[i])    ((TClonesArray*)(*fDchambers)[i])->Clear();
723         if ((*fDchambers)[i])    ((TClonesArray*)fDchambers->At(i))->Clear();
724         if (fNdch)  fNdch[i]=0;
725     }
726 }
727 //____________________________________________
728 void AliMUON::ResetRawClusters()
729 {
730     //
731     // Reset number of raw clusters and the raw clust array for this detector
732     //
733     for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
734       //PH      if ((*fRawClusters)[i])    ((TClonesArray*)(*fRawClusters)[i])->Clear();
735         if ((*fRawClusters)[i])    ((TClonesArray*)fRawClusters->At(i))->Clear();
736         if (fNrawch)  fNrawch[i]=0;
737     }
738 }
739
740 //____________________________________________
741 void AliMUON::ResetTrigger()
742 {
743   //  Reset Local and Global Trigger 
744   fNGlobalTrigger = 0;
745   if (fGlobalTrigger) fGlobalTrigger->Clear();
746   fNLocalTrigger = 0;
747   if (fLocalTrigger) fLocalTrigger->Clear();
748 }
749
750 //____________________________________________
751 void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
752 {
753 // Set the pad size for chamber id and cathode isec
754     Int_t i=2*(id-1);
755     //PH    ((AliMUONChamber*) (*fChambers)[i])  ->SetPadSize(isec,p1,p2);
756     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2);
757     ((AliMUONChamber*) fChambers->At(i))  ->SetPadSize(isec,p1,p2);
758     ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
759 }
760
761 //___________________________________________
762 void AliMUON::SetChambersZ(const Float_t *Z)
763 {
764   // Set Z values for all chambers (tracking and trigger)
765   // from the array pointed to by "Z"
766     for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
767       //PH      ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
768         ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
769     return;
770 }
771
772 //___________________________________________
773 void AliMUON::SetChambersZToDefault()
774 {
775   // Set Z values for all chambers (tracking and trigger)
776   // to default values
777   SetChambersZ(AliMUONConstants::DefaultChamberZ());
778   return;
779 }
780
781 //___________________________________________
782 void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
783 {
784 // Set the inverse charge slope for chamber id
785     Int_t i=2*(id-1);
786     //PH    ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1);
787     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1);
788     ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
789     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
790 }
791
792 //___________________________________________
793 void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
794 {
795 // Set sigma of charge spread for chamber id
796     Int_t i=2*(id-1);
797     //PH    ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
798     //PH    ((AliMUONChamber*) fChambers->Ati+1])->SetChargeSpread(p1,p2);
799     ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
800     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
801 }
802
803 //___________________________________________
804 void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
805 {
806 // Set integration limits for charge spread
807     Int_t i=2*(id-1);
808     //PH    ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
809     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
810     ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
811     ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
812 }
813
814 //___________________________________________
815 void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
816 {
817 // Set maximum number for ADCcounts (saturation)
818     Int_t i=2*(id-1);
819     //PH    ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1);
820     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1);
821     ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
822     ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
823 }
824
825 //___________________________________________
826 void AliMUON::SetMaxStepGas(Float_t p1)
827 {
828 // Set stepsize in gas
829      fMaxStepGas=p1;
830 }
831
832 //___________________________________________
833 void AliMUON::SetMaxStepAlu(Float_t p1)
834 {
835 // Set step size in Alu
836     fMaxStepAlu=p1;
837 }
838
839 //___________________________________________
840 void AliMUON::SetMaxDestepGas(Float_t p1)
841 {
842 // Set maximum step size in Gas
843     fMaxDestepGas=p1;
844 }
845
846 //___________________________________________
847 void AliMUON::SetMaxDestepAlu(Float_t p1)
848 {
849 // Set maximum step size in Alu
850     fMaxDestepAlu=p1;
851 }
852 //___________________________________________
853 void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
854 {
855 // Set acceptance cuts 
856    fAccCut=acc;
857    fAccMin=angmin*TMath::Pi()/180;
858    fAccMax=angmax*TMath::Pi()/180;
859    Int_t ch;
860    if (acc) {
861        for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
862            // Loop over 2 chambers in the station
863            for (Int_t stCH = 0; stCH < 2; stCH++) {
864                ch = 2 * st + stCH;
865 //         Set chamber inner and outer radius according to acceptance cuts
866                Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
867                Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
868            } // chamber loop
869        } // station loop
870    }
871 }
872 //___________________________________________
873 void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
874 {
875 // Set the segmentation for chamber id cathode isec
876   //PH    ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
877     ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
878
879 }
880 //___________________________________________
881 void   AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
882 {
883 // Set the response for chamber id
884   //PH    ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
885     ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
886 }
887
888 void   AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
889 {
890 // Set ClusterFinder for chamber id
891   //PH    ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
892     ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
893 }
894
895 void   AliMUON::SetNsec(Int_t id, Int_t nsec)
896 {
897 // Set number of segmented cathods for chamber id
898   //PH    ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
899     ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
900 }
901
902 //___________________________________________
903 void AliMUON::SDigits2Digits()
904 {
905
906 // write TreeD here 
907
908     if (!fMerger) {
909       if (gAlice->GetDebug()>0) {
910         cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl;
911         cerr<<" no merging, just digitization of 1 event will be done"<<endl;
912       }
913       fMerger = new AliMUONMerger();
914     }
915     fMerger->Init();
916     fMerger->Digitise();
917     char hname[30];
918     sprintf(hname,"TreeD%d",gAlice->GetHeader()->GetEvent());
919     gAlice->TreeD()->Write(hname,TObject::kOverwrite);
920     gAlice->TreeD()->Reset();
921 }
922
923 //___________________________________________
924 // To be removed
925 void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
926                           Float_t eloss, Float_t tof,  Int_t idvol)
927 {
928 //
929 //  Calls the charge disintegration method of the current chamber and adds
930 //  the simulated cluster to the root treee 
931 //
932     Int_t clhits[7];
933     Float_t newclust[6][500];
934     Int_t nnew;
935     
936     
937 //
938 //  Integrated pulse height on chamber
939
940     
941     clhits[0]=fNhits+1;
942 //
943 //
944 //    if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
945     
946
947     //PH    ((AliMUONChamber*) (*fChambers)[idvol])
948     ((AliMUONChamber*) fChambers->At(idvol))
949         ->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust);
950     Int_t ic=0;
951 //    if (idvol == 6) printf("\n nnew  %d \n", nnew);
952 //
953 //  Add new clusters
954     for (Int_t i=0; i<nnew; i++) {
955         if (Int_t(newclust[3][i]) > 0) {
956             ic++;
957 // Cathode plane
958             clhits[1] = Int_t(newclust[5][i]);
959 //  Cluster Charge
960             clhits[2] = Int_t(newclust[0][i]);
961 //  Pad: ix
962             clhits[3] = Int_t(newclust[1][i]);
963 //  Pad: iy 
964             clhits[4] = Int_t(newclust[2][i]);
965 //  Pad: charge
966             clhits[5] = Int_t(newclust[3][i]);
967 //  Pad: chamber sector
968             clhits[6] = Int_t(newclust[4][i]);
969             
970             AddPadHit(clhits);
971         }
972     }
973 }
974
975 //___________________________________________
976 void AliMUON::Trigger(Int_t nev){
977 // call the Trigger Algorithm and fill TreeR
978
979   Int_t singlePlus[3]  = {0,0,0}; 
980   Int_t singleMinus[3] = {0,0,0}; 
981   Int_t singleUndef[3] = {0,0,0};
982   Int_t pairUnlike[3]  = {0,0,0}; 
983   Int_t pairLike[3]    = {0,0,0};
984
985   ResetTrigger();
986   AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
987   decision->Trigger();   
988   decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
989                              pairUnlike, pairLike);
990 // add a local trigger in the list 
991   AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
992   Int_t i;
993   
994   for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) { 
995       if(decision->GetITrigger(icirc)==1) {
996           Int_t localtr[7]={0,0,0,0,0,0,0};      
997           Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
998           decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
999           localtr[0] = icirc;
1000           localtr[1] = decision->GetStripX11(icirc);
1001           localtr[2] = decision->GetDev(icirc);
1002           localtr[3] = decision->GetStripY11(icirc);
1003           for (i=0; i<2; i++) {    // convert the Lut output in 1 digit 
1004               localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
1005               localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
1006               localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
1007           }
1008           AddLocalTrigger(localtr);  // add a local trigger in the list
1009       }
1010   }
1011   delete decision;
1012
1013   gAlice->TreeR()->Fill();
1014   ResetTrigger();
1015   char hname[30];
1016   sprintf(hname,"TreeR%d",nev);
1017   gAlice->TreeR()->Write(hname,TObject::kOverwrite);
1018   gAlice->TreeR()->Reset();
1019   printf("\n End of trigger for event %d", nev);
1020 }
1021
1022
1023 //____________________________________________
1024 void AliMUON::Digits2Reco()
1025 {
1026   FindClusters();
1027   Int_t nev = gAlice->GetHeader()->GetEvent();
1028   gAlice->TreeR()->Fill();
1029   char hname[30];
1030   sprintf(hname,"TreeR%d", nev);
1031   gAlice->TreeR()->Write(hname);
1032   gAlice->TreeR()->Reset();
1033   ResetRawClusters();        
1034   printf("\n End of cluster finding for event %d", nev);
1035 }
1036
1037 void AliMUON::FindClusters()
1038 {
1039 //
1040 //  Perform cluster finding
1041 //
1042     TClonesArray *dig1, *dig2;
1043     Int_t ndig, k;
1044     dig1 = new TClonesArray("AliMUONDigit",1000);
1045     dig2 = new TClonesArray("AliMUONDigit",1000);
1046     AliMUONDigit *digit;
1047 //
1048 // Loop on chambers and on cathode planes
1049 //
1050     ResetRawClusters();        
1051     for (Int_t ich = 0; ich < 10; ich++) {
1052       //PH      AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
1053         AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
1054         AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
1055     
1056         gAlice->ResetDigits();
1057         gAlice->TreeD()->GetEvent(0);
1058         TClonesArray *muonDigits = this->DigitsAddress(ich);
1059         ndig=muonDigits->GetEntriesFast();
1060         printf("\n 1 Found %d digits in %p %d", ndig, muonDigits,ich);
1061         TClonesArray &lhits1 = *dig1;
1062         Int_t n = 0;
1063         for (k = 0; k < ndig; k++) {
1064             digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
1065             if (rec->TestTrack(digit->Track(0)))
1066                 new(lhits1[n++]) AliMUONDigit(*digit);
1067         }
1068         gAlice->ResetDigits();
1069         gAlice->TreeD()->GetEvent(1);
1070         muonDigits  = this->DigitsAddress(ich);
1071         ndig=muonDigits->GetEntriesFast();
1072         printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
1073         TClonesArray &lhits2 = *dig2;
1074         n=0;
1075         
1076         for (k=0; k<ndig; k++) {
1077             digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
1078             if (rec->TestTrack(digit->Track(0)))
1079             new(lhits2[n++]) AliMUONDigit(*digit);
1080         }
1081
1082         if (rec) {       
1083             AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
1084             rec->FindRawClusters();
1085         }
1086         dig1->Delete();
1087         dig2->Delete();
1088     } // for ich
1089     delete dig1;
1090     delete dig2;
1091 }
1092  
1093 #ifdef never
1094 void AliMUON::Streamer(TBuffer &R__b)
1095 {
1096    // Stream an object of class AliMUON.
1097       AliMUONChamber        *iChamber;
1098       AliMUONTriggerCircuit *iTriggerCircuit;
1099       AliSegmentation       *segmentation;
1100       AliMUONResponse       *response;
1101       TClonesArray          *digitsaddress;
1102       TClonesArray          *rawcladdress;
1103       Int_t i;
1104       if (R__b.IsReading()) {
1105           Version_t R__v = R__b.ReadVersion(); if (R__v) { }
1106           AliDetector::Streamer(R__b);
1107           R__b >> fNPadHits;
1108           R__b >> fPadHits; // diff
1109           R__b >> fNLocalTrigger;       
1110           R__b >> fLocalTrigger;       
1111           R__b >> fNGlobalTrigger;       
1112           R__b >> fGlobalTrigger;   
1113           R__b >> fDchambers;
1114           R__b >> fRawClusters;
1115           R__b.ReadArray(fNdch);
1116           R__b.ReadArray(fNrawch);
1117           R__b >> fAccCut;
1118           R__b >> fAccMin;
1119           R__b >> fAccMax; 
1120           R__b >> fChambers;
1121           R__b >> fTriggerCircuits;
1122           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
1123               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
1124               iTriggerCircuit->Streamer(R__b);
1125           }
1126 // Stream chamber related information
1127           for (i =0; i<AliMUONConstants::NCh(); i++) {
1128               iChamber=(AliMUONChamber*) (*fChambers)[i];
1129               iChamber->Streamer(R__b);
1130               if (iChamber->Nsec()==1) {
1131                   segmentation=iChamber->SegmentationModel(1);
1132                   if (segmentation)
1133                       segmentation->Streamer(R__b);
1134               } else {
1135                   segmentation=iChamber->SegmentationModel(1);
1136                   if (segmentation)
1137                       segmentation->Streamer(R__b);
1138                   if (segmentation)
1139                       segmentation=iChamber->SegmentationModel(2);
1140                   segmentation->Streamer(R__b);
1141               }
1142               response=iChamber->ResponseModel();
1143               if (response)
1144                   response->Streamer(R__b);       
1145               digitsaddress=(TClonesArray*) (*fDchambers)[i];
1146               digitsaddress->Streamer(R__b);
1147               if (i < AliMUONConstants::NTrackingCh()) {
1148                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
1149                   rawcladdress->Streamer(R__b);
1150               }
1151           }
1152           
1153       } else {
1154           R__b.WriteVersion(AliMUON::IsA());
1155           AliDetector::Streamer(R__b);
1156           R__b << fNPadHits;
1157           R__b << fPadHits; // diff
1158           R__b << fNLocalTrigger;       
1159           R__b << fLocalTrigger;       
1160           R__b << fNGlobalTrigger;       
1161           R__b << fGlobalTrigger; 
1162           R__b << fDchambers;
1163           R__b << fRawClusters;
1164           R__b.WriteArray(fNdch, AliMUONConstants::NCh());
1165           R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
1166           
1167           R__b << fAccCut;
1168           R__b << fAccMin;
1169           R__b << fAccMax; 
1170           
1171           R__b << fChambers;
1172           R__b << fTriggerCircuits;
1173           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
1174               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
1175               iTriggerCircuit->Streamer(R__b);
1176           }
1177           for (i =0; i<AliMUONConstants::NCh(); i++) {
1178               iChamber=(AliMUONChamber*) (*fChambers)[i];
1179               iChamber->Streamer(R__b);
1180               if (iChamber->Nsec()==1) {
1181                   segmentation=iChamber->SegmentationModel(1);
1182                   if (segmentation)
1183                       segmentation->Streamer(R__b);
1184               } else {
1185                   segmentation=iChamber->SegmentationModel(1);
1186                   if (segmentation)
1187                       segmentation->Streamer(R__b);
1188                   segmentation=iChamber->SegmentationModel(2);
1189                   if (segmentation)
1190                       segmentation->Streamer(R__b);
1191               }
1192               response=iChamber->ResponseModel();
1193               if (response)
1194                   response->Streamer(R__b);
1195               digitsaddress=(TClonesArray*) (*fDchambers)[i];
1196               digitsaddress->Streamer(R__b);
1197               if (i < AliMUONConstants::NTrackingCh()) {
1198                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
1199                   rawcladdress->Streamer(R__b);
1200               }
1201           }
1202       }
1203 }
1204 #endif
1205
1206 AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters) 
1207 {
1208 // to be removed
1209     // Initialise the pad iterator
1210     // Return the address of the first padhit for hit
1211     TClonesArray *theClusters = clusters;
1212     Int_t nclust = theClusters->GetEntriesFast();
1213     if (nclust && hit->PHlast() > 0) {
1214         AliMUON::fMaxIterPad=hit->PHlast();
1215         AliMUON::fCurIterPad=hit->PHfirst();
1216         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
1217     } else {
1218         return 0;
1219     }
1220 }
1221
1222 AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters) 
1223 {
1224   // To be removed
1225 // Get next pad (in iterator) 
1226 //
1227     AliMUON::fCurIterPad++;
1228     if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
1229         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
1230     } else {
1231         return 0;
1232     }
1233 }
1234
1235
1236 AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
1237 {
1238 //
1239 //  Return rawcluster (icluster) for chamber ichamber and cathode icathod
1240 //  Obsolete ??
1241     TClonesArray *muonRawCluster  = RawClustAddress(ichamber);
1242     ResetRawClusters();
1243     TTree *treeR = gAlice->TreeR();
1244     Int_t nent=(Int_t)treeR->GetEntries();
1245     treeR->GetEvent(nent-2+icathod-1);
1246     //treeR->GetEvent(icathod);
1247     //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
1248
1249     AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
1250     //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
1251     
1252     return  mRaw;
1253 }
1254  
1255 void   AliMUON::SetMerger(AliMUONMerger* merger)
1256 {
1257 // Set pointer to merger 
1258     fMerger = merger;
1259 }
1260
1261 AliMUONMerger*  AliMUON::Merger()
1262 {
1263 // Return pointer to merger
1264     return fMerger;
1265 }
1266
1267
1268
1269 AliMUON& AliMUON::operator = (const AliMUON& rhs)
1270 {
1271 // copy operator
1272 // dummy version
1273     return *this;
1274 }
1275
1276 ////////////////////////////////////////////////////////////////////////
1277 void AliMUON::MakeBranchInTreeD(TTree *treeD, const char *file)
1278 {
1279     //
1280     // Create TreeD branches for the MUON.
1281     //
1282
1283   const Int_t kBufferSize = 4000;
1284   char branchname[30];
1285     
1286   //
1287   // one branch for digits per chamber
1288   // 
1289   for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
1290     sprintf(branchname,"%sDigits%d",GetName(),i+1);     
1291     if (fDchambers && treeD) {
1292       MakeBranchInTree(treeD, 
1293                        branchname, &((*fDchambers)[i]), kBufferSize, file);
1294 //      printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
1295     }
1296   }
1297 }
1298
1299 //___________________________________________
1300