Line data Source code
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 : /* $Id$ */
16 : /** @file AliFMDAltroMapping.cxx
17 : @author Christian Holm Christensen <cholm@nbi.dk>
18 : @date Sun Mar 26 18:27:56 2006
19 : @brief Map HW to detector
20 : */
21 : //____________________________________________________________________
22 : //
23 : // Mapping of ALTRO hardware channel to detector coordinates
24 : //
25 : // The hardware address consist of a DDL number and 12bits of ALTRO
26 : // addresses. The ALTRO address are formatted as follows.
27 : //
28 : // 12 7 4 0
29 : // |---------------|---------|------------|
30 : // | Board # | ALTRO # | Channel # |
31 : // +---------------+---------+------------+
32 : //
33 : // The mapping is done purely by calculations. In the future,
34 : // however, we may need some hard-coded stuff, or an external file to
35 : // read from.
36 : //
37 : #include "AliFMDAltroMapping.h" // ALIFMDALTROMAPPING_H
38 : #include "AliFMDParameters.h"
39 : #include "AliLog.h"
40 : #include "AliFMDDebug.h"
41 : #include <iostream>
42 : #include <iomanip>
43 :
44 : //____________________________________________________________________
45 12 : ClassImp(AliFMDAltroMapping)
46 : #if 0
47 : ; // This is here to keep Emacs for indenting the next line
48 : #endif
49 :
50 : //_____________________________________________________________________________
51 8 : AliFMDAltroMapping::AliFMDAltroMapping()
52 40 : {
53 : // Constructor
54 16 : }
55 :
56 :
57 : //_____________________________________________________________________________
58 : Bool_t
59 : AliFMDAltroMapping::ReadMapping()
60 : {
61 : // Read map from file - not used
62 0 : return kTRUE;
63 : }
64 :
65 : //_____________________________________________________________________________
66 : Bool_t
67 : AliFMDAltroMapping::CreateInvMapping()
68 : {
69 : // Create inverse mapping - not used
70 0 : return kTRUE;
71 : }
72 :
73 :
74 : //____________________________________________________________________
75 : Bool_t
76 : AliFMDAltroMapping::Channel2StripBase(UShort_t board, UShort_t altro,
77 : UShort_t chan, Char_t& ring,
78 : UShort_t& sec, Short_t& str) const
79 : {
80 : // Translate a hardware address to detector coordinates.
81 : // The detector is simply
82 : //
83 : // ddl + 1
84 : //
85 : // The ring number, sector, and strip number is given by the addr
86 : // argument. The address argument, has the following format
87 : //
88 : // 12 7 4 0
89 : // +-------------+----------+----------+
90 : // | Board | ALTRO | Channel |
91 : // +-------------+----------+----------+
92 : //
93 : // The board number identifier among other things the ring. There's
94 : // up to 4 boards per DDL, and the two first (0 and 16) corresponds
95 : // to the inner rings, while the two last (1 and 17) corresponds to
96 : // the outer rings.
97 : //
98 : // The board number and ALTRO number together identifies the sensor,
99 : // and hence. The lower board number (0 or 16) are the first N / 2
100 : // sensors (where N is the number of sensors in the ring).
101 : //
102 : // There are 3 ALTRO's per card, and each ALTRO serves up to 4
103 : // sensors. Which of sensor is determined by the channel number.
104 : // For the inner rings, the map is
105 : //
106 : // ALTRO 0, Channel 0 to 7 -> Sensor 0 or 5
107 : // ALTRO 0, Channel 8 to 15 -> Sensor 1 or 6
108 : // ALTRO 1, Channel 0 to 7 -> Sensor 2 or 7
109 : // ALTRO 2, Channel 0 to 7 -> Sensor 3 or 8
110 : // ALTRO 2, Channel 8 to 15 -> Sensor 4 or 9
111 : //
112 : // For the outer rings, the map is
113 : //
114 : // ALTRO 0, Channel 0 to 3 -> Sensor 0 or 10
115 : // ALTRO 0, Channel 4 to 7 -> Sensor 1 or 11
116 : // ALTRO 0, Channel 8 to 11 -> Sensor 2 or 12
117 : // ALTRO 0, Channel 12 to 15 -> Sensor 3 or 13
118 : // ALTRO 1, Channel 0 to 3 -> Sensor 4 or 14
119 : // ALTRO 1, Channel 4 to 7 -> Sensor 5 or 15
120 : // ALTRO 2, Channel 0 to 3 -> Sensor 6 or 16
121 : // ALTRO 2, Channel 4 to 7 -> Sensor 7 or 17
122 : // ALTRO 2, Channel 8 to 11 -> Sensor 8 or 18
123 : // ALTRO 2, Channel 12 to 15 -> Sensor 9 or 19
124 : //
125 : // Which divison of the sensor we're in, depends on the channel
126 : // number only. For the inner rings, the map is
127 : //
128 : // Channel 0 -> Sector 0, strips 0-127
129 : // Channel 1 -> Sector 1, strips 127-0
130 : // Channel 3 -> Sector 0, strips 128-255
131 : // Channel 4 -> Sector 1, strips 255-128
132 : // Channel 5 -> Sector 0, strips 256-383
133 : // Channel 6 -> Sector 1, strips 383-256
134 : // Channel 7 -> Sector 0, strips 384-511
135 : // Channel 8 -> Sector 1, strips 511-384
136 : //
137 : // There are only half as many strips in the outer sensors, so there
138 : // only 4 channels are used for a full sensor. The map is
139 : //
140 : // Channel 0 -> Sector 0, strips 0-127
141 : // Channel 1 -> Sector 1, strips 127-0
142 : // Channel 3 -> Sector 0, strips 128-255
143 : // Channel 4 -> Sector 1, strips 255-128
144 : //
145 : // With this information, we can decode the hardware address to give
146 : // us detector coordinates, unique at least up a 128 strips. We
147 : // return the first strip, as seen by the ALTRO channel, in the
148 : // given range.
149 : //
150 4800 : ring = Board2Ring(board);
151 3200 : UShort_t fsec = board < 16 ? 1 : 0;
152 3200 : switch (ring) {
153 : case 'i':
154 : case 'I':
155 3456 : sec = (fsec * 10 + (altro < 1 ? 0 : altro < 2 ? 4 : 6)
156 960 : + 2 * (chan / 8) + chan % 2);
157 960 : str = ((chan % 8) / 2) * 128;
158 960 : break;
159 : case 'o':
160 : case 'O':
161 2304 : sec = (fsec * 20 + (altro < 1 ? 0 : altro < 2 ? 8 : 12)
162 640 : + 2 * (chan / 4) + chan % 2);
163 640 : str = ((chan % 4) / 2) * 128;
164 640 : break;
165 : }
166 2400 : if (sec % 2) str += 127;
167 : // AliFMDDebug(1, ("%02x/%x/%x Base strip = %d", board, altro, chan, str));
168 1600 : return kTRUE;
169 : }
170 :
171 : //____________________________________________________________________
172 : void
173 : AliFMDAltroMapping::Timebin2Strip(UShort_t sec,
174 : UShort_t timebin,
175 : UShort_t preSamples,
176 : UShort_t sampleRate,
177 : Short_t& stripOff,
178 : UShort_t& sample) const
179 : {
180 : // Compute the strip off-set in the current channel from the sector
181 : // and timebin. Also needed for this computation is the basic
182 : // offset in timebins, as well as the sample rat.
183 1638400 : UShort_t t = (timebin - preSamples);
184 819200 : sample = (t % sampleRate);
185 819200 : t -= sample;
186 819200 : stripOff = (sec % 2 ? -1 : 1) * t / sampleRate;
187 : #if 0
188 : AliInfo(Form("[%2d],%4d -> %d * (%4d - %d)-((%4d - %d) %% %d) / %d = %3d,%d",
189 : sec,timebin, (sec % 2 ? -1 : 1), timebin, preSamples,
190 : timebin, preSamples, sampleRate, sampleRate, stripOff, sample));
191 : #endif
192 819200 : }
193 :
194 : //____________________________________________________________________
195 : Bool_t
196 : AliFMDAltroMapping::Hardware2Detector(UShort_t ddl, UShort_t board,
197 : UShort_t altro, UShort_t chan,
198 : UShort_t timebin, UShort_t preSamples,
199 : UShort_t sampleRate,
200 : UShort_t& det, Char_t& ring,
201 : UShort_t& sec, Short_t& str,
202 : UShort_t& sam) const
203 : {
204 : // Full conversion from hardware address, including timebin number,
205 : // to detector coordinates and sample number. Note, that this
206 : // conversion depends on the oversampling rate and the number of
207 : // pre-samples
208 0 : Short_t baseStrip, stripOffset, tdet = DDL2Detector(ddl);
209 0 : if (tdet < 0) return kFALSE;
210 0 : det = tdet;
211 0 : if (!Channel2StripBase(board, altro, chan, ring, sec, baseStrip))
212 0 : return kFALSE;
213 0 : Timebin2Strip(sec, timebin, preSamples, sampleRate, stripOffset, sam);
214 : {
215 0 : AliFMDDebug(50, ("0x%x/0x%02x/0x%x/0x%x/%04d -> FMD%d%c[%2d,%3d]-%d "
216 : "(pre=%d,rate=%d,base=%3d,off=%3d)",
217 : ddl,
218 : board,
219 : altro,
220 : chan,
221 : timebin,
222 : det,
223 : ring,
224 : sec,
225 : str,
226 : sam,
227 : preSamples,
228 : sampleRate,
229 : baseStrip,
230 : stripOffset));
231 : }
232 0 : str = baseStrip + stripOffset;
233 0 : return kTRUE;
234 0 : }
235 :
236 : //____________________________________________________________________
237 : Bool_t
238 : AliFMDAltroMapping::Hardware2Detector(UShort_t ddl, UShort_t addr,
239 : UShort_t timebin, UShort_t preSamples,
240 : UShort_t sampleRate,
241 : UShort_t& det, Char_t& ring,
242 : UShort_t& sec, Short_t& str,
243 : UShort_t& sam) const
244 : {
245 : // Translate a hardware address to detector coordinates.
246 : //
247 : // See also Hardware2Detector that accepts 4 inputs
248 0 : UShort_t board, altro, chan;
249 0 : ChannelAddress(addr, board, altro, chan);
250 0 : return Hardware2Detector(ddl, board, altro, chan,
251 : timebin, preSamples, sampleRate,
252 : det, ring, sec, str, sam);
253 0 : }
254 :
255 :
256 : //____________________________________________________________________
257 : Short_t
258 : AliFMDAltroMapping::Sector2Board(Char_t ring, UShort_t sec) const
259 : {
260 : //
261 : // Return board address corresponding to a sector
262 : //
263 : // Parameters:
264 : // ring Ring identifier
265 : // sec Sector number
266 : // Return:
267 : // The board number, or negative number in case of failure
268 : //
269 0 : switch (ring) {
270 : case 'I':
271 : case 'i':
272 0 : return (sec < 10 ? 16 : 0); // (sec / 10) * 16;
273 : case 'O':
274 : case 'o':
275 0 : return (sec < 20 ? 16 : 0) + 1; // (sec / 20) * 16 + 1;
276 : }
277 0 : return -1;
278 0 : }
279 :
280 : //_____________________________________________ _______________________
281 : Bool_t
282 : AliFMDAltroMapping::Strip2Channel(Char_t ring, UShort_t sec,
283 : UShort_t str, UShort_t& board,
284 : UShort_t& altro, UShort_t& chan) const
285 : {
286 : // Translate detector coordinates to a hardware address.
287 : // The ddl is simply
288 : //
289 : // (det - 1)
290 : //
291 : // The ring number, sector, and strip number must be encoded into a
292 : // hardware address. The address argument, will have the following
293 : // format on output
294 : //
295 : // 12 7 4 0
296 : // +-------------+----------+----------+
297 : // | Board | ALTRO | Channel |
298 : // +-------------+----------+----------+
299 : //
300 : // The board number is given by the ring and sector. The inner
301 : // rings board 0 and 16, while the outer are 1 and 17. Which of these
302 : // depends on the sector. The map is
303 : //
304 : // Ring I, sector 0- 9 -> board 0
305 : // Ring I, sector 10-19 -> board 16
306 : // Ring O, sector 0-19 -> board 1
307 : // Ring O, sector 20-39 -> board 17
308 : //
309 : // There are 3 ALTRO's per board. The ALTRO number is given by the
310 : // sector number. For the inner rings, these are given by
311 : //
312 : // Sector 0- 3 or 10-13 -> ALTRO 0
313 : // Sector 4- 5 or 14-15 -> ALTRO 1
314 : // Sector 6- 9 or 16-19 -> ALTRO 2
315 : //
316 : // For the outers, it's given by
317 : //
318 : // Sector 0- 7 or 20-27 -> ALTRO 0
319 : // Sector 8-11 or 28-31 -> ALTRO 1
320 : // Sector 12-19 or 32-39 -> ALTRO 2
321 : //
322 : // The channel number is given by the sector and strip number. For
323 : // the inners, the map is
324 : //
325 : // Sector 0, strips 0-127 -> Channel 0
326 : // Sector 0, strips 128-255 -> Channel 2
327 : // Sector 0, strips 256-383 -> Channel 4
328 : // Sector 0, strips 384-511 -> Channel 6
329 : // Sector 1, strips 127- 0 -> Channel 1
330 : // Sector 1, strips 255-128 -> Channel 3
331 : // Sector 1, strips 383-256 -> Channel 5
332 : // Sector 1, strips 511-384 -> Channel 7
333 : // Sector 2, strips 0-127 -> Channel 8
334 : // Sector 2, strips 128-255 -> Channel 10
335 : // Sector 2, strips 256-383 -> Channel 12
336 : // Sector 2, strips 384-511 -> Channel 14
337 : // Sector 3, strips 127- 0 -> Channel 9
338 : // Sector 3, strips 255-128 -> Channel 11
339 : // Sector 3, strips 383-256 -> Channel 13
340 : // Sector 3, strips 511-384 -> Channel 15
341 : //
342 : // and so on, up to sector 19. For the outer, the map is
343 : //
344 : // Sector 0, strips 0-127 -> Channel 0
345 : // Sector 0, strips 128-255 -> Channel 2
346 : // Sector 1, strips 127- 0 -> Channel 1
347 : // Sector 1, strips 255-128 -> Channel 3
348 : // Sector 2, strips 0-127 -> Channel 4
349 : // Sector 2, strips 128-255 -> Channel 6
350 : // Sector 3, strips 127- 0 -> Channel 5
351 : // Sector 3, strips 255-128 -> Channel 7
352 : // Sector 4, strips 0-127 -> Channel 8
353 : // Sector 4, strips 128-255 -> Channel 10
354 : // Sector 5, strips 127- 0 -> Channel 9
355 : // Sector 5, strips 255-128 -> Channel 11
356 : // Sector 6, strips 0-127 -> Channel 12
357 : // Sector 6, strips 128-255 -> Channel 14
358 : // Sector 7, strips 127- 0 -> Channel 13
359 : // Sector 7, strips 255-128 -> Channel 15
360 : //
361 : // and so on upto sector 40.
362 : //
363 : // With this information, we can decode the detector coordinates to
364 : // give us a unique hardware address
365 : //
366 : UInt_t tmp = 0;
367 : UShort_t fboard = 0;
368 2457600 : switch (ring) {
369 : case 'I':
370 : case 'i':
371 491520 : fboard = sec < 10 ? 1 : 0;
372 491520 : board = fboard * 16;
373 1277952 : altro = (sec % 10) < 4 ? 0 : (sec % 10) < 6 ? 1 : 2;
374 1277952 : tmp = (sec % 10) - (altro == 0 ? 0 : altro == 1 ? 4 : 6);
375 491520 : chan = 2 * (str / 128) + (sec % 2) + ((tmp / 2) % 2) * 8;
376 491520 : break;
377 : case 'O':
378 : case 'o':
379 327680 : fboard = sec < 20 ? 1 : 0;
380 327680 : board = fboard * 16 + 1;
381 851968 : altro = (sec % 20) < 8 ? 0 : (sec % 20) < 12 ? 1 : 2;
382 851968 : tmp = (sec % 20) - (altro == 0 ? 0 : altro == 1 ? 8 : 12);
383 327680 : chan = 2 * (str / 128) + (sec % 2) + ((tmp / 2) % 4) * 4;
384 327680 : break;
385 : }
386 819200 : return kTRUE;
387 : }
388 :
389 : //_____________________________________________ _______________________
390 : UShort_t
391 : AliFMDAltroMapping::Strip2Timebin(UShort_t sec, UShort_t strip,
392 : UShort_t sam, UShort_t preSamples,
393 : UShort_t sampleRate) const
394 : {
395 : //
396 : // Get the timebin correspoding to a strip and sample
397 : //
398 : // Parameters:
399 : // sec Sector number
400 : // str Strip number
401 : // sam Sample number
402 : // preSamples Number of pre-samples.
403 : // sampleRate The over-sampling rate
404 : // Return:
405 : // the timebin corresponding to the passed strip
406 : //
407 : UShort_t timebin = preSamples;
408 2457600 : if (sec % 2) {
409 1228800 : timebin += (127 - (strip % 128)) * sampleRate;
410 : #if 0
411 : AliInfo(Form("[%2d,%3d]-%d (%d)-> %d + (127 - (%d %% 128)) * %d + %d = %d",
412 : sec, strip, sam, (strip % 128),
413 : preSamples, strip, sampleRate, sam,
414 : timebin+sam));
415 : #endif
416 409600 : }
417 : else {
418 409600 : timebin += (strip % 128) * sampleRate;
419 : #if 0
420 : AliInfo(Form("[%2d,%3d]-%d (%d)-> %d + (%d %% 128) * %d + %d = %d",
421 : sec, strip, sam, (strip % 128),
422 : preSamples, strip, sampleRate, sam, timebin+sam));
423 : #endif
424 : }
425 819200 : timebin += sam;
426 819200 : return timebin;
427 : }
428 :
429 :
430 : //____________________________________________________________________
431 : Bool_t
432 : AliFMDAltroMapping::Detector2Hardware(UShort_t det, Char_t ring,
433 : UShort_t sec, UShort_t str,
434 : UShort_t sam,
435 : UShort_t preSamples,
436 : UShort_t sampleRate,
437 : UShort_t& ddl, UShort_t& board,
438 : UShort_t& altro, UShort_t& channel,
439 : UShort_t& timebin) const
440 : {
441 : //
442 : // Map a detector index into a hardware address.
443 : //
444 : // Parameters:
445 : // det The detector #
446 : // ring The ring ID
447 : // sec The sector #
448 : // str The strip #
449 : // sam The sample number
450 : // preSamples Number of pre-samples
451 : // sampleRate The oversampling rate
452 : // ddl On return, hardware DDL number
453 : // board On return, the FEC board address (local to DDL)
454 : // altro On return, the ALTRO number (local to FEC)
455 : // channel On return, the channel number (local to ALTRO)
456 : // timebin On return, the timebin number (local to ALTRO)
457 : // Return:
458 : // @c true on success, false otherwise
459 : //
460 1638400 : ddl = Detector2DDL(det);
461 819200 : if (!Strip2Channel(ring,sec,str,board,altro,channel)) return kFALSE;
462 819200 : timebin = Strip2Timebin(sec, str, sam, preSamples, sampleRate);
463 819200 : return kTRUE;
464 819200 : }
465 :
466 :
467 : //____________________________________________________________________
468 : Bool_t
469 : AliFMDAltroMapping::Detector2Hardware(UShort_t det, Char_t ring,
470 : UShort_t sec, UShort_t str,
471 : UShort_t sam,
472 : UShort_t preSamples, UShort_t sampleRate,
473 : UShort_t& ddl, UShort_t& hwaddr,
474 : UShort_t& timebin) const
475 : {
476 : //
477 : // Map a detector index into a hardware address.
478 : //
479 : // Parameters:
480 : // det The detector #
481 : // ring The ring ID
482 : // sec The sector #
483 : // str The strip #
484 : // sam The sample number
485 : // preSamples Number of pre-samples
486 : // sampleRate The oversampling rate
487 : // ddl On return, hardware DDL number
488 : // hwaddr On return, hardware address.
489 : // timebin On return, the timebin number (local to ALTRO)
490 : // Return:
491 : // @c true on success, false otherwise
492 : //
493 1638400 : UShort_t board = 0;
494 819200 : UShort_t altro = 0;
495 819200 : UShort_t chan = 0;
496 819200 : if (!Detector2Hardware(det, ring, sec, str, sam,
497 : preSamples, sampleRate,
498 0 : ddl, board, altro, chan, timebin)) return kFALSE;
499 819200 : hwaddr = ChannelAddress(board, altro, chan);
500 819200 : return kTRUE;
501 819200 : }
502 :
503 :
504 : //____________________________________________________________________
505 : UInt_t
506 : AliFMDAltroMapping::ChannelAddress(UShort_t board, UShort_t altro,
507 : UShort_t channel) const
508 : {
509 : //
510 : // Convert board, chip, channel to a hardware address
511 : //
512 : // Parameters:
513 : // board Board number
514 : // altro Altro number
515 : // channel Channel number
516 : // Return:
517 : // hardware address of a channel
518 : //
519 1638400 : return (((board & 0x1F) << 7) | ((altro & 0x7) << 4) | (channel & 0xF));
520 : }
521 :
522 : //____________________________________________________________________
523 : void
524 : AliFMDAltroMapping::ChannelAddress(UShort_t hwaddr, UShort_t& board,
525 : UShort_t& altro, UShort_t& channel) const
526 : {
527 : //
528 : // Convert a channel address to board, altro, channel fields
529 : //
530 : // Parameters:
531 : // hwaddr Channel address
532 : // board On return, the Board number
533 : // altro On return, the Altro number
534 : // channel On return, the Channel number
535 : //
536 3200 : board = ((hwaddr >> 7) & 0x1F);
537 1600 : altro = ((hwaddr >> 4) & 0x07);
538 1600 : channel = ((hwaddr >> 0) & 0x0F);
539 1600 : }
540 :
541 : //____________________________________________________________________
542 : Int_t
543 : AliFMDAltroMapping::GetHWAddress(Int_t sec, Int_t str, Int_t ring)
544 : {
545 : // Return hardware address corresponding to sector sec, strip str,
546 : // and ring ring. Mapping from TPC to FMD coordinates are
547 : //
548 : // TPC | FMD
549 : // --------+------
550 : // padrow | sector
551 : // pad | strip
552 : // sector | ring
553 : //
554 0 : Char_t r = Char_t(ring);
555 0 : UShort_t board, altro, channel;
556 0 : Strip2Channel(r, sec, str, board, altro, channel);
557 0 : return ChannelAddress(board, altro, channel);
558 0 : }
559 :
560 : //____________________________________________________________________
561 : Int_t
562 : AliFMDAltroMapping::GetPadRow(Int_t hwaddr) const
563 : {
564 : // Return sector corresponding to hardware address hwaddr. Mapping
565 : // from TPC to FMD coordinates are
566 : //
567 : // TPC | FMD
568 : // --------+------
569 : // padrow | sector
570 : // pad | strip
571 : // sector | ring
572 : //
573 0 : Char_t ring;
574 0 : UShort_t board, altro, channel, sector;
575 0 : Short_t baseStrip;
576 0 : ChannelAddress(hwaddr, board, altro, channel);
577 0 : if (!Channel2StripBase(board, altro, channel, ring, sector, baseStrip))
578 0 : return -1;
579 0 : return Int_t(sector);
580 0 : }
581 :
582 : //____________________________________________________________________
583 : Int_t
584 : AliFMDAltroMapping::GetPad(Int_t hwaddr) const
585 : {
586 : // Return strip corresponding to hardware address hwaddr. Mapping
587 : // from TPC to FMD coordinates are
588 : //
589 : // TPC | FMD
590 : // --------+------
591 : // padrow | sector
592 : // pad | strip
593 : // sector | ring
594 : //
595 0 : Char_t ring;
596 0 : UShort_t board, altro, channel, sector;
597 0 : Short_t baseStrip;
598 0 : ChannelAddress(hwaddr, board, altro, channel);
599 0 : if (!Channel2StripBase(board, altro, channel, ring, sector, baseStrip))
600 0 : return -1;
601 0 : return Int_t(baseStrip);
602 0 : }
603 :
604 : //____________________________________________________________________
605 : Int_t
606 : AliFMDAltroMapping::GetSector(Int_t hwaddr) const
607 : {
608 : // Return ring corresponding to hardware address hwaddr. Mapping
609 : // from TPC to FMD coordinates are
610 : //
611 : // TPC | FMD
612 : // --------+------
613 : // padrow | sector
614 : // pad | strip
615 : // sector | ring
616 : //
617 0 : Char_t ring;
618 0 : UShort_t board, altro, channel, sector;
619 0 : Short_t baseStrip;
620 0 : ChannelAddress(hwaddr, board, altro, channel);
621 0 : if (!Channel2StripBase(board, altro, channel, ring, sector, baseStrip))
622 0 : return -1;
623 0 : return Int_t(ring);
624 0 : }
625 :
626 : //____________________________________________________________________
627 : void
628 : AliFMDAltroMapping::Print(Option_t* option) const
629 : {
630 : //
631 : // Print map to standard out
632 : //
633 : // Parameters:
634 : // option Option string (hw, or det)
635 : //
636 0 : TString opt(option);
637 0 : opt.ToLower();
638 0 : UShort_t ddl, board, chip, chan, addr;
639 0 : UShort_t det, sec;
640 0 : Short_t strBase;
641 0 : Char_t rng;
642 :
643 0 : if (opt.Contains("hw") || opt.Contains("hardware")) {
644 0 : std::cout << " DDL | Board | Chip | Chan | Address | Detector\n"
645 0 : << "=====+=======+======+======+=========+==============="
646 0 : << std::endl;
647 0 : for (ddl = 0; ddl <= 2; ddl++) {
648 0 : Int_t boards[] = { 0, 16, (ddl == 0 ? 32 : 1), 17, 32};
649 0 : Int_t* ptr = boards;
650 0 : det = DDL2Detector(ddl);
651 0 : while ((board = *(ptr++)) < 32) {
652 0 : for (chip = 0; chip <= 2; chip++) {
653 0 : UShort_t nchan = (chip == 1 ? 8 : 16);
654 0 : for (chan = 0; chan < nchan; chan++) {
655 0 : Channel2StripBase(board, chip, chan, rng, sec, strBase);
656 0 : addr = ChannelAddress(board, chip, chan);
657 0 : std::cout << " "
658 0 : << std::setw(3) << ddl << " | "
659 0 : << std::setfill('0') << std::hex << " 0x"
660 0 : << std::setw(2) << board << " | 0x"
661 0 : << std::setw(1) << chip << " | 0x"
662 0 : << std::setw(1) << chan << " | 0x"
663 0 : << std::setw(3) << addr << " | "
664 0 : << std::setfill(' ') << std::dec << " FMD"
665 0 : << std::setw(1) << det << rng << "["
666 0 : << std::setw(2) << sec << ","
667 0 : << std::setw(3) << strBase << "]" << std::endl;
668 : } // for chan ...
669 0 : if (chip == 2 && *ptr >= 32) continue;
670 0 : std::cout << " + + + + + "
671 0 : << std::endl;
672 0 : } // for chip ...
673 : } // while board
674 0 : std::cout << "-----+-------+------+------+---------+---------------"
675 0 : << std::endl;
676 0 : } // for ddl ...
677 : } // if hw
678 0 : if (opt.Contains("det")) {
679 0 : std::cout << " Detector | DDL | Board | Chip | Chan | Address\n"
680 0 : << "===============+=====+=======+======+======+========"
681 0 : << std::endl;
682 0 : for (det = 1; det <= 3; det++) {
683 0 : Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'),'\0' };
684 0 : Char_t* ptr = rings;
685 0 : ddl = Detector2DDL(det);
686 0 : while ((rng = *(ptr++)) != '\0') {
687 0 : UShort_t nsec = (rng == 'I' ? 20 : 40);
688 0 : UShort_t nstr = (rng == 'I' ? 512 : 256);
689 0 : for (sec = 0; sec < nsec; sec++) {
690 0 : for (strBase = 0; strBase < nstr; strBase += 128) {
691 0 : Strip2Channel(rng, sec, strBase, board, chip, chan);
692 0 : addr = ChannelAddress(board, chip, chan);
693 0 : std::cout << std::setfill(' ') << std::dec << " FMD"
694 0 : << std::setw(1) << det << rng << "["
695 0 : << std::setw(2) << sec << ","
696 0 : << std::setw(3) << strBase << "] | "
697 0 : << std::setw(3) << ddl << " | 0x"
698 0 : << std::setfill('0') << std::hex
699 0 : << std::setw(2) << board << " | 0x"
700 0 : << std::setw(1) << chip << " | 0x"
701 0 : << std::setw(1) << chan << " | 0x"
702 0 : << std::setw(3) << addr << std::endl;
703 : } // for str ...
704 : } // for sec ...
705 0 : if (*ptr == '\0') continue;
706 0 : std::cout << " + + + + + "
707 0 : << std::endl;
708 0 : } // while rng ...
709 0 : std::cout << "---------------+-----+-------+------+------+--------"
710 0 : << std::endl;
711 :
712 0 : } // for det ...
713 : } // if det
714 0 : }
715 :
716 : //_____________________________________________________________________________
717 : //
718 : // EOF
719 : //
|
