]>
Commit | Line | Data |
---|---|---|
2ab3623b | 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 | #include "AliMUONTriggerIO.h" | |
19 | ||
20 | #include "AliLog.h" | |
890cc210 | 21 | #include "AliMpCDB.h" |
5dde41b3 | 22 | #include "AliMpHelper.h" |
5eff9abc | 23 | #include "AliMpConstants.h" |
5dde41b3 | 24 | #include "AliMpFiles.h" |
2ab3623b | 25 | #include "AliMpDDLStore.h" |
5eff9abc | 26 | #include "AliMpLocalBoard.h" |
2ab3623b | 27 | #include "AliMpTriggerCrate.h" |
890cc210 | 28 | #include "AliMUONTriggerLut.h" |
2ab3623b | 29 | #include "AliMUONCalibParamNI.h" |
30 | #include "AliMUONVStore.h" | |
5eff9abc | 31 | |
32 | ||
2ab3623b | 33 | #include <Riostream.h> |
34 | #include <TSystem.h> | |
35 | ||
36 | /// \class AliMUONTriggerIO | |
37 | /// | |
38 | /// Handles read/write of masks and LUT to/from online files, | |
39 | /// to be used by Shuttle and Trigger DA. | |
40 | /// | |
5eff9abc | 41 | /// \author Laurent Aphecetche, Christian Finck Subatech |
890cc210 | 42 | /// \author Bogdan Vulpescu, LPC Clermont-Ferrand |
2ab3623b | 43 | |
44 | /// \cond CLASSIMP | |
45 | ClassImp(AliMUONTriggerIO) | |
46 | /// \endcond | |
47 | ||
48 | //_____________________________________________________________________________ | |
5eff9abc | 49 | AliMUONTriggerIO::AliMUONTriggerIO() |
50 | : TObject(), | |
51 | fLocalBoardIds(), | |
52 | fNofLocalBoards(0), | |
53 | fTriggerCrates(true), | |
5dde41b3 | 54 | fLocalBoards(true), |
55 | fGlobalCrate() | |
2ab3623b | 56 | { |
57 | /// ctor | |
5eff9abc | 58 | |
59 | fTriggerCrates.SetOwner(true); | |
60 | fTriggerCrates.SetSize(AliMpConstants::LocalBoardNofChannels()); | |
61 | ||
62 | fLocalBoards.SetOwner(true); | |
63 | fLocalBoards.SetSize(AliMpConstants::NofLocalBoards()+8); // included non-notified board FIXEME should be put in AliMpConstants | |
2ab3623b | 64 | } |
65 | ||
890cc210 | 66 | //_____________________________________________________________________________ |
5eff9abc | 67 | AliMUONTriggerIO::AliMUONTriggerIO(const char* regionalFileToRead) |
68 | :TObject(), | |
69 | fLocalBoardIds(), | |
70 | fNofLocalBoards(0), | |
71 | fTriggerCrates(true), | |
5dde41b3 | 72 | fLocalBoards(true), |
73 | fGlobalCrate() | |
890cc210 | 74 | { |
75 | /// ctor | |
76 | ReadRegional(regionalFileToRead,0); | |
77 | } | |
78 | ||
2ab3623b | 79 | //_____________________________________________________________________________ |
80 | AliMUONTriggerIO::~AliMUONTriggerIO() | |
81 | { | |
82 | /// dtor | |
83 | } | |
84 | ||
890cc210 | 85 | //_____________________________________________________________________________ |
86 | void | |
87 | AliMUONTriggerIO::DeCompAddress(UChar_t &ypos, UChar_t &ytri, UChar_t &xdev, UChar_t &xpos, | |
88 | UShort_t address) const | |
89 | { | |
90 | /// decompose the 15-bits address | |
91 | ||
92 | UChar_t bitsYpos = 4; | |
93 | UChar_t bitsYtri = 1; | |
94 | UChar_t bitsXdev = 5; | |
95 | // UChar_t bitsXpos = 5; | |
96 | ||
97 | UShort_t maskYpos = 0x000F; // ...0 00001111 | |
98 | UShort_t maskYtri = 0x0001; // ...0 00000001 | |
99 | UShort_t maskXdev = 0x001F; // ...0 00011111 | |
100 | UShort_t maskXpos = 0x001F; // ...0 00011111 | |
101 | ||
102 | ypos = address & maskYpos; | |
103 | ytri = (address >> bitsYpos) & maskYtri; | |
104 | xdev = (address >> (bitsYpos+bitsYtri)) & maskXdev; | |
105 | xpos = (address >> (bitsYpos+bitsYtri+bitsXdev)) & maskXpos; | |
106 | } | |
107 | ||
108 | //_____________________________________________________________________________ | |
109 | void | |
110 | AliMUONTriggerIO::FillLut(AliMUONTriggerLut& lut, | |
111 | Int_t icirc, UChar_t istripX, UChar_t idev, | |
112 | Int_t lutLpt[16][2], Int_t lutHpt[16][2]) | |
113 | { | |
114 | /// Fill the LUT histograms | |
115 | ||
116 | if (icirc == 0 && istripX == 0 && idev == 0) | |
117 | { | |
118 | AliDebug(1,"Copy board, not filled ..."); | |
119 | return; | |
120 | } | |
121 | ||
122 | Short_t iLptPlus, iLptMinu, iLptUnde; | |
123 | Short_t iHptPlus, iHptMinu, iHptUnde; | |
124 | ||
125 | iLptPlus = iLptMinu = iLptUnde = 0; | |
126 | iHptPlus = iHptMinu = iHptUnde = 0; | |
127 | ||
128 | for (Int_t istripY=0; istripY<16; istripY++) | |
129 | { | |
130 | if (lutLpt[istripY][1] == 0 && lutLpt[istripY][0] ==1) | |
131 | iLptMinu=iLptMinu+(1 << istripY); | |
132 | if (lutLpt[istripY][1] == 1 && lutLpt[istripY][0] ==0) | |
133 | iLptPlus=iLptPlus+(1 << istripY); | |
134 | if (lutLpt[istripY][1] == 1 && lutLpt[istripY][0] ==1) | |
135 | iLptUnde=iLptUnde+(1 << istripY); | |
136 | ||
137 | if (lutHpt[istripY][1] == 0 && lutHpt[istripY][0] ==1) | |
138 | iHptMinu=iHptMinu+(1 << istripY); | |
139 | if (lutHpt[istripY][1] == 1 && lutHpt[istripY][0] ==0) | |
140 | iHptPlus=iHptPlus+(1 << istripY); | |
141 | if (lutHpt[istripY][1] == 1 && lutHpt[istripY][0] ==1) | |
142 | iHptUnde=iHptUnde+(1 << istripY); | |
143 | ||
144 | } // loop on istripY | |
145 | ||
146 | lut.SetContent("LptMinu",icirc,istripX,idev,iLptMinu); | |
147 | lut.SetContent("LptUnde",icirc,istripX,idev,iLptUnde); | |
148 | lut.SetContent("LptPlus",icirc,istripX,idev,iLptPlus); | |
149 | ||
150 | lut.SetContent("HptMinu",icirc,istripX,idev,iLptMinu); | |
151 | lut.SetContent("HptUnde",icirc,istripX,idev,iLptUnde); | |
152 | lut.SetContent("HptPlus",icirc,istripX,idev,iLptPlus); | |
153 | } | |
154 | ||
2ab3623b | 155 | //_____________________________________________________________________________ |
156 | Int_t | |
157 | AliMUONTriggerIO::LocalBoardId(Int_t index) const | |
158 | { | |
159 | /// Return the i-th localBoardId, or -1 if index is out of bounds | |
160 | if ( index >= 0 && index < fNofLocalBoards ) | |
161 | { | |
162 | return fLocalBoardIds[index]; | |
163 | } | |
164 | return -1; | |
165 | } | |
166 | ||
167 | //_____________________________________________________________________________ | |
168 | Int_t | |
169 | AliMUONTriggerIO::ReadLocalMasks(const char* localFile, AliMUONVStore& localMasks) const | |
170 | { | |
171 | /// Fills the local masks store from file | |
172 | ||
173 | if ( !NofLocalBoards() ) | |
174 | { | |
175 | AliError("No local board to read"); | |
176 | return 0; | |
177 | } | |
178 | ||
179 | FILE* fp = fopen(gSystem->ExpandPathName(localFile),"r"); | |
180 | if (!fp) | |
181 | { | |
182 | AliError(Form("Could not read file %s",localFile)); | |
183 | return 0; | |
184 | } | |
185 | ||
186 | UShort_t maskBuffer[8]; | |
187 | ||
188 | Int_t nLocalBoards(0); | |
189 | ||
190 | while ( fread ( maskBuffer, 2, 8, fp ) ) | |
191 | { | |
192 | Int_t localBoardId = LocalBoardId(nLocalBoards); | |
193 | AliDebug(1,Form("LB %03d X1 %4x X2 %4x X3 %4x X4 %4x " | |
194 | "Y1 %4x Y2 %4x Y3 %4x Y4 %4x", | |
195 | localBoardId, | |
196 | maskBuffer[0], | |
197 | maskBuffer[1], | |
198 | maskBuffer[2], | |
199 | maskBuffer[3], | |
200 | maskBuffer[4], | |
201 | maskBuffer[5], | |
202 | maskBuffer[6], | |
203 | maskBuffer[7])); | |
204 | ||
205 | if ( localBoardId ) | |
206 | { | |
207 | AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8,localBoardId,0,0); | |
5eff9abc | 208 | for ( Int_t index = 0; index < 8; ++index ) |
2ab3623b | 209 | { |
5eff9abc | 210 | localBoard->SetValueAsInt(index,0,maskBuffer[index]); |
2ab3623b | 211 | } |
212 | localMasks.Add(localBoard); | |
213 | } | |
214 | ||
215 | ++nLocalBoards; | |
216 | } | |
217 | ||
218 | if ( nLocalBoards != NofLocalBoards() ) | |
219 | { | |
220 | AliError(Form("Read %d out of %d local boards", | |
221 | nLocalBoards, NofLocalBoards())); | |
222 | } | |
223 | ||
224 | fclose(fp); | |
225 | ||
226 | return nLocalBoards; | |
227 | } | |
228 | ||
890cc210 | 229 | //_____________________________________________________________________________ |
230 | void | |
231 | AliMUONTriggerIO::ReadLocalLUT(AliMUONTriggerLut& lut, | |
232 | Int_t localBoardId, | |
233 | FILE* flut) | |
234 | { | |
235 | /// Read the LUT for one local board from an online file | |
236 | ||
237 | UShort_t address; | |
238 | ||
239 | UChar_t buffer; | |
240 | UChar_t mask1 = 0xF0; | |
241 | UChar_t mask2 = 0x0F; | |
242 | UChar_t maskLpt = 0x0C; | |
243 | UChar_t maskHpt = 0x03; | |
244 | UChar_t lh, lpt, hpt; | |
245 | ||
246 | UChar_t xpos, xdev, ypos, ytri; | |
247 | ||
248 | Int_t lutLpt[16][2], lutHpt[16][2]; | |
249 | ||
250 | Int_t boardnr = localBoardId; | |
251 | ||
252 | AliDebug(1,Form("Reading LUT values for local board %d",boardnr)); | |
253 | ||
254 | Int_t ny = 0; | |
255 | ||
256 | // create the 32767 addresses for the 4-bits lpt and hpt half-bytes | |
257 | for (UShort_t ilut = 0; ilut < 0x7FFF; ilut += 2) | |
258 | { | |
259 | // read two lut addresses at once | |
260 | fread(&buffer,1,1,flut); | |
261 | ||
262 | // 1st 4-bits half-byte | |
263 | address = ilut; | |
264 | lh = (buffer & mask1) >> 4; | |
265 | ||
266 | // Lpt and Hpt response | |
267 | lpt = (lh & maskLpt) >> 2; | |
268 | hpt = lh & maskHpt; | |
269 | ||
270 | // decompose the 15-bits address | |
271 | DeCompAddress(ypos,ytri,xdev,xpos,address); | |
272 | ||
273 | // calculate group of y-strips | |
274 | if (ny < 16) | |
275 | { | |
276 | lutLpt[ny][0] = lpt & 1; | |
277 | lutLpt[ny][1] = (lpt & 2) >> 1; | |
278 | lutHpt[ny][0] = hpt & 1; | |
279 | lutHpt[ny][1] = (hpt & 2) >> 1; | |
280 | ny++; | |
281 | if (ny == 16) | |
282 | { | |
283 | ny = 0; | |
284 | // ytri == 1 means no trigger in y-direction | |
285 | if (ytri == 0) | |
286 | { | |
287 | FillLut(lut,boardnr,xpos,xdev,lutLpt,lutHpt); | |
288 | } | |
289 | } | |
290 | } | |
291 | ||
292 | // 2nd 4-bits half-byte | |
293 | address = ilut+1; | |
294 | lh = (buffer & mask2); | |
295 | ||
296 | // Lpt and Hpt response | |
297 | lpt = (lh & maskLpt) >> 2; | |
298 | hpt = lh & maskHpt; | |
299 | ||
300 | // decompose the 15-bits address | |
301 | DeCompAddress(ypos,ytri,xdev,xpos,address); | |
302 | ||
303 | // calculate group of y-strips | |
304 | if (ny < 16) | |
305 | { | |
306 | lutLpt[ny][0] = lpt & 1; | |
307 | lutLpt[ny][1] = (lpt & 2) >> 1; | |
308 | lutHpt[ny][0] = hpt & 1; | |
309 | lutHpt[ny][1] = (hpt & 2) >> 1; | |
310 | ny++; | |
311 | if (ny == 16) | |
312 | { | |
313 | ny = 0; | |
314 | // ytri == 1 means no trigger in y-direction | |
315 | if (ytri == 0) | |
316 | { | |
317 | FillLut(lut,boardnr,xpos,xdev,lutLpt,lutHpt); | |
318 | } | |
319 | } | |
320 | } | |
321 | } | |
322 | } | |
323 | ||
324 | //_____________________________________________________________________________ | |
325 | Bool_t | |
326 | AliMUONTriggerIO::ReadLUT(const char* lutFileToRead, AliMUONTriggerLut& lut) | |
327 | { | |
328 | /// Fill the LUT object from online file | |
329 | ||
330 | if ( !NofLocalBoards() ) | |
331 | { | |
332 | AliError("No local board id defined. Must read a regional file first"); | |
333 | return kFALSE; | |
334 | } | |
335 | ||
336 | FILE* flut = fopen(gSystem->ExpandPathName(lutFileToRead),"rb"); | |
337 | if (!flut) | |
338 | { | |
ca6cee23 | 339 | AliError(Form("Could not read LUT file %s",lutFileToRead)); |
890cc210 | 340 | return kFALSE; |
341 | } | |
342 | ||
343 | for ( Int_t i = 0; i < NofLocalBoards(); ++i ) | |
344 | { | |
345 | ReadLocalLUT(lut,LocalBoardId(i),flut); | |
346 | } | |
347 | ||
348 | fclose(flut); | |
349 | ||
350 | return kTRUE; | |
351 | ||
352 | } | |
353 | ||
2ab3623b | 354 | //_____________________________________________________________________________ |
355 | Bool_t | |
356 | AliMUONTriggerIO::ReadMasks(const char* localFile, | |
357 | const char* regionalFile, | |
5dde41b3 | 358 | const char* globalFile, |
2ab3623b | 359 | AliMUONVStore* localMasks, |
360 | AliMUONVStore* regionalMasks, | |
5dde41b3 | 361 | AliMUONVCalibParam* globalMasks, |
5eff9abc | 362 | Bool_t warn) |
2ab3623b | 363 | { |
364 | /// Fill the various masks store from files | |
365 | ||
366 | if ( !regionalFile ) | |
367 | { | |
368 | AliError("Must have a regional file name to proceeed"); | |
369 | return kFALSE; | |
370 | } | |
371 | ||
5eff9abc | 372 | Int_t nCrates = ReadRegional(regionalFile,regionalMasks, warn); |
2ab3623b | 373 | |
374 | if (!nCrates) return kFALSE; | |
375 | ||
376 | if (localMasks && localFile) | |
377 | { | |
378 | Int_t nLocal = ReadLocalMasks(localFile,*localMasks); | |
379 | AliDebug(1,Form("Read masks for %d local boards",nLocal)); | |
380 | } | |
381 | ||
5dde41b3 | 382 | Int_t nDarc = ReadGlobal(globalFile, globalMasks); |
383 | AliDebug(1,Form("Read disable for %d DARC boards",nDarc)); | |
384 | ||
385 | if (!nDarc) return kFALSE; | |
386 | ||
2ab3623b | 387 | return kTRUE; |
388 | } | |
389 | ||
5dde41b3 | 390 | //_____________________________________________________________________________ |
391 | Int_t | |
392 | AliMUONTriggerIO::ReadGlobal(const char* globalFile, AliMUONVCalibParam* globalMasks) | |
393 | { | |
394 | /// read the global crate file and file corresponding mask | |
395 | /// the masks are disable bit for each crate, 8 per darc board | |
396 | /// bit value 0 means enable, 1 means disable * | |
397 | ||
398 | Int_t nDarc = 0; | |
399 | if (!AliMpDDLStore::ReadGlobalTrigger(fGlobalCrate, globalFile)) return 0; | |
400 | ||
401 | UChar_t mask = fGlobalCrate.GetFirstDarcDisable(); | |
402 | ULong_t vmeAddr = fGlobalCrate.GetFirstDarcVmeAddr(); | |
403 | if (vmeAddr) nDarc++; | |
404 | globalMasks->SetValueAsInt(0,0,mask); | |
405 | ||
406 | mask = fGlobalCrate.GetSecondDarcDisable(); | |
407 | vmeAddr = fGlobalCrate.GetSecondDarcVmeAddr(); | |
408 | if (vmeAddr) nDarc++; | |
409 | globalMasks->SetValueAsInt(1,0,mask); | |
410 | ||
411 | return nDarc; | |
412 | } | |
413 | ||
2ab3623b | 414 | //_____________________________________________________________________________ |
415 | Int_t | |
5eff9abc | 416 | AliMUONTriggerIO::ReadRegional(const char* regionalFile, AliMUONVStore* regionalMasks, Bool_t warn) |
2ab3623b | 417 | { |
418 | /// Read regional file to fill the regional mask store *AND* | |
419 | /// determine the order in which local boards will appear in local | |
420 | /// and lut files. | |
421 | ||
422 | fLocalBoardIds.Reset(); | |
423 | fNofLocalBoards = 0; | |
5eff9abc | 424 | |
5eff9abc | 425 | AliMpLocalBoard* board = 0x0; |
426 | AliMpTriggerCrate* crate = 0x0; | |
427 | ||
2ab3623b | 428 | std::ifstream in(gSystem->ExpandPathName(regionalFile)); |
429 | if (!in.good()) | |
430 | { | |
431 | AliError(Form("Cannot read file %s",regionalFile)); | |
432 | return 0; | |
433 | } | |
434 | ||
435 | char name[80]; | |
436 | char line[80]; | |
437 | ||
438 | Int_t nCrates(0); | |
439 | ||
5eff9abc | 440 | |
441 | if (warn) | |
890cc210 | 442 | { |
5eff9abc | 443 | if (!AliMpDDLStore::Instance(kFALSE)) |
444 | { | |
445 | AliMpCDB::LoadDDLStore(); | |
446 | } | |
890cc210 | 447 | } |
5eff9abc | 448 | |
2ab3623b | 449 | while (!in.eof()) |
450 | { | |
451 | in.getline(name,80); | |
452 | ||
453 | if (!strlen(name)) break; | |
454 | ||
455 | AliDebug(1,Form("Looking for crate %s",name)); | |
456 | ||
5eff9abc | 457 | if (warn) |
2ab3623b | 458 | { |
5eff9abc | 459 | AliMpTriggerCrate* triggerCrate = AliMpDDLStore::Instance()->GetTriggerCrate(name); |
2ab3623b | 460 | |
5eff9abc | 461 | if (!triggerCrate) |
462 | { | |
463 | AliError(Form("Mapping error : could not get crate %s",name)); | |
464 | return 0; | |
465 | } | |
466 | } | |
2ab3623b | 467 | ++nCrates; |
468 | ||
469 | UShort_t id, mask; | |
470 | Int_t mode, coincidence; | |
471 | ||
472 | in.getline(line,80); | |
473 | sscanf(line,"%hx",&id); | |
474 | ||
475 | in.getline(line,80); | |
476 | sscanf(line,"%d",&mode); | |
477 | ||
478 | in.getline(line,80); | |
479 | sscanf(line,"%d",&coincidence); | |
480 | ||
481 | in.getline(line,80); | |
482 | sscanf(line,"%hx",&mask); | |
483 | ||
5eff9abc | 484 | if (!GetTriggerCrate(name, false)) { |
485 | crate = new AliMpTriggerCrate(name, id, mask, mode, coincidence); | |
486 | fTriggerCrates.Add(name, crate); | |
487 | } | |
488 | ||
2ab3623b | 489 | if ( regionalMasks ) |
490 | { | |
5dde41b3 | 491 | AliMUONVCalibParam* regionalBoard = new AliMUONCalibParamNI(1,1,id,0,0); |
2ab3623b | 492 | regionalBoard->SetValueAsInt(0,0,mask); |
493 | regionalMasks->Add(regionalBoard); | |
2ab3623b | 494 | } |
495 | ||
496 | AliDebug(1,Form("Name %s ID %x Mode %d Coin %d Mask %x", | |
497 | name,id,mode,coincidence,mask)); | |
498 | ||
499 | for ( Int_t i = 0; i < 16; ++i ) | |
500 | { | |
501 | if ( (mask >> i ) & 0x1 ) | |
502 | { | |
503 | in.getline(line,80); | |
5eff9abc | 504 | Char_t localBoardName[20]; |
505 | Int_t j,localBoardId; | |
506 | UInt_t switches; | |
2ab3623b | 507 | sscanf(line,"%02d %s %03d %03x",&j,localBoardName,&localBoardId,&switches); |
508 | AliDebug(1,Form("%02d %s %03d %03x",j,localBoardName,localBoardId,switches)); | |
5eff9abc | 509 | |
5eff9abc | 510 | // FIXEME should not need this array anymore |
2ab3623b | 511 | fLocalBoardIds.Set(fNofLocalBoards+1); |
512 | fLocalBoardIds[fNofLocalBoards] = localBoardId; | |
513 | ++fNofLocalBoards; | |
5eff9abc | 514 | |
515 | board = new AliMpLocalBoard(localBoardId, localBoardName, j); | |
516 | board->SetSwitch(switches); | |
517 | board->SetCrate(name); | |
5dde41b3 | 518 | if (localBoardId > AliMpConstants::NofLocalBoards()) |
519 | board->SetNotified(false); | |
520 | ||
521 | // DE list | |
522 | in.getline(line,80); | |
523 | TArrayI list; | |
524 | TString tmp(AliMpHelper::Normalize(line)); | |
525 | AliMpHelper::DecodeName(tmp,' ',list); | |
526 | ||
527 | for (Int_t i = 0; i < list.GetSize(); ++i) | |
528 | board->AddDE(list[i]); | |
529 | ||
530 | // set copy number and transverse connector | |
531 | in.getline(line,80); | |
532 | tmp = AliMpHelper::Normalize(line); | |
533 | AliMpHelper::DecodeName(tmp,' ',list); | |
534 | ||
535 | board->SetInputXfrom(list[0]); | |
536 | board->SetInputXto(list[1]); | |
537 | ||
538 | board->SetInputYfrom(list[2]); | |
539 | board->SetInputYto(list[3]); | |
540 | ||
541 | board->SetTC(list[4]); | |
542 | ||
5eff9abc | 543 | fLocalBoards.Add(localBoardId, board); |
544 | crate->AddLocalBoard(localBoardId); | |
2ab3623b | 545 | } |
546 | } | |
547 | } | |
548 | ||
549 | return nCrates; | |
550 | } | |
890cc210 | 551 | |
552 | //_____________________________________________________________________________ | |
553 | Bool_t | |
554 | AliMUONTriggerIO::WriteLUT(const AliMUONTriggerLut& lut, | |
555 | const char* lutFileToWrite) | |
556 | { | |
557 | /// Convert an offline lut into an online (binary) lut file | |
558 | ||
559 | if ( !NofLocalBoards() ) | |
560 | { | |
561 | AliError("No local board id defined. Must read a regional file first"); | |
562 | return kFALSE; | |
563 | } | |
564 | ||
565 | FILE* flut = fopen(gSystem->ExpandPathName(lutFileToWrite),"wb"); | |
566 | if (!flut) | |
567 | { | |
568 | AliError(Form("Could not create output LUT file %s",lutFileToWrite)); | |
569 | return kFALSE; | |
570 | } | |
571 | ||
572 | for ( Int_t i = 0; i < NofLocalBoards(); ++i ) | |
573 | { | |
574 | WriteLocalLUT(lut,LocalBoardId(i),flut); | |
575 | } | |
576 | ||
577 | fclose(flut); | |
578 | ||
579 | return kTRUE; | |
580 | } | |
581 | ||
5eff9abc | 582 | //_____________________________________________________________________________ |
583 | Bool_t | |
584 | AliMUONTriggerIO::WriteMasks(const char* localFile, | |
585 | const char* regionalFile, | |
5dde41b3 | 586 | const char* globalFile, |
5eff9abc | 587 | AliMUONVStore* localMasks, |
588 | AliMUONVStore* regionalMasks, | |
5dde41b3 | 589 | AliMUONVCalibParam* globalMasks) const |
5eff9abc | 590 | { |
591 | /// write mask files | |
5dde41b3 | 592 | Bool_t ok; |
593 | ok = WriteLocalMasks(localFile, *localMasks); | |
594 | ok &= WriteRegional(regionalFile, regionalMasks); | |
595 | ok &= WriteGlobal(globalFile, globalMasks); | |
596 | ||
597 | return ok; | |
598 | } | |
5eff9abc | 599 | |
5dde41b3 | 600 | //_____________________________________________________________________________ |
601 | Bool_t | |
602 | AliMUONTriggerIO::WriteGlobal(const char* globalFile, AliMUONVCalibParam* globalMasks) const | |
603 | { | |
604 | /// write global file | |
605 | /// if no global masks defined take the one of configuration | |
606 | ||
607 | ofstream out; | |
608 | Int_t disable = 0; | |
609 | ||
610 | out.open(globalFile); | |
611 | if (!out.good()) | |
612 | { | |
613 | AliError(Form("Could not create output regional file %s", globalFile)); | |
614 | return kFALSE; | |
615 | } | |
616 | ||
617 | out << fGlobalCrate.GetName() << endl; | |
618 | ||
619 | // Jtag | |
620 | out << fGlobalCrate.GetJtagName() << endl; | |
621 | out << Form("0x%08x", fGlobalCrate.GetJtagVmeAddr()) << endl; | |
622 | out << Form("%d %d %d", fGlobalCrate.GetJtagClockDiv(), | |
623 | fGlobalCrate.GetJtagRxPhase(), fGlobalCrate.GetJtagRdDelay()) << endl; | |
624 | ||
625 | for (Int_t i = 0; i < fGlobalCrate.GetJtagNofLines(); ++i) | |
626 | out << Form("%d ", fGlobalCrate.GetEnableJtag(i)); | |
627 | out << endl; | |
628 | ||
629 | ||
630 | for (Int_t i = 0; i < fGlobalCrate.GetJtagNofLines(); ++i) | |
631 | { | |
632 | out << i << endl; | |
633 | for (Int_t j = 0; j < fGlobalCrate.GetJtagNofLines(); ++j) | |
634 | out << Form(" %s", fGlobalCrate.GetJtagCrateName(i,j).Data()) << endl; | |
635 | } | |
636 | ||
637 | // first darc board | |
638 | out << fGlobalCrate.GetFirstDarcName() << endl; | |
639 | out << Form("0x%08x", fGlobalCrate.GetFirstDarcVmeAddr()) << endl; | |
640 | out << fGlobalCrate.GetFirstDarcType() << endl; | |
641 | if (globalMasks != 0x0) | |
642 | disable = globalMasks->ValueAsInt(0); | |
643 | else | |
644 | disable = fGlobalCrate.GetFirstDarcDisable(); | |
645 | out << Form("0x%02x", disable) << endl; | |
646 | out << Form("0x%x", fGlobalCrate.GetFirstDarcL0Delay()) << endl; | |
647 | out << Form("0x%x", fGlobalCrate.GetFirstDarcL1TimeOut()) << endl; | |
648 | ||
649 | // second darc board | |
650 | out << fGlobalCrate.GetSecondDarcName() << endl; | |
651 | out << Form("0x%08x", fGlobalCrate.GetSecondDarcVmeAddr()) << endl; | |
652 | out << fGlobalCrate.GetSecondDarcType() << endl; | |
653 | if (globalMasks != 0x0) | |
654 | disable = globalMasks->ValueAsInt(1); | |
655 | else | |
656 | disable = fGlobalCrate.GetSecondDarcDisable(); | |
657 | out << Form("0x%02x", disable) << endl; | |
658 | out << Form("0x%x", fGlobalCrate.GetSecondDarcL0Delay()) << endl; | |
659 | out << Form("0x%x", fGlobalCrate.GetSecondDarcL1TimeOut()) << endl; | |
660 | ||
661 | // global board | |
662 | out << fGlobalCrate.GetGlobalName() << endl; | |
663 | out << Form("0x%08x", fGlobalCrate.GetGlobalVmeAddr()) << endl; | |
664 | for (Int_t i = 0; i < fGlobalCrate.GetGlobalNofRegisters(); ++i) | |
665 | out << Form("0x%x", fGlobalCrate.GetGlobalRegister(i)) << endl; | |
666 | ||
667 | // Fet board | |
668 | out << fGlobalCrate.GetFetName() << endl; | |
669 | out << Form("0x%08x", fGlobalCrate.GetFetVmeAddr()) << endl; | |
670 | for (Int_t i = 0; i < fGlobalCrate.GetFetNofRegisters(); ++i) | |
671 | out << Form("0x%x", fGlobalCrate.GetFetRegister(i)) << endl; | |
672 | ||
673 | return kTRUE; | |
5eff9abc | 674 | } |
5dde41b3 | 675 | |
5eff9abc | 676 | |
677 | //_____________________________________________________________________________ | |
678 | Bool_t | |
679 | AliMUONTriggerIO::WriteRegional(const char* regionalFile, AliMUONVStore* regionalMasks) const | |
680 | { | |
681 | ||
682 | /// write regional mask with the current configuration | |
5dde41b3 | 683 | /// if regional masks not defined, take the one from current configuration |
5eff9abc | 684 | |
685 | ofstream out; | |
686 | out.open(regionalFile); | |
5dde41b3 | 687 | |
5eff9abc | 688 | if (!out.good()) |
689 | { | |
690 | AliError(Form("Could not create output regional file %s",regionalFile)); | |
691 | return kFALSE; | |
692 | } | |
693 | ||
694 | for (Int_t iCrate = 0; iCrate < fTriggerCrates.GetSize(); ++iCrate) | |
695 | { | |
696 | AliMpTriggerCrate* crate = static_cast<AliMpTriggerCrate*>(fTriggerCrates.GetObject(iCrate)); | |
697 | ||
698 | out << crate->GetName() << endl; | |
699 | out << Form("%02x", crate->GetId()) << endl; | |
700 | out << crate->GetMode() << endl; | |
701 | out << crate->GetCoinc() << endl; | |
702 | ||
5dde41b3 | 703 | UShort_t masks = 0; |
704 | if (regionalMasks != 0x0) | |
705 | { | |
706 | AliMUONVCalibParam* maskParam = | |
707 | static_cast<AliMUONVCalibParam*>(regionalMasks->FindObject(crate->GetId())); | |
708 | masks = maskParam->ValueAsInt(0,0); | |
709 | } | |
710 | else | |
711 | { | |
712 | masks = crate->GetMask(); | |
713 | } | |
714 | ||
715 | out << Form("%04x", masks) << endl; | |
716 | ||
5eff9abc | 717 | for (Int_t iLocal = 0; iLocal < crate->GetNofLocalBoards(); ++iLocal) |
718 | { | |
719 | Int_t localBoardId = crate->GetLocalBoardId(iLocal); | |
720 | ||
721 | AliMpLocalBoard* board = static_cast<AliMpLocalBoard*>(fLocalBoards.GetValue(localBoardId)); | |
5eff9abc | 722 | |
723 | out << Form("%02d ", board->GetSlot()) | |
724 | << board->GetName() | |
725 | << Form(" %03d ", localBoardId) | |
726 | << Form("%03x", board->GetSwitch()) | |
727 | << endl; | |
5dde41b3 | 728 | |
729 | out << " "; | |
730 | for (Int_t i = 0; i < board->GetNofDEs(); ++i) | |
731 | out << Form("%4d ", board->GetDEId(i)); | |
732 | out << endl; | |
733 | ||
734 | // print copy card numbers | |
735 | out << Form(" %4d %4d", board->GetInputXfrom(), board->GetInputXto()); | |
736 | out << Form(" %4d %4d", board->GetInputYfrom(), board->GetInputYto()); | |
737 | out << Form(" %4d", board->GetTC()) << endl; | |
5eff9abc | 738 | } |
739 | } | |
740 | out.close(); | |
741 | ||
742 | return kTRUE; | |
743 | } | |
744 | ||
745 | //_____________________________________________________________________________ | |
746 | Bool_t | |
747 | AliMUONTriggerIO::WriteLocalMasks(const char* localFile, AliMUONVStore& localMasks) const | |
748 | { | |
749 | /// write local mask | |
750 | /// removing/adding enable for a local board need a update of the configuration | |
751 | /// before calling this method | |
752 | /// mask are written for all boards including the copy card (Ch.F.) | |
753 | ||
754 | FILE* fp = fopen(gSystem->ExpandPathName(localFile),"wb"); | |
755 | if (!fp) | |
756 | { | |
757 | AliError(Form("Could not create output local file %s",localFile)); | |
758 | return kFALSE; | |
759 | } | |
760 | ||
761 | UShort_t maskBuffer[8]; | |
762 | ||
763 | for (Int_t iCrate = 0; iCrate < fTriggerCrates.GetSize(); ++iCrate) | |
764 | { | |
765 | AliMpTriggerCrate* crate = static_cast<AliMpTriggerCrate*>(fTriggerCrates.GetObject(iCrate)); | |
766 | ||
767 | UShort_t mask = crate->GetMask(); // getting mask from current config | |
768 | ||
769 | for (Int_t iLocal = 0; iLocal < crate->GetNofLocalBoards(); ++iLocal) | |
770 | { | |
771 | Int_t localBoardId = crate->GetLocalBoardId(iLocal); | |
772 | ||
773 | if ( (mask >> iLocal ) & 0x1 ) | |
774 | { | |
775 | AliMUONVCalibParam* localMask = | |
776 | static_cast<AliMUONVCalibParam*>(localMasks.FindObject(localBoardId)); | |
777 | ||
778 | for (Int_t index = 0; index < 8; ++index) | |
779 | { | |
780 | maskBuffer[index] = localMask->ValueAsInt(index,0); | |
781 | } | |
782 | ||
783 | fwrite ( maskBuffer, 2, 8, fp); | |
784 | } | |
785 | ||
786 | } | |
787 | } | |
788 | ||
789 | fclose(fp); | |
790 | ||
791 | return kTRUE; | |
792 | ||
793 | } | |
794 | ||
890cc210 | 795 | //_____________________________________________________________________________ |
796 | void | |
797 | AliMUONTriggerIO::WriteLocalLUT(const AliMUONTriggerLut& lut, | |
798 | Int_t localBoardId, | |
799 | FILE* flut) | |
800 | { | |
801 | /// loop over the address for the 4-bits lpt and hpt decisions | |
802 | ||
803 | const Int_t kMaskYpos = 0x0F; | |
804 | const Int_t kMaskYtri = 0x01; | |
805 | const Int_t kMaskXdev = 0x1F; | |
806 | const Int_t kMaskXpos = 0x1F; | |
807 | ||
808 | for (Int_t i = 0; i < 32768; ++i) | |
809 | { | |
810 | Int_t lutLpt[2] = { 0 }; | |
811 | Int_t lutHpt[2] = { 0 }; | |
812 | ||
813 | // decompose address | |
814 | Int_t iYpos = i & kMaskYpos; | |
815 | Int_t iYtri = ( i >> 4 ) & kMaskYtri; | |
816 | Int_t iXdev = ( i >> ( 4 + 1 ) ) & kMaskXdev; | |
817 | Int_t iXpos = ( i >> ( 4 + 1 + 5 ) ) & kMaskXpos; | |
818 | ||
819 | // iYtri == 1 means no trigger in y-direction | |
820 | if (iYtri == 0) | |
821 | { | |
822 | lut.GetLutOutput(localBoardId,iXpos,iXdev,iYpos,lutLpt,lutHpt); | |
823 | } | |
824 | ||
825 | UChar_t buffer; | |
826 | ||
827 | // fill byte | |
828 | if (i%2 == 0) | |
829 | { | |
830 | // upper half-byte | |
831 | buffer = 0; | |
832 | buffer += lutLpt[1] << 7; | |
833 | buffer += lutLpt[0] << 6; | |
834 | buffer += lutHpt[1] << 5; | |
835 | buffer += lutHpt[0] << 4; | |
836 | } else { | |
837 | // lower half-byte | |
838 | buffer += lutLpt[1] << 3; | |
839 | buffer += lutLpt[0] << 2; | |
840 | buffer += lutHpt[1] << 1; | |
841 | buffer += lutHpt[0] << 0; | |
842 | fwrite(&buffer,1,1,flut); | |
843 | } | |
844 | } | |
845 | } | |
846 | ||
5eff9abc | 847 | //_____________________________________________________________________________ |
848 | AliMpTriggerCrate* | |
849 | AliMUONTriggerIO::GetTriggerCrate(TString name, Bool_t warn) const | |
850 | { | |
851 | /// Return trigger crate with given name | |
852 | ||
853 | AliMpTriggerCrate* crate | |
854 | = (AliMpTriggerCrate*) fTriggerCrates.GetValue(name.Data()); | |
855 | ||
856 | if ( ! crate && warn ) { | |
857 | AliErrorStream() | |
858 | << "Trigger crate with name = " << name.Data() << " not defined." << endl; | |
859 | } | |
860 | ||
861 | return crate; | |
862 | } | |
863 | ||
864 | //_____________________________________________________________________________ | |
865 | AliMpLocalBoard* | |
866 | AliMUONTriggerIO::GetLocalBoard(Int_t localBoardId, Bool_t warn) const | |
867 | { | |
868 | /// Return bus patch with given Id | |
869 | ||
870 | AliMpLocalBoard* localBoard | |
871 | = (AliMpLocalBoard*) fLocalBoards.GetValue(localBoardId); | |
872 | ||
873 | if ( ! localBoard && warn ) { | |
874 | AliErrorStream() | |
875 | << "Local board with Id = " << localBoardId << " not defined." << endl; | |
876 | } | |
877 | ||
878 | return localBoard; | |
879 | } | |
880 | ||
881 | //_____________________________________________________________________________ | |
882 | void | |
5dde41b3 | 883 | AliMUONTriggerIO::UpdateMapping(Bool_t writeFile) const |
5eff9abc | 884 | { |
885 | /// check if mapping in database different from current Mtg configuration | |
5dde41b3 | 886 | /// Update mapping in databse and read regional crate file in repository (ext .out |
887 | /// to avoid overwriting). This case has a low probability to happen. | |
5eff9abc | 888 | |
889 | // Assuming that crates do not change | |
890 | ||
891 | if (!AliMpDDLStore::Instance(kFALSE)) | |
892 | { | |
893 | AliMpCDB::LoadDDLStore(); | |
894 | } | |
895 | ||
896 | Bool_t modified = false; | |
897 | ||
898 | TExMapIter itr = AliMpDDLStore::Instance()->GetLocalBoardItr(); | |
899 | ||
900 | Long_t key, value; | |
901 | ||
902 | while(itr.Next(key, value)) | |
903 | { | |
904 | AliMpLocalBoard* boardMapping = reinterpret_cast<AliMpLocalBoard*>(value); | |
905 | ||
906 | Int_t localBoardId = boardMapping->GetId(); | |
907 | AliMpLocalBoard* board = static_cast<AliMpLocalBoard*>(fLocalBoards.GetValue(localBoardId)); | |
908 | ||
5dde41b3 | 909 | if (board->GetCrate().CompareTo(boardMapping->GetCrate()) != 0) |
910 | { | |
5eff9abc | 911 | AliWarning(Form("Crate Name different for board %d (%s %s)", localBoardId, boardMapping->GetCrate().Data(), |
912 | board->GetCrate().Data())); | |
913 | boardMapping->SetCrate( board->GetCrate() ); | |
914 | modified = true; | |
915 | } | |
916 | ||
5dde41b3 | 917 | if ((board->GetSlot()) != boardMapping->GetSlot()) |
918 | { | |
5eff9abc | 919 | AliWarning(Form("Slot different for board %d (%d %d)", localBoardId, boardMapping->GetSlot(), board->GetSlot()+1)); |
920 | boardMapping->SetSlot(board->GetSlot()); | |
921 | modified = true; | |
922 | } | |
923 | ||
924 | if (boardMapping->GetSwitch() != board->GetSwitch()) { | |
925 | AliWarning(Form("Switch different for board %d (0x%x 0x%x)", localBoardId, | |
926 | boardMapping->GetSwitch(), board->GetSwitch())); | |
927 | boardMapping->SetSwitch(board->GetSwitch()); | |
928 | modified = true; | |
929 | } | |
930 | } | |
931 | ||
5dde41b3 | 932 | if (modified) |
933 | { | |
934 | AliMpCDB::WriteDDLStore(false); | |
935 | AliWarning("Wrote new version of mapping in databse"); | |
936 | if (writeFile) | |
937 | { | |
938 | TString file = AliMpFiles::LocalTriggerBoardMapping(); | |
939 | file += ".out"; | |
940 | WriteRegional(file.Data(), 0x0); | |
941 | AliWarning(Form("Wrote regional file %s", file.Data())); | |
942 | ||
943 | } | |
944 | } | |
5eff9abc | 945 | |
946 | } |