]> git.uio.no Git - u/mrichter/AliRoot.git/blame - MUON/AliMUONTest.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Read trigger info from Digits in MUONTestTrigger (Christian)
[u/mrichter/AliRoot.git] / MUON / AliMUONTest.cxx
CommitLineData
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
43ClassImp(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//__________________________________________________________________
57AliMUONTest::AliMUONTest()
152d6f4e 58 : TObject(),
59 fCanvas(0)
e118b27e 60{
61// Default Constructor
62//
63}
64
65//____________________________________________________________________
66AliMUONTest::AliMUONTest(const AliMUONTest& rhs)
67 : TObject(rhs)
68{
69// Protected copy constructor
70
71 AliFatal("Not implemented.");
72}
73
74//____________________________________________________________________
75AliMUONTest::~AliMUONTest()
76{
77// Destructor
152d6f4e 78
79 delete fCanvas;
e118b27e 80}
81
82//________________________________________________________________________
83AliMUONTest& 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//________________________________________________________________________
99AliMUONGeometrySegmentation*
100AliMUONTest::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 144AliMUONGeometrySegmentation*
145AliMUONTest::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//______________________________________________________________________________
557AliMUONGeometrySegmentation*
558AliMUONTest::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//______________________________________________________________________________
605void 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//________________________________________________________________________
647void 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//______________________________________________________________________________
698void 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//______________________________________________________________________________
738void 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//______________________________________________________________________________
768void 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//______________________________________________________________________________
798void 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//______________________________________________________________________________
818void 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//______________________________________________________________________________
838void 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//______________________________________________________________________________
856void 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
6b1e4b22 879 if (!fCanvas) Before(kDrawPads);
880
152d6f4e 881 fCanvas->cd();
882 TPave* pave = new TPave(x-dpx/2., y-dpy/2., x+dpx/2., y+dpy/2., 1);
883 pave->Draw();
884}
885
886//______________________________________________________________________________
f48459ab 887void AliMUONTest::DrawSegmentation(AliMUONGeometrySegmentation *seg)
152d6f4e 888{
889// TBR
890
891 // Drawing slat504
892 Int_t ix, iy, deId;
893 Float_t x, y, z;
894 Float_t dpx, dpy;
895// TH2F * frame = new TH2F(" "," ",10,-10.,245.,10, -5., 45.);
f48459ab 896// TH2F * frame = new TH2F(" "," ",10,-300.,300.,10, -300., 300.);
897 TH2F * frame = new TH2F(" "," ",10,-200.,200.,10, -200., 200.);
152d6f4e 898 frame->Draw();
899// (new TPave( 0., 0., 40., 40.,2))->Draw();
900// (new TPave( 40., 0., 80., 40.,2))->Draw();
901// (new TPave( 80., 0.,120., 40.,2))->Draw();
902// (new TPave(120., 0.,160., 40.,2))->Draw();
903// (new TPave(160., 0.,200., 40.,2))->Draw();
904// (new TPave(200., 0.,240., 40.,2))->Draw();
905
f48459ab 906 // Loop over detection elements
907 //
908 AliMUONGeometryStore* detElements
909 = seg->GetGeometry()->GetDetElementStore();
910
911 for (Int_t iDE=0; iDE<detElements->GetNofEntries(); iDE++) {
152d6f4e 912
f48459ab 913 deId = detElements->GetEntry(iDE)->GetUniqueID();
914 cout << "Detection element id: " << deId << endl;
915
916
917 // for ( seg->FirstPad(detElementId, 0., 0., 0., 100., 100.);
918 // seg->MorePads(detElementId);
919 // seg->NextPad(detElementId) ) {
920 for(ix=1; ix<=seg->Npx(deId); ix++) {
921 for(iy=1; iy<=seg->Npy(deId); iy++) {
152d6f4e 922
f48459ab 923 seg->GetPadC(deId, ix, iy, x, y, z);
924 Int_t sector = seg->Sector(deId, ix, iy);
925 dpx = seg->Dpx(deId,sector);
926 dpy = seg->Dpy(deId,sector);
152d6f4e 927
f48459ab 928 //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);
929 (new TPave(x-dpx/2., y-dpy/2., x+dpx/2., y+dpy/2., 1))->Draw();
152d6f4e 930 }
f48459ab 931
152d6f4e 932 }
933 }
934}
935