git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Removing AliMUON version 3
[u/mrichter/AliRoot.git] / MUON / AliMUON.cxx
CommitLineData
4c039060 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 **************************************************************************/
4c039060 15
88cb7938 16/* $Id$ */
17
a9e2aefa 18
19///////////////////////////////////////////////
fe4da5cc 20// Manager and hits classes for set:MUON //
21////////////////////////////////////////////////
22
88cb7938 23#include "Riostream.h"
24
25#include <AliPDG.h>
a897a37a 26#include <TBRIK.h>
88cb7938 27#include <TCanvas.h>
28#include <TDirectory.h>
29#include <TFile.h>
94de3818 30#include <TGeometry.h>
88cb7938 31#include <TMinuit.h>
fe4da5cc 32#include <TNode.h>
88cb7938 33#include <TNtuple.h>
fe4da5cc 34#include <TObjArray.h>
88cb7938 35#include <TObject.h>
36#include <TObjectTable.h>
37#include <TPad.h>
a897a37a 38#include <TParticle.h>
39#include <TROOT.h>
88cb7938 40#include <TRandom.h>
41#include <TRotMatrix.h>
42#include <TTUBE.h>
a9e2aefa 43#include <TTUBE.h>
88cb7938 44#include <TTree.h>
45#include <TVector.h>
46#include <TVirtualMC.h>
fe4da5cc 47
88cb7938 48#include "AliConst.h"
49#include "AliHeader.h"
50#include "AliHitMap.h"
51#include "AliLoader.h"
fe4da5cc 52#include "AliMUON.h"
88cb7938 53#include "AliMUONChamberTrigger.h"
54#include "AliMUONClusterFinderVS.h"
55#include "AliMUONClusterInput.h"
56#include "AliMUONConstants.h"
57#include "AliMUONDigit.h"
58#include "AliMUONGlobalTrigger.h"
a9e2aefa 59#include "AliMUONHit.h"
88cb7938 60#include "AliMUONHitMapA1.h"
61#include "AliMUONLocalTrigger.h"
62#include "AliMUONMerger.h"
a9e2aefa 63#include "AliMUONPadHit.h"
a9e2aefa 64#include "AliMUONRawCluster.h"
88cb7938 65#include "AliMUONTransientDigit.h"
ecfa008b 66#include "AliMUONTriggerCircuit.h"
a9e2aefa 67#include "AliMUONTriggerDecision.h"
88cb7938 68#include "AliRun.h"
69
a9e2aefa 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
fe4da5cc 84
fe4da5cc 85ClassImp(AliMUON)
fe4da5cc 86//___________________________________________
87AliMUON::AliMUON()
88{
de05461e 89// Default Constructor
90//
1bd28025 91 fNCh = 0;
92 fNTrackingCh = 0;
1bd26093 93 fIshunt = 0;
1bd26093 94 fPadHits = 0;
95 fNPadHits = 0;
1bd28025 96 fChambers = 0;
1bd26093 97 fDchambers = 0;
1bd28025 98 fTriggerCircuits = 0;
1bd26093 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;
1cae9436 109 fMerger = 0;
edf34242 110 fFileName = 0;
fe4da5cc 111}
112
113//___________________________________________
114AliMUON::AliMUON(const char *name, const char *title)
115 : AliDetector(name,title)
116{
117//Begin_Html
118/*
a897a37a 119<img src="gif/alimuon.gif">
fe4da5cc 120*/
121//End_Html
f665c1ea 122
a9e2aefa 123 fHits = new TClonesArray("AliMUONHit",1000);
1cedd08a 124 gAlice->AddHitList(fHits);
a9e2aefa 125 fPadHits = new TClonesArray("AliMUONPadHit",10000);
126 fNPadHits = 0;
fe4da5cc 127 fIshunt = 0;
128
1bd28025 129 fNCh = AliMUONConstants::NCh();
1bd26093 130 fNTrackingCh = AliMUONConstants::NTrackingCh();
1bd28025 131 fNdch = new Int_t[fNCh];
fe4da5cc 132
f665c1ea 133 fDchambers = new TObjArray(AliMUONConstants::NCh());
fe4da5cc 134
135 Int_t i;
136
f665c1ea 137 for (i=0; i<AliMUONConstants::NCh() ;i++) {
cd4df77b 138 fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i);
fe4da5cc 139 fNdch[i]=0;
140 }
141
1bd28025 142 fNrawch = new Int_t[fNTrackingCh];
a897a37a 143
f665c1ea 144 fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
a897a37a 145
f665c1ea 146 for (i=0; i<AliMUONConstants::NTrackingCh();i++) {
cd4df77b 147 fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
a897a37a 148 fNrawch[i]=0;
149 }
150
a9e2aefa 151 fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
152 fNGlobalTrigger = 0;
153 fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
154 fNLocalTrigger = 0;
fe4da5cc 155
fe4da5cc 156 SetMarkerColor(kRed);
a9e2aefa 157//
158//
159//
160//
f665c1ea 161
a9e2aefa 162 Int_t ch;
163
f665c1ea 164 fChambers = new TObjArray(AliMUONConstants::NCh());
a9e2aefa 165
166 // Loop over stations
f665c1ea 167 for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
a9e2aefa 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//
f665c1ea 177 if (ch < AliMUONConstants::NTrackingCh()) {
cd4df77b 178 fChambers->AddAt(new AliMUONChamber(ch),ch);
a9e2aefa 179 } else {
cd4df77b 180 fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
a9e2aefa 181 }
182
2682e810 183 //PH AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
184 AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
a9e2aefa 185
186 chamber->SetGid(0);
187 // Default values for Z of chambers
f665c1ea 188 chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
a9e2aefa 189//
f665c1ea 190 chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
5c1f55c5 191// Set chamber inner and outer radius to default
f665c1ea 192 chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
193 chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
a9e2aefa 194//
195 } // Chamber stCH (0, 1) in
196 } // Station st (0...)
cd4df77b 197// fChambers->SetLast(AliMUONConstants::NCh());
a9e2aefa 198 fMaxStepGas=0.01;
199 fMaxStepAlu=0.1;
200 fMaxDestepGas=-1;
201 fMaxDestepAlu=-1;
202//
203 fMaxIterPad = 0;
204 fCurIterPad = 0;
5c1f55c5 205//
206 fAccMin = 0.;
207 fAccMax = 0.;
208 fAccCut = kFALSE;
a9e2aefa 209
210 // cp new design of AliMUONTriggerDecision
f665c1ea 211 fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
212 for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
cd4df77b 213 fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);
a9e2aefa 214
1cae9436 215 }
216 fMerger = 0;
fe4da5cc 217}
218
219//___________________________________________
50e97f19 220AliMUON::AliMUON(const AliMUON& rMUON):AliDetector(rMUON)
a9e2aefa 221{
222// Dummy copy constructor
223 ;
224
225}
226
fe4da5cc 227AliMUON::~AliMUON()
228{
de05461e 229// Destructor
9e1a0ddb 230 if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
a897a37a 231
f665c1ea 232 fIshunt = 0;
c2c0190f 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 }
62468ef9 255
256 if (fNrawch) delete [] fNrawch;
c2c0190f 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 }
f665c1ea 269 fNGlobalTrigger = 0;
270
c2c0190f 271 if (fLocalTrigger){
272 fLocalTrigger->Delete();
273 delete fLocalTrigger;
274 }
f665c1ea 275 fNLocalTrigger = 0;
a897a37a 276
c2c0190f 277 if (fHits) {
278 fHits->Delete();
279 delete fHits;
280 }
281
1cae9436 282 if (fMerger) delete fMerger;
62468ef9 283 if (fNdch) delete [] fNdch;
284
fe4da5cc 285}
286
287//___________________________________________
288void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
289{
290 TClonesArray &lhits = *fHits;
a9e2aefa 291 new(lhits[fNhits++]) AliMUONHit(fIshunt,track,vol,hits);
fe4da5cc 292}
293//___________________________________________
5a35ac13 294void 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//___________________________________________
306void AliMUON::AddPadHit(Int_t *clhits) // To be removed
fe4da5cc 307{
a9e2aefa 308 TClonesArray &lclusters = *fPadHits;
309 new(lclusters[fNPadHits++]) AliMUONPadHit(clhits);
fe4da5cc 310}
311//_____________________________________________________________________________
312void 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
1e7c351a 318 //PH TClonesArray &ldigits = * ((TClonesArray*)(*fDchambers)[id]);
319 TClonesArray &ldigits = * ( (TClonesArray*) fDchambers->At(id) );
a9e2aefa 320 new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
fe4da5cc 321}
322
a897a37a 323//_____________________________________________________________________________
324void AliMUON::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
325{
326 //
327 // Add a MUON digit to the list
328 //
329
2682e810 330 //PH TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
331 TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
a897a37a 332 new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
333}
a897a37a 334
a9e2aefa 335//___________________________________________
336void 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//___________________________________________
347void 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);
a897a37a 352}
353
fe4da5cc 354//___________________________________________
355void AliMUON::BuildGeometry()
356{
de05461e 357// Geometry for event display
5fd73042 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");
a897a37a 362 }
5fd73042 363 }
fe4da5cc 364}
365
366//___________________________________________
367Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
368{
369 return 9999;
370}
371
372//___________________________________________
88cb7938 373void AliMUON::MakeBranch(Option_t* option)
fe4da5cc 374{
2ab0c725 375 //
f665c1ea 376 // Create Tree branches for the MUON.
2ab0c725 377 //
f665c1ea 378 const Int_t kBufferSize = 4000;
379 char branchname[30];
380 sprintf(branchname,"%sCluster",GetName());
381
f665c1ea 382
5cf7bbad 383 const char *cD = strstr(option,"D");
384 const char *cR = strstr(option,"R");
385 const char *cH = strstr(option,"H");
2ab0c725 386
88cb7938 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);
f665c1ea 395
88cb7938 396 if (cD && fLoader->TreeD()) {
2ab0c725 397 //
398 // one branch for digits per chamber
399 //
400 Int_t i;
88cb7938 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 }
2ab0c725 407 }
88cb7938 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 }
f665c1ea 415 }
416
88cb7938 417 if (cR && fLoader->TreeR()) {
2ab0c725 418 //
419 // one branch for raw clusters per chamber
420 //
88cb7938 421 printf("Make Branch - TreeR address %p\n",fLoader->TreeR());
2ab0c725 422
423 Int_t i;
88cb7938 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 }
2ab0c725 431
88cb7938 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);
2ab0c725 437 }
438 //
439 // one branch for global trigger
440 //
441 sprintf(branchname,"%sGlobalTrigger",GetName());
88cb7938 442
443 if (fGlobalTrigger == 0x0) {
444 fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
2ab0c725 445 }
88cb7938 446 MakeBranchInTree(fLoader->TreeR(), branchname, &fGlobalTrigger, kBufferSize, 0);
447 printf("Making Branch %s for Global Trigger\n",branchname);
2ab0c725 448 //
449 // one branch for local trigger
450 //
451 sprintf(branchname,"%sLocalTrigger",GetName());
88cb7938 452
453 if (fLocalTrigger == 0x0) {
454 fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
2ab0c725 455 }
88cb7938 456
457 MakeBranchInTree(fLoader->TreeR(), branchname, &fLocalTrigger, kBufferSize, 0);
458 printf("Making Branch %s for Local Trigger\n",branchname);
2ab0c725 459 }
fe4da5cc 460}
461
462//___________________________________________
463void AliMUON::SetTreeAddress()
464{
465 // Set branch address for the Hits and Digits Tree.
a897a37a 466 char branchname[30];
fe4da5cc 467
468 TBranch *branch;
88cb7938 469 TTree *treeH = fLoader->TreeH();
470 TTree *treeD = fLoader->TreeD();
471 TTree *treeR = fLoader->TreeR();
fe4da5cc 472
473 if (treeH) {
88cb7938 474 if (fPadHits == 0x0) fPadHits = new TClonesArray("AliMUONPadHit",10000);
a9e2aefa 475 if (fPadHits) {
fe4da5cc 476 branch = treeH->GetBranch("MUONCluster");
a9e2aefa 477 if (branch) branch->SetAddress(&fPadHits);
fe4da5cc 478 }
88cb7938 479 if (fHits == 0x0) fHits = new TClonesArray("AliMUONHit",1000);
fe4da5cc 480 }
88cb7938 481 //it must be under fHits creation
482 AliDetector::SetTreeAddress();
fe4da5cc 483
484 if (treeD) {
88cb7938 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 }
f665c1ea 492 for (int i=0; i<AliMUONConstants::NCh(); i++) {
fe4da5cc 493 sprintf(branchname,"%sDigits%d",GetName(),i+1);
88cb7938 494
495 if (fDchambers) {
fe4da5cc 496 branch = treeD->GetBranch(branchname);
497 if (branch) branch->SetAddress(&((*fDchambers)[i]));
498 }
499 }
500 }
a897a37a 501
502 // printf("SetTreeAddress --- treeR address %p \n",treeR);
503
504 if (treeR) {
88cb7938 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
f665c1ea 513 for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
a897a37a 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 }
a897a37a 520
88cb7938 521 if (fLocalTrigger == 0x0) {
522 fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
523 }
524
a9e2aefa 525 if (fLocalTrigger) {
526 branch = treeR->GetBranch("MUONLocalTrigger");
527 if (branch) branch->SetAddress(&fLocalTrigger);
528 }
88cb7938 529
530 if (fGlobalTrigger == 0x0) {
531 fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
532 }
533
a9e2aefa 534 if (fGlobalTrigger) {
535 branch = treeR->GetBranch("MUONGlobalTrigger");
536 if (branch) branch->SetAddress(&fGlobalTrigger);
537 }
538 }
fe4da5cc 539}
540//___________________________________________
541void AliMUON::ResetHits()
542{
543 // Reset number of clusters and the cluster array for this detector
544 AliDetector::ResetHits();
a9e2aefa 545 fNPadHits = 0;
546 if (fPadHits) fPadHits->Clear();
fe4da5cc 547}
548
549//____________________________________________
550void AliMUON::ResetDigits()
551{
552 //
553 // Reset number of digits and the digits array for this detector
554 //
03a51b7f 555 if (fDchambers == 0x0) return;
f665c1ea 556 for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
2682e810 557 //PH if ((*fDchambers)[i]) ((TClonesArray*)(*fDchambers)[i])->Clear();
558 if ((*fDchambers)[i]) ((TClonesArray*)fDchambers->At(i))->Clear();
fe4da5cc 559 if (fNdch) fNdch[i]=0;
560 }
561}
a897a37a 562//____________________________________________
563void AliMUON::ResetRawClusters()
564{
565 //
566 // Reset number of raw clusters and the raw clust array for this detector
567 //
f665c1ea 568 for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
2682e810 569 //PH if ((*fRawClusters)[i]) ((TClonesArray*)(*fRawClusters)[i])->Clear();
570 if ((*fRawClusters)[i]) ((TClonesArray*)fRawClusters->At(i))->Clear();
a897a37a 571 if (fNrawch) fNrawch[i]=0;
572 }
573}
a9e2aefa 574
a897a37a 575//____________________________________________
a9e2aefa 576void AliMUON::ResetTrigger()
a897a37a 577{
a9e2aefa 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//____________________________________________
586void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
587{
de05461e 588// Set the pad size for chamber id and cathode isec
a9e2aefa 589 Int_t i=2*(id-1);
2682e810 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);
a897a37a 594}
595
fe4da5cc 596//___________________________________________
a9e2aefa 597void 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"
f665c1ea 601 for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
2682e810 602 //PH ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
603 ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
f665c1ea 604 return;
a9e2aefa 605}
fe4da5cc 606
a9e2aefa 607//___________________________________________
608void AliMUON::SetChambersZToDefault()
fe4da5cc 609{
a9e2aefa 610 // Set Z values for all chambers (tracking and trigger)
611 // to default values
f665c1ea 612 SetChambersZ(AliMUONConstants::DefaultChamberZ());
a9e2aefa 613 return;
fe4da5cc 614}
615
616//___________________________________________
a897a37a 617void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
fe4da5cc 618{
de05461e 619// Set the inverse charge slope for chamber id
fe4da5cc 620 Int_t i=2*(id-1);
2682e810 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);
fe4da5cc 625}
626
627//___________________________________________
a897a37a 628void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
fe4da5cc 629{
de05461e 630// Set sigma of charge spread for chamber id
fe4da5cc 631 Int_t i=2*(id-1);
2682e810 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);
fe4da5cc 636}
637
638//___________________________________________
a897a37a 639void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
fe4da5cc 640{
de05461e 641// Set integration limits for charge spread
fe4da5cc 642 Int_t i=2*(id-1);
2682e810 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);
fe4da5cc 647}
648
649//___________________________________________
d09fafb0 650void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
fe4da5cc 651{
de05461e 652// Set maximum number for ADCcounts (saturation)
fe4da5cc 653 Int_t i=2*(id-1);
2682e810 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);
fe4da5cc 658}
659
660//___________________________________________
a897a37a 661void AliMUON::SetMaxStepGas(Float_t p1)
fe4da5cc 662{
de05461e 663// Set stepsize in gas
fe4da5cc 664 fMaxStepGas=p1;
665}
666
667//___________________________________________
a897a37a 668void AliMUON::SetMaxStepAlu(Float_t p1)
fe4da5cc 669{
de05461e 670// Set step size in Alu
fe4da5cc 671 fMaxStepAlu=p1;
672}
673
674//___________________________________________
a897a37a 675void AliMUON::SetMaxDestepGas(Float_t p1)
fe4da5cc 676{
de05461e 677// Set maximum step size in Gas
fe4da5cc 678 fMaxDestepGas=p1;
679}
680
681//___________________________________________
a897a37a 682void AliMUON::SetMaxDestepAlu(Float_t p1)
fe4da5cc 683{
de05461e 684// Set maximum step size in Alu
fe4da5cc 685 fMaxDestepAlu=p1;
686}
687//___________________________________________
5c1f55c5 688void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
fe4da5cc 689{
de05461e 690// Set acceptance cuts
fe4da5cc 691 fAccCut=acc;
5c1f55c5 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 }
fe4da5cc 706}
707//___________________________________________
a30a000f 708void AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
fe4da5cc 709{
de05461e 710// Set the segmentation for chamber id cathode isec
2682e810 711 //PH ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
712 ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
fe4da5cc 713
714}
715//___________________________________________
a9e2aefa 716void AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
fe4da5cc 717{
de05461e 718// Set the response for chamber id
2682e810 719 //PH ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
720 ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
fe4da5cc 721}
722
30aaba74 723void AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
a897a37a 724{
de05461e 725// Set ClusterFinder for chamber id
2682e810 726 //PH ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
727 ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
a897a37a 728}
729
fe4da5cc 730void AliMUON::SetNsec(Int_t id, Int_t nsec)
731{
de05461e 732// Set number of segmented cathods for chamber id
2682e810 733 //PH ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
734 ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
fe4da5cc 735}
736
fe4da5cc 737//___________________________________________
2ab0c725 738void AliMUON::SDigits2Digits()
739{
d963c261 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();
2ab0c725 749 }
d963c261 750 fMerger->Init();
751 fMerger->Digitise();
752 char hname[30];
88cb7938 753 // sprintf(hname,"TreeD%d",fLoader->GetHeader()->GetEvent());
754 fLoader->TreeD()->Write(hname,TObject::kOverwrite);
755 fLoader->TreeD()->Reset();
2ab0c725 756}
a9e2aefa 757
2ab0c725 758//___________________________________________
5a35ac13 759// To be removed
802a864d 760void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
a9e2aefa 761 Float_t eloss, Float_t tof, Int_t idvol)
fe4da5cc 762{
763//
a897a37a 764// Calls the charge disintegration method of the current chamber and adds
765// the simulated cluster to the root treee
fe4da5cc 766//
a897a37a 767 Int_t clhits[7];
768 Float_t newclust[6][500];
769 Int_t nnew;
770
771
fe4da5cc 772//
a897a37a 773// Integrated pulse height on chamber
774
775
776 clhits[0]=fNhits+1;
fe4da5cc 777//
a897a37a 778//
7ab910ae 779// if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
780
781
2682e810 782 //PH ((AliMUONChamber*) (*fChambers)[idvol])
783 ((AliMUONChamber*) fChambers->At(idvol))
802a864d 784 ->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust);
a897a37a 785 Int_t ic=0;
7ab910ae 786// if (idvol == 6) printf("\n nnew %d \n", nnew);
a897a37a 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
a9e2aefa 805 AddPadHit(clhits);
a897a37a 806 }
807 }
a897a37a 808}
809
a9e2aefa 810//___________________________________________
811void 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();
a9e2aefa 821 AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
822 decision->Trigger();
823 decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
824 pairUnlike, pairLike);
88cb7938 825
a9e2aefa 826// add a local trigger in the list
827 AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
9ae15266 828 Int_t i;
a9e2aefa 829
f665c1ea 830 for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) {
9ae15266 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
a897a37a 845 }
a9e2aefa 846 }
88cb7938 847
a9e2aefa 848 delete decision;
a897a37a 849
88cb7938 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");
a9e2aefa 856 ResetTrigger();
88cb7938 857
a9e2aefa 858 printf("\n End of trigger for event %d", nev);
a897a37a 859}
a897a37a 860
a897a37a 861
a9e2aefa 862//____________________________________________
fe311ef1 863void AliMUON::Digits2Reco()
864{
865 FindClusters();
e365e1ee 866 Int_t nev = gAlice->GetHeader()->GetEvent();
88cb7938 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");
e365e1ee 873 ResetRawClusters();
874 printf("\n End of cluster finding for event %d", nev);
fe311ef1 875}
876
877void AliMUON::FindClusters()
a9e2aefa 878{
de05461e 879//
880// Perform cluster finding
881//
a9e2aefa 882 TClonesArray *dig1, *dig2;
883 Int_t ndig, k;
884 dig1 = new TClonesArray("AliMUONDigit",1000);
885 dig2 = new TClonesArray("AliMUONDigit",1000);
886 AliMUONDigit *digit;
a9e2aefa 887// Loop on chambers and on cathode planes
a897a37a 888//
fe311ef1 889 ResetRawClusters();
88cb7938 890 TClonesArray * muonDigits;
891
1bd28025 892 for (Int_t ich = 0; ich < 10; ich++) {
2682e810 893 //PH AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
894 AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
fe311ef1 895 AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
896
88cb7938 897 ResetDigits();
898 fLoader->TreeD()->GetEvent(0);
899 //TClonesArray *
900 muonDigits = (TClonesArray *) Dchambers()->At(ich);
a9e2aefa 901 ndig=muonDigits->GetEntriesFast();
88cb7938 902 printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich);
a9e2aefa 903 TClonesArray &lhits1 = *dig1;
1bd28025 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)))
a9e2aefa 908 new(lhits1[n++]) AliMUONDigit(*digit);
909 }
88cb7938 910 ResetDigits();
911 fLoader->TreeD()->GetEvent(1);
912 //muonDigits = this->DigitsAddress(ich);
913 muonDigits = (TClonesArray *) Dchambers()->At(ich);
a9e2aefa 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);
1bd28025 921 if (rec->TestTrack(digit->Track(0)))
a9e2aefa 922 new(lhits2[n++]) AliMUONDigit(*digit);
a897a37a 923 }
a897a37a 924
9825400f 925 if (rec) {
926 AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
a9e2aefa 927 rec->FindRawClusters();
928 }
929 dig1->Delete();
930 dig2->Delete();
931 } // for ich
a9e2aefa 932 delete dig1;
933 delete dig2;
a897a37a 934}
a9e2aefa 935
2ab0c725 936#ifdef never
fe4da5cc 937void AliMUON::Streamer(TBuffer &R__b)
938{
939 // Stream an object of class AliMUON.
a30a000f 940 AliMUONChamber *iChamber;
a9e2aefa 941 AliMUONTriggerCircuit *iTriggerCircuit;
a30a000f 942 AliSegmentation *segmentation;
943 AliMUONResponse *response;
944 TClonesArray *digitsaddress;
945 TClonesArray *rawcladdress;
9ae15266 946 Int_t i;
9ae15266 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;
f665c1ea 965 for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
9ae15266 966 iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
967 iTriggerCircuit->Streamer(R__b);
fe4da5cc 968 }
9ae15266 969// Stream chamber related information
f665c1ea 970 for (i =0; i<AliMUONConstants::NCh(); i++) {
9ae15266 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);
f665c1ea 990 if (i < AliMUONConstants::NTrackingCh()) {
9ae15266 991 rawcladdress=(TClonesArray*) (*fRawClusters)[i];
992 rawcladdress->Streamer(R__b);
993 }
a9e2aefa 994 }
9ae15266 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;
f665c1ea 1007 R__b.WriteArray(fNdch, AliMUONConstants::NCh());
1008 R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
9ae15266 1009
1010 R__b << fAccCut;
1011 R__b << fAccMin;
1012 R__b << fAccMax;
1013
1014 R__b << fChambers;
1015 R__b << fTriggerCircuits;
f665c1ea 1016 for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
9ae15266 1017 iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
1018 iTriggerCircuit->Streamer(R__b);
fe4da5cc 1019 }
f665c1ea 1020 for (i =0; i<AliMUONConstants::NCh(); i++) {
9ae15266 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);
f665c1ea 1040 if (i < AliMUONConstants::NTrackingCh()) {
9ae15266 1041 rawcladdress=(TClonesArray*) (*fRawClusters)[i];
1042 rawcladdress->Streamer(R__b);
1043 }
a9e2aefa 1044 }
fe4da5cc 1045 }
fe4da5cc 1046}
2ab0c725 1047#endif
1048
a9e2aefa 1049AliMUONPadHit* AliMUON::FirstPad(AliMUONHit* hit, TClonesArray *clusters)
fe4da5cc 1050{
5a35ac13 1051// to be removed
fe4da5cc 1052 // Initialise the pad iterator
1053 // Return the address of the first padhit for hit
a897a37a 1054 TClonesArray *theClusters = clusters;
fe4da5cc 1055 Int_t nclust = theClusters->GetEntriesFast();
1bd28025 1056 if (nclust && hit->PHlast() > 0) {
1057 AliMUON::fMaxIterPad=hit->PHlast();
1058 AliMUON::fCurIterPad=hit->PHfirst();
a9e2aefa 1059 return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
fe4da5cc 1060 } else {
1061 return 0;
1062 }
1063}
1064
a9e2aefa 1065AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters)
fe4da5cc 1066{
5a35ac13 1067 // To be removed
de05461e 1068// Get next pad (in iterator)
1069//
a9e2aefa 1070 AliMUON::fCurIterPad++;
1071 if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
1072 return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
fe4da5cc 1073 } else {
1074 return 0;
1075 }
1076}
1077
a897a37a 1078
1079AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
1080{
de05461e 1081//
1082// Return rawcluster (icluster) for chamber ichamber and cathode icathod
1083// Obsolete ??
a9e2aefa 1084 TClonesArray *muonRawCluster = RawClustAddress(ichamber);
a897a37a 1085 ResetRawClusters();
88cb7938 1086 TTree *treeR = fLoader->TreeR();
a9e2aefa 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();
a897a37a 1091
a9e2aefa 1092 AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
a897a37a 1093 //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
1094
1095 return mRaw;
1096}
1cae9436 1097
1098void AliMUON::SetMerger(AliMUONMerger* merger)
1099{
1100// Set pointer to merger
1101 fMerger = merger;
1102}
1103
1104AliMUONMerger* AliMUON::Merger()
1105{
1106// Return pointer to merger
1107 return fMerger;
1108}
1109
1110
a897a37a 1111
50e97f19 1112AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
a897a37a 1113{
a9e2aefa 1114// copy operator
1115// dummy version
1116 return *this;
a897a37a 1117}
1118
cd4df77b 1119////////////////////////////////////////////////////////////////////////
1120void AliMUON::MakeBranchInTreeD(TTree *treeD, const char *file)
1121{
1122 //
1123 // Create TreeD branches for the MUON.
1124 //
a897a37a 1125
cd4df77b 1126 const Int_t kBufferSize = 4000;
1127 char branchname[30];
1128
1e7c351a 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 }
cd4df77b 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);
62468ef9 1143// printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
cd4df77b 1144 }
1145 }
1146}
a897a37a 1147
cd4df77b 1148//___________________________________________
fe4da5cc 1149