]>
Commit | Line | Data |
---|---|---|
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 | 85 | ClassImp(AliMUON) |
fe4da5cc | 86 | //___________________________________________ |
87 | AliMUON::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 | //___________________________________________ | |
114 | AliMUON::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 | //___________________________________________ | |
a9e2aefa | 220 | AliMUON::AliMUON(const AliMUON& rMUON) |
221 | { | |
222 | // Dummy copy constructor | |
223 | ; | |
224 | ||
225 | } | |
226 | ||
fe4da5cc | 227 | AliMUON::~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 | //___________________________________________ | |
288 | void 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 | 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 | |
fe4da5cc | 307 | { |
a9e2aefa | 308 | TClonesArray &lclusters = *fPadHits; |
309 | new(lclusters[fNPadHits++]) AliMUONPadHit(clhits); | |
fe4da5cc | 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 | ||
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 | //_____________________________________________________________________________ |
324 | void 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 | //___________________________________________ |
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); | |
a897a37a | 352 | } |
353 | ||
fe4da5cc | 354 | //___________________________________________ |
355 | void 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 | //___________________________________________ | |
367 | Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t ) | |
368 | { | |
369 | return 9999; | |
370 | } | |
371 | ||
372 | //___________________________________________ | |
88cb7938 | 373 | void 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 | //___________________________________________ | |
463 | void 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 | //___________________________________________ | |
541 | void 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 | //____________________________________________ | |
550 | void AliMUON::ResetDigits() | |
551 | { | |
552 | // | |
553 | // Reset number of digits and the digits array for this detector | |
554 | // | |
f665c1ea | 555 | for ( int i=0;i<AliMUONConstants::NCh();i++ ) { |
2682e810 | 556 | //PH if ((*fDchambers)[i]) ((TClonesArray*)(*fDchambers)[i])->Clear(); |
557 | if ((*fDchambers)[i]) ((TClonesArray*)fDchambers->At(i))->Clear(); | |
fe4da5cc | 558 | if (fNdch) fNdch[i]=0; |
559 | } | |
560 | } | |
a897a37a | 561 | //____________________________________________ |
562 | void AliMUON::ResetRawClusters() | |
563 | { | |
564 | // | |
565 | // Reset number of raw clusters and the raw clust array for this detector | |
566 | // | |
f665c1ea | 567 | for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) { |
2682e810 | 568 | //PH if ((*fRawClusters)[i]) ((TClonesArray*)(*fRawClusters)[i])->Clear(); |
569 | if ((*fRawClusters)[i]) ((TClonesArray*)fRawClusters->At(i))->Clear(); | |
a897a37a | 570 | if (fNrawch) fNrawch[i]=0; |
571 | } | |
572 | } | |
a9e2aefa | 573 | |
a897a37a | 574 | //____________________________________________ |
a9e2aefa | 575 | void AliMUON::ResetTrigger() |
a897a37a | 576 | { |
a9e2aefa | 577 | // Reset Local and Global Trigger |
578 | fNGlobalTrigger = 0; | |
579 | if (fGlobalTrigger) fGlobalTrigger->Clear(); | |
580 | fNLocalTrigger = 0; | |
581 | if (fLocalTrigger) fLocalTrigger->Clear(); | |
582 | } | |
583 | ||
584 | //____________________________________________ | |
585 | void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2) | |
586 | { | |
de05461e | 587 | // Set the pad size for chamber id and cathode isec |
a9e2aefa | 588 | Int_t i=2*(id-1); |
2682e810 | 589 | //PH ((AliMUONChamber*) (*fChambers)[i]) ->SetPadSize(isec,p1,p2); |
590 | //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2); | |
591 | ((AliMUONChamber*) fChambers->At(i)) ->SetPadSize(isec,p1,p2); | |
592 | ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2); | |
a897a37a | 593 | } |
594 | ||
fe4da5cc | 595 | //___________________________________________ |
a9e2aefa | 596 | void AliMUON::SetChambersZ(const Float_t *Z) |
597 | { | |
598 | // Set Z values for all chambers (tracking and trigger) | |
599 | // from the array pointed to by "Z" | |
f665c1ea | 600 | for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++) |
2682e810 | 601 | //PH ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]); |
602 | ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]); | |
f665c1ea | 603 | return; |
a9e2aefa | 604 | } |
fe4da5cc | 605 | |
a9e2aefa | 606 | //___________________________________________ |
607 | void AliMUON::SetChambersZToDefault() | |
fe4da5cc | 608 | { |
a9e2aefa | 609 | // Set Z values for all chambers (tracking and trigger) |
610 | // to default values | |
f665c1ea | 611 | SetChambersZ(AliMUONConstants::DefaultChamberZ()); |
a9e2aefa | 612 | return; |
fe4da5cc | 613 | } |
614 | ||
615 | //___________________________________________ | |
a897a37a | 616 | void AliMUON::SetChargeSlope(Int_t id, Float_t p1) |
fe4da5cc | 617 | { |
de05461e | 618 | // Set the inverse charge slope for chamber id |
fe4da5cc | 619 | Int_t i=2*(id-1); |
2682e810 | 620 | //PH ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1); |
621 | //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1); | |
622 | ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1); | |
623 | ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1); | |
fe4da5cc | 624 | } |
625 | ||
626 | //___________________________________________ | |
a897a37a | 627 | void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2) |
fe4da5cc | 628 | { |
de05461e | 629 | // Set sigma of charge spread for chamber id |
fe4da5cc | 630 | Int_t i=2*(id-1); |
2682e810 | 631 | //PH ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2); |
632 | //PH ((AliMUONChamber*) fChambers->Ati+1])->SetChargeSpread(p1,p2); | |
633 | ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2); | |
634 | ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2); | |
fe4da5cc | 635 | } |
636 | ||
637 | //___________________________________________ | |
a897a37a | 638 | void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1) |
fe4da5cc | 639 | { |
de05461e | 640 | // Set integration limits for charge spread |
fe4da5cc | 641 | Int_t i=2*(id-1); |
2682e810 | 642 | //PH ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1); |
643 | //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1); | |
644 | ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1); | |
645 | ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1); | |
fe4da5cc | 646 | } |
647 | ||
648 | //___________________________________________ | |
d09fafb0 | 649 | void AliMUON::SetMaxAdc(Int_t id, Int_t p1) |
fe4da5cc | 650 | { |
de05461e | 651 | // Set maximum number for ADCcounts (saturation) |
fe4da5cc | 652 | Int_t i=2*(id-1); |
2682e810 | 653 | //PH ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1); |
654 | //PH ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1); | |
655 | ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1); | |
656 | ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1); | |
fe4da5cc | 657 | } |
658 | ||
659 | //___________________________________________ | |
a897a37a | 660 | void AliMUON::SetMaxStepGas(Float_t p1) |
fe4da5cc | 661 | { |
de05461e | 662 | // Set stepsize in gas |
fe4da5cc | 663 | fMaxStepGas=p1; |
664 | } | |
665 | ||
666 | //___________________________________________ | |
a897a37a | 667 | void AliMUON::SetMaxStepAlu(Float_t p1) |
fe4da5cc | 668 | { |
de05461e | 669 | // Set step size in Alu |
fe4da5cc | 670 | fMaxStepAlu=p1; |
671 | } | |
672 | ||
673 | //___________________________________________ | |
a897a37a | 674 | void AliMUON::SetMaxDestepGas(Float_t p1) |
fe4da5cc | 675 | { |
de05461e | 676 | // Set maximum step size in Gas |
fe4da5cc | 677 | fMaxDestepGas=p1; |
678 | } | |
679 | ||
680 | //___________________________________________ | |
a897a37a | 681 | void AliMUON::SetMaxDestepAlu(Float_t p1) |
fe4da5cc | 682 | { |
de05461e | 683 | // Set maximum step size in Alu |
fe4da5cc | 684 | fMaxDestepAlu=p1; |
685 | } | |
686 | //___________________________________________ | |
5c1f55c5 | 687 | void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax) |
fe4da5cc | 688 | { |
de05461e | 689 | // Set acceptance cuts |
fe4da5cc | 690 | fAccCut=acc; |
5c1f55c5 | 691 | fAccMin=angmin*TMath::Pi()/180; |
692 | fAccMax=angmax*TMath::Pi()/180; | |
693 | Int_t ch; | |
694 | if (acc) { | |
695 | for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) { | |
696 | // Loop over 2 chambers in the station | |
697 | for (Int_t stCH = 0; stCH < 2; stCH++) { | |
698 | ch = 2 * st + stCH; | |
699 | // Set chamber inner and outer radius according to acceptance cuts | |
700 | Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin)); | |
701 | Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax)); | |
702 | } // chamber loop | |
703 | } // station loop | |
704 | } | |
fe4da5cc | 705 | } |
706 | //___________________________________________ | |
a30a000f | 707 | void AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation) |
fe4da5cc | 708 | { |
de05461e | 709 | // Set the segmentation for chamber id cathode isec |
2682e810 | 710 | //PH ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation); |
711 | ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation); | |
fe4da5cc | 712 | |
713 | } | |
714 | //___________________________________________ | |
a9e2aefa | 715 | void AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response) |
fe4da5cc | 716 | { |
de05461e | 717 | // Set the response for chamber id |
2682e810 | 718 | //PH ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response); |
719 | ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response); | |
fe4da5cc | 720 | } |
721 | ||
30aaba74 | 722 | void AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst) |
a897a37a | 723 | { |
de05461e | 724 | // Set ClusterFinder for chamber id |
2682e810 | 725 | //PH ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst); |
726 | ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst); | |
a897a37a | 727 | } |
728 | ||
fe4da5cc | 729 | void AliMUON::SetNsec(Int_t id, Int_t nsec) |
730 | { | |
de05461e | 731 | // Set number of segmented cathods for chamber id |
2682e810 | 732 | //PH ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec); |
733 | ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec); | |
fe4da5cc | 734 | } |
735 | ||
fe4da5cc | 736 | //___________________________________________ |
2ab0c725 | 737 | void AliMUON::SDigits2Digits() |
738 | { | |
d963c261 | 739 | |
740 | // write TreeD here | |
741 | ||
742 | if (!fMerger) { | |
743 | if (gAlice->GetDebug()>0) { | |
744 | cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl; | |
745 | cerr<<" no merging, just digitization of 1 event will be done"<<endl; | |
746 | } | |
747 | fMerger = new AliMUONMerger(); | |
2ab0c725 | 748 | } |
d963c261 | 749 | fMerger->Init(); |
750 | fMerger->Digitise(); | |
751 | char hname[30]; | |
88cb7938 | 752 | // sprintf(hname,"TreeD%d",fLoader->GetHeader()->GetEvent()); |
753 | fLoader->TreeD()->Write(hname,TObject::kOverwrite); | |
754 | fLoader->TreeD()->Reset(); | |
2ab0c725 | 755 | } |
a9e2aefa | 756 | |
2ab0c725 | 757 | //___________________________________________ |
5a35ac13 | 758 | // To be removed |
802a864d | 759 | void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit, |
a9e2aefa | 760 | Float_t eloss, Float_t tof, Int_t idvol) |
fe4da5cc | 761 | { |
762 | // | |
a897a37a | 763 | // Calls the charge disintegration method of the current chamber and adds |
764 | // the simulated cluster to the root treee | |
fe4da5cc | 765 | // |
a897a37a | 766 | Int_t clhits[7]; |
767 | Float_t newclust[6][500]; | |
768 | Int_t nnew; | |
769 | ||
770 | ||
fe4da5cc | 771 | // |
a897a37a | 772 | // Integrated pulse height on chamber |
773 | ||
774 | ||
775 | clhits[0]=fNhits+1; | |
fe4da5cc | 776 | // |
a897a37a | 777 | // |
7ab910ae | 778 | // if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss ); |
779 | ||
780 | ||
2682e810 | 781 | //PH ((AliMUONChamber*) (*fChambers)[idvol]) |
782 | ((AliMUONChamber*) fChambers->At(idvol)) | |
802a864d | 783 | ->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust); |
a897a37a | 784 | Int_t ic=0; |
7ab910ae | 785 | // if (idvol == 6) printf("\n nnew %d \n", nnew); |
a897a37a | 786 | // |
787 | // Add new clusters | |
788 | for (Int_t i=0; i<nnew; i++) { | |
789 | if (Int_t(newclust[3][i]) > 0) { | |
790 | ic++; | |
791 | // Cathode plane | |
792 | clhits[1] = Int_t(newclust[5][i]); | |
793 | // Cluster Charge | |
794 | clhits[2] = Int_t(newclust[0][i]); | |
795 | // Pad: ix | |
796 | clhits[3] = Int_t(newclust[1][i]); | |
797 | // Pad: iy | |
798 | clhits[4] = Int_t(newclust[2][i]); | |
799 | // Pad: charge | |
800 | clhits[5] = Int_t(newclust[3][i]); | |
801 | // Pad: chamber sector | |
802 | clhits[6] = Int_t(newclust[4][i]); | |
803 | ||
a9e2aefa | 804 | AddPadHit(clhits); |
a897a37a | 805 | } |
806 | } | |
a897a37a | 807 | } |
808 | ||
a9e2aefa | 809 | //___________________________________________ |
810 | void AliMUON::Trigger(Int_t nev){ | |
811 | // call the Trigger Algorithm and fill TreeR | |
812 | ||
813 | Int_t singlePlus[3] = {0,0,0}; | |
814 | Int_t singleMinus[3] = {0,0,0}; | |
815 | Int_t singleUndef[3] = {0,0,0}; | |
816 | Int_t pairUnlike[3] = {0,0,0}; | |
817 | Int_t pairLike[3] = {0,0,0}; | |
818 | ||
819 | ResetTrigger(); | |
a9e2aefa | 820 | AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1); |
821 | decision->Trigger(); | |
822 | decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef, | |
823 | pairUnlike, pairLike); | |
88cb7938 | 824 | |
a9e2aefa | 825 | // add a local trigger in the list |
826 | AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike); | |
9ae15266 | 827 | Int_t i; |
a9e2aefa | 828 | |
f665c1ea | 829 | for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) { |
9ae15266 | 830 | if(decision->GetITrigger(icirc)==1) { |
831 | Int_t localtr[7]={0,0,0,0,0,0,0}; | |
832 | Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0}; | |
833 | decision->GetLutOutput(icirc, loLpt, loHpt, loApt); | |
834 | localtr[0] = icirc; | |
835 | localtr[1] = decision->GetStripX11(icirc); | |
836 | localtr[2] = decision->GetDev(icirc); | |
837 | localtr[3] = decision->GetStripY11(icirc); | |
838 | for (i=0; i<2; i++) { // convert the Lut output in 1 digit | |
839 | localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i)); | |
840 | localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i)); | |
841 | localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i)); | |
842 | } | |
843 | AddLocalTrigger(localtr); // add a local trigger in the list | |
a897a37a | 844 | } |
a9e2aefa | 845 | } |
88cb7938 | 846 | |
a9e2aefa | 847 | delete decision; |
a897a37a | 848 | |
88cb7938 | 849 | fLoader->TreeR()->Fill(); |
850 | // char hname[30]; | |
851 | // sprintf(hname,"TreeR%d",nev); | |
852 | // fLoader->TreeR()->Write(hname,TObject::kOverwrite); | |
853 | // fLoader->TreeR()->Reset(); | |
854 | fLoader->WriteRecPoints("OVERWRITE"); | |
a9e2aefa | 855 | ResetTrigger(); |
88cb7938 | 856 | |
a9e2aefa | 857 | printf("\n End of trigger for event %d", nev); |
a897a37a | 858 | } |
a897a37a | 859 | |
a897a37a | 860 | |
a9e2aefa | 861 | //____________________________________________ |
fe311ef1 | 862 | void AliMUON::Digits2Reco() |
863 | { | |
864 | FindClusters(); | |
e365e1ee | 865 | Int_t nev = gAlice->GetHeader()->GetEvent(); |
88cb7938 | 866 | fLoader->TreeR()->Fill(); |
867 | // char hname[30]; | |
868 | // sprintf(hname,"TreeR%d", nev); | |
869 | //fLoader->TreeR()->Write(hname); | |
870 | //fLoader->TreeR()->Reset(); | |
871 | fLoader->WriteRecPoints("OVERWRITE"); | |
e365e1ee | 872 | ResetRawClusters(); |
873 | printf("\n End of cluster finding for event %d", nev); | |
fe311ef1 | 874 | } |
875 | ||
876 | void AliMUON::FindClusters() | |
a9e2aefa | 877 | { |
de05461e | 878 | // |
879 | // Perform cluster finding | |
880 | // | |
a9e2aefa | 881 | TClonesArray *dig1, *dig2; |
882 | Int_t ndig, k; | |
883 | dig1 = new TClonesArray("AliMUONDigit",1000); | |
884 | dig2 = new TClonesArray("AliMUONDigit",1000); | |
885 | AliMUONDigit *digit; | |
a9e2aefa | 886 | // Loop on chambers and on cathode planes |
a897a37a | 887 | // |
fe311ef1 | 888 | ResetRawClusters(); |
88cb7938 | 889 | TClonesArray * muonDigits; |
890 | ||
1bd28025 | 891 | for (Int_t ich = 0; ich < 10; ich++) { |
2682e810 | 892 | //PH AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich]; |
893 | AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich); | |
fe311ef1 | 894 | AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel(); |
895 | ||
88cb7938 | 896 | ResetDigits(); |
897 | fLoader->TreeD()->GetEvent(0); | |
898 | //TClonesArray * | |
899 | muonDigits = (TClonesArray *) Dchambers()->At(ich); | |
a9e2aefa | 900 | ndig=muonDigits->GetEntriesFast(); |
88cb7938 | 901 | printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich); |
a9e2aefa | 902 | TClonesArray &lhits1 = *dig1; |
1bd28025 | 903 | Int_t n = 0; |
904 | for (k = 0; k < ndig; k++) { | |
905 | digit = (AliMUONDigit*) muonDigits->UncheckedAt(k); | |
906 | if (rec->TestTrack(digit->Track(0))) | |
a9e2aefa | 907 | new(lhits1[n++]) AliMUONDigit(*digit); |
908 | } | |
88cb7938 | 909 | ResetDigits(); |
910 | fLoader->TreeD()->GetEvent(1); | |
911 | //muonDigits = this->DigitsAddress(ich); | |
912 | muonDigits = (TClonesArray *) Dchambers()->At(ich); | |
a9e2aefa | 913 | ndig=muonDigits->GetEntriesFast(); |
914 | printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich); | |
915 | TClonesArray &lhits2 = *dig2; | |
916 | n=0; | |
917 | ||
918 | for (k=0; k<ndig; k++) { | |
919 | digit= (AliMUONDigit*) muonDigits->UncheckedAt(k); | |
1bd28025 | 920 | if (rec->TestTrack(digit->Track(0))) |
a9e2aefa | 921 | new(lhits2[n++]) AliMUONDigit(*digit); |
a897a37a | 922 | } |
a897a37a | 923 | |
9825400f | 924 | if (rec) { |
925 | AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2); | |
a9e2aefa | 926 | rec->FindRawClusters(); |
927 | } | |
928 | dig1->Delete(); | |
929 | dig2->Delete(); | |
930 | } // for ich | |
a9e2aefa | 931 | delete dig1; |
932 | delete dig2; | |
a897a37a | 933 | } |
a9e2aefa | 934 | |
2ab0c725 | 935 | #ifdef never |
fe4da5cc | 936 | void AliMUON::Streamer(TBuffer &R__b) |
937 | { | |
938 | // Stream an object of class AliMUON. | |
a30a000f | 939 | AliMUONChamber *iChamber; |
a9e2aefa | 940 | AliMUONTriggerCircuit *iTriggerCircuit; |
a30a000f | 941 | AliSegmentation *segmentation; |
942 | AliMUONResponse *response; | |
943 | TClonesArray *digitsaddress; | |
944 | TClonesArray *rawcladdress; | |
9ae15266 | 945 | Int_t i; |
9ae15266 | 946 | if (R__b.IsReading()) { |
947 | Version_t R__v = R__b.ReadVersion(); if (R__v) { } | |
948 | AliDetector::Streamer(R__b); | |
949 | R__b >> fNPadHits; | |
950 | R__b >> fPadHits; // diff | |
951 | R__b >> fNLocalTrigger; | |
952 | R__b >> fLocalTrigger; | |
953 | R__b >> fNGlobalTrigger; | |
954 | R__b >> fGlobalTrigger; | |
955 | R__b >> fDchambers; | |
956 | R__b >> fRawClusters; | |
957 | R__b.ReadArray(fNdch); | |
958 | R__b.ReadArray(fNrawch); | |
959 | R__b >> fAccCut; | |
960 | R__b >> fAccMin; | |
961 | R__b >> fAccMax; | |
962 | R__b >> fChambers; | |
963 | R__b >> fTriggerCircuits; | |
f665c1ea | 964 | for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) { |
9ae15266 | 965 | iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i]; |
966 | iTriggerCircuit->Streamer(R__b); | |
fe4da5cc | 967 | } |
9ae15266 | 968 | // Stream chamber related information |
f665c1ea | 969 | for (i =0; i<AliMUONConstants::NCh(); i++) { |
9ae15266 | 970 | iChamber=(AliMUONChamber*) (*fChambers)[i]; |
971 | iChamber->Streamer(R__b); | |
972 | if (iChamber->Nsec()==1) { | |
973 | segmentation=iChamber->SegmentationModel(1); | |
974 | if (segmentation) | |
975 | segmentation->Streamer(R__b); | |
976 | } else { | |
977 | segmentation=iChamber->SegmentationModel(1); | |
978 | if (segmentation) | |
979 | segmentation->Streamer(R__b); | |
980 | if (segmentation) | |
981 | segmentation=iChamber->SegmentationModel(2); | |
982 | segmentation->Streamer(R__b); | |
983 | } | |
984 | response=iChamber->ResponseModel(); | |
985 | if (response) | |
986 | response->Streamer(R__b); | |
987 | digitsaddress=(TClonesArray*) (*fDchambers)[i]; | |
988 | digitsaddress->Streamer(R__b); | |
f665c1ea | 989 | if (i < AliMUONConstants::NTrackingCh()) { |
9ae15266 | 990 | rawcladdress=(TClonesArray*) (*fRawClusters)[i]; |
991 | rawcladdress->Streamer(R__b); | |
992 | } | |
a9e2aefa | 993 | } |
9ae15266 | 994 | |
995 | } else { | |
996 | R__b.WriteVersion(AliMUON::IsA()); | |
997 | AliDetector::Streamer(R__b); | |
998 | R__b << fNPadHits; | |
999 | R__b << fPadHits; // diff | |
1000 | R__b << fNLocalTrigger; | |
1001 | R__b << fLocalTrigger; | |
1002 | R__b << fNGlobalTrigger; | |
1003 | R__b << fGlobalTrigger; | |
1004 | R__b << fDchambers; | |
1005 | R__b << fRawClusters; | |
f665c1ea | 1006 | R__b.WriteArray(fNdch, AliMUONConstants::NCh()); |
1007 | R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh()); | |
9ae15266 | 1008 | |
1009 | R__b << fAccCut; | |
1010 | R__b << fAccMin; | |
1011 | R__b << fAccMax; | |
1012 | ||
1013 | R__b << fChambers; | |
1014 | R__b << fTriggerCircuits; | |
f665c1ea | 1015 | for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) { |
9ae15266 | 1016 | iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i]; |
1017 | iTriggerCircuit->Streamer(R__b); | |
fe4da5cc | 1018 | } |
f665c1ea | 1019 | for (i =0; i<AliMUONConstants::NCh(); i++) { |
9ae15266 | 1020 | iChamber=(AliMUONChamber*) (*fChambers)[i]; |
1021 | iChamber->Streamer(R__b); | |
1022 | if (iChamber->Nsec()==1) { | |
1023 | segmentation=iChamber->SegmentationModel(1); | |
1024 | if (segmentation) | |
1025 | segmentation->Streamer(R__b); | |
1026 | } else { | |
1027 | segmentation=iChamber->SegmentationModel(1); | |
1028 | if (segmentation) | |
1029 | segmentation->Streamer(R__b); | |
1030 | segmentation=iChamber->SegmentationModel(2); | |
1031 | if (segmentation) | |
1032 | segmentation->Streamer(R__b); | |
1033 | } | |
1034 | response=iChamber->ResponseModel(); | |
1035 | if (response) | |
1036 | response->Streamer(R__b); | |
1037 | digitsaddress=(TClonesArray*) (*fDchambers)[i]; | |
1038 | digitsaddress->Streamer(R__b); | |
f665c1ea | 1039 | if (i < AliMUONConstants::NTrackingCh()) { |
9ae15266 | 1040 | rawcladdress=(TClonesArray*) (*fRawClusters)[i]; |
1041 | rawcladdress->Streamer(R__b); | |
1042 | } | |
a9e2aefa | 1043 | } |
fe4da5cc | 1044 | } |
fe4da5cc | 1045 | } |
2ab0c725 | 1046 | #endif |
1047 | ||
a9e2aefa | 1048 | AliMUONPadHit* AliMUON::FirstPad(AliMUONHit* hit, TClonesArray *clusters) |
fe4da5cc | 1049 | { |
5a35ac13 | 1050 | // to be removed |
fe4da5cc | 1051 | // Initialise the pad iterator |
1052 | // Return the address of the first padhit for hit | |
a897a37a | 1053 | TClonesArray *theClusters = clusters; |
fe4da5cc | 1054 | Int_t nclust = theClusters->GetEntriesFast(); |
1bd28025 | 1055 | if (nclust && hit->PHlast() > 0) { |
1056 | AliMUON::fMaxIterPad=hit->PHlast(); | |
1057 | AliMUON::fCurIterPad=hit->PHfirst(); | |
a9e2aefa | 1058 | return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1); |
fe4da5cc | 1059 | } else { |
1060 | return 0; | |
1061 | } | |
1062 | } | |
1063 | ||
a9e2aefa | 1064 | AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters) |
fe4da5cc | 1065 | { |
5a35ac13 | 1066 | // To be removed |
de05461e | 1067 | // Get next pad (in iterator) |
1068 | // | |
a9e2aefa | 1069 | AliMUON::fCurIterPad++; |
1070 | if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) { | |
1071 | return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1); | |
fe4da5cc | 1072 | } else { |
1073 | return 0; | |
1074 | } | |
1075 | } | |
1076 | ||
a897a37a | 1077 | |
1078 | AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster) | |
1079 | { | |
de05461e | 1080 | // |
1081 | // Return rawcluster (icluster) for chamber ichamber and cathode icathod | |
1082 | // Obsolete ?? | |
a9e2aefa | 1083 | TClonesArray *muonRawCluster = RawClustAddress(ichamber); |
a897a37a | 1084 | ResetRawClusters(); |
88cb7938 | 1085 | TTree *treeR = fLoader->TreeR(); |
a9e2aefa | 1086 | Int_t nent=(Int_t)treeR->GetEntries(); |
1087 | treeR->GetEvent(nent-2+icathod-1); | |
1088 | //treeR->GetEvent(icathod); | |
1089 | //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast(); | |
a897a37a | 1090 | |
a9e2aefa | 1091 | AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster); |
a897a37a | 1092 | //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw); |
1093 | ||
1094 | return mRaw; | |
1095 | } | |
1cae9436 | 1096 | |
1097 | void AliMUON::SetMerger(AliMUONMerger* merger) | |
1098 | { | |
1099 | // Set pointer to merger | |
1100 | fMerger = merger; | |
1101 | } | |
1102 | ||
1103 | AliMUONMerger* AliMUON::Merger() | |
1104 | { | |
1105 | // Return pointer to merger | |
1106 | return fMerger; | |
1107 | } | |
1108 | ||
1109 | ||
a897a37a | 1110 | |
a9e2aefa | 1111 | AliMUON& AliMUON::operator = (const AliMUON& rhs) |
a897a37a | 1112 | { |
a9e2aefa | 1113 | // copy operator |
1114 | // dummy version | |
1115 | return *this; | |
a897a37a | 1116 | } |
1117 | ||
cd4df77b | 1118 | //////////////////////////////////////////////////////////////////////// |
1119 | void AliMUON::MakeBranchInTreeD(TTree *treeD, const char *file) | |
1120 | { | |
1121 | // | |
1122 | // Create TreeD branches for the MUON. | |
1123 | // | |
a897a37a | 1124 | |
cd4df77b | 1125 | const Int_t kBufferSize = 4000; |
1126 | char branchname[30]; | |
1127 | ||
1e7c351a | 1128 | if (fDchambers == 0x0) { |
1129 | fDchambers = new TObjArray(AliMUONConstants::NCh()); | |
1130 | for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) { | |
1131 | fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); | |
1132 | } | |
1133 | } | |
cd4df77b | 1134 | // |
1135 | // one branch for digits per chamber | |
1136 | // | |
1137 | for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) { | |
1138 | sprintf(branchname,"%sDigits%d",GetName(),i+1); | |
1139 | if (fDchambers && treeD) { | |
1140 | MakeBranchInTree(treeD, | |
1141 | branchname, &((*fDchambers)[i]), kBufferSize, file); | |
62468ef9 | 1142 | // printf("Making Branch %s for digits in chamber %d\n",branchname,i+1); |
cd4df77b | 1143 | } |
1144 | } | |
1145 | } | |
a897a37a | 1146 | |
cd4df77b | 1147 | //___________________________________________ |
fe4da5cc | 1148 |