New MUON data container AliMUONData implementation
[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 /* $Id$ */
17
18
19 ///////////////////////////////////////////////
20 //  Manager and hits classes for set:MUON     //
21 ////////////////////////////////////////////////
22
23 #include "Riostream.h"
24
25 #include <AliPDG.h>
26 #include <TBRIK.h>
27 #include <TCanvas.h>
28 #include <TDirectory.h>
29 #include <TFile.h>
30 #include <TGeometry.h>
31 #include <TMinuit.h>
32 #include <TNode.h> 
33 #include <TNtuple.h>
34 #include <TObjArray.h>
35 #include <TObject.h>
36 #include <TObjectTable.h>
37 #include <TPad.h>
38 #include <TParticle.h>
39 #include <TROOT.h>
40 #include <TRandom.h> 
41 #include <TRotMatrix.h>
42 #include <TTUBE.h>
43 #include <TTUBE.h>
44 #include <TTree.h> 
45 #include <TVector.h>
46 #include <TVirtualMC.h>
47
48 #include "AliConst.h" 
49 #include "AliHeader.h"
50 #include "AliHitMap.h"
51 #include "AliLoader.h"
52 #include "AliMUONLoader.h"
53 #include "AliMUON.h"
54 #include "AliMUONChamberTrigger.h"
55 #include "AliMUONClusterFinderVS.h"
56 #include "AliMUONClusterInput.h"
57 #include "AliMUONConstants.h"
58 #include "AliMUONDigit.h"
59 #include "AliMUONGlobalTrigger.h"
60 #include "AliMUONHit.h"
61 #include "AliMUONHitMapA1.h"
62 #include "AliMUONLocalTrigger.h"
63 #include "AliMUONMerger.h"      
64 #include "AliMUONPadHit.h"
65 #include "AliMUONRawCluster.h"
66 #include "AliMUONTransientDigit.h"
67 #include "AliMUONTriggerCircuit.h"
68 #include "AliMUONTriggerDecision.h"
69 #include "AliRun.h"     
70
71
72 // Defaults parameters for Z positions of chambers
73 // taken from values for "stations" in AliMUON::AliMUON
74 //     const Float_t zch[7]={528, 690., 975., 1249., 1449., 1610, 1710.};
75 // and from array "dstation" in AliMUONv1::CreateGeometry
76 //          Float_t dstation[5]={20., 20., 20, 20., 20.};
77 //     for tracking chambers,
78 //          according to (Z1 = zch - dstation) and  (Z2 = zch + dstation)
79 //          for the first and second chambers in the station, respectively,
80 // and from "DTPLANES" in AliMUONv1::CreateGeometry
81 //           const Float_t DTPLANES = 15.;
82 //     for trigger chambers,
83 //          according to (Z1 = zch) and  (Z2 = zch + DTPLANES)
84 //          for the first and second chambers in the station, respectively
85
86 ClassImp(AliMUON)
87 //__________________________________________________________________
88 AliMUON::AliMUON()
89 {
90 // Default Constructor
91 //
92     fNCh             = 0;
93     fNTrackingCh     = 0;
94     fIshunt          = 0;
95     fChambers        = 0;
96     fTriggerCircuits = 0;
97     fAccMin          = 0.;
98     fAccMax          = 0.;   
99     fAccCut          = kFALSE;
100     fMerger          = 0;
101     fFileName        = 0;
102 }
103 //__________________________________________________________________
104 AliMUON::AliMUON(const char *name, const char *title)
105   : AliDetector(name,title)
106 {
107 //Begin_Html
108 /*
109 <img src="gif/alimuon.gif">
110 */
111 //End_Html
112   fMUONData  = 0x0;
113   fIshunt     =  0;
114
115   fNCh             = AliMUONConstants::NCh(); 
116   fNTrackingCh     = AliMUONConstants::NTrackingCh();
117
118   SetMarkerColor(kRed);//
119 //
120 // Creating List of Chambers
121     Int_t ch;
122     fChambers = new TObjArray(AliMUONConstants::NCh());
123     // Loop over stations
124     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
125       // Loop over 2 chambers in the station
126       for (Int_t stCH = 0; stCH < 2; stCH++) {
127         //
128         //    
129         //    Default Parameters for Muon Tracking Stations
130         ch = 2 * st + stCH;
131         if (ch < AliMUONConstants::NTrackingCh()) {
132           fChambers->AddAt(new AliMUONChamber(ch),ch);
133         } else {
134           fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
135         }
136         AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
137         chamber->SetGid(0);
138         // Default values for Z of chambers
139         chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
140         //
141         chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
142         //          Set chamber inner and outer radius to default
143         chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
144         chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
145         //
146       } // Chamber stCH (0, 1) in 
147     }     // Station st (0...)
148     
149     fMaxStepGas=0.01; 
150     fMaxStepAlu=0.1; 
151     fMaxDestepGas=-1;
152     fMaxDestepAlu=-1;
153     
154     fMaxIterPad   = 0;
155     fCurIterPad   = 0;
156     
157     fAccMin          = 0.;
158     fAccMax          = 0.;   
159     fAccCut          = kFALSE;
160     
161     // cp new design of AliMUONTriggerDecision
162     fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
163     for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
164       fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);          
165     }
166     fMerger = 0;
167 }
168 //____________________________________________________________________
169 AliMUON::AliMUON(const AliMUON& rMUON):AliDetector(rMUON)
170 {
171 // Dummy copy constructor
172     ;
173     
174 }
175 //____________________________________________________________________
176 AliMUON::~AliMUON()
177 {
178 // Destructor
179   if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
180   fIshunt  = 0;
181   if (fMerger) delete fMerger;
182 }
183 //____________________________________________________________________
184 void AliMUON::BuildGeometry()
185 {
186 // Geometry for event display
187   for (Int_t i=0; i<7; i++) {
188     for (Int_t j=0; j<2; j++) {
189       Int_t id=2*i+j+1;
190       this->Chamber(id-1).SegmentationModel(1)->Draw("eventdisplay");
191     }
192   }
193 }
194 //___________________________________________________________________
195 Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
196 {
197   return 9999;
198 }
199 //__________________________________________________________________
200 void  AliMUON::SetTreeAddress()
201 {
202   GetMUONData()->SetLoader(fLoader); 
203   GetMUONData()->SetTreeAddress("H,D,RC");
204 }
205
206 //____________________________________________________________________
207 void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
208 {
209 // Set the pad size for chamber id and cathode isec
210     Int_t i=2*(id-1);
211     ((AliMUONChamber*) fChambers->At(i))  ->SetPadSize(isec,p1,p2);
212     ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
213 }
214
215 //___________________________________________
216 void AliMUON::SetChambersZ(const Float_t *Z)
217 {
218   // Set Z values for all chambers (tracking and trigger)
219   // from the array pointed to by "Z"
220     for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
221         ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
222     return;
223 }
224 //_________________________________________________________________
225 void AliMUON::SetChambersZToDefault()
226 {
227   // Set Z values for all chambers (tracking and trigger)
228   // to default values
229   SetChambersZ(AliMUONConstants::DefaultChamberZ());
230   return;
231 }
232 //_________________________________________________________________
233 void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
234 {
235 // Set the inverse charge slope for chamber id
236     Int_t i=2*(id-1);    //PH    ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
237     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
238     ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
239     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
240 }
241 //__________________________________________________________________
242 void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
243 {
244 // Set sigma of charge spread for chamber id
245     Int_t i=2*(id-1);
246     ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
247     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
248 }
249 //___________________________________________________________________
250 void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
251 {
252 // Set integration limits for charge spread
253     Int_t i=2*(id-1);
254     ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
255     ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
256 }
257
258 //__________________________________________________________________
259 void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
260 {
261 // Set maximum number for ADCcounts (saturation)
262     Int_t i=2*(id-1);
263     ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
264     ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
265 }
266 //__________________________________________________________________
267 void AliMUON::SetMaxStepGas(Float_t p1)
268 {
269 // Set stepsize in gas
270   fMaxStepGas=p1;
271 }
272 //__________________________________________________________________
273 void AliMUON::SetMaxStepAlu(Float_t p1)
274 {
275 // Set step size in Alu
276     fMaxStepAlu=p1;
277 }
278 //__________________________________________________________________
279 void AliMUON::SetMaxDestepGas(Float_t p1)
280 {
281 // Set maximum step size in Gas
282     fMaxDestepGas=p1;
283 }
284 //__________________________________________________________________
285 void AliMUON::SetMaxDestepAlu(Float_t p1)
286 {
287 // Set maximum step size in Alu
288   fMaxDestepAlu=p1;
289 }
290 //___________________________________________________________________
291 void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
292 {
293 // Set acceptance cuts 
294   fAccCut=acc;
295   fAccMin=angmin*TMath::Pi()/180;
296   fAccMax=angmax*TMath::Pi()/180;
297   Int_t ch;
298   if (acc) {
299     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
300       // Loop over 2 chambers in the station
301       for (Int_t stCH = 0; stCH < 2; stCH++) {
302         ch = 2 * st + stCH;
303         //         Set chamber inner and outer radius according to acceptance cuts
304         Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
305         Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
306       } // chamber loop
307     } // station loop
308   }
309 }
310 //____________________________________________________________________
311 void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
312 {
313 // Set the segmentation for chamber id cathode isec
314     ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
315
316 }
317 //____________________________________________________________________
318 void   AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
319 {
320 // Set the response for chamber id
321     ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
322 }
323 //____________________________________________________________________
324 void   AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
325 {
326 // Set ClusterFinder for chamber id
327     ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
328 }
329 //____________________________________________________________________
330 void   AliMUON::SetNsec(Int_t id, Int_t nsec)
331 {
332 // Set number of segmented cathods for chamber id
333     ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
334 }
335 //_____________________________________________________________________
336 void AliMUON::SDigits2Digits()
337 {
338
339 // write TreeD here 
340
341     if (!fMerger) {
342       if (gAlice->GetDebug()>0) {
343         cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl;
344         cerr<<" no merging, just digitization of 1 event will be done"<<endl;
345       }
346       fMerger = new AliMUONMerger();
347     }
348     fMerger->Init();
349     fMerger->Digitise();
350     char hname[30];
351     //    sprintf(hname,"TreeD%d",fLoader->GetHeader()->GetEvent());
352     fLoader->TreeD()->Write(hname,TObject::kOverwrite);
353     fLoader->TreeD()->Reset();
354 }
355
356 //_______________________________________________________________________
357 AliLoader* AliMUON::MakeLoader(const char* topfoldername)
358
359 //builds standard getter (AliLoader type)
360 //if detector wants to use castomized getter, it must overload this method
361
362  if (GetDebug())
363    Info("MakeLoader",
364         "Creating standard getter for detector %s. Top folder is %s.",
365          GetName(),topfoldername);
366      
367  fLoader   = new AliLoader(GetName(),topfoldername);
368  fMUONData = new AliMUONData(fLoader,GetName(),GetName()); 
369  return fLoader;
370 }
371
372 //_______________________________________________________________________
373 void AliMUON::Trigger(Int_t nev){
374 // call the Trigger Algorithm and fill TreeR
375
376   Int_t singlePlus[3]  = {0,0,0}; 
377   Int_t singleMinus[3] = {0,0,0}; 
378   Int_t singleUndef[3] = {0,0,0};
379   Int_t pairUnlike[3]  = {0,0,0}; 
380   Int_t pairLike[3]    = {0,0,0};
381   
382   ResetTrigger();
383   AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
384   decision->Trigger();   
385   decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
386                              pairUnlike, pairLike);
387   
388   // add a local trigger in the list 
389   GetMUONData()->AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
390   Int_t i;
391   
392   for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) { 
393     if(decision->GetITrigger(icirc)==1) {
394       Int_t localtr[7]={0,0,0,0,0,0,0};      
395       Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
396       decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
397       localtr[0] = icirc;
398       localtr[1] = decision->GetStripX11(icirc);
399       localtr[2] = decision->GetDev(icirc);
400       localtr[3] = decision->GetStripY11(icirc);
401       for (i=0; i<2; i++) {    // convert the Lut output in 1 digit 
402         localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
403         localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
404         localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
405       }
406       GetMUONData()->AddLocalTrigger(localtr);  // add a local trigger in the list
407     }
408   }
409   
410   delete decision;
411   
412   fLoader->TreeR()->Fill();
413   //  char hname[30];
414   //  sprintf(hname,"TreeR%d",nev);
415   //  fLoader->TreeR()->Write(hname,TObject::kOverwrite);
416   //  fLoader->TreeR()->Reset();
417   fLoader->WriteRecPoints("OVERWRITE");
418   ResetTrigger();
419   
420   printf("\n End of trigger for event %d", nev);
421 }
422
423 //____________________________________________________________________
424 void AliMUON::Digits2Reco()
425 {
426   FindClusters();
427   Int_t nev = gAlice->GetHeader()->GetEvent();
428   fLoader->TreeR()->Fill();
429   // char hname[30];
430   // sprintf(hname,"TreeR%d", nev);
431   //fLoader->TreeR()->Write(hname);
432   //fLoader->TreeR()->Reset();
433   fLoader->WriteRecPoints("OVERWRITE");
434   GetMUONData()->ResetRawClusters();        
435   printf("\n End of cluster finding for event %d", nev);
436 }
437 //____________________________________________________________________
438 void AliMUON::FindClusters()
439 {
440 //
441 //  Perform cluster finding
442 //
443     TClonesArray *dig1, *dig2;
444     Int_t ndig, k;
445     dig1 = new TClonesArray("AliMUONDigit",1000);
446     dig2 = new TClonesArray("AliMUONDigit",1000);
447     AliMUONDigit *digit;
448 // Loop on chambers and on cathode planes
449 //
450     ResetRawClusters();        
451     TClonesArray * muonDigits;
452
453     for (Int_t ich = 0; ich < 10; ich++) {
454       //PH      AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
455         AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
456         AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
457     
458         ResetDigits();
459         fLoader->TreeD()->GetEvent(0);
460         //TClonesArray *
461         muonDigits = GetMUONData()->Digits(ich,0);  // cathode plane not yet operational
462         ndig=muonDigits->GetEntriesFast();
463         printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich);
464         TClonesArray &lhits1 = *dig1;
465         Int_t n = 0;
466         for (k = 0; k < ndig; k++) {
467             digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
468             if (rec->TestTrack(digit->Track(0)))
469                 new(lhits1[n++]) AliMUONDigit(*digit);
470         }
471         ResetDigits();
472         fLoader->TreeD()->GetEvent(1);
473         //muonDigits  = this->DigitsAddress(ich);
474         muonDigits =  GetMUONData()->Digits(ich,1);  // cathode plane not yet operational
475         ndig=muonDigits->GetEntriesFast();
476         printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
477         TClonesArray &lhits2 = *dig2;
478         n=0;
479         
480         for (k=0; k<ndig; k++) {
481             digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
482             if (rec->TestTrack(digit->Track(0)))
483             new(lhits2[n++]) AliMUONDigit(*digit);
484         }
485
486         if (rec) {       
487             AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
488             rec->FindRawClusters();
489         }
490         dig1->Delete();
491         dig2->Delete();
492     } // for ich
493     delete dig1;
494     delete dig2;
495 }
496 //______________________________________________________________________
497 #ifdef never
498 void AliMUON::Streamer(TBuffer &R__b)_
499 {
500    // Stream an object of class AliMUON.
501       AliMUONChamber        *iChamber;
502       AliMUONTriggerCircuit *iTriggerCircuit;
503       AliSegmentation       *segmentation;
504       AliMUONResponse       *response;
505       TClonesArray          *digitsaddress;
506       TClonesArray          *rawcladdress;
507       Int_t i;
508       if (R__b.IsReading()) {
509           Version_t R__v = R__b.ReadVersion(); if (R__v) { }
510           AliDetector::Streamer(R__b);
511           R__b >> fNPadHits;
512           R__b >> fPadHits; // diff
513           R__b >> fNLocalTrigger;       
514           R__b >> fLocalTrigger;       
515           R__b >> fNGlobalTrigger;       
516           R__b >> fGlobalTrigger;   
517           R__b >> fDchambers;
518           R__b >> fRawClusters;
519           R__b.ReadArray(fNdch);
520           R__b.ReadArray(fNrawch);
521           R__b >> fAccCut;
522           R__b >> fAccMin;
523           R__b >> fAccMax; 
524           R__b >> fChambers;
525           R__b >> fTriggerCircuits;
526           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
527               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
528               iTriggerCircuit->Streamer(R__b);
529           }
530 // Stream chamber related information
531           for (i =0; i<AliMUONConstants::NCh(); i++) {
532               iChamber=(AliMUONChamber*) (*fChambers)[i];
533               iChamber->Streamer(R__b);
534               if (iChamber->Nsec()==1) {
535                   segmentation=iChamber->SegmentationModel(1);
536                   if (segmentation)
537                       segmentation->Streamer(R__b);
538               } else {
539                   segmentation=iChamber->SegmentationModel(1);
540                   if (segmentation)
541                       segmentation->Streamer(R__b);
542                   if (segmentation)
543                       segmentation=iChamber->SegmentationModel(2);
544                   segmentation->Streamer(R__b);
545               }
546               response=iChamber->ResponseModel();
547               if (response)
548                   response->Streamer(R__b);       
549               digitsaddress=(TClonesArray*) (*fDchambers)[i];
550               digitsaddress->Streamer(R__b);
551               if (i < AliMUONConstants::NTrackingCh()) {
552                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
553                   rawcladdress->Streamer(R__b);
554               }
555           }
556           
557       } else {
558           R__b.WriteVersion(AliMUON::IsA());
559           AliDetector::Streamer(R__b);
560           R__b << fNPadHits;
561           R__b << fPadHits; // diff
562           R__b << fNLocalTrigger;       
563           R__b << fLocalTrigger;       
564           R__b << fNGlobalTrigger;       
565           R__b << fGlobalTrigger; 
566           R__b << fDchambers;
567           R__b << fRawClusters;
568           R__b.WriteArray(fNdch, AliMUONConstants::NCh());
569           R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
570           
571           R__b << fAccCut;
572           R__b << fAccMin;
573           R__b << fAccMax; 
574           
575           R__b << fChambers;
576           R__b << fTriggerCircuits;
577           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
578               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
579               iTriggerCircuit->Streamer(R__b);
580           }
581           for (i =0; i<AliMUONConstants::NCh(); i++) {
582               iChamber=(AliMUONChamber*) (*fChambers)[i];
583               iChamber->Streamer(R__b);
584               if (iChamber->Nsec()==1) {
585                   segmentation=iChamber->SegmentationModel(1);
586                   if (segmentation)
587                       segmentation->Streamer(R__b);
588               } else {
589                   segmentation=iChamber->SegmentationModel(1);
590                   if (segmentation)
591                       segmentation->Streamer(R__b);
592                   segmentation=iChamber->SegmentationModel(2);
593                   if (segmentation)
594                       segmentation->Streamer(R__b);
595               }
596               response=iChamber->ResponseModel();
597               if (response)
598                   response->Streamer(R__b);
599               digitsaddress=(TClonesArray*) (*fDchambers)[i];
600               digitsaddress->Streamer(R__b);
601               if (i < AliMUONConstants::NTrackingCh()) {
602                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
603                   rawcladdress->Streamer(R__b);
604               }
605           }
606       }
607 }
608 #endif
609 //_______________________________________________________________________
610 AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters) 
611 {
612 // to be removed
613     // Initialise the pad iterator
614     // Return the address of the first padhit for hit
615     TClonesArray *theClusters = clusters;
616     Int_t nclust = theClusters->GetEntriesFast();
617     if (nclust && hit->PHlast() > 0) {
618         AliMUON::fMaxIterPad=hit->PHlast();
619         AliMUON::fCurIterPad=hit->PHfirst();
620         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
621     } else {
622         return 0;
623     }
624 }
625 //_______________________________________________________________________
626 AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters) 
627 {
628   // To be removed
629 // Get next pad (in iterator) 
630 //
631     AliMUON::fCurIterPad++;
632     if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
633         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
634     } else {
635         return 0;
636     }
637 }
638 //_______________________________________________________________________
639
640 AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
641 {
642 //
643 //  Return rawcluster (icluster) for chamber ichamber and cathode icathod
644 //  Obsolete ??
645     TClonesArray *muonRawCluster  = GetMUONData()->RawClusters(ichamber);
646     ResetRawClusters();
647     TTree *treeR = fLoader->TreeR();
648     Int_t nent=(Int_t)treeR->GetEntries();
649     treeR->GetEvent(nent-2+icathod-1);
650     //treeR->GetEvent(icathod);
651     //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
652
653     AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
654     //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
655     
656     return  mRaw;
657 }
658 //________________________________________________________________________
659 void   AliMUON::SetMerger(AliMUONMerger* merger)
660 {
661 // Set pointer to merger 
662     fMerger = merger;
663 }
664 //________________________________________________________________________
665 AliMUONMerger*  AliMUON::Merger()
666 {
667 // Return pointer to merger
668     return fMerger;
669 }
670 //________________________________________________________________________
671 AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
672 {
673 // copy operator
674 // dummy version
675     return *this;
676 }
677