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