MUON/AliMUONTriggerIO.cxx

   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 #include "AliMUONTriggerLut.h"
  20 #include "AliMUONCalibParamNI.h"
  21 #include "AliMUONVStore.h"
  22
  23 #include "AliMpCDB.h"
  24 #include "AliMpHelper.h"
  25 #include "AliMpConstants.h"
  26 #include "AliMpDDL.h"
  27 #include "AliMpFiles.h"
  28 #include "AliMpDDLStore.h"
  29 #include "AliMpLocalBoard.h"
  30 #include "AliMpTriggerCrate.h"
  31 #include "AliMUONGlobalCrateConfig.h"
  32 #include "AliMUONRegionalTriggerConfig.h"
  33 #include "AliMUONTriggerCrateConfig.h"
  34
  35 #include "AliLog.h"
  36
  37 #include <Riostream.h>
  38 #include <TSystem.h>
  39
  40 /// \class AliMUONTriggerIO
  41 ///
  42 /// Handles read/write of masks and LUT to/from online files,
  43 /// to be used by Shuttle and Trigger DA.
  44 ///
  45 /// \author Laurent Aphecetche, Christian Finck Subatech
  46 /// \author Bogdan Vulpescu, LPC Clermont-Ferrand
  47
  48 /// \cond CLASSIMP
  49 ClassImp(AliMUONTriggerIO)
  50 /// \endcond
  51
  52
  53 const UInt_t AliMUONTriggerIO::fgkLocalLutSize = 1 << 14; // 16384
  54
  55 //_____________________________________________________________________________
  56 AliMUONTriggerIO::AliMUONTriggerIO()
  57     : TObject(),
  58       fRegionalTrigger()
  59 {
  60   /// ctor
  61 }
  62
  63 //_____________________________________________________________________________
  64 AliMUONTriggerIO::AliMUONTriggerIO(const char* regionalFileToRead)
  65     :TObject(),
  66      fRegionalTrigger()
  67 {
  68   /// ctor
  69   ReadRegionalConfig(regionalFileToRead,0);
  70 }
  71
  72 //_____________________________________________________________________________
  73 AliMUONTriggerIO::~AliMUONTriggerIO()
  74 {
  75   /// dtor
  76 }
  77
  78 //_____________________________________________________________________________
  79 Bool_t
  80 AliMUONTriggerIO::DeCompAddress(UChar_t &ypos, UChar_t &ytri, UChar_t &xdev, UChar_t &xpos,
  81                                 UShort_t address) const
  82 {
  83   /// decompose the 15-bits address
  84
  85   UChar_t bitsYpos = 4;
  86   UChar_t bitsYtri = 1;
  87   UChar_t bitsXdev = 5;
  88   //  UChar_t bitsXpos = 5;
  89
  90   UShort_t maskYpos = 0x000F; // ...0 00001111
  91   UShort_t maskYtri = 0x0001; // ...0 00000001
  92   UShort_t maskXdev = 0x001F; // ...0 00011111
  93   UShort_t maskXpos = 0x001F; // ...0 00011111
  94
  95   ypos =  address                                  & maskYpos;
  96   ytri = (address >>  bitsYpos)                    & maskYtri;
  97   xdev = (address >> (bitsYpos+bitsYtri))          & maskXdev;
  98   xpos = (address >> (bitsYpos+bitsYtri+bitsXdev)) & maskXpos;
  99
 100   // convert deviation format
 101   // online: sign 1bit , dev 4bit
 102   // sign    dev    trigger
 103   // 0       1-15   mu-
 104   // 1       1-15   mu+
 105   // 0       0      mu+, mu- infinite momentum (unde)
 106   // 1       0      no x-trigger
 107   // offline: dev 5bit
 108   // sign    dev    trigger
 109   // -        0-14  mu-
 110   // -       16-31  mu+
 111   // -       15     mu+, mu- infinite momentum (unde)
 112
 113   Int_t iXdevOff, iXdevOn, iXdev, sign;
 114   Bool_t trigx;
 115
 116   iXdev = xdev;
 117
 118   iXdevOn = sign = 0;
 119   iXdevOn +=  iXdev & 0x0F;
 120   sign    += (iXdev >> 4) & 0x01;
 121   if (iXdevOn == 0) {
 122     if (sign == 0) {
 123       iXdevOff = 15;
 124       trigx = kTRUE;
 125     } else {
 126       iXdevOff = 15;
 127       trigx = kFALSE;
 128     }
 129   } else {
 130     trigx = kTRUE;
 131     if (sign == 0) {
 132       iXdevOff = - iXdevOn + 15;  // gives range  0-14
 133     } else {
 134       iXdevOff = + iXdevOn + 15;  // gives range 16-30 !
 135     }
 136   }
 137
 138   xdev = iXdevOff;
 139
 140   return trigx;
 141
 142 }
 143
 144 //_____________________________________________________________________________
 145 void
 146 AliMUONTriggerIO::FillLut(AliMUONTriggerLut& lut,
 147                           Int_t icirc, UChar_t istripX, UChar_t idev,
 148                           Int_t lutLpt[16][2], Int_t lutHpt[16][2])
 149 {
 150   /// Fill the LUT histograms
 151
 152   if (icirc == 0 && istripX == 0 && idev == 0)
 153   {
 154     AliDebug(1,"Copy board, not filled ...");
 155     return;
 156   }
 157
 158   Short_t iLptPlus, iLptMinu, iLptUnde;
 159   Short_t iHptPlus, iHptMinu, iHptUnde;
 160
 161   iLptPlus = iLptMinu = iLptUnde = 0;
 162   iHptPlus = iHptMinu = iHptUnde = 0;
 163
 164   for (Int_t istripY=0; istripY<16; istripY++)
 165   {
 166     if (lutLpt[istripY][1] == 0 && lutLpt[istripY][0] ==1)
 167       iLptMinu=iLptMinu+(1 << istripY);
 168     if (lutLpt[istripY][1] == 1 && lutLpt[istripY][0] ==0)
 169       iLptPlus=iLptPlus+(1 << istripY);
 170     if (lutLpt[istripY][1] == 1 && lutLpt[istripY][0] ==1)
 171       iLptUnde=iLptUnde+(1 << istripY);
 172
 173     if (lutHpt[istripY][1] == 0 && lutHpt[istripY][0] ==1)
 174       iHptMinu=iHptMinu+(1 << istripY);
 175     if (lutHpt[istripY][1] == 1 && lutHpt[istripY][0] ==0)
 176       iHptPlus=iHptPlus+(1 << istripY);
 177     if (lutHpt[istripY][1] == 1 && lutHpt[istripY][0] ==1)
 178       iHptUnde=iHptUnde+(1 << istripY);
 179
 180   } // loop on istripY
 181
 182   lut.SetContent("LptMinu",icirc,istripX,idev,iLptMinu);
 183   lut.SetContent("LptUnde",icirc,istripX,idev,iLptUnde);
 184   lut.SetContent("LptPlus",icirc,istripX,idev,iLptPlus);
 185
 186   lut.SetContent("HptMinu",icirc,istripX,idev,iHptMinu);
 187   lut.SetContent("HptUnde",icirc,istripX,idev,iHptUnde);
 188   lut.SetContent("HptPlus",icirc,istripX,idev,iHptPlus);
 189 }
 190
 191 //_____________________________________________________________________________
 192 Int_t
 193 AliMUONTriggerIO::ReadLocalMasks(const char* localFile, AliMUONVStore& localMasks) const
 194 {
 195   /// Fills the local masks store from file
 196
 197   if ( !NofLocalBoards() )
 198   {
 199     AliError("No local board to read");
 200     return 0;
 201   }
 202
 203   FILE* fp = fopen(gSystem->ExpandPathName(localFile),"r");
 204   if (!fp)
 205   {
 206     AliError(Form("Could not read file %s",localFile));
 207     return 0;
 208   }
 209
 210   UShort_t maskBuffer[8];
 211
 212   Int_t localBoardIndex(0);
 213
 214   while ( fread ( maskBuffer, 2, 8, fp ) )
 215   {
 216     Int_t localBoardId = fRegionalTrigger.LocalBoardId(localBoardIndex);
 217     AliDebug(1,Form("LB %03d X1 %4x X2 %4x X3 %4x X4 %4x "
 218                     "Y1 %4x Y2 %4x Y3 %4x Y4 %4x",
 219                     localBoardId,
 220                     maskBuffer[0],
 221                     maskBuffer[1],
 222                     maskBuffer[2],
 223                     maskBuffer[3],
 224                     maskBuffer[4],
 225                     maskBuffer[5],
 226                     maskBuffer[6],
 227                     maskBuffer[7]));
 228
 229     if ( localBoardId > 0 )
 230     {
 231       AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8,localBoardId,0,0);
 232       for ( Int_t index = 0; index < 8; ++index )
 233       {
 234         localBoard->SetValueAsInt(index,0,maskBuffer[index]);
 235       }
 236       localMasks.Add(localBoard);
 237     }
 238     else
 239     {
 240       AliError(Form("Oups. Got localBoardId=%d for index=%d",localBoardId,localBoardIndex));
 241     }
 242
 243     ++localBoardIndex;
 244   }
 245
 246   if ( localBoardIndex != NofLocalBoards() )
 247   {
 248     AliError(Form("Read %d out of %d local boards",
 249                   localBoardIndex, NofLocalBoards()));
 250   }
 251
 252   fclose(fp);
 253
 254   return localBoardIndex+1;
 255 }
 256
 257 //_____________________________________________________________________________
 258 void
 259 AliMUONTriggerIO::ReadLocalLUT(AliMUONTriggerLut& lut,
 260                                Int_t localBoardId,
 261                                FILE* flut)
 262 {
 263   /// Read the LUT for one local board from an online file
 264
 265   UShort_t address;
 266
 267   UChar_t buffer[fgkLocalLutSize];   // 32768 hpt/lpt addresses divided by two
 268   UChar_t mask1 = 0xF0;
 269   UChar_t mask2 = 0x0F;
 270   UChar_t maskHpt = 0x0C;
 271   UChar_t maskLpt = 0x03;
 272   UChar_t lh, lpt, hpt;
 273
 274   UChar_t xpos, xdev, ypos, ytri;
 275
 276   Int_t lutLpt[16][2], lutHpt[16][2];
 277
 278   Int_t boardnr = localBoardId;
 279
 280   AliDebug(1,Form("Reading LUT values for local board %d",boardnr));
 281
 282   Int_t ny = 0;
 283   Bool_t trigx = kFALSE;
 284
 285   // read two lut addresses at once, 32768/2=16384 times
 286   fread(buffer,fgkLocalLutSize,1,flut);
 287
 288   // create the 32767 addresses for the 4-bits lpt and hpt half-bytes
 289   for (UShort_t ilut = 0; ilut < fgkLocalLutSize*2; ilut += 2)
 290   {
 291
 292     // 1st 4-bits half-byte
 293     address = ilut;
 294     lh = (buffer[ilut/2] & mask1) >> 4;
 295
 296     // Lpt and Hpt response
 297     hpt = (lh & maskHpt) >> 2;
 298     lpt =  lh & maskLpt;
 299
 300     // decompose the 15-bits address
 301     trigx = DeCompAddress(ypos,ytri,xdev,xpos,address);
 302
 303     // calculate group of y-strips
 304     if (trigx && (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     // 2nd 4-bits half-byte
 323     address = ilut+1;
 324     lh = (buffer[ilut/2] & mask2);
 325
 326     // Lpt and Hpt response
 327     hpt = (lh & maskHpt) >> 2;
 328     lpt =  lh & maskLpt;
 329
 330     // decompose the 15-bits address
 331     trigx = DeCompAddress(ypos,ytri,xdev,xpos,address);
 332
 333     // calculate group of y-strips
 334     if (trigx && (ny < 16))
 335     {
 336       lutLpt[ny][0] =  lpt & 1;
 337       lutLpt[ny][1] = (lpt & 2) >> 1;
 338       lutHpt[ny][0] =  hpt & 1;
 339       lutHpt[ny][1] = (hpt & 2) >> 1;
 340       ny++;
 341       if (ny == 16)
 342       {
 343         ny = 0;
 344         // ytri == 1 means no trigger in y-direction
 345         if (ytri == 0)
 346         {
 347           FillLut(lut,boardnr,xpos,xdev,lutLpt,lutHpt);
 348         }
 349       }
 350     }
 351   }
 352 }
 353
 354 //_____________________________________________________________________________
 355 Bool_t
 356 AliMUONTriggerIO::ReadLUT(const char* lutFileToRead, AliMUONTriggerLut& lut)
 357 {
 358   /// Fill the LUT object from online file
 359
 360   if ( !NofLocalBoards() )
 361   {
 362     AliError("No local board id defined. Must read a regional file first");
 363     return kFALSE;
 364   }
 365
 366   FILE* flut = fopen(gSystem->ExpandPathName(lutFileToRead),"rb");
 367   if (!flut)
 368   {
 369     AliError(Form("Could not read LUT file %s",lutFileToRead));
 370     return kFALSE;
 371   }
 372
 373   for ( Int_t i = 0; i < NofLocalBoards(); ++i )
 374   {
 375     ReadLocalLUT(lut,fRegionalTrigger.LocalBoardId(i),flut);
 376   }
 377
 378   fclose(flut);
 379
 380   return kTRUE;
 381
 382 }
 383
 384 //_____________________________________________________________________________
 385 Bool_t
 386 AliMUONTriggerIO::ReadConfig(const char* localFile,
 387                              const char* regionalFile,
 388                              const char* globalFile,
 389                              AliMUONVStore* localMasks,
 390                              AliMUONRegionalTriggerConfig* regionalConfig,
 391                              AliMUONGlobalCrateConfig* globalConfig)
 392 {
 393   /// Fill the various masks store from files
 394
 395   if ( !regionalFile || strlen(regionalFile)==0 )
 396   {
 397     AliError("Must have a regional file name to proceeed");
 398     return kFALSE;
 399   }
 400
 401   AliDebug(1,Form("regionalConfig=%p",regionalConfig));
 402
 403   Int_t nCrates = ReadRegionalConfig(regionalFile, regionalConfig);
 404
 405   if (!nCrates)
 406   {
 407     AliError("nCrates=0 !");
 408     return kFALSE;
 409   }
 410
 411   if (localMasks && localFile && strlen(localFile) > 0 )
 412   {
 413     Int_t nLocal = ReadLocalMasks(localFile,*localMasks);
 414     AliDebug(1,Form("Read masks for %d local boards",nLocal));
 415   }
 416
 417   Int_t nDarc = ReadGlobalConfig(globalFile, globalConfig);
 418   AliDebug(1,Form("Read config for %d DARC boards",nDarc));
 419
 420   if (!nDarc) return kFALSE;
 421
 422   return kTRUE;
 423 }
 424
 425
 426
 427 //_____________________________________________________________________________
 428  Int_t
 429  AliMUONTriggerIO::ReadGlobalConfig(const char* globalFile, AliMUONGlobalCrateConfig* globalConfig) const
 430 {
 431   /// read the global crate file
 432   /// the masks are disable bit for each crate, 8 per darc board
 433   /// bit value 0 means enable, 1 means disable                                                 *
 434
 435   Int_t nDarc = 0;
 436   if ( !(nDarc = globalConfig->ReadData(globalFile)) ) return 0;
 437
 438   return nDarc;
 439 }
 440
 441 //_____________________________________________________________________________
 442 Int_t
 443 AliMUONTriggerIO::ReadRegionalConfig(const char* regionalFile, AliMUONRegionalTriggerConfig* regionalConfig)
 444 {
 445   /// Read regional file to fill
 446
 447   AliDebug(1,Form("regionalConfig=%p",regionalConfig));
 448
 449   Int_t nCrates = 0;
 450   if ( !(nCrates = regionalConfig->ReadData(regionalFile)) ) return 0;
 451
 452   // read the mapping file also
 453   if ( ! fRegionalTrigger.ReadData(regionalFile) ) return 0;
 454
 455   return nCrates;
 456 }
 457
 458
 459 //_____________________________________________________________________________
 460 Bool_t
 461 AliMUONTriggerIO::WriteLUT(const AliMUONTriggerLut& lut,
 462                            const char* lutFileToWrite)
 463 {
 464   /// Convert an offline lut into an online (binary) lut file
 465
 466   if ( !NofLocalBoards() )
 467   {
 468     AliError("No local board id defined. Must read a regional file first");
 469     return kFALSE;
 470   }
 471
 472   FILE* flut = fopen(gSystem->ExpandPathName(lutFileToWrite),"wb");
 473   if (!flut)
 474   {
 475     AliError(Form("Could not create output LUT file %s",lutFileToWrite));
 476     return kFALSE;
 477   }
 478
 479   for ( Int_t i = 0; i < NofLocalBoards(); ++i )
 480   {
 481     WriteLocalLUT(lut,fRegionalTrigger.LocalBoardId(i),flut);
 482   }
 483
 484   fclose(flut);
 485
 486   return kTRUE;
 487 }
 488
 489
 490 //_____________________________________________________________________________
 491 Bool_t
 492 AliMUONTriggerIO::WriteConfig(const char* localFile,
 493                              const char* regionalFile,
 494                              const char* globalFile,
 495                              AliMUONVStore* localMasks,
 496                     AliMUONRegionalTriggerConfig* regionalConfig,
 497                     AliMUONGlobalCrateConfig* globalConfig) const
 498 {
 499 /// write config files
 500
 501     Bool_t ok;
 502     ok  = WriteLocalMasks(localFile, *localMasks, regionalConfig);
 503     ok &= WriteRegionalConfig(regionalFile, regionalConfig);
 504     ok &= WriteGlobalConfig(globalFile, globalConfig);
 505
 506     return ok;
 507
 508
 509 }
 510
 511
 512  //_____________________________________________________________________________
 513 Bool_t
 514 AliMUONTriggerIO::WriteGlobalConfig(const char* globalFile, AliMUONGlobalCrateConfig* globalConfig) const
 515 {
 516     /// write global config
 517
 518   ofstream out;
 519   Int_t disable = 0;
 520
 521   out.open(globalFile);
 522   if (!out.good())
 523   {
 524     AliError(Form("Could not create output global file %s", globalFile));
 525     return kFALSE;
 526   }
 527
 528   out << globalConfig->GetName() << endl;
 529   out << Form("0x%x",globalConfig->GetGlobalCrateEnable()) << endl;
 530
 531   // Jtag
 532   out << globalConfig->GetJtagName() << endl;
 533   out << Form("0x%08x", globalConfig->GetJtagVmeAddr()) << endl;
 534   out << Form("%d %d %d", globalConfig->GetJtagClockDiv(),
 535               globalConfig->GetJtagRxPhase(), globalConfig->GetJtagRdDelay()) << endl;
 536
 537   for (Int_t i = 0; i < globalConfig->GetJtagNofLines(); ++i)
 538     out << Form("%d ", globalConfig->GetEnableJtag(i));
 539   out << endl;
 540
 541
 542   for (Int_t i = 0; i < globalConfig->GetJtagNofLines(); ++i)
 543   {
 544     out << i << endl;
 545     for (Int_t j = 0; j < globalConfig->GetJtagNofLines(); ++j)
 546       out << Form(" %s", globalConfig->GetJtagCrateName(i,j).Data()) << endl;
 547   }
 548
 549   // first darc board
 550   out << globalConfig->GetFirstDarcName() << endl;
 551   out << Form("0x%08x", globalConfig->GetFirstDarcVmeAddr()) << endl;
 552   out << globalConfig->GetFirstDarcType() << endl;
 553   disable = globalConfig->GetFirstDarcDisable();
 554   out << Form("0x%02x", disable) << endl;
 555   out << Form("0x%x", globalConfig->GetFirstDarcL0Delay()) << endl;
 556   out << Form("0x%x", globalConfig->GetFirstDarcL1TimeOut()) << endl;
 557   out << Form("0x%x", globalConfig->GetFirstDarcGlobalL0()) << endl;
 558   out << Form("0x%x", globalConfig->GetFirstDarcConfig()) << endl;
 559
 560   // second darc board
 561   out << globalConfig->GetSecondDarcName() << endl;
 562   out << Form("0x%08x", globalConfig->GetSecondDarcVmeAddr()) << endl;
 563   out << globalConfig->GetSecondDarcType() << endl;
 564   disable = globalConfig->GetSecondDarcDisable();
 565   out << Form("0x%02x", disable) << endl;
 566   out << Form("0x%x", globalConfig->GetSecondDarcL0Delay()) << endl;
 567   out << Form("0x%x", globalConfig->GetSecondDarcL1TimeOut()) << endl;
 568   out << Form("0x%x", globalConfig->GetSecondDarcGlobalL0()) << endl;
 569   out << Form("0x%x", globalConfig->GetSecondDarcConfig()) << endl;
 570
 571   // global board
 572   out << globalConfig->GetGlobalName() << endl;
 573   out << Form("0x%08x", globalConfig->GetGlobalVmeAddr()) << endl;
 574   for (Int_t i = 0; i < globalConfig->GetGlobalNofRegisters(); ++i)
 575     out << Form("0x%x", globalConfig->GetGlobalRegister(i)) << endl;
 576
 577   // Fet board
 578   out << globalConfig->GetFetName() << endl;
 579   out << Form("0x%08x", globalConfig->GetFetVmeAddr()) << endl;
 580   for (Int_t i = 0; i < globalConfig->GetFetNofRegisters(); ++i)
 581     out << Form("0x%x", globalConfig->GetFetRegister(i)) << endl;
 582
 583   return kTRUE;
 584 }
 585
 586 //_____________________________________________________________________________
 587 Bool_t
 588 AliMUONTriggerIO::WriteRegionalConfig(const char* regionalFile, AliMUONRegionalTriggerConfig* regionalConfig) const
 589 {
 590
 591     /// write regional mask with the current configuration
 592    /// if regional masks not defined, take the one from current configuration
 593
 594     ofstream out;
 595     out.open(regionalFile);
 596
 597     if (!out.good())
 598     {
 599       AliError(Form("Could not create output regional file %s",regionalFile));
 600       return kFALSE;
 601     }
 602
 603     Int_t nCrate = fRegionalTrigger.GetNofTriggerCrates();
 604     if (!nCrate)
 605     {
 606       AliError("Could not write regional no configuration in memory");
 607       return kFALSE;
 608     }
 609
 610     Int_t nofDDLs = 0;
 611     TString name;
 612     AliMpTriggerCrate* crate;
 613     for (Int_t ddlId = 0; ddlId < 2; ddlId++) // right & left side
 614       {
 615         for (Int_t crateId = 0; crateId < 8; crateId++) // 8 crates/regional boards for each side.
 616           {
 617
 618             name = AliMpTriggerCrate::GenerateName(crateId, ddlId, nofDDLs);
 619
 620             crate = fRegionalTrigger.FindTriggerCrate(name, false);
 621
 622             AliMUONTriggerCrateConfig* crateConfig = regionalConfig->FindTriggerCrate(crate->GetName());
 623             if (!crateConfig)
 624               {
 625                 AliError(Form("Cannot find crate %s in CDB", crate->GetName()));
 626                 return kFALSE;
 627               }
 628
 629             out << crate->GetName()  << endl;
 630             out << Form("%02x", crate->GetId())   << endl;
 631             out << crateConfig->GetMode()  << endl;
 632             out << crateConfig->GetCoinc() << endl;
 633             out << Form("%04x", crateConfig->GetMask()) << endl;
 634             out << Form("%02d",crate->GetNofLocalBoards()) << endl;
 635
 636             for (Int_t iLocal = 0; iLocal < crate->GetNofLocalBoards(); ++iLocal)
 637               {
 638                 Int_t localBoardId = crate->GetLocalBoardId(iLocal);
 639
 640                 AliMpLocalBoard* board = fRegionalTrigger.FindLocalBoard(localBoardId);
 641
 642                 out << Form("%02d ", board->GetSlot())
 643                     << board->GetName()
 644                     << Form(" %03d ", localBoardId)
 645                     << Form("%03x", board->GetSwitch())
 646                     << endl;
 647
 648                 out << " ";
 649
 650                 if (board->IsNotified()) {
 651                   for (Int_t i = 0; i < board->GetNofDEs(); ++i)
 652                     out << Form("%4d ", board->GetDEId(i));
 653                 } else {
 654                   out << Form("%4d ", 0);
 655                 }
 656                 out << endl;
 657
 658                 // print copy card numbers & TC
 659                 out << Form(" %4d %4d", board->GetInputXfrom(), board->GetInputXto());
 660                 out << Form(" %4d %4d", board->GetInputYfrom(), board->GetInputYto());
 661                 out << Form(" %4d",     board->GetTC()) << endl;
 662               }
 663           }
 664       }
 665
 666     out.close();
 667
 668     return kTRUE;
 669 }
 670
 671
 672 //_____________________________________________________________________________
 673 Bool_t
 674 AliMUONTriggerIO::WriteLocalMasks(const char* localFile, AliMUONVStore& localMasks, AliMUONRegionalTriggerConfig* regionalConfig) const
 675 {
 676     /// write local mask
 677     /// removing/adding enable for a local board need a update of the configuration
 678     /// before calling this method
 679     /// mask are written for all boards including the copy card (Ch.F.)
 680
 681     FILE* fp = fopen(gSystem->ExpandPathName(localFile),"wb");
 682     if (!fp)
 683     {
 684       AliError(Form("Could not create output local file %s",localFile));
 685       return kFALSE;
 686     }
 687
 688     UShort_t maskBuffer[8];
 689
 690     TIter next(regionalConfig->CreateCrateIterator());
 691     AliMUONTriggerCrateConfig* crate;
 692
 693     while ( ( crate = static_cast<AliMUONTriggerCrateConfig*>(next()) ) )
 694     {
 695       UShort_t mask = crate->GetMask(); // getting mask from current config
 696
 697       for (Int_t iLocal = 0; iLocal < crate->GetNofLocalBoards(); ++iLocal)
 698       {
 699         Int_t localBoardId = crate->GetLocalBoardId(iLocal);
 700
 701         if ( (mask >> iLocal ) & 0x1 )
 702         {
 703           AliMUONVCalibParam* localMask =
 704               static_cast<AliMUONVCalibParam*>(localMasks.FindObject(localBoardId));
 705
 706           for (Int_t index = 0; index < 8; ++index)
 707           {
 708             maskBuffer[index] = localMask->ValueAsInt(index,0);
 709           }
 710
 711           fwrite ( maskBuffer, 2, 8, fp);
 712         }
 713
 714       }
 715     }
 716
 717     fclose(fp);
 718
 719     return kTRUE;
 720
 721 }
 722
 723 //_____________________________________________________________________________
 724 void
 725 AliMUONTriggerIO::WriteLocalLUT(const AliMUONTriggerLut& lut,
 726                                 Int_t localBoardId,
 727                                 FILE* flut)
 728 {
 729   /// loop over the address for the 4-bits lpt and hpt decisions
 730
 731   const Int_t kMaskYpos = 0x0F;
 732   const Int_t kMaskYtri = 0x01;
 733   const Int_t kMaskXdev = 0x1F;
 734   const Int_t kMaskXpos = 0x1F;
 735
 736   UChar_t buffer[fgkLocalLutSize];  // 32768 hpt/lpt addresses divided by two
 737   Int_t bc = 0;
 738
 739   for (UInt_t i = 0; i < fgkLocalLutSize*2; ++i)
 740   {
 741     Int_t lutLpt[2] = { 0 };
 742     Int_t lutHpt[2] = { 0 };
 743
 744     // decompose address
 745     Int_t iYpos =   i                    & kMaskYpos;
 746     Int_t iYtri = ( i >>   4           ) & kMaskYtri;
 747     Int_t iXdev = ( i >> ( 4 + 1 )     ) & kMaskXdev;
 748     Int_t iXpos = ( i >> ( 4 + 1 + 5 ) ) & kMaskXpos;
 749
 750     // convert deviation format
 751     // online: sign 1bit , dev 4bit
 752     // sign    dev    trigger
 753     // 0       1-15   mu-
 754     // 1       1-15   mu+
 755     // 0       0      mu+, mu- infinite momentum (unde)
 756     // 1       0      no x-trigger
 757     // offline: dev 5bit
 758     // sign    dev    trigger
 759     // -        0-14  mu-
 760     // -       16-31  mu+
 761     // -       15     mu+, mu- infinite momentum (unde)
 762     Int_t iXdevOn  = 0;
 763     Int_t iXdevOff = 0;
 764     Int_t sign     = 0;
 765     Bool_t trigx = kFALSE;
 766     iXdevOn +=  iXdev & 0x0F;
 767     sign    += (iXdev >> 4) & 0x01;
 768     if (iXdevOn == 0) {
 769       if (sign == 0) {
 770         iXdevOff = 15;
 771         trigx = kTRUE;
 772       } else {
 773         iXdevOff = 15;
 774         trigx = kFALSE;
 775       }
 776     } else {
 777       trigx = kTRUE;
 778       if (sign == 0) {
 779         iXdevOff = - iXdevOn + 15;  // gives range  0-14
 780       } else {
 781         iXdevOff = + iXdevOn + 15;  // gives range 16-30 !
 782       }
 783     }
 784     iXdev = iXdevOff;
 785
 786     // iYtri == 1 means no trigger in y-direction
 787     if (iYtri == 0 && trigx)
 788     {
 789       lut.GetLutOutput(localBoardId,iXpos,iXdev,iYpos,lutLpt,lutHpt);
 790     }
 791
 792     // fill byte
 793     if (i%2 == 0)
 794     {
 795       // upper half-byte
 796       buffer[bc] = 0;
 797       buffer[bc] += lutHpt[1] << 7;
 798       buffer[bc] += lutHpt[0] << 6;
 799       buffer[bc] += lutLpt[1] << 5;
 800       buffer[bc] += lutLpt[0] << 4;
 801     } else {
 802       // lower half-byte
 803       buffer[bc] += lutHpt[1] << 3;
 804       buffer[bc] += lutHpt[0] << 2;
 805       buffer[bc] += lutLpt[1] << 1;
 806       buffer[bc] += lutLpt[0] << 0;
 807       bc++;
 808     }
 809   }
 810   fwrite(&buffer,bc,1,flut);
 811 }
 812
 813 //_____________________________________________________________________________
 814 Int_t
 815 AliMUONTriggerIO::LocalBoardId(Int_t index) const
 816 {
 817   /// Return the i-th localBoardId, or -1 if index is out of bounds
 818
 819   return fRegionalTrigger.LocalBoardId(index);
 820 }
 821
 822
 823 //______________________________________________________________________________
 824
 825 Int_t AliMUONTriggerIO::LocalBoardId(Int_t ddlId, Int_t crateId, Int_t localId) const
 826 {
 827     /// Return local board id from crate and local indexes.
 828
 829     Int_t nofDDLs = 0;
 830     TString name = AliMpTriggerCrate::GenerateName(crateId, ddlId, nofDDLs);
 831
 832     AliMpTriggerCrate* crate = fRegionalTrigger.FindTriggerCrate(name, false);
 833     return crate->GetLocalBoardId(localId);
 834 }