63e9994f370828629f67629169ccf4b09c4e8d80
[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 "AliMUON.h"
53 #include "AliMUONChamberTrigger.h"
54 #include "AliMUONClusterFinderVS.h"
55 #include "AliMUONClusterInput.h"
56 #include "AliMUONConstants.h"
57 #include "AliMUONDigit.h"
58 #include "AliMUONGlobalTrigger.h"
59 #include "AliMUONHit.h"
60 #include "AliMUONHitMapA1.h"
61 #include "AliMUONLocalTrigger.h"
62 #include "AliMUONMerger.h"      
63 #include "AliMUONPadHit.h"
64 #include "AliMUONRawCluster.h"
65 #include "AliMUONTransientDigit.h"
66 #include "AliMUONTriggerCircuit.h"
67 #include "AliMUONTriggerDecision.h"
68 #include "AliRun.h"     
69
70
71 // Defaults parameters for Z positions of chambers
72 // taken from values for "stations" in AliMUON::AliMUON
73 //     const Float_t zch[7]={528, 690., 975., 1249., 1449., 1610, 1710.};
74 // and from array "dstation" in AliMUONv1::CreateGeometry
75 //          Float_t dstation[5]={20., 20., 20, 20., 20.};
76 //     for tracking chambers,
77 //          according to (Z1 = zch - dstation) and  (Z2 = zch + dstation)
78 //          for the first and second chambers in the station, respectively,
79 // and from "DTPLANES" in AliMUONv1::CreateGeometry
80 //           const Float_t DTPLANES = 15.;
81 //     for trigger chambers,
82 //          according to (Z1 = zch) and  (Z2 = zch + DTPLANES)
83 //          for the first and second chambers in the station, respectively
84
85 ClassImp(AliMUON)
86 //___________________________________________
87 AliMUON::AliMUON()
88 {
89 // Default Constructor
90 //
91     fNCh             = 0;
92     fNTrackingCh     = 0;
93     fIshunt          = 0;
94     fPadHits         = 0;
95     fNPadHits        = 0;
96     fChambers        = 0;
97     fDchambers       = 0;
98     fTriggerCircuits = 0;  
99     fNdch            = 0;
100     fRawClusters     = 0;
101     fNrawch          = 0;
102     fGlobalTrigger   = 0;
103     fNLocalTrigger   = 0;
104     fLocalTrigger    = 0;
105     fNLocalTrigger   = 0;
106     fAccMin          = 0.;
107     fAccMax          = 0.;   
108     fAccCut          = kFALSE;
109     fMerger          = 0;
110     fFileName        = 0;
111 }
112  
113 //___________________________________________
114 AliMUON::AliMUON(const char *name, const char *title)
115        : AliDetector(name,title)
116 {
117 //Begin_Html
118 /*
119 <img src="gif/alimuon.gif">
120 */
121 //End_Html
122
123    fHits     = new TClonesArray("AliMUONHit",1000);
124    gAlice->AddHitList(fHits);
125    fPadHits = new TClonesArray("AliMUONPadHit",10000);
126    fNPadHits  =  0;
127    fIshunt     =  0;
128
129    fNCh             = AliMUONConstants::NCh(); 
130    fNTrackingCh     = AliMUONConstants::NTrackingCh();
131    fNdch            = new Int_t[fNCh];
132
133    fDchambers = new TObjArray(AliMUONConstants::NCh());
134
135    Int_t i;
136    
137    for (i=0; i<AliMUONConstants::NCh() ;i++) {
138        fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
139        fNdch[i]=0;
140    }
141
142    fNrawch      = new Int_t[fNTrackingCh];
143
144    fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
145
146    for (i=0; i<AliMUONConstants::NTrackingCh();i++) {
147        fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
148        fNrawch[i]=0;
149    }
150
151    fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);    
152    fNGlobalTrigger = 0;
153    fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);    
154    fNLocalTrigger = 0;
155
156    SetMarkerColor(kRed);
157 //
158 //
159 //
160 //
161
162     Int_t ch;
163
164     fChambers = new TObjArray(AliMUONConstants::NCh());
165
166     // Loop over stations
167     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
168       // Loop over 2 chambers in the station
169         for (Int_t stCH = 0; stCH < 2; stCH++) {
170 //
171 //    
172 //    Default Parameters for Muon Tracking Stations
173
174
175             ch = 2 * st + stCH;
176 //
177             if (ch < AliMUONConstants::NTrackingCh()) {
178               fChambers->AddAt(new AliMUONChamber(ch),ch);
179             } else {
180               fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
181             }
182             
183         //PH        AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
184             AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
185             
186             chamber->SetGid(0);
187             // Default values for Z of chambers
188             chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
189 //
190             chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
191 //          Set chamber inner and outer radius to default
192             chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
193             chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
194 //
195         } // Chamber stCH (0, 1) in 
196     }     // Station st (0...)
197 //    fChambers->SetLast(AliMUONConstants::NCh());
198     fMaxStepGas=0.01; 
199     fMaxStepAlu=0.1; 
200     fMaxDestepGas=-1;
201     fMaxDestepAlu=-1;
202 //
203    fMaxIterPad   = 0;
204    fCurIterPad   = 0;
205 //
206    fAccMin          = 0.;
207    fAccMax          = 0.;   
208    fAccCut          = kFALSE;
209
210    // cp new design of AliMUONTriggerDecision
211    fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
212    for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
213      fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);     
214
215    }
216      fMerger = 0;
217 }
218  
219 //___________________________________________
220 AliMUON::AliMUON(const AliMUON& rMUON):AliDetector(rMUON)
221 {
222 // Dummy copy constructor
223     ;
224     
225 }
226
227 AliMUON::~AliMUON()
228 {
229 // Destructor
230     if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
231     
232     fIshunt  = 0;
233  
234     // Delete TObjArrays
235  
236     if (fChambers){
237       fChambers->Delete();
238       delete fChambers;
239     }
240  
241     if (fTriggerCircuits){
242       fTriggerCircuits->Delete();
243       delete fTriggerCircuits;
244     }
245  
246     if (fDchambers){
247       fDchambers->Delete();
248       delete fDchambers;
249     }
250  
251     if (fRawClusters){
252       fRawClusters->Delete();
253       delete fRawClusters;
254     }
255
256     if (fNrawch) delete [] fNrawch;
257  
258     // Delete TClonesArrays
259  
260     if (fPadHits){
261       fPadHits->Delete();
262       delete fPadHits;
263     }
264  
265     if (fGlobalTrigger){
266       fGlobalTrigger->Delete();
267       delete fGlobalTrigger;
268     }
269     fNGlobalTrigger = 0;
270     
271     if (fLocalTrigger){
272       fLocalTrigger->Delete();
273       delete fLocalTrigger;
274     }
275     fNLocalTrigger = 0;
276
277     if (fHits) {
278       fHits->Delete();
279       delete fHits;
280     }
281
282     if (fMerger) delete fMerger;
283     if (fNdch) delete [] fNdch;
284
285 }
286  
287 //___________________________________________
288 void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
289 {
290   TClonesArray &lhits = *fHits;
291   new(lhits[fNhits++]) AliMUONHit(fIshunt,track,vol,hits);
292 }
293 //___________________________________________
294 void AliMUON::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber, 
295               Int_t idpart, Float_t X, Float_t Y, Float_t Z, 
296               Float_t tof, Float_t momentum, Float_t theta, 
297               Float_t phi, Float_t length, Float_t destep)
298 {
299   TClonesArray &lhits = *fHits;
300   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber, 
301                idpart, X, Y, Z, 
302                tof, momentum, theta, 
303                phi, length, destep);
304 }
305 //___________________________________________
306 void AliMUON::AddPadHit(Int_t *clhits)  // To be removed
307 {
308    TClonesArray &lclusters = *fPadHits;
309    new(lclusters[fNPadHits++]) AliMUONPadHit(clhits);
310 }
311 //_____________________________________________________________________________
312 void AliMUON::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
313 {
314     //
315     // Add a MUON digit to the list
316     //
317
318   //PH    TClonesArray &ldigits = * ((TClonesArray*)(*fDchambers)[id]);
319     TClonesArray &ldigits = * ( (TClonesArray*) fDchambers->At(id) );
320     new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
321 }
322
323 //_____________________________________________________________________________
324 void AliMUON::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
325 {
326     //
327     // Add a MUON digit to the list
328     //
329
330   //PH    TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
331     TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
332     new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
333 }
334
335 //___________________________________________
336 void AliMUON::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
337                                Int_t *singleUndef,
338                                Int_t *pairUnlike, Int_t *pairLike)
339 {
340 // add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
341   TClonesArray &globalTrigger = *fGlobalTrigger;
342   new(globalTrigger[fNGlobalTrigger++]) 
343     AliMUONGlobalTrigger(singlePlus, singleMinus,  singleUndef, pairUnlike, 
344                          pairLike);
345 }
346 //___________________________________________
347 void AliMUON::AddLocalTrigger(Int_t *localtr)
348 {
349 // add a MUON Local Trigger to the list
350   TClonesArray &localTrigger = *fLocalTrigger;
351   new(localTrigger[fNLocalTrigger++]) AliMUONLocalTrigger(localtr);
352 }
353
354 //___________________________________________
355 void AliMUON::BuildGeometry()
356 {
357 // Geometry for event display
358   for (Int_t i=0; i<7; i++) {
359     for (Int_t j=0; j<2; j++) {
360       Int_t id=2*i+j+1;
361       this->Chamber(id-1).SegmentationModel(1)->Draw("eventdisplay");
362     }
363   }
364 }
365
366 //___________________________________________
367 Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
368 {
369    return 9999;
370 }
371
372 //___________________________________________
373 void AliMUON::MakeBranch(Option_t* option)
374 {
375     //
376     // Create Tree branches for the MUON.
377     //
378     const Int_t kBufferSize = 4000;
379     char branchname[30];
380     sprintf(branchname,"%sCluster",GetName());
381     
382     
383     const char *cD = strstr(option,"D");
384     const char *cR = strstr(option,"R");
385     const char *cH = strstr(option,"H");
386
387     if (TreeH() && cH) 
388      {
389       if (fPadHits == 0x0) fPadHits = new TClonesArray("AliMUONPadHit",10000);
390       MakeBranchInTree(TreeH(), branchname, &fPadHits, kBufferSize, 0);
391       if (fHits == 0x0) fHits     = new TClonesArray("AliMUONHit",1000);
392      }
393     //it must be under fHits creation
394     AliDetector::MakeBranch(option);
395     
396     if (cD  && fLoader->TreeD()) {
397       //
398       // one branch for digits per chamber
399       // 
400       Int_t i;
401       if (fDchambers  == 0x0) 
402         {
403           fDchambers = new TObjArray(AliMUONConstants::NCh());
404           for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
405               fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
406           }
407         }
408     
409       for (i=0; i<AliMUONConstants::NCh() ;i++) 
410        {
411         sprintf(branchname,"%sDigits%d",GetName(),i+1); 
412         MakeBranchInTree(fLoader->TreeD(), branchname, &((*fDchambers)[i]), kBufferSize, 0);
413         printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
414        }
415     }
416     
417     if (cR  && fLoader->TreeR()) {
418       //     
419       // one branch for raw clusters per chamber
420       //  
421       printf("Make Branch - TreeR address %p\n",fLoader->TreeR());
422       
423       Int_t i;
424       if (fRawClusters == 0x0)
425       {
426         fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
427         for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
428             fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
429         }
430       }
431
432       for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) 
433        {
434          sprintf(branchname,"%sRawClusters%d",GetName(),i+1);   
435          MakeBranchInTree(fLoader->TreeR(), branchname, &((*fRawClusters)[i]), kBufferSize, 0);
436          printf("Making Branch %s for raw clusters in chamber %d\n",branchname,i+1);
437       }
438       //
439       // one branch for global trigger
440       //
441       sprintf(branchname,"%sGlobalTrigger",GetName());
442       
443       if (fGlobalTrigger == 0x0) {
444         fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1); 
445       }
446       MakeBranchInTree(fLoader->TreeR(), branchname, &fGlobalTrigger, kBufferSize, 0);
447       printf("Making Branch %s for Global Trigger\n",branchname);
448       //
449       // one branch for local trigger
450       //  
451       sprintf(branchname,"%sLocalTrigger",GetName());
452       
453       if (fLocalTrigger == 0x0) {
454         fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
455       }
456       
457       MakeBranchInTree(fLoader->TreeR(), branchname, &fLocalTrigger, kBufferSize, 0);
458       printf("Making Branch %s for Local Trigger\n",branchname);
459    }
460 }
461
462 //___________________________________________
463 void AliMUON::SetTreeAddress()
464 {
465   // Set branch address for the Hits and Digits Tree.
466   char branchname[30];
467
468   TBranch *branch;
469   TTree *treeH = fLoader->TreeH();
470   TTree *treeD = fLoader->TreeD();
471   TTree *treeR = fLoader->TreeR();
472
473   if (treeH) {
474     if (fPadHits == 0x0) fPadHits = new TClonesArray("AliMUONPadHit",10000);
475     if (fPadHits) {
476       branch = treeH->GetBranch("MUONCluster");
477       if (branch) branch->SetAddress(&fPadHits);
478     }
479     if (fHits == 0x0) fHits     = new TClonesArray("AliMUONHit",1000);
480   }
481   //it must be under fHits creation
482   AliDetector::SetTreeAddress();
483
484   if (treeD) {
485       if (fDchambers == 0x0) 
486         {
487           fDchambers = new TObjArray(AliMUONConstants::NCh());
488           for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
489               fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
490           }
491         }
492       for (int i=0; i<AliMUONConstants::NCh(); i++) {
493           sprintf(branchname,"%sDigits%d",GetName(),i+1);
494                         
495                       if (fDchambers) {
496               branch = treeD->GetBranch(branchname);
497               if (branch) branch->SetAddress(&((*fDchambers)[i]));
498           }
499       }
500   }
501
502   // printf("SetTreeAddress --- treeR address  %p \n",treeR);
503
504   if (treeR) {
505       if (fRawClusters == 0x0)
506       {
507         fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
508         for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
509             fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
510         }
511       }
512       
513       for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
514           sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
515           if (fRawClusters) {
516               branch = treeR->GetBranch(branchname);
517               if (branch) branch->SetAddress(&((*fRawClusters)[i]));
518           }
519       }
520
521       if (fLocalTrigger == 0x0) {
522         fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
523       }
524
525       if (fLocalTrigger) {
526         branch = treeR->GetBranch("MUONLocalTrigger");
527         if (branch) branch->SetAddress(&fLocalTrigger);
528       }
529       
530       if (fGlobalTrigger == 0x0) {
531         fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1); 
532       }
533       
534       if (fGlobalTrigger) {
535         branch = treeR->GetBranch("MUONGlobalTrigger");
536         if (branch) branch->SetAddress(&fGlobalTrigger);
537       }
538   }
539 }
540 //___________________________________________
541 void AliMUON::ResetHits()
542 {
543   // Reset number of clusters and the cluster array for this detector
544   AliDetector::ResetHits();
545   fNPadHits = 0;
546   if (fPadHits) fPadHits->Clear();
547 }
548
549 //____________________________________________
550 void AliMUON::ResetDigits()
551 {
552     //
553     // Reset number of digits and the digits array for this detector
554     //
555     if (fDchambers == 0x0) return;
556     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
557       //PH      if ((*fDchambers)[i])    ((TClonesArray*)(*fDchambers)[i])->Clear();
558         if ((*fDchambers)[i])    ((TClonesArray*)fDchambers->At(i))->Clear();
559         if (fNdch)  fNdch[i]=0;
560     }
561 }
562 //____________________________________________
563 void AliMUON::ResetRawClusters()
564 {
565     //
566     // Reset number of raw clusters and the raw clust array for this detector
567     //
568     for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
569       //PH      if ((*fRawClusters)[i])    ((TClonesArray*)(*fRawClusters)[i])->Clear();
570         if ((*fRawClusters)[i])    ((TClonesArray*)fRawClusters->At(i))->Clear();
571         if (fNrawch)  fNrawch[i]=0;
572     }
573 }
574
575 //____________________________________________
576 void AliMUON::ResetTrigger()
577 {
578   //  Reset Local and Global Trigger 
579   fNGlobalTrigger = 0;
580   if (fGlobalTrigger) fGlobalTrigger->Clear();
581   fNLocalTrigger = 0;
582   if (fLocalTrigger) fLocalTrigger->Clear();
583 }
584
585 //____________________________________________
586 void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
587 {
588 // Set the pad size for chamber id and cathode isec
589     Int_t i=2*(id-1);
590     //PH    ((AliMUONChamber*) (*fChambers)[i])  ->SetPadSize(isec,p1,p2);
591     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2);
592     ((AliMUONChamber*) fChambers->At(i))  ->SetPadSize(isec,p1,p2);
593     ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
594 }
595
596 //___________________________________________
597 void AliMUON::SetChambersZ(const Float_t *Z)
598 {
599   // Set Z values for all chambers (tracking and trigger)
600   // from the array pointed to by "Z"
601     for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
602       //PH      ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
603         ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
604     return;
605 }
606
607 //___________________________________________
608 void AliMUON::SetChambersZToDefault()
609 {
610   // Set Z values for all chambers (tracking and trigger)
611   // to default values
612   SetChambersZ(AliMUONConstants::DefaultChamberZ());
613   return;
614 }
615
616 //___________________________________________
617 void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
618 {
619 // Set the inverse charge slope for chamber id
620     Int_t i=2*(id-1);
621     //PH    ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1);
622     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1);
623     ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
624     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
625 }
626
627 //___________________________________________
628 void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
629 {
630 // Set sigma of charge spread for chamber id
631     Int_t i=2*(id-1);
632     //PH    ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
633     //PH    ((AliMUONChamber*) fChambers->Ati+1])->SetChargeSpread(p1,p2);
634     ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
635     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
636 }
637
638 //___________________________________________
639 void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
640 {
641 // Set integration limits for charge spread
642     Int_t i=2*(id-1);
643     //PH    ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
644     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
645     ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
646     ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
647 }
648
649 //___________________________________________
650 void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
651 {
652 // Set maximum number for ADCcounts (saturation)
653     Int_t i=2*(id-1);
654     //PH    ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1);
655     //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1);
656     ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
657     ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
658 }
659
660 //___________________________________________
661 void AliMUON::SetMaxStepGas(Float_t p1)
662 {
663 // Set stepsize in gas
664      fMaxStepGas=p1;
665 }
666
667 //___________________________________________
668 void AliMUON::SetMaxStepAlu(Float_t p1)
669 {
670 // Set step size in Alu
671     fMaxStepAlu=p1;
672 }
673
674 //___________________________________________
675 void AliMUON::SetMaxDestepGas(Float_t p1)
676 {
677 // Set maximum step size in Gas
678     fMaxDestepGas=p1;
679 }
680
681 //___________________________________________
682 void AliMUON::SetMaxDestepAlu(Float_t p1)
683 {
684 // Set maximum step size in Alu
685     fMaxDestepAlu=p1;
686 }
687 //___________________________________________
688 void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
689 {
690 // Set acceptance cuts 
691    fAccCut=acc;
692    fAccMin=angmin*TMath::Pi()/180;
693    fAccMax=angmax*TMath::Pi()/180;
694    Int_t ch;
695    if (acc) {
696        for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
697            // Loop over 2 chambers in the station
698            for (Int_t stCH = 0; stCH < 2; stCH++) {
699                ch = 2 * st + stCH;
700 //         Set chamber inner and outer radius according to acceptance cuts
701                Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
702                Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
703            } // chamber loop
704        } // station loop
705    }
706 }
707 //___________________________________________
708 void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
709 {
710 // Set the segmentation for chamber id cathode isec
711   //PH    ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
712     ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
713
714 }
715 //___________________________________________
716 void   AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
717 {
718 // Set the response for chamber id
719   //PH    ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
720     ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
721 }
722
723 void   AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
724 {
725 // Set ClusterFinder for chamber id
726   //PH    ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
727     ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
728 }
729
730 void   AliMUON::SetNsec(Int_t id, Int_t nsec)
731 {
732 // Set number of segmented cathods for chamber id
733   //PH    ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
734     ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
735 }
736
737 //___________________________________________
738 void AliMUON::SDigits2Digits()
739 {
740
741 // write TreeD here 
742
743     if (!fMerger) {
744       if (gAlice->GetDebug()>0) {
745         cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl;
746         cerr<<" no merging, just digitization of 1 event will be done"<<endl;
747       }
748       fMerger = new AliMUONMerger();
749     }
750     fMerger->Init();
751     fMerger->Digitise();
752     char hname[30];
753     //    sprintf(hname,"TreeD%d",fLoader->GetHeader()->GetEvent());
754     fLoader->TreeD()->Write(hname,TObject::kOverwrite);
755     fLoader->TreeD()->Reset();
756 }
757
758 //___________________________________________
759 // To be removed
760 void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
761                           Float_t eloss, Float_t tof,  Int_t idvol)
762 {
763 //
764 //  Calls the charge disintegration method of the current chamber and adds
765 //  the simulated cluster to the root treee 
766 //
767     Int_t clhits[7];
768     Float_t newclust[6][500];
769     Int_t nnew;
770     
771     
772 //
773 //  Integrated pulse height on chamber
774
775     
776     clhits[0]=fNhits+1;
777 //
778 //
779 //    if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
780     
781
782     //PH    ((AliMUONChamber*) (*fChambers)[idvol])
783     ((AliMUONChamber*) fChambers->At(idvol))
784         ->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust);
785     Int_t ic=0;
786 //    if (idvol == 6) printf("\n nnew  %d \n", nnew);
787 //
788 //  Add new clusters
789     for (Int_t i=0; i<nnew; i++) {
790         if (Int_t(newclust[3][i]) > 0) {
791             ic++;
792 // Cathode plane
793             clhits[1] = Int_t(newclust[5][i]);
794 //  Cluster Charge
795             clhits[2] = Int_t(newclust[0][i]);
796 //  Pad: ix
797             clhits[3] = Int_t(newclust[1][i]);
798 //  Pad: iy 
799             clhits[4] = Int_t(newclust[2][i]);
800 //  Pad: charge
801             clhits[5] = Int_t(newclust[3][i]);
802 //  Pad: chamber sector
803             clhits[6] = Int_t(newclust[4][i]);
804             
805             AddPadHit(clhits);
806         }
807     }
808 }
809
810 //___________________________________________
811 void AliMUON::Trigger(Int_t nev){
812 // call the Trigger Algorithm and fill TreeR
813
814   Int_t singlePlus[3]  = {0,0,0}; 
815   Int_t singleMinus[3] = {0,0,0}; 
816   Int_t singleUndef[3] = {0,0,0};
817   Int_t pairUnlike[3]  = {0,0,0}; 
818   Int_t pairLike[3]    = {0,0,0};
819
820   ResetTrigger();
821   AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
822   decision->Trigger();   
823   decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
824                              pairUnlike, pairLike);
825
826 // add a local trigger in the list 
827   AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
828   Int_t i;
829   
830   for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) { 
831       if(decision->GetITrigger(icirc)==1) {
832           Int_t localtr[7]={0,0,0,0,0,0,0};      
833           Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
834           decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
835           localtr[0] = icirc;
836           localtr[1] = decision->GetStripX11(icirc);
837           localtr[2] = decision->GetDev(icirc);
838           localtr[3] = decision->GetStripY11(icirc);
839           for (i=0; i<2; i++) {    // convert the Lut output in 1 digit 
840               localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
841               localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
842               localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
843           }
844           AddLocalTrigger(localtr);  // add a local trigger in the list
845       }
846   }
847
848   delete decision;
849
850   fLoader->TreeR()->Fill();
851 //  char hname[30];
852 //  sprintf(hname,"TreeR%d",nev);
853 //  fLoader->TreeR()->Write(hname,TObject::kOverwrite);
854 //  fLoader->TreeR()->Reset();
855   fLoader->WriteRecPoints("OVERWRITE");
856   ResetTrigger();
857   
858   printf("\n End of trigger for event %d", nev);
859 }
860
861
862 //____________________________________________
863 void AliMUON::Digits2Reco()
864 {
865   FindClusters();
866   Int_t nev = gAlice->GetHeader()->GetEvent();
867   fLoader->TreeR()->Fill();
868   // char hname[30];
869   // sprintf(hname,"TreeR%d", nev);
870   //fLoader->TreeR()->Write(hname);
871   //fLoader->TreeR()->Reset();
872   fLoader->WriteRecPoints("OVERWRITE");
873   ResetRawClusters();        
874   printf("\n End of cluster finding for event %d", nev);
875 }
876
877 void AliMUON::FindClusters()
878 {
879 //
880 //  Perform cluster finding
881 //
882     TClonesArray *dig1, *dig2;
883     Int_t ndig, k;
884     dig1 = new TClonesArray("AliMUONDigit",1000);
885     dig2 = new TClonesArray("AliMUONDigit",1000);
886     AliMUONDigit *digit;
887 // Loop on chambers and on cathode planes
888 //
889     ResetRawClusters();        
890     TClonesArray * muonDigits;
891
892     for (Int_t ich = 0; ich < 10; ich++) {
893       //PH      AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
894         AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
895         AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
896     
897         ResetDigits();
898         fLoader->TreeD()->GetEvent(0);
899         //TClonesArray *
900         muonDigits = (TClonesArray *) Dchambers()->At(ich);
901         ndig=muonDigits->GetEntriesFast();
902         printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich);
903         TClonesArray &lhits1 = *dig1;
904         Int_t n = 0;
905         for (k = 0; k < ndig; k++) {
906             digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
907             if (rec->TestTrack(digit->Track(0)))
908                 new(lhits1[n++]) AliMUONDigit(*digit);
909         }
910         ResetDigits();
911         fLoader->TreeD()->GetEvent(1);
912         //muonDigits  = this->DigitsAddress(ich);
913         muonDigits = (TClonesArray *) Dchambers()->At(ich);
914         ndig=muonDigits->GetEntriesFast();
915         printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
916         TClonesArray &lhits2 = *dig2;
917         n=0;
918         
919         for (k=0; k<ndig; k++) {
920             digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
921             if (rec->TestTrack(digit->Track(0)))
922             new(lhits2[n++]) AliMUONDigit(*digit);
923         }
924
925         if (rec) {       
926             AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
927             rec->FindRawClusters();
928         }
929         dig1->Delete();
930         dig2->Delete();
931     } // for ich
932     delete dig1;
933     delete dig2;
934 }
935  
936 #ifdef never
937 void AliMUON::Streamer(TBuffer &R__b)
938 {
939    // Stream an object of class AliMUON.
940       AliMUONChamber        *iChamber;
941       AliMUONTriggerCircuit *iTriggerCircuit;
942       AliSegmentation       *segmentation;
943       AliMUONResponse       *response;
944       TClonesArray          *digitsaddress;
945       TClonesArray          *rawcladdress;
946       Int_t i;
947       if (R__b.IsReading()) {
948           Version_t R__v = R__b.ReadVersion(); if (R__v) { }
949           AliDetector::Streamer(R__b);
950           R__b >> fNPadHits;
951           R__b >> fPadHits; // diff
952           R__b >> fNLocalTrigger;       
953           R__b >> fLocalTrigger;       
954           R__b >> fNGlobalTrigger;       
955           R__b >> fGlobalTrigger;   
956           R__b >> fDchambers;
957           R__b >> fRawClusters;
958           R__b.ReadArray(fNdch);
959           R__b.ReadArray(fNrawch);
960           R__b >> fAccCut;
961           R__b >> fAccMin;
962           R__b >> fAccMax; 
963           R__b >> fChambers;
964           R__b >> fTriggerCircuits;
965           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
966               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
967               iTriggerCircuit->Streamer(R__b);
968           }
969 // Stream chamber related information
970           for (i =0; i<AliMUONConstants::NCh(); i++) {
971               iChamber=(AliMUONChamber*) (*fChambers)[i];
972               iChamber->Streamer(R__b);
973               if (iChamber->Nsec()==1) {
974                   segmentation=iChamber->SegmentationModel(1);
975                   if (segmentation)
976                       segmentation->Streamer(R__b);
977               } else {
978                   segmentation=iChamber->SegmentationModel(1);
979                   if (segmentation)
980                       segmentation->Streamer(R__b);
981                   if (segmentation)
982                       segmentation=iChamber->SegmentationModel(2);
983                   segmentation->Streamer(R__b);
984               }
985               response=iChamber->ResponseModel();
986               if (response)
987                   response->Streamer(R__b);       
988               digitsaddress=(TClonesArray*) (*fDchambers)[i];
989               digitsaddress->Streamer(R__b);
990               if (i < AliMUONConstants::NTrackingCh()) {
991                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
992                   rawcladdress->Streamer(R__b);
993               }
994           }
995           
996       } else {
997           R__b.WriteVersion(AliMUON::IsA());
998           AliDetector::Streamer(R__b);
999           R__b << fNPadHits;
1000           R__b << fPadHits; // diff
1001           R__b << fNLocalTrigger;       
1002           R__b << fLocalTrigger;       
1003           R__b << fNGlobalTrigger;       
1004           R__b << fGlobalTrigger; 
1005           R__b << fDchambers;
1006           R__b << fRawClusters;
1007           R__b.WriteArray(fNdch, AliMUONConstants::NCh());
1008           R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
1009           
1010           R__b << fAccCut;
1011           R__b << fAccMin;
1012           R__b << fAccMax; 
1013           
1014           R__b << fChambers;
1015           R__b << fTriggerCircuits;
1016           for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
1017               iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
1018               iTriggerCircuit->Streamer(R__b);
1019           }
1020           for (i =0; i<AliMUONConstants::NCh(); i++) {
1021               iChamber=(AliMUONChamber*) (*fChambers)[i];
1022               iChamber->Streamer(R__b);
1023               if (iChamber->Nsec()==1) {
1024                   segmentation=iChamber->SegmentationModel(1);
1025                   if (segmentation)
1026                       segmentation->Streamer(R__b);
1027               } else {
1028                   segmentation=iChamber->SegmentationModel(1);
1029                   if (segmentation)
1030                       segmentation->Streamer(R__b);
1031                   segmentation=iChamber->SegmentationModel(2);
1032                   if (segmentation)
1033                       segmentation->Streamer(R__b);
1034               }
1035               response=iChamber->ResponseModel();
1036               if (response)
1037                   response->Streamer(R__b);
1038               digitsaddress=(TClonesArray*) (*fDchambers)[i];
1039               digitsaddress->Streamer(R__b);
1040               if (i < AliMUONConstants::NTrackingCh()) {
1041                   rawcladdress=(TClonesArray*) (*fRawClusters)[i];
1042                   rawcladdress->Streamer(R__b);
1043               }
1044           }
1045       }
1046 }
1047 #endif
1048
1049 AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters) 
1050 {
1051 // to be removed
1052     // Initialise the pad iterator
1053     // Return the address of the first padhit for hit
1054     TClonesArray *theClusters = clusters;
1055     Int_t nclust = theClusters->GetEntriesFast();
1056     if (nclust && hit->PHlast() > 0) {
1057         AliMUON::fMaxIterPad=hit->PHlast();
1058         AliMUON::fCurIterPad=hit->PHfirst();
1059         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
1060     } else {
1061         return 0;
1062     }
1063 }
1064
1065 AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters) 
1066 {
1067   // To be removed
1068 // Get next pad (in iterator) 
1069 //
1070     AliMUON::fCurIterPad++;
1071     if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
1072         return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
1073     } else {
1074         return 0;
1075     }
1076 }
1077
1078
1079 AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
1080 {
1081 //
1082 //  Return rawcluster (icluster) for chamber ichamber and cathode icathod
1083 //  Obsolete ??
1084     TClonesArray *muonRawCluster  = RawClustAddress(ichamber);
1085     ResetRawClusters();
1086     TTree *treeR = fLoader->TreeR();
1087     Int_t nent=(Int_t)treeR->GetEntries();
1088     treeR->GetEvent(nent-2+icathod-1);
1089     //treeR->GetEvent(icathod);
1090     //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
1091
1092     AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
1093     //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
1094     
1095     return  mRaw;
1096 }
1097  
1098 void   AliMUON::SetMerger(AliMUONMerger* merger)
1099 {
1100 // Set pointer to merger 
1101     fMerger = merger;
1102 }
1103
1104 AliMUONMerger*  AliMUON::Merger()
1105 {
1106 // Return pointer to merger
1107     return fMerger;
1108 }
1109
1110
1111
1112 AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
1113 {
1114 // copy operator
1115 // dummy version
1116     return *this;
1117 }
1118
1119 ////////////////////////////////////////////////////////////////////////
1120 void AliMUON::MakeBranchInTreeD(TTree *treeD, const char *file)
1121 {
1122     //
1123     // Create TreeD branches for the MUON.
1124     //
1125
1126   const Int_t kBufferSize = 4000;
1127   char branchname[30];
1128     
1129   if (fDchambers  == 0x0)   {
1130     fDchambers = new TObjArray(AliMUONConstants::NCh());
1131     for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
1132       fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
1133     }
1134   }
1135   //
1136   // one branch for digits per chamber
1137   // 
1138   for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
1139     sprintf(branchname,"%sDigits%d",GetName(),i+1);     
1140     if (fDchambers && treeD) {
1141       MakeBranchInTree(treeD, 
1142                        branchname, &((*fDchambers)[i]), kBufferSize, file);
1143 //      printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
1144     }
1145   }
1146 }
1147
1148 //___________________________________________
1149