]>
Commit | Line | Data |
---|---|---|
e118b27e | 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 | // Class AliMUONTest | |
19 | // ----------------- | |
20 | // Class with functions for testing | |
21 | // | |
22 | // Author: Ivana Hrivnacova, IPN Orsay | |
23 | ||
24 | #include <TStopwatch.h> | |
25 | #include <Riostream.h> | |
24def874 | 26 | #include <TH2F.h> |
27 | #include <TPave.h> | |
152d6f4e | 28 | #include <TCanvas.h> |
e118b27e | 29 | |
30 | #include "AliRun.h" | |
31 | #include "AliSegmentation.h" | |
32 | #include "AliLog.h" | |
33 | ||
34 | #include "AliMUONTest.h" | |
35 | #include "AliMUON.h" | |
36 | #include "AliMUONConstants.h" | |
37 | #include "AliMUONGeometryModule.h" | |
38 | #include "AliMUONGeometryStore.h" | |
39 | #include "AliMUONGeometrySegmentation.h" | |
40 | #include "AliMUONSt12QuadrantSegmentation.h" | |
24def874 | 41 | #include "AliMUONSt345SlatSegmentation.h" |
e118b27e | 42 | |
43 | ClassImp(AliMUONTest) | |
44 | ||
45 | //__________________________________________________________________ | |
24def874 | 46 | AliMUONTest::AliMUONTest(const TString& configMacro) |
152d6f4e | 47 | : TObject(), |
48 | fCanvas(0) | |
e118b27e | 49 | { |
50 | // Standard Constructor | |
51 | // | |
52 | // Initialize AliRoot | |
53 | gAlice->Init(configMacro.Data()); | |
54 | } | |
55 | ||
56 | //__________________________________________________________________ | |
57 | AliMUONTest::AliMUONTest() | |
152d6f4e | 58 | : TObject(), |
59 | fCanvas(0) | |
e118b27e | 60 | { |
61 | // Default Constructor | |
62 | // | |
63 | } | |
64 | ||
65 | //____________________________________________________________________ | |
66 | AliMUONTest::AliMUONTest(const AliMUONTest& rhs) | |
67 | : TObject(rhs) | |
68 | { | |
69 | // Protected copy constructor | |
70 | ||
71 | AliFatal("Not implemented."); | |
72 | } | |
73 | ||
74 | //____________________________________________________________________ | |
75 | AliMUONTest::~AliMUONTest() | |
76 | { | |
77 | // Destructor | |
152d6f4e | 78 | |
79 | delete fCanvas; | |
e118b27e | 80 | } |
81 | ||
82 | //________________________________________________________________________ | |
83 | AliMUONTest& AliMUONTest::operator = (const AliMUONTest& rhs) | |
84 | { | |
85 | // Protected assignement operator | |
86 | ||
87 | if (this == &rhs) return *this; | |
88 | ||
89 | AliFatal("Not implemented."); | |
90 | ||
91 | return *this; | |
92 | } | |
93 | ||
94 | // | |
152d6f4e | 95 | // private methods |
e118b27e | 96 | // |
97 | ||
152d6f4e | 98 | //________________________________________________________________________ |
99 | AliMUONGeometrySegmentation* | |
100 | AliMUONTest::CreateSt1Segmentation(Int_t chamberId, Int_t cathod) | |
e118b27e | 101 | { |
152d6f4e | 102 | // Create St1 geometry segmentation for given chamber and cathod |
e118b27e | 103 | |
104 | AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON"); | |
105 | if (!muon) { | |
106 | AliFatal("MUON detector not defined."); | |
152d6f4e | 107 | return 0; |
e118b27e | 108 | } |
109 | ||
152d6f4e | 110 | AliMUONGeometrySegmentation* segmentation |
111 | = new AliMUONGeometrySegmentation(muon->Chamber(chamberId).GetGeometry()); | |
e118b27e | 112 | |
152d6f4e | 113 | // Quadrant segmentations: |
114 | AliMUONSt12QuadrantSegmentation* bendSt1 | |
115 | = new AliMUONSt12QuadrantSegmentation(kStation1, kBendingPlane); | |
116 | AliMUONSt12QuadrantSegmentation* nonbendSt1 | |
117 | = new AliMUONSt12QuadrantSegmentation(kStation1, kNonBendingPlane); | |
118 | ||
119 | // The same configuration for both chambers of Station 1 | |
120 | Int_t id0 = (chamberId+1)*100; | |
121 | ||
122 | // Configure St1 chamber segmentations | |
123 | if (cathod == 0) { | |
152d6f4e | 124 | segmentation->Add(id0, bendSt1); |
125 | segmentation->Add(id0 + 1, nonbendSt1); | |
126 | segmentation->Add(id0 + 50, bendSt1); | |
127 | segmentation->Add(id0 + 51, nonbendSt1); | |
128 | } | |
129 | else if (cathod == 1) { | |
152d6f4e | 130 | segmentation->Add(id0, nonbendSt1); |
131 | segmentation->Add(id0 + 1, bendSt1); | |
132 | segmentation->Add(id0 + 50, nonbendSt1); | |
133 | segmentation->Add(id0 + 51, bendSt1); | |
134 | } | |
135 | else { | |
136 | AliError("Wrong cathod number"); | |
137 | return 0; | |
24def874 | 138 | } |
e118b27e | 139 | |
152d6f4e | 140 | return segmentation; |
141 | } | |
e118b27e | 142 | |
24def874 | 143 | //_____________________________________________________________________________ |
152d6f4e | 144 | AliMUONGeometrySegmentation* |
145 | AliMUONTest::CreateSlatSegmentation(Int_t chamberId, Int_t cathod) | |
24def874 | 146 | { |
152d6f4e | 147 | // Create St1 geometry segmentation for given chamber and cathod |
24def874 | 148 | |
149 | AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON"); | |
150 | if (!muon) { | |
151 | AliFatal("MUON detector not defined."); | |
152d6f4e | 152 | return 0; |
24def874 | 153 | } |
154 | ||
f48459ab | 155 | AliMUONGeometrySegmentation *chamberSeg = new AliMUONGeometrySegmentation(muon->Chamber(chamberId).GetGeometry()); |
156 | ||
24def874 | 157 | //Slats Segmentations |
f48459ab | 158 | AliMUONSt345SlatSegmentation *slatsegB[14]; // Types of segmentation for St3 in this framework |
159 | AliMUONSt345SlatSegmentation *slatsegNB[14]; // Types of segmentation for St3 in this framework | |
160 | // Bending | |
24def874 | 161 | Int_t ndiv[4] ={ 4, 4, 2, 1}; // densities zones |
f48459ab | 162 | for(Int_t i=0; i<14; i++) { |
163 | slatsegB[i] = new AliMUONSt345SlatSegmentation(1); | |
164 | slatsegB[i]->SetPadSize(10.,0.5); | |
165 | slatsegB[i]->SetPadDivision(ndiv); | |
166 | slatsegB[i]->SetId(1); | |
167 | slatsegB[i]->SetDAnod(0.25); | |
168 | slatsegNB[i] = new AliMUONSt345SlatSegmentation(0); | |
169 | slatsegNB[i]->SetPadSize(1.,10.); // must be 0.713 !!! | |
170 | slatsegNB[i]->SetPadDivision(ndiv); | |
171 | slatsegNB[i]->SetId(1); | |
172 | slatsegNB[i]->SetDAnod(0.25); | |
24def874 | 173 | } |
174 | ||
f48459ab | 175 | |
24def874 | 176 | //****************************************************************************************** |
177 | // Station 3 | |
178 | //****************************************************************************************** | |
179 | ||
f48459ab | 180 | if (chamberId == 4 || chamberId == 5) { |
181 | // Type 112200 for 500, 501, 508, 509, 510, 517 in Ch5 (similar for Ch6) for the futur official numbering | |
182 | // Type 112200 for 503, 504, 505, 555, 554, 553 in Ch5 (similar for Ch6) actual numbering in the code to be changed in jan05 | |
183 | Int_t n0[4] = { 0, 2, 2, 0 }; | |
184 | slatsegB[0]->SetPcbBoards(n0); | |
185 | slatsegB[0]->Init(0); | |
186 | slatsegNB[0]->SetPcbBoards(n0); | |
187 | slatsegNB[0]->Init(0); | |
188 | ||
189 | // Type 122200 for 502, 507, 511, 516 (similar in Ch6) for future official numbering of ALICE | |
190 | // Type 122200 for 502, 506, 556, 552 (similiarin Ch6) for actual numbering in muon code to be changed in jan05 | |
191 | Int_t n1[4] = { 0, 1, 3, 0 }; | |
192 | slatsegB[1]->SetPcbBoards(n1); | |
193 | slatsegB[1]->Init(0); | |
194 | slatsegNB[1]->SetPcbBoards(n1); | |
195 | slatsegNB[1]->Init(0); | |
196 | ||
197 | // Type 222000 for 503, 506, 512, 515 (similar in Ch6) for future official numbering of ALICE | |
198 | // Type 222000 for 501, 507, 557, 551 (similiarin Ch6) for actual numbering in muon code to be changed in jan05 | |
199 | Int_t n2[4] = { 0, 0, 3, 0 }; | |
200 | slatsegB[2]->SetPcbBoards(n2); | |
201 | slatsegB[2]->Init(0); | |
202 | slatsegNB[2]->SetPcbBoards(n2); | |
203 | slatsegNB[2]->Init(0); | |
204 | ||
205 | // Type 220000 for 504, 505, 513, 514 (similar in Ch6) for future official numbering of ALICE | |
206 | // Type 220000 for 500, 508, 558, 550 (similiarin Ch6) for actual numbering in muon code to be changed in jan05 | |
207 | Int_t n3[4] = { 0, 0, 2, 0 }; | |
208 | slatsegB[3]->SetPcbBoards(n3); | |
209 | slatsegB[3]->Init(0); | |
210 | slatsegNB[3]->SetPcbBoards(n3); | |
211 | slatsegNB[3]->Init(0); | |
212 | } | |
24def874 | 213 | |
24def874 | 214 | |
f48459ab | 215 | //*************************************************************************************** |
24def874 | 216 | // Station 4 & 5 |
217 | //**************************************************************************************** | |
218 | ||
f48459ab | 219 | if (chamberId >= 6 && chamberId <= 9) { |
220 | // Type 122330 for 700, 713 in Ch7 (similar for Ch8) for the futur official numbering | |
221 | // Type 122330 for 706, 756 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05 | |
222 | // Type 122330 for 900, 913 in Ch9 (similar for Ch10) for the futur official numbering | |
223 | // Type 122330 for 906, 956 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05 | |
224 | ||
225 | Int_t n4[4] = { 0, 1, 2, 2 }; | |
226 | slatsegB[4]->SetPcbBoards(n4); | |
227 | slatsegB[4]->Init(0); // 0 detection element id | |
228 | slatsegNB[4]->SetPcbBoards(n4); | |
229 | slatsegNB[4]->Init(0); // 0 detection element id | |
230 | ||
231 | // Type 112233 for 701, 712, 714, 725 in Ch7 (similar for Ch8) for the futur official numbering | |
232 | // Type 112233 for 705, 707, 755, 757 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05 | |
233 | // Type 112233 for 901, 902, 911, 912, 914, 915, 924, 925 in Ch9 (similar for Ch10) for the futur official numbering | |
234 | // Type 112233 for 904, 905, 907, 908, 954, 955, 957, 958 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05 | |
235 | Int_t n5[4] = { 0, 2, 2, 2 }; | |
236 | slatsegB[5]->SetPcbBoards(n5); | |
237 | slatsegB[5]->Init(0); // 0 detection element id | |
238 | slatsegNB[5]->SetPcbBoards(n5); | |
239 | slatsegNB[5]->Init(0); // 0 detection element id | |
240 | ||
241 | // Type 112230 for 702, 711, 715, 724 in Ch7 (similar for Ch8) for the futur official numbering | |
242 | // Type 112230 for 704, 708, 754, 758 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05 | |
243 | Int_t n6[4] = { 0, 2, 2, 1 }; | |
244 | slatsegB[6]->SetPcbBoards(n6); | |
245 | slatsegB[6]->Init(0); // 0 detection element id | |
246 | slatsegNB[6]->SetPcbBoards(n6); | |
247 | slatsegNB[6]->Init(0); // 0 detection element id | |
248 | ||
249 | // Type 222330 for 703, 710, 716, 723 in Ch7 (similar for Ch8) for the futur official numbering | |
250 | // Type 222330 for 703, 709, 753, 759 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05 | |
251 | Int_t n7[4] = { 0, 0, 3, 2 }; | |
252 | slatsegB[7]->SetPcbBoards(n7); | |
253 | slatsegB[7]->Init(0); // 0 detection element id | |
254 | slatsegNB[7]->SetPcbBoards(n7); | |
255 | slatsegNB[7]->Init(0); // 0 detection element id | |
256 | ||
257 | // Type 223300 for 704, 709, 717, 722 in Ch7 (similar for Ch8) for the futur official numbering | |
258 | // Type 223300 for 702, 710, 752, 760 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05 | |
259 | Int_t n8[4] = { 0, 0, 2, 2 }; | |
260 | slatsegB[8]->SetPcbBoards(n8); | |
261 | slatsegB[8]->Init(0); // 0 detection element id | |
262 | slatsegNB[8]->SetPcbBoards(n8); | |
263 | slatsegNB[8]->Init(0); // 0 detection element id | |
264 | ||
265 | // Type 333000 for 705, 708, 718, 721 in Ch7 (similar for Ch8) for the futur official numbering | |
266 | // Type 333000 for 701, 711, 751, 761 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05 | |
267 | // Type 333000 for 906, 907, 919, 920 in Ch9 (similar for Ch10) for the futur official numbering | |
268 | // Type 333000 for 900, 912, 950, 962 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05 | |
269 | Int_t n9[4] = { 0, 0, 0, 3 }; | |
270 | slatsegB[9]->SetPcbBoards(n9); | |
271 | slatsegB[9]->Init(0); // 0 detection element id | |
272 | slatsegNB[9]->SetPcbBoards(n9); | |
273 | slatsegNB[9]->Init(0); // 0 detection element id | |
274 | ||
275 | // Type 330000 for 706, 707, 719, 720 in Ch7 (similar for Ch8) for the futur official numbering | |
276 | // Type 330000 for 700, 712, 750, 762 in Ch7 (similar for Ch8) actual numbering in the code to be changed in jan05 | |
277 | Int_t n10[4] = { 0, 0, 0, 2 }; | |
278 | slatsegB[10]->SetPcbBoards(n10); | |
279 | slatsegB[10]->Init(0); // 0 detection element id | |
280 | slatsegNB[10]->SetPcbBoards(n10); | |
281 | slatsegNB[10]->Init(0); // 0 detection element id | |
282 | ||
283 | // Type 222333 for 903, 910, 916, 923 in Ch9 (similar for Ch10) for the futur official numbering | |
284 | // Type 222333 for 903, 909, 953, 959 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05 | |
285 | Int_t n11[4] = { 0, 0, 3, 3 }; | |
286 | slatsegB[11]->SetPcbBoards(n11); | |
287 | slatsegB[11]->Init(0); // 0 detection element id | |
288 | slatsegNB[11]->SetPcbBoards(n11); | |
289 | slatsegNB[11]->Init(0); // 0 detection element id | |
24def874 | 290 | |
f48459ab | 291 | // Type 223330 for 904, 909, 917, 922 in Ch9 (similar for Ch10) for the futur official numbering |
292 | // Type 223330 for 902, 910, 952, 960 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05 | |
293 | Int_t n12[4] = { 0, 0, 2, 3 }; | |
294 | slatsegB[12]->SetPcbBoards(n12); | |
295 | slatsegB[12]->Init(0); // 0 detection element id | |
296 | slatsegNB[12]->SetPcbBoards(n12); | |
297 | slatsegNB[12]->Init(0); // 0 detection element id | |
298 | ||
299 | // Type 333300 for 905, 908, 918, 921 in Ch9 (similar for Ch10) for the futur official numbering | |
300 | // Type 333300 for 901, 911, 951, 961 in Ch9 (similar for Ch10) actual numbering in the code to be changed in jan05 | |
301 | Int_t n13[4] = { 0, 0, 0, 4 }; | |
302 | slatsegB[13]->SetPcbBoards(n13); | |
303 | slatsegB[13]->Init(0); // 0 detection element id | |
304 | slatsegNB[13]->SetPcbBoards(n13); | |
305 | slatsegNB[13]->Init(0); // 0 detection element id | |
24def874 | 306 | |
f48459ab | 307 | } |
308 | ||
309 | Int_t id0 = 0; | |
310 | ||
311 | // For St3 | |
312 | if (chamberId == 4 || chamberId == 5) { | |
313 | // Create chamber segmentations | |
314 | ||
315 | id0=(chamberId+1)*100; | |
24def874 | 316 | // type 220000 |
f48459ab | 317 | if (cathod == 0) { |
318 | chamberSeg->Add(id0, slatsegB[3]); | |
319 | chamberSeg->Add(id0+ 8, slatsegB[3]); | |
320 | chamberSeg->Add(id0+50, slatsegB[3]); | |
321 | chamberSeg->Add(id0+58, slatsegB[3]); | |
322 | } else { | |
323 | chamberSeg->Add(id0, slatsegNB[3]); | |
324 | chamberSeg->Add(id0+ 8, slatsegNB[3]); | |
325 | chamberSeg->Add(id0+50, slatsegNB[3]); | |
326 | chamberSeg->Add(id0+58, slatsegNB[3]); | |
327 | } | |
24def874 | 328 | // type 222000 |
f48459ab | 329 | if (cathod == 0) { |
330 | chamberSeg->Add(id0+ 1, slatsegB[2]); | |
331 | chamberSeg->Add(id0+ 7, slatsegB[2]); | |
332 | chamberSeg->Add(id0+51, slatsegB[2]); | |
333 | chamberSeg->Add(id0+57, slatsegB[2]); | |
334 | } else { | |
335 | chamberSeg->Add(id0+ 1, slatsegNB[2]); | |
336 | chamberSeg->Add(id0+ 7, slatsegNB[2]); | |
337 | chamberSeg->Add(id0+51, slatsegNB[2]); | |
338 | chamberSeg->Add(id0+57, slatsegNB[2]); | |
339 | } | |
24def874 | 340 | // type 122200 |
f48459ab | 341 | if (cathod == 0) { |
342 | chamberSeg->Add(id0+ 2, slatsegB[1]); | |
343 | chamberSeg->Add(id0+ 6, slatsegB[1]); | |
344 | chamberSeg->Add(id0+52, slatsegB[1]); | |
345 | chamberSeg->Add(id0+56, slatsegB[1]); | |
346 | } else { | |
347 | chamberSeg->Add(id0+ 2, slatsegNB[1]); | |
348 | chamberSeg->Add(id0+ 6, slatsegNB[1]); | |
349 | chamberSeg->Add(id0+52, slatsegNB[1]); | |
350 | chamberSeg->Add(id0+56, slatsegNB[1]); | |
351 | } | |
24def874 | 352 | // type 112200 |
f48459ab | 353 | if (cathod == 0) { |
354 | chamberSeg->Add(id0+ 3, slatsegB[0]); | |
355 | chamberSeg->Add(id0+ 4, slatsegB[0]); | |
356 | chamberSeg->Add(id0+ 5, slatsegB[0]); | |
357 | chamberSeg->Add(id0+53, slatsegB[0]); | |
358 | chamberSeg->Add(id0+54, slatsegB[0]); | |
359 | chamberSeg->Add(id0+55, slatsegB[0]); | |
360 | } else { | |
361 | chamberSeg->Add(id0+ 3, slatsegNB[0]); | |
362 | chamberSeg->Add(id0+ 4, slatsegNB[0]); | |
363 | chamberSeg->Add(id0+ 5, slatsegNB[0]); | |
364 | chamberSeg->Add(id0+53, slatsegNB[0]); | |
365 | chamberSeg->Add(id0+54, slatsegNB[0]); | |
366 | chamberSeg->Add(id0+55, slatsegNB[0]); | |
367 | } | |
152d6f4e | 368 | |
24def874 | 369 | } |
370 | ||
f48459ab | 371 | // For St4 |
372 | if (chamberId == 6 || chamberId == 7) { | |
24def874 | 373 | // Create chamber segmentations |
f48459ab | 374 | id0=(chamberId+1)*100; |
24def874 | 375 | // type 122330 |
f48459ab | 376 | if (cathod == 0) { |
377 | chamberSeg->Add(id0+ 6, slatsegB[4]); | |
378 | chamberSeg->Add(id0+56, slatsegB[4]); | |
379 | } else { | |
380 | chamberSeg->Add(id0+ 6, slatsegNB[4]); | |
381 | chamberSeg->Add(id0+56, slatsegNB[4]); | |
382 | } | |
24def874 | 383 | // type 112233 |
f48459ab | 384 | if (cathod == 0) { |
385 | chamberSeg->Add(id0+ 5, slatsegB[5]); | |
386 | chamberSeg->Add(id0+ 7, slatsegB[5]); | |
387 | chamberSeg->Add(id0+55, slatsegB[5]); | |
388 | chamberSeg->Add(id0+57, slatsegB[5]); | |
389 | } else { | |
390 | chamberSeg->Add(id0+ 5, slatsegNB[5]); | |
391 | chamberSeg->Add(id0+ 7, slatsegNB[5]); | |
392 | chamberSeg->Add(id0+55, slatsegNB[5]); | |
393 | chamberSeg->Add(id0+57, slatsegNB[5]); | |
394 | } | |
24def874 | 395 | // type 112230 |
f48459ab | 396 | if (cathod == 0) { |
397 | chamberSeg->Add(id0+ 4, slatsegB[6]); | |
398 | chamberSeg->Add(id0+ 8, slatsegB[6]); | |
399 | chamberSeg->Add(id0+54, slatsegB[6]); | |
400 | chamberSeg->Add(id0+58, slatsegB[6]); | |
401 | } else { | |
402 | chamberSeg->Add(id0+ 4, slatsegNB[6]); | |
403 | chamberSeg->Add(id0+ 8, slatsegNB[6]); | |
404 | chamberSeg->Add(id0+54, slatsegNB[6]); | |
405 | chamberSeg->Add(id0+58, slatsegNB[6]); | |
406 | } | |
24def874 | 407 | // type 222330 |
f48459ab | 408 | if (cathod == 0) { |
409 | chamberSeg->Add(id0+ 3, slatsegB[7]); | |
410 | chamberSeg->Add(id0+ 9, slatsegB[7]); | |
411 | chamberSeg->Add(id0+53, slatsegB[7]); | |
412 | chamberSeg->Add(id0+59, slatsegB[7]); | |
413 | } else { | |
414 | chamberSeg->Add(id0+ 3, slatsegNB[7]); | |
415 | chamberSeg->Add(id0+ 9, slatsegNB[7]); | |
416 | chamberSeg->Add(id0+53, slatsegNB[7]); | |
417 | chamberSeg->Add(id0+59, slatsegNB[7]); | |
418 | } | |
24def874 | 419 | // type 223300 |
f48459ab | 420 | if (cathod == 0) { |
421 | chamberSeg->Add(id0+ 2, slatsegB[8]); | |
422 | chamberSeg->Add(id0+10, slatsegB[8]); | |
423 | chamberSeg->Add(id0+52, slatsegB[8]); | |
424 | chamberSeg->Add(id0+60, slatsegB[8]); | |
425 | } else { | |
426 | chamberSeg->Add(id0+ 2, slatsegNB[8]); | |
427 | chamberSeg->Add(id0+10, slatsegNB[8]); | |
428 | chamberSeg->Add(id0+52, slatsegNB[8]); | |
429 | chamberSeg->Add(id0+60, slatsegNB[8]); | |
430 | } | |
24def874 | 431 | // type 333000 |
f48459ab | 432 | if (cathod == 0) { |
433 | chamberSeg->Add(id0+ 1, slatsegB[9]); | |
434 | chamberSeg->Add(id0+11, slatsegB[9]); | |
435 | chamberSeg->Add(id0+51, slatsegB[9]); | |
436 | chamberSeg->Add(id0+61, slatsegB[9]); | |
437 | } else { | |
438 | chamberSeg->Add(id0+ 1, slatsegNB[9]); | |
439 | chamberSeg->Add(id0+11, slatsegNB[9]); | |
440 | chamberSeg->Add(id0+51, slatsegNB[9]); | |
441 | chamberSeg->Add(id0+61, slatsegNB[9]); | |
442 | } | |
24def874 | 443 | // type 330000 |
f48459ab | 444 | if (cathod == 0) { |
445 | chamberSeg->Add(id0 , slatsegB[10]); | |
446 | chamberSeg->Add(id0+12, slatsegB[10]); | |
447 | chamberSeg->Add(id0+50, slatsegB[10]); | |
448 | chamberSeg->Add(id0+62, slatsegB[10]); | |
449 | } else { | |
450 | chamberSeg->Add(id0 , slatsegNB[10]); | |
451 | chamberSeg->Add(id0+12, slatsegNB[10]); | |
452 | chamberSeg->Add(id0+50, slatsegNB[10]); | |
453 | chamberSeg->Add(id0+62, slatsegNB[10]); | |
454 | } | |
24def874 | 455 | } |
456 | ||
f48459ab | 457 | // For St5 |
458 | if (chamberId == 8 || chamberId == 9) { | |
459 | // Create chamber segmentations | |
460 | id0=(chamberId+1)*100; | |
24def874 | 461 | // type 122330 |
f48459ab | 462 | if (cathod == 0) { |
463 | chamberSeg->Add(id0+ 6, slatsegB[4]); | |
464 | chamberSeg->Add(id0+56, slatsegB[4]); | |
465 | } else { | |
466 | chamberSeg->Add(id0+ 6, slatsegNB[4]); | |
467 | chamberSeg->Add(id0+56, slatsegNB[4]); | |
468 | } | |
24def874 | 469 | // type 112233 |
f48459ab | 470 | if (cathod == 0) { |
471 | chamberSeg->Add(id0+ 4, slatsegB[5]); | |
472 | chamberSeg->Add(id0+ 5, slatsegB[5]); | |
473 | chamberSeg->Add(id0+ 7, slatsegB[5]); | |
474 | chamberSeg->Add(id0+ 8, slatsegB[5]); | |
475 | chamberSeg->Add(id0+54, slatsegB[5]); | |
476 | chamberSeg->Add(id0+55, slatsegB[5]); | |
477 | chamberSeg->Add(id0+57, slatsegB[5]); | |
478 | chamberSeg->Add(id0+58, slatsegB[5]); | |
479 | } else { | |
480 | chamberSeg->Add(id0+ 4, slatsegNB[5]); | |
481 | chamberSeg->Add(id0+ 5, slatsegNB[5]); | |
482 | chamberSeg->Add(id0+ 7, slatsegNB[5]); | |
483 | chamberSeg->Add(id0+ 8, slatsegNB[5]); | |
484 | chamberSeg->Add(id0+54, slatsegNB[5]); | |
485 | chamberSeg->Add(id0+55, slatsegNB[5]); | |
486 | chamberSeg->Add(id0+57, slatsegNB[5]); | |
487 | chamberSeg->Add(id0+58, slatsegNB[5]); | |
488 | } | |
24def874 | 489 | // type 222333 |
f48459ab | 490 | if (cathod == 0) { |
491 | chamberSeg->Add(id0+ 3, slatsegB[11]); | |
492 | chamberSeg->Add(id0+ 9, slatsegB[11]); | |
493 | chamberSeg->Add(id0+53, slatsegB[11]); | |
494 | chamberSeg->Add(id0+59, slatsegB[11]); | |
495 | } else { | |
496 | chamberSeg->Add(id0+ 3, slatsegNB[11]); | |
497 | chamberSeg->Add(id0+ 9, slatsegNB[11]); | |
498 | chamberSeg->Add(id0+53, slatsegNB[11]); | |
499 | chamberSeg->Add(id0+59, slatsegNB[11]); | |
500 | } | |
24def874 | 501 | // type 223330 |
f48459ab | 502 | if (cathod == 0) { |
503 | chamberSeg->Add(id0+ 2, slatsegB[12]); | |
504 | chamberSeg->Add(id0+10, slatsegB[12]); | |
505 | chamberSeg->Add(id0+52, slatsegB[12]); | |
506 | chamberSeg->Add(id0+60, slatsegB[12]); | |
507 | } else { | |
508 | chamberSeg->Add(id0+ 2, slatsegNB[12]); | |
509 | chamberSeg->Add(id0+10, slatsegNB[12]); | |
510 | chamberSeg->Add(id0+52, slatsegNB[12]); | |
511 | chamberSeg->Add(id0+60, slatsegNB[12]); | |
512 | } | |
24def874 | 513 | // type 333300 |
f48459ab | 514 | if (cathod == 0) { |
515 | chamberSeg->Add(id0+ 1, slatsegB[13]); | |
516 | chamberSeg->Add(id0+11, slatsegB[13]); | |
517 | chamberSeg->Add(id0+51, slatsegB[13]); | |
518 | chamberSeg->Add(id0+61, slatsegB[13]); | |
519 | } else { | |
520 | chamberSeg->Add(id0+ 1, slatsegNB[13]); | |
521 | chamberSeg->Add(id0+11, slatsegNB[13]); | |
522 | chamberSeg->Add(id0+51, slatsegNB[13]); | |
523 | chamberSeg->Add(id0+61, slatsegNB[13]); | |
524 | } | |
24def874 | 525 | // type 333000 |
f48459ab | 526 | if (cathod == 0) { |
527 | chamberSeg->Add(id0 , slatsegB[9]); | |
528 | chamberSeg->Add(id0+12, slatsegB[9]); | |
529 | chamberSeg->Add(id0+50, slatsegB[9]); | |
530 | chamberSeg->Add(id0+62, slatsegB[9]); | |
531 | } else { | |
532 | chamberSeg->Add(id0 , slatsegNB[9]); | |
533 | chamberSeg->Add(id0+12, slatsegNB[9]); | |
534 | chamberSeg->Add(id0+50, slatsegNB[9]); | |
535 | chamberSeg->Add(id0+62, slatsegNB[9]); | |
536 | } | |
537 | } | |
538 | ||
539 | ||
540 | if (!id0) { | |
541 | AliWarning(Form("Segmentation for chamber %d , cathod %d is not yet defined", | |
542 | chamberId, cathod)); | |
543 | return 0; | |
24def874 | 544 | |
152d6f4e | 545 | } |
f48459ab | 546 | |
547 | DrawSegmentation(chamberSeg); | |
548 | return chamberSeg; | |
549 | ||
152d6f4e | 550 | } |
551 | ||
552 | // | |
553 | // public methods | |
554 | // | |
555 | ||
556 | //______________________________________________________________________________ | |
557 | AliMUONGeometrySegmentation* | |
558 | AliMUONTest::CreateSegmentation(Int_t chamberId, Int_t cath) | |
559 | { | |
560 | // Create geometry segmentation for the specified chamber and cathod | |
561 | ||
562 | switch (chamberId) { | |
563 | ||
564 | // Station1 | |
565 | case 0: | |
566 | case 1: | |
567 | return CreateSt1Segmentation(chamberId, cath); | |
568 | break; | |
569 | ||
570 | // Station2 | |
571 | case 2: | |
572 | case 3: | |
573 | AliWarning("Not yet implemented"); | |
574 | return 0; | |
575 | break; | |
576 | ||
577 | // Slat stations | |
578 | case 4: | |
579 | case 5: | |
580 | case 6: | |
581 | case 7: | |
582 | case 8: | |
583 | case 9: | |
584 | return CreateSlatSegmentation(chamberId, cath); | |
585 | break; | |
586 | ||
587 | // Trigger stations | |
588 | case 10: | |
589 | case 11: | |
590 | case 12: | |
591 | case 13: | |
592 | //return CreateTriggerSegmentation(chamberId, cath); | |
593 | AliWarning("Not yet implemented"); | |
594 | return 0; | |
595 | break; | |
596 | ||
597 | default: | |
598 | AliWarning("Wrong chamber Id"); | |
599 | return 0; | |
600 | break; | |
601 | } | |
602 | } | |
603 | ||
604 | //______________________________________________________________________________ | |
605 | void AliMUONTest::DetElemTransforms() | |
606 | { | |
607 | // | |
608 | AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON"); | |
609 | if (!muon) { | |
610 | AliFatal("MUON detector not defined."); | |
611 | return; | |
612 | } | |
613 | ||
614 | // Loop over chambers | |
615 | for (Int_t i=0; i<AliMUONConstants::NCh(); i++) { | |
616 | ||
617 | AliMUONGeometryModule* geometry = muon->Chamber(i).GetGeometry(); | |
618 | AliMUONGeometryStore* detElements = geometry->GetDetElementStore(); | |
619 | ||
620 | // Loop over detection elements | |
621 | for (Int_t j=0; j<detElements->GetNofEntries(); j++) { | |
622 | ||
623 | //Int_t detElemId = geometry->GetDetElemId(j); | |
624 | Int_t detElemId = detElements->GetEntry(j)->GetUniqueID(); | |
625 | cout << "Detection element Id: " << detElemId << endl; | |
626 | ||
627 | Double_t x, y, z; | |
628 | geometry->Local2Global(detElemId, 0., 0., 0., x, y, z); | |
629 | cout << " Global DE position: " | |
630 | << x << ", " << y << ", " << z << endl; | |
631 | ||
632 | Double_t x2, y2, z2; | |
633 | geometry->Global2Local(detElemId, 0., 0., 0., x2, y2, z2); | |
634 | cout << " ALIC center in the local frame: " | |
635 | << x2 << ", " << y2 << ", " << z2 << endl; | |
636 | ||
637 | Double_t x3, y3, z3; | |
638 | geometry->Global2Local(detElemId, x, y, z, x3, y3, z3); | |
639 | cout << " Back in the local frame: " | |
640 | << x3 << ", " << y3 << ", " << z3 << endl; | |
641 | cout << endl; | |
642 | } | |
24def874 | 643 | } |
152d6f4e | 644 | } |
645 | ||
646 | //________________________________________________________________________ | |
647 | void AliMUONTest::PrintPadPositionsOld() | |
648 | { | |
649 | // Iterate over all old chamber segmentations and prints | |
650 | // global pad positions | |
651 | ||
652 | AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON"); | |
653 | if (!muon) { | |
654 | AliFatal("MUON detector not defined."); | |
655 | return; | |
656 | } | |
657 | ||
658 | // Loop over chambers | |
659 | for (Int_t i=0; i<1; i++) { | |
24def874 | 660 | |
152d6f4e | 661 | // Create chamber segmentations |
662 | AliSegmentation* seg[2]; | |
663 | seg[0] = muon->Chamber(i).SegmentationModel(0); | |
664 | seg[1] = muon->Chamber(i).SegmentationModel(1); | |
665 | ||
666 | // Iterate over the whole plane and return pad indices and | |
667 | // global/local positions | |
668 | cout << "Go to loop over pads" << endl; | |
669 | for (Int_t cath=0; cath<2; cath++) { | |
670 | ||
671 | cout << setw(6) << "Pads in chamber " << i << " cathod " << cath << endl; | |
672 | cout << "===================================" << endl; | |
673 | TStopwatch timer; | |
674 | timer.Start(); | |
675 | ||
676 | Int_t counter = 0; | |
677 | for ( seg[cath]->FirstPad(70., 70., 0., 80., 80.); | |
678 | seg[cath]->MorePads(); | |
679 | seg[cath]->NextPad() ) | |
680 | { | |
681 | cout << setw(6) << "counter " << counter++ << " "; | |
682 | ||
683 | Int_t ix = seg[cath]->Ix(); | |
684 | Int_t iy = seg[cath]->Iy(); | |
685 | cout << "Pad indices: ( " << ix << ", " << iy << " ) " ; | |
686 | ||
687 | Float_t x, y, z; | |
688 | seg[cath]->GetPadC(ix, iy, x, y, z); | |
689 | cout << "Pad position: ( " << x << ", " << y << ", " << z << " )" << endl; | |
690 | } | |
691 | timer.Stop(); | |
692 | timer.Print(); | |
693 | } | |
694 | } | |
695 | } | |
696 | ||
697 | //______________________________________________________________________________ | |
698 | void AliMUONTest::ForWhole(AliMUONTests testCase) | |
699 | { | |
700 | // Perform test for all chambers and first cathod | |
701 | ||
702 | AliMUON* muon = (AliMUON*)gAlice->GetModule("MUON"); | |
703 | if (!muon) { | |
704 | AliFatal("MUON detector not defined."); | |
705 | return; | |
706 | } | |
707 | ||
708 | TStopwatch timer; | |
709 | timer.Start(); | |
710 | ||
711 | // Loop over chambers | |
712 | for (Int_t iChamber=0; iChamber<AliMUONConstants::NCh(); iChamber++) { | |
713 | ||
714 | // Loop over cathods | |
715 | //for (Int_t cath=0; cath<2; cath++) { | |
716 | for (Int_t cath=0; cath<1; cath++) { | |
717 | ||
718 | AliMUONGeometrySegmentation* segmentation | |
719 | = CreateSegmentation(iChamber, cath); | |
720 | ||
721 | if (!segmentation) continue; | |
722 | ||
723 | cout << setw(6) << "Pads in chamber " << iChamber | |
724 | << " cathod " << cath << endl; | |
725 | cout << "===================================" << endl; | |
726 | ||
727 | ForSegmentation(testCase, segmentation); | |
728 | ||
729 | //if (testCase == kDrawPads) { | |
730 | //} | |
731 | } | |
732 | } | |
733 | timer.Stop(); | |
734 | timer.Print(); | |
735 | } | |
736 | ||
737 | //______________________________________________________________________________ | |
738 | void AliMUONTest::ForSegmentation(AliMUONTests testCase, | |
739 | AliMUONGeometrySegmentation *segmentation) | |
740 | { | |
741 | // Perform test for a given segmentation | |
742 | ||
743 | TStopwatch timer; | |
744 | timer.Start(); | |
745 | ||
746 | Before(testCase); | |
747 | ||
748 | // Loop over detection elements | |
749 | // | |
750 | AliMUONGeometryStore* detElements | |
751 | = segmentation->GetGeometry()->GetDetElementStore(); | |
752 | ||
753 | for (Int_t j=0; j<detElements->GetNofEntries(); j++) { | |
754 | ||
755 | Int_t detElemId = detElements->GetEntry(j)->GetUniqueID(); | |
756 | cout << "Detection element id: " << detElemId << endl; | |
757 | ||
758 | ForDetElement(testCase, detElemId, segmentation); | |
759 | } | |
760 | ||
761 | After(testCase); | |
762 | ||
763 | timer.Stop(); | |
764 | timer.Print(); | |
24def874 | 765 | } |
152d6f4e | 766 | |
767 | //______________________________________________________________________________ | |
768 | void AliMUONTest::ForDetElement(AliMUONTests testCase, | |
769 | Int_t detElemId, | |
770 | AliMUONGeometrySegmentation *segmentation) | |
771 | { | |
772 | // Prints global pad positions for given detection element | |
773 | // in a given geometry segmentation | |
774 | ||
775 | ||
776 | Int_t counter = 0; | |
777 | ||
778 | // Loop over pads in a detection element | |
779 | // | |
780 | ||
781 | for(Int_t ix=1; ix<=segmentation->Npx(detElemId); ix++) | |
782 | for(Int_t iy=1; iy<=segmentation->Npy(detElemId); iy++) | |
783 | { | |
784 | switch (testCase) { | |
785 | ||
786 | case kPrintPads: | |
787 | PrintPad(counter, detElemId, ix, iy, segmentation); | |
788 | break; | |
789 | ||
790 | case kDrawPads: | |
791 | DrawPad(counter, detElemId, ix, iy, segmentation); | |
792 | break; | |
793 | } | |
794 | } | |
795 | } | |
796 | ||
797 | //______________________________________________________________________________ | |
798 | void AliMUONTest::Before(AliMUONTests testCase) | |
799 | { | |
800 | // Do some initialization if necessary | |
801 | ||
802 | switch (testCase) { | |
803 | ||
804 | case kPrintPads: | |
805 | break; | |
806 | ||
807 | case kDrawPads: | |
808 | if (!fCanvas) { | |
809 | fCanvas = new TCanvas("c1","c1", 0, 0, 600, 600); | |
810 | fCanvas->Range(-300,-300, 300, 300); | |
811 | fCanvas->cd(); | |
812 | } | |
813 | break; | |
814 | } | |
815 | } | |
816 | ||
817 | //______________________________________________________________________________ | |
818 | void AliMUONTest::After(AliMUONTests testCase) | |
819 | { | |
820 | // Do some cleanup if necessary | |
821 | ||
822 | switch (testCase) { | |
823 | ||
824 | case kPrintPads: | |
825 | break; | |
826 | ||
827 | case kDrawPads: | |
828 | fCanvas->Update(); | |
829 | cout << "Print any key + enter to continue ..." << endl; | |
830 | char c; | |
831 | cin >> c; | |
832 | fCanvas->Clear(); | |
833 | break; | |
834 | } | |
835 | } | |
836 | ||
837 | //______________________________________________________________________________ | |
838 | void AliMUONTest::PrintPad(Int_t& counter, | |
839 | Int_t detElemId, Int_t ix, Int_t iy, | |
840 | AliMUONGeometrySegmentation* segmentation) | |
841 | { | |
842 | // Prints global pad positions for the given pad | |
843 | ||
844 | Float_t x, y, z; | |
845 | Bool_t success | |
846 | = segmentation->GetPadC(detElemId, ix, iy, x, y, z); | |
847 | ||
848 | if (!success) return; | |
849 | ||
850 | cout << setw(6) << "counter " << counter++ << " "; | |
851 | cout << "Pad indices: ( " << detElemId << "; " << ix << ", " << iy << " ) " ; | |
852 | cout << "Pad position: ( " << x << ", " << y << ", " << z << " )" << endl; | |
853 | } | |
854 | ||
855 | //______________________________________________________________________________ | |
856 | void AliMUONTest::DrawPad(Int_t& counter, | |
857 | Int_t detElemId, Int_t ix, Int_t iy, | |
858 | AliMUONGeometrySegmentation* segmentation) | |
859 | { | |
860 | // Prints global pad positions for the given pad | |
861 | ||
862 | Float_t x, y, z; | |
863 | Bool_t success | |
864 | = segmentation->GetPadC(detElemId, ix, iy, x, y, z); | |
865 | ||
866 | if (!success) return; | |
867 | ||
868 | // PrintPad(counter,detElemId, ix, iy, segmentation); | |
869 | ||
870 | counter++; | |
871 | ||
872 | Int_t sector = segmentation->Sector(detElemId, ix, iy); | |
873 | Float_t dpx = segmentation->Dpx(detElemId, sector); | |
874 | Float_t dpy = segmentation->Dpy(detElemId, sector); | |
875 | ||
876 | //printf(" ***** Pad position is ix: %d iy: %d x: %f y: %f sector: %d dpx: %f dpy: %f \n", | |
877 | // ix, iy, x, y, sector, dpx, dpy); | |
878 | ||
879 | fCanvas->cd(); | |
880 | TPave* pave = new TPave(x-dpx/2., y-dpy/2., x+dpx/2., y+dpy/2., 1); | |
881 | pave->Draw(); | |
882 | } | |
883 | ||
884 | //______________________________________________________________________________ | |
f48459ab | 885 | void AliMUONTest::DrawSegmentation(AliMUONGeometrySegmentation *seg) |
152d6f4e | 886 | { |
887 | // TBR | |
888 | ||
889 | // Drawing slat504 | |
890 | Int_t ix, iy, deId; | |
891 | Float_t x, y, z; | |
892 | Float_t dpx, dpy; | |
893 | // TH2F * frame = new TH2F(" "," ",10,-10.,245.,10, -5., 45.); | |
f48459ab | 894 | // TH2F * frame = new TH2F(" "," ",10,-300.,300.,10, -300., 300.); |
895 | TH2F * frame = new TH2F(" "," ",10,-200.,200.,10, -200., 200.); | |
152d6f4e | 896 | frame->Draw(); |
897 | // (new TPave( 0., 0., 40., 40.,2))->Draw(); | |
898 | // (new TPave( 40., 0., 80., 40.,2))->Draw(); | |
899 | // (new TPave( 80., 0.,120., 40.,2))->Draw(); | |
900 | // (new TPave(120., 0.,160., 40.,2))->Draw(); | |
901 | // (new TPave(160., 0.,200., 40.,2))->Draw(); | |
902 | // (new TPave(200., 0.,240., 40.,2))->Draw(); | |
903 | ||
f48459ab | 904 | // Loop over detection elements |
905 | // | |
906 | AliMUONGeometryStore* detElements | |
907 | = seg->GetGeometry()->GetDetElementStore(); | |
908 | ||
909 | for (Int_t iDE=0; iDE<detElements->GetNofEntries(); iDE++) { | |
152d6f4e | 910 | |
f48459ab | 911 | deId = detElements->GetEntry(iDE)->GetUniqueID(); |
912 | cout << "Detection element id: " << deId << endl; | |
913 | ||
914 | ||
915 | // for ( seg->FirstPad(detElementId, 0., 0., 0., 100., 100.); | |
916 | // seg->MorePads(detElementId); | |
917 | // seg->NextPad(detElementId) ) { | |
918 | for(ix=1; ix<=seg->Npx(deId); ix++) { | |
919 | for(iy=1; iy<=seg->Npy(deId); iy++) { | |
152d6f4e | 920 | |
f48459ab | 921 | seg->GetPadC(deId, ix, iy, x, y, z); |
922 | Int_t sector = seg->Sector(deId, ix, iy); | |
923 | dpx = seg->Dpx(deId,sector); | |
924 | dpy = seg->Dpy(deId,sector); | |
152d6f4e | 925 | |
f48459ab | 926 | //printf(" ***** Pad position is ix: %d iy: %d x: %f y: %f sector: %d dpx: %f dpy: %f \n",ix, iy, x, y, sector, dpx, dpy); |
927 | (new TPave(x-dpx/2., y-dpy/2., x+dpx/2., y+dpy/2., 1))->Draw(); | |
152d6f4e | 928 | } |
f48459ab | 929 | |
152d6f4e | 930 | } |
931 | } | |
932 | } | |
933 |