]>
Commit | Line | Data |
---|---|---|
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 | /* | |
17 | $Log$ | |
18 | Revision 1.2 2007/10/12 13:36:27 cvetan | |
19 | Coding convention fixes from Stefan | |
20 | ||
21 | Revision 1.1 2007/09/17 10:23:31 cvetan | |
22 | New TPC monitoring package from Stefan Kniege. The monitoring package can be started by running TPCMonitor.C macro located in macros folder. | |
23 | ||
24 | */ | |
25 | ||
26 | //////////////////////////////////////////////////////////////////////// | |
27 | //// | |
28 | //// AliTPCMonitorMappingHandler class | |
29 | //// | |
30 | //// Class for handling mapping information TPC | |
31 | //// | |
32 | //// The mapping information for the TPC front end electornics (pads, front end cards) | |
33 | //// are handled by this class. | |
34 | //// The information from the design mapping and from the hardware address can be | |
35 | //// cross checked in the TPCMonitor.C. | |
36 | //// Malfunctioning front end cards can be identified by looking at single channels | |
37 | //// displayed with the TPCMonitor. | |
38 | //// | |
39 | //// | |
40 | //// Authors: Roland Bramm, | |
41 | //// Stefan Kniege, IKF, Frankfurt | |
42 | //// | |
43 | ///////////////////////////////////////////////////////////////////////// | |
44 | ||
45 | ||
46 | #include <cstdlib> | |
47 | #include "AliTPCMonitorMappingHandler.h" | |
48 | #include "TH1.h" | |
49 | #include "TLegend.h" | |
50 | #include <TMath.h> | |
51 | #include "AliLog.h" | |
52 | #include <Riostream.h> | |
53 | #include <string> | |
54 | #include <TString.h> | |
55 | ||
56 | using std::ifstream; | |
57 | using std::ios; | |
58 | ||
59 | ClassImp(AliTPCMonitorMappingHandler) | |
60 | ||
61 | //_____________________________________________________________________________________________ | |
62 | AliTPCMonitorMappingHandler::AliTPCMonitorMappingHandler(const Char_t* name, const Char_t* title): | |
63 | TNamed(name,title), | |
64 | fnumofChannels(0), | |
65 | fmaxHWAdress(0), | |
66 | fsizeofArray(0) | |
67 | { | |
68 | // Constructor : Initialize mapping arrays | |
69 | ||
70 | for(Int_t in = 0; in<159; ++in) | |
71 | for(Int_t jn = 0; jn<150; ++jn) | |
72 | fmappingChannelinRow[in][jn] = 0; | |
73 | ||
74 | for(Int_t i = 0; i<7000; ++i){ | |
75 | for(Int_t j = 0; j<8; ++j) | |
76 | fu2ftestmapping[i][j] = 0; | |
77 | ||
78 | for(Int_t j = 0; j<128; ++j) | |
79 | fecGainMap[i][j] = 0.; | |
80 | } | |
81 | ||
82 | for(Int_t i = 0; i<24000; ++i){ | |
83 | for(Int_t j = 0; j<2; ++j) | |
84 | fMapHwFECglobal[i][j]=0; | |
85 | ||
86 | for (Int_t j=0; j<11; ++j) | |
87 | fmapping[i][j]=0; | |
88 | fmapping[i][1]=-1; | |
89 | } | |
90 | } | |
91 | ||
92 | //____________________________________________________________________________ | |
93 | AliTPCMonitorMappingHandler::AliTPCMonitorMappingHandler(const AliTPCMonitorMappingHandler &maphand) : | |
94 | TNamed(maphand.GetName(),maphand.GetTitle()), | |
95 | fnumofChannels(maphand.fnumofChannels), | |
96 | fmaxHWAdress(maphand.fmaxHWAdress), | |
97 | fsizeofArray(maphand.fsizeofArray) | |
98 | { | |
99 | // copy constructor | |
100 | ||
101 | ||
102 | for(Int_t in = 0; in<159; ++in) | |
103 | for(Int_t jn = 0; jn<150; ++jn) | |
104 | fmappingChannelinRow[in][jn] = maphand.fmappingChannelinRow[in][jn]; | |
105 | ||
106 | for(Int_t i = 0; i<7000; ++i){ | |
107 | for(Int_t j = 0; j<8; ++j) | |
108 | fu2ftestmapping[i][j] = maphand.fu2ftestmapping[i][j]; | |
109 | ||
110 | for(Int_t j = 0; j<128; ++j) | |
111 | fecGainMap[i][j] = maphand.fecGainMap[i][j]; | |
112 | } | |
113 | ||
114 | for(Int_t i = 0; i<24000; ++i){ | |
115 | for (Int_t j = 0; j<2; ++j) | |
116 | fMapHwFECglobal[i][j]=maphand.fMapHwFECglobal[i][j]; | |
117 | ||
118 | for (Int_t j=0; j<11; ++j) | |
119 | fmapping[i][j] = maphand.fmapping[i][j]; | |
120 | } | |
121 | } | |
122 | ||
123 | ||
124 | //____________________________________________________________________________ | |
125 | AliTPCMonitorMappingHandler &AliTPCMonitorMappingHandler:: operator= (const AliTPCMonitorMappingHandler& maphand) | |
126 | { | |
127 | // assignment operator | |
128 | if (this == &maphand) return *this; | |
129 | ||
130 | fnumofChannels=maphand.fnumofChannels; | |
131 | fmaxHWAdress=maphand.fmaxHWAdress; | |
132 | fsizeofArray=maphand.fsizeofArray; | |
133 | ||
134 | for(Int_t in = 0; in<159; ++in) | |
135 | for(Int_t jn = 0; jn<150; ++jn) | |
136 | fmappingChannelinRow[in][jn] = maphand.fmappingChannelinRow[in][jn]; | |
137 | ||
138 | for(Int_t i = 0; i<7000; ++i){ | |
139 | for(Int_t j = 0; j<8; ++j) | |
140 | fu2ftestmapping[i][j]=maphand.fu2ftestmapping[i][j]; | |
141 | ||
142 | for(Int_t j = 0; j<128; ++j) | |
143 | fecGainMap[i][j] = maphand.fecGainMap[i][j]; | |
144 | } | |
145 | ||
146 | for(Int_t i = 0; i<24000; ++i){ | |
147 | for(Int_t j = 0; j<2; ++j) | |
148 | fMapHwFECglobal[i][j] = maphand.fMapHwFECglobal[i][j]; | |
149 | ||
150 | for (Int_t j=0; j<11; ++j) | |
151 | fmapping[i][j] = maphand.fmapping[i][j]; | |
152 | } | |
153 | ||
154 | return *this; | |
155 | } | |
156 | ||
157 | ||
158 | //_____________________________________________________________________________________________ | |
159 | AliTPCMonitorMappingHandler::~AliTPCMonitorMappingHandler() | |
160 | { | |
161 | // Destructor | |
162 | } | |
163 | ||
164 | //_____________________________________________________________________________________________ | |
165 | void AliTPCMonitorMappingHandler::ReadMapping(const char* mapfile) | |
166 | { | |
167 | // Read global Mapping file | |
168 | // Format of data in mapping file: | |
169 | // column 0: hadrware address | |
170 | // column 1: readout index in IROC/OROC | |
171 | // column 2: global pad row number (0-158) | |
172 | // column 3 pad number in row | |
173 | // column 4: connector | |
174 | // column 5: pin | |
175 | // column 6: fec number in IROC/OROC | |
176 | // column 7: fec channel | |
177 | // column 8: fec connector | |
178 | // column 9: altro channel | |
179 | // column 10: altro chip | |
180 | ||
181 | // Mapping data for a given hardware address are placed at the | |
182 | // index corresponding to the value of the hardware address in | |
183 | // the fmapping array.. | |
184 | // The mapping information for the hardware address 'hwaddr' | |
185 | // can hence be found in fmapping[hwaddr] | |
186 | ||
187 | ||
188 | Int_t version = -1; | |
189 | Int_t actPos = 0; | |
190 | ||
191 | ifstream infile(mapfile,ios::in); | |
192 | ||
193 | // printf("file1: %s\n",mapfile); | |
194 | if (!infile.is_open()) return; | |
195 | // int numLines = 0; | |
196 | // std::string line; | |
197 | // while ( std::getline(infile, line) ) | |
198 | // ++numLines; | |
199 | // infile.seekg(0,ios::beg); | |
200 | // infile.clear(); | |
201 | ||
202 | // printf("file: %s - %d\n",mapfile,numLines); | |
203 | ||
204 | infile >> version; | |
205 | // --numLines; | |
206 | ||
207 | infile >> fnumofChannels; | |
208 | // --numLines; | |
209 | ||
210 | infile >> fmaxHWAdress; | |
211 | fsizeofArray = fmaxHWAdress; | |
212 | // --numLines; | |
213 | ||
214 | //consistency check | |
215 | fnumofChannels=TMath::Abs(fnumofChannels); | |
216 | // fnumofChannels=TMath::Min(fnumofChannels,numLines); | |
217 | ||
218 | Int_t val=0; | |
219 | for(Int_t i = 0; i < fnumofChannels ; i++) { | |
220 | //get hw address | |
221 | infile >> actPos; | |
222 | ||
223 | //set first value of hw address to channel number | |
224 | if (actPos>0 && actPos<24000) | |
225 | fmapping[actPos][0] = (Short_t)i; | |
226 | ||
227 | //loop over channel parameters | |
228 | for(Int_t j = 1 ; j < 11 ; j++) { | |
229 | infile >> val; | |
230 | if (actPos>0 && actPos<24000) | |
231 | fmapping[actPos][j] = (Short_t)val; | |
232 | } | |
233 | } | |
234 | ||
235 | infile.close(); | |
236 | } | |
237 | ||
238 | //_____________________________________________________________________________________________ | |
239 | Int_t AliTPCMonitorMappingHandler::ReadFECMapping(const char* u2ftestfile) | |
240 | { | |
241 | // Read in Mapping of global FEC numbers to branches, rcu patches etc. | |
242 | // Format in Mapping file | |
243 | // column 0: global card number (set to 0 if card number does not exist) | |
244 | // column 1: side of the TPC | |
245 | // column 2: sector on the side (0-17) | |
246 | // column 3: rcu in the sector (0-5) | |
247 | // column 4: fec number in rcu (0-24) | |
248 | // column 5: fec number in branch (0-12) | |
249 | // column 6: branch number (0,1) | |
250 | // column 7: local hardware address of first channel (not used) | |
251 | ||
252 | // Order of data is kept in fu2ftestmapping | |
253 | ||
254 | ifstream datin(u2ftestfile); | |
255 | ||
256 | Int_t carry = 0; | |
257 | Int_t ncards = 0; | |
258 | ||
259 | for(Int_t ind = 0; ind<7000; ind++) { | |
260 | for(Int_t entr = 0; entr<8; entr++) { | |
261 | datin >> carry ; | |
262 | fu2ftestmapping[ind][entr] = carry ; | |
263 | ||
264 | if(entr==0 && carry!=0) ncards++; | |
265 | } | |
266 | } | |
267 | return ncards ; | |
268 | } | |
269 | ||
270 | ||
271 | ||
272 | //_____________________________________________________________________________________________ | |
273 | void AliTPCMonitorMappingHandler::ReadfecHwMap(Int_t sector) | |
274 | { | |
275 | // Create mapping of global FEC numbers to hardware addresses for a given sector | |
276 | ||
277 | Int_t fside =0; | |
278 | Int_t fsector = 0; | |
279 | Int_t fec = 0; | |
280 | Int_t branch = 0; | |
281 | Int_t rcupatch = 0; | |
282 | Int_t altrchann = 0; | |
283 | Int_t altrchip = 0; | |
284 | Int_t nextHwAddress = 0; | |
285 | Int_t nfecs = 0; | |
286 | ||
287 | if(sector/18==0) fside =65; | |
288 | else fside =67; | |
289 | ||
290 | if(sector>18) fsector= sector-18; | |
291 | else fsector= sector ; | |
292 | ||
293 | for(Int_t ind = 0; ind<7000; ind++) { | |
294 | if((Int_t)U2fGetSide(ind)==fside && U2fGetSector(ind)==fsector) { | |
295 | nfecs++; | |
296 | fec = U2fGetFECinBranch(ind); | |
297 | branch = U2fGetBranch(ind); | |
298 | rcupatch = U2fGetRCU(ind); | |
299 | ||
300 | for(Int_t ch = 0; ch<128; ch++) { | |
301 | altrchann = ch%16; | |
302 | altrchip = ch/16; | |
303 | ||
304 | nextHwAddress = ( ((branch&1)<<11) + (fec<<7) + (altrchip<<4) + (altrchann) + ((rcupatch-1)<<12) ); | |
305 | ||
306 | if (nextHwAddress<0 || nextHwAddress>=24000) continue; | |
307 | fMapHwFECglobal[nextHwAddress][0] = ind; | |
308 | fMapHwFECglobal[nextHwAddress][1] = ch ; | |
309 | } | |
310 | } | |
311 | } | |
312 | } | |
313 | //_____________________________________________________________________________________________ | |
314 | void AliTPCMonitorMappingHandler::ReadfecGainMap(const char* fecgainmap) | |
315 | { | |
316 | // Read global gain calibration pap | |
317 | // Format in file : | |
318 | // colummn 0 : FEC number | |
319 | // colums 1-128 : gain calibration factors | |
320 | ifstream datin(fecgainmap); | |
321 | ||
322 | Int_t fecnr = 0; | |
323 | Float_t val = 0.0 ; | |
324 | ||
325 | while(!datin.eof()) | |
326 | { | |
327 | datin >> fecnr ; | |
328 | for(Int_t in = 0; in<128; in++) | |
329 | { | |
330 | datin >> val ; | |
331 | if (fecnr<0 || fecnr>=7000) continue; | |
332 | fecGainMap[fecnr][in] = val; | |
333 | } | |
334 | } | |
335 | } | |
336 | ||
337 | //_____________________________________________________________________________________________ | |
338 | void AliTPCMonitorMappingHandler::ReadRowMappingGlob(const char* fpathtoMappingRowfile) | |
339 | { | |
340 | // Read mapping of hardware addresses in rows | |
341 | // Format of file: | |
342 | // column 0: global row number (0-158) | |
343 | // column 1: number of pads in this row (npads) | |
344 | // column 2-npads: hardware addresses for these pads | |
345 | ||
346 | TString readcarry; | |
347 | TString readcarry2; | |
348 | ifstream in(fpathtoMappingRowfile,ios::in); | |
349 | ||
350 | for(Int_t i = 0; i < 159 ; i++) { | |
351 | in >> readcarry; // row number | |
352 | in >> readcarry2; // numof pads | |
353 | fmappingChannelinRow[i][0] = readcarry2.Atoi(); | |
354 | fmappingChannelinRow[i][1] = TMath::Min(TMath::Abs(readcarry.Atoi()),140); //maximum number of pads is 140 | |
355 | ||
356 | for(Int_t j = 2 ; j < fmappingChannelinRow[i][0]+2 ; j++) { | |
357 | in >> readcarry; | |
358 | fmappingChannelinRow[i][j] = readcarry.Atoi(); | |
359 | } | |
360 | } | |
361 | in.close(); | |
362 | } | |
363 | ||
364 | ||
365 | ||
366 | //_____________________________________________________________________________________________ | |
367 | Int_t AliTPCMonitorMappingHandler::GetNumOfChannels() const | |
368 | { | |
369 | // Return number of channels | |
370 | return fnumofChannels; | |
371 | } | |
372 | ||
373 | //_____________________________________________________________________________________________ | |
374 | Int_t AliTPCMonitorMappingHandler::GetSizeofArray() const | |
375 | { | |
376 | // Return sise of global mapping fmapping array. | |
377 | // Value orresponds to max value of hardware addresses | |
378 | return fsizeofArray; | |
379 | } | |
380 | ||
381 | ||
382 | //_____________________________________________________________________________________________ | |
383 | const Short_t* AliTPCMonitorMappingHandler::GetLine(Int_t hwaddr) const | |
384 | { | |
385 | // Return pointer to mapping array for the hardware address hwaddr | |
386 | const Short_t* retval=0x0; | |
387 | if(hwaddr <= fsizeofArray) | |
388 | retval = fmapping[hwaddr]; | |
389 | else | |
390 | retval = 0; | |
391 | return retval; | |
392 | } | |
393 | ||
394 | //_____________________________________________________________________________________________ | |
395 | Int_t AliTPCMonitorMappingHandler::GetIndex(Int_t hwaddr) const | |
396 | { | |
397 | // Return readout index for the hardware address hwaddr | |
398 | Int_t retval; | |
399 | if(hwaddr <= fsizeofArray) | |
400 | retval = fmapping[hwaddr][1]; | |
401 | else | |
402 | retval = 0; | |
403 | return retval; | |
404 | } | |
405 | ||
406 | //_____________________________________________________________________________________________ | |
407 | Int_t AliTPCMonitorMappingHandler::GetPadRow(Int_t hwaddr) const | |
408 | { | |
409 | // Return global pad row for the hardware address hwaddr | |
410 | Int_t retval; | |
411 | if(hwaddr <= fsizeofArray) | |
412 | retval = fmapping[hwaddr][2]; | |
413 | else | |
414 | retval = 0; | |
415 | return retval; | |
416 | } | |
417 | ||
418 | //_____________________________________________________________________________________________ | |
419 | Int_t AliTPCMonitorMappingHandler::GetPad(Int_t hwaddr) const | |
420 | { | |
421 | // Return pad number in row for the hardware address hwaddr | |
422 | Int_t retval; | |
423 | if(hwaddr < fsizeofArray) | |
424 | retval = fmapping[hwaddr][3]; | |
425 | else | |
426 | retval = 0; | |
427 | return retval; | |
428 | } | |
429 | ||
430 | //_____________________________________________________________________________________________ | |
431 | Int_t AliTPCMonitorMappingHandler::GetConnector(Int_t hwaddr) const | |
432 | { | |
433 | // Return connector for the hardware address hwaddr | |
434 | Int_t retval; | |
435 | if(hwaddr <= fsizeofArray) | |
436 | retval = fmapping[hwaddr][4]; | |
437 | else | |
438 | retval = 0; | |
439 | return retval; | |
440 | } | |
441 | ||
442 | //_____________________________________________________________________________________________ | |
443 | Int_t AliTPCMonitorMappingHandler::GetPin(Int_t hwaddr) const | |
444 | { | |
445 | // Return pin for the hardware address hwaddr | |
446 | Int_t retval; | |
447 | if(hwaddr <= fsizeofArray) | |
448 | retval = fmapping[hwaddr][5]; | |
449 | else | |
450 | retval = 0; | |
451 | return retval; | |
452 | } | |
453 | ||
454 | //_____________________________________________________________________________________________ | |
455 | Int_t AliTPCMonitorMappingHandler::GetFEC(Int_t hwaddr) const | |
456 | { | |
457 | // Return fec number in IROC/OROC for the hardware address hwaddr | |
458 | Int_t retval; | |
459 | if(hwaddr <= fsizeofArray) | |
460 | retval = fmapping[hwaddr][6]; | |
461 | else | |
462 | retval = 0; | |
463 | return retval; | |
464 | } | |
465 | ||
466 | //_____________________________________________________________________________________________ | |
467 | Int_t AliTPCMonitorMappingHandler::GetFECchannel(Int_t hwaddr) const | |
468 | { | |
469 | // Return FEC channel for the hardware address hwaddr | |
470 | Int_t retval; | |
471 | if(hwaddr < fsizeofArray) | |
472 | retval = fmapping[hwaddr][7]; | |
473 | else | |
474 | retval = 0; | |
475 | return retval; | |
476 | } | |
477 | ||
478 | //_____________________________________________________________________________________________ | |
479 | Int_t AliTPCMonitorMappingHandler::GetFECconnector(Int_t hwaddr) const | |
480 | { | |
481 | // Return FEC connector for the hardware address hwaddr | |
482 | Int_t retval; | |
483 | if(hwaddr <= fsizeofArray) | |
484 | retval = fmapping[hwaddr][8]; | |
485 | else | |
486 | retval = 0; | |
487 | return retval; | |
488 | } | |
489 | ||
490 | //_____________________________________________________________________________________________ | |
491 | Int_t AliTPCMonitorMappingHandler::GetAltroChannel(Int_t hwaddr) const | |
492 | { | |
493 | // Return Altro channel for the hardware address hwaddr | |
494 | Int_t retval; | |
495 | if(hwaddr <= fsizeofArray) | |
496 | retval = fmapping[hwaddr][9]; | |
497 | else | |
498 | retval = 0; | |
499 | return retval; | |
500 | } | |
501 | ||
502 | //_____________________________________________________________________________________________ | |
503 | Int_t AliTPCMonitorMappingHandler::GetAltro(Int_t hwaddr) const | |
504 | { | |
505 | // Return Altro chip number in FEC for the hardware address hwaddr | |
506 | Int_t retval; | |
507 | if(hwaddr <= fsizeofArray) | |
508 | retval = fmapping[hwaddr][10]; | |
509 | else | |
510 | retval = 0; | |
511 | return retval; | |
512 | } | |
513 | ||
514 | ||
515 | //_____________________________________________________________________________________________ | |
516 | Int_t AliTPCMonitorMappingHandler::GetNumofPads(Int_t row) | |
517 | { | |
518 | // Return number of pads in row | |
519 | if(row>=0&&row<159) | |
520 | return fmappingChannelinRow[row][0]; | |
521 | else { | |
522 | AliError("Wrong row number"); | |
523 | return 0; | |
524 | } | |
525 | } | |
526 | ||
527 | //_____________________________________________________________________________________________ | |
528 | Int_t AliTPCMonitorMappingHandler::GetPadAddInRow(Int_t row,Int_t pad ) | |
529 | { | |
530 | // Return hardware address for given pad in row | |
531 | if(row>=0&&row<159) | |
532 | return fmappingChannelinRow[row][pad+2]; | |
533 | else { | |
534 | AliError("Wrong row number"); | |
535 | return 0; | |
536 | } | |
537 | } | |
538 | ||
539 | ||
540 | ||
541 | //_____________________________________________________________________________________________ | |
542 | Int_t AliTPCMonitorMappingHandler::U2fGetFECnr(Int_t index) const | |
543 | { | |
544 | // Return FEC number for index (FEC number should be equal to index) | |
545 | return fu2ftestmapping[index][0]; | |
546 | } | |
547 | ||
548 | //_____________________________________________________________________________________________ | |
549 | Int_t AliTPCMonitorMappingHandler::U2fGetSide(Int_t fecnr) const | |
550 | { | |
551 | // Return side on which FEC is installed | |
552 | return fu2ftestmapping[fecnr][1]; | |
553 | } | |
554 | ||
555 | //_____________________________________________________________________________________________ | |
556 | Int_t AliTPCMonitorMappingHandler::U2fGetSector(Int_t fecnr) const | |
557 | { | |
558 | // Return sector in which FEC is installed | |
559 | return fu2ftestmapping[fecnr][2]; | |
560 | } | |
561 | ||
562 | //_____________________________________________________________________________________________ | |
563 | Int_t AliTPCMonitorMappingHandler::U2fGetRCU(Int_t fecnr) const | |
564 | { | |
565 | // Rerurn rcu patch in which FEC is installed | |
566 | return fu2ftestmapping[fecnr][3]; | |
567 | } | |
568 | ||
569 | //_____________________________________________________________________________________________ | |
570 | Int_t AliTPCMonitorMappingHandler::U2fGetFECinRCU(Int_t fecnr) const | |
571 | { | |
572 | // Return index of FEC in RCU (0-25) | |
573 | return fu2ftestmapping[fecnr][4]; | |
574 | } | |
575 | ||
576 | //_____________________________________________________________________________________________ | |
577 | Int_t AliTPCMonitorMappingHandler::U2fGetFECinBranch(Int_t fecnr) const | |
578 | { | |
579 | // Return index of FEC in branch (0-12) | |
580 | return fu2ftestmapping[fecnr][5]; | |
581 | } | |
582 | ||
583 | //_____________________________________________________________________________________________ | |
584 | Int_t AliTPCMonitorMappingHandler::U2fGetBranch(Int_t fecnr) const | |
585 | { | |
586 | // Return branch in which FEC is installed (0,1) | |
587 | return fu2ftestmapping[fecnr][6]; | |
588 | ||
589 | } |