TOF/AliTOFFEEReader.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 /*
  17  * author: Roberto Preghenella (R+), Roberto.Preghenella@bo.infn.it
  18  */
  19
  20 //////////////////////////////////////////////////////////////////////
  21 //                                                                  //
  22 //                                                                  //
  23 //   This class provides the TOF FEE reader.                        //
  24 //                                                                  //
  25 //                                                                  //
  26 //////////////////////////////////////////////////////////////////////
  27
  28 #include <TSystem.h>
  29 #include "AliTOFFEEReader.h"
  30 #include "AliTOFFEEConfig.h"
  31 #include "AliTOFFEElightConfig.h"
  32 #include "AliTOFRawStream.h"
  33 #include "AliTOFGeometry.h"
  34 #include "AliTOFcalibHisto.h"
  35 #include "AliLog.h"
  36 #include <fstream>
  37
  38 ClassImp(AliTOFFEEReader)
  39
  40 //_______________________________________________________________
  41
  42 AliTOFFEEReader::AliTOFFEEReader() :
  43   TObject(),
  44   fFEEConfig(new AliTOFFEEConfig()),
  45   fFEElightConfig(new AliTOFFEElightConfig()),
  46   fChannelEnabled(),
  47   fMatchingWindow(),
  48   fLatencyWindow()
  49 {
  50   /*
  51    *
  52    * default constructor
  53    *
  54    */
  55
  56   Reset();
  57 }
  58
  59 //_______________________________________________________________
  60
  61 AliTOFFEEReader::AliTOFFEEReader(const AliTOFFEEReader &source) :
  62   TObject(source),
  63   fFEEConfig(new AliTOFFEEConfig()),
  64   fFEElightConfig(new AliTOFFEElightConfig())
  65 {
  66   /*
  67    *
  68    * copy constructor
  69    *
  70    */
  71
  72   Reset();
  73   memcpy(fFEEConfig, source.fFEEConfig, sizeof(AliTOFFEEConfig));
  74   memcpy(fFEElightConfig, source.fFEElightConfig, sizeof(AliTOFFEElightConfig));
  75 }
  76
  77 //_______________________________________________________________
  78
  79 AliTOFFEEReader &
  80 AliTOFFEEReader::operator=(const AliTOFFEEReader &source)
  81 {
  82   /*
  83    *
  84    * operator =
  85    *
  86    */
  87
  88   TObject::operator=(source);
  89   memcpy(fFEEConfig, source.fFEEConfig, sizeof(AliTOFFEEConfig));
  90   memcpy(fFEElightConfig, source.fFEElightConfig, sizeof(AliTOFFEElightConfig));
  91   return *this;
  92 }
  93
  94 //_______________________________________________________________
  95
  96 AliTOFFEEReader::~AliTOFFEEReader()
  97 {
  98   /*
  99    *
 100    * default destructor
 101    *
 102    */
 103
 104   delete fFEEConfig;
 105   delete fFEElightConfig;
 106 }
 107
 108 //_______________________________________________________________
 109
 110 void
 111 AliTOFFEEReader::ResetChannelEnabledArray()
 112 {
 113   /*
 114    *
 115    * reset channel enabled array
 116    *
 117    */
 118
 119   for (Int_t iIndex = 0; iIndex < GetNumberOfIndexes(); iIndex++)
 120     fChannelEnabled[iIndex] = kFALSE;
 121 }
 122
 123 //_______________________________________________________________
 124
 125 void
 126 AliTOFFEEReader::ResetTriggerMaskArray()
 127 {
 128   /*
 129    *
 130    * reset trigger mask array
 131    *
 132    */
 133
 134   for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++)
 135     fTriggerMask[iddl] = 0x0;
 136 }
 137
 138 //_______________________________________________________________
 139
 140 void
 141 AliTOFFEEReader::Reset()
 142 {
 143   /*
 144    *
 145    * reset
 146    *
 147    */
 148
 149   for (Int_t iIndex = 0; iIndex < GetNumberOfIndexes(); iIndex++) {
 150     fChannelEnabled[iIndex] = kFALSE;
 151     fMatchingWindow[iIndex] = 0;
 152     fLatencyWindow[iIndex] = 0;
 153   }
 154
 155   for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++)
 156     fTriggerMask[iddl] = 0x0;
 157 }
 158
 159 //_______________________________________________________________
 160
 161 void
 162 AliTOFFEEReader::LoadFEEConfig(const Char_t *FileName) const
 163 {
 164   /*
 165    *
 166    * load FEE config
 167    *
 168    */
 169
 170   Char_t *expandedFileName = gSystem->ExpandPathName(FileName);
 171   std::ifstream is;
 172   is.open(expandedFileName, std::ios::binary);
 173   is.read((Char_t *)fFEEConfig, sizeof(AliTOFFEEConfig));
 174   is.close();
 175 }
 176
 177 //_______________________________________________________________
 178
 179 void
 180 AliTOFFEEReader::LoadFEElightConfig(const Char_t *FileName) const
 181 {
 182   /*
 183    *
 184    * load FEElight config
 185    *
 186    */
 187
 188   Char_t *expandedFileName = gSystem->ExpandPathName(FileName);
 189   std::ifstream is;
 190   is.open(expandedFileName, std::ios::binary);
 191   is.read((Char_t *)fFEElightConfig, sizeof(AliTOFFEElightConfig));
 192   is.close();
 193 }
 194
 195 //_______________________________________________________________
 196
 197 Int_t
 198 AliTOFFEEReader::ParseFEEConfig()
 199 {
 200   /*
 201    *
 202    * parse FEE config
 203    *
 204    * loops over all FEE channels, checks whether they are enabled
 205    * and sets channel enabled
 206    *
 207    */
 208
 209   AliInfo("parsing TOF FEE config");
 210
 211   AliTOFRawStream rawStream;
 212   Int_t nEnabled = 0;
 213   Int_t volume[5], index;
 214   Int_t temp;
 215
 216   Reset();
 217
 218   /* loop over all FEE channels */
 219   for (Int_t iDDL = 0; iDDL < GetNumberOfDDLs(); iDDL++)
 220     for (Int_t iTRM = 0; iTRM < GetNumberOfTRMs(); iTRM++)
 221       for (Int_t iChain = 0; iChain < GetNumberOfChains(); iChain++)
 222         for (Int_t iTDC = 0; iTDC < GetNumberOfTDCs(); iTDC++)
 223           for (Int_t iChannel = 0; iChannel < GetNumberOfChannels(); iChannel++)
 224             /* check whether FEE channel is enabled */
 225             if (IsChannelEnabled(iDDL, iTRM + 3, iChain, iTDC, iChannel)) {
 226               /* convert FEE channel indexes into detector indexes */
 227               rawStream.EquipmentId2VolumeId(iDDL, iTRM + 3, iChain, iTDC, iChannel, volume);
 228               /* swap padx and padz to fit AliTOFGeometry::GetIndex behaviour */
 229               temp = volume[4]; volume[4] = volume[3]; volume[3] = temp;
 230               /* check if index is ok */
 231               if (volume[0] < 0 || volume[0] > 17 ||
 232                   volume[1] < 0 || volume[1] > 4 ||
 233                   volume[2] < 0 || volume[2] > 18 ||
 234                   volume[3] < 0 || volume[3] > 1 ||
 235                   volume[4] < 0 || volume[4] > 47)
 236                 continue;
 237               /* convert detector indexes into calibration index */
 238               index = AliTOFGeometry::GetIndex(volume);
 239               /* check calibration index */
 240               if (index != -1 && index < GetNumberOfIndexes()) {
 241                 /* set calibration channel enabled */
 242                 fChannelEnabled[index] = kTRUE;
 243                 fMatchingWindow[index] = GetMatchingWindow(iDDL, iTRM + 3, iChain, iTDC, iChannel);
 244                 nEnabled++;
 245               }
 246             }
 247   return nEnabled;
 248 }
 249
 250 //_______________________________________________________________
 251
 252 Int_t
 253 AliTOFFEEReader::ParseFEElightConfig()
 254 {
 255   /*
 256    *
 257    * parse FEElight config
 258    *
 259    * loops over all FEE channels, checks whether they are enabled
 260    * and sets channel enabled
 261    *
 262    */
 263
 264   AliInfo("parsing TOF FEElight config");
 265
 266   Reset();
 267
 268   AliTOFcalibHisto calibHisto;
 269   calibHisto.LoadCalibHisto();
 270
 271   Int_t nEnabled = 0, index;
 272   AliTOFFEEchannelConfig *channelConfig = NULL;
 273   for (Int_t i = 0; i < GetNumberOfIndexesEO(); i++) {
 274     channelConfig = fFEElightConfig->GetChannelConfig(i);
 275     if (!channelConfig->IsEnabled()) continue;
 276     /* get index DO from index EO */
 277     index = (Int_t)calibHisto.GetCalibMap(AliTOFcalibHisto::kIndex, i);
 278     if (index == -1) continue;
 279     nEnabled++;
 280     fChannelEnabled[index] = channelConfig->IsEnabled();
 281     fMatchingWindow[index] = channelConfig->GetMatchingWindow();
 282     fLatencyWindow[index] = channelConfig->GetLatencyWindow();
 283   }
 284
 285   AliTOFFEEtriggerConfig *triggerConfig = NULL;
 286   for (Int_t iddl = 0; iddl < GetNumberOfDDLs(); iddl++) {
 287     triggerConfig = fFEElightConfig->GetTriggerConfig(iddl);
 288     fTriggerMask[iddl] = triggerConfig->GetStatusMap();
 289   }
 290
 291   return nEnabled;
 292 }
 293
 294 //_______________________________________________________________
 295
 296 Bool_t
 297 AliTOFFEEReader::IsChannelEnabled(Int_t iDDL, Int_t iTRM, Int_t iChain, Int_t iTDC, Int_t iChannel) const
 298 {
 299   /*
 300    *
 301    * is channel enabled
 302    *
 303    * checks whether a FEE channel is enabled using the
 304    * TOF FEE config object.
 305    *
 306    */
 307
 308   AliTOFFEEConfig *feeConfig;
 309   AliTOFCrateConfig *crateConfig;
 310   AliTOFTRMConfig *trmConfig;
 311   Int_t maskPB, maskTDC, activeChip;
 312
 313   /* get and check fee config */
 314   if (!(feeConfig = GetFEEConfig()))
 315     return kFALSE;
 316
 317   /* get and check crate config */
 318   if (!(crateConfig = feeConfig->GetCrateConfig(iDDL)))
 319     return kFALSE;
 320
 321   /* get and check TRM config */
 322   if (!(trmConfig = crateConfig->GetTRMConfig(iTRM - 3)))
 323     return kFALSE;
 324
 325   /* check DRM enabled */
 326   if (!crateConfig->IsDRMEnabled())
 327     return kFALSE;
 328
 329   /* check TRM enabled */
 330   if (!crateConfig->IsTRMEnabled(iTRM - 3))
 331     return kFALSE;
 332
 333   /* switch chain */
 334   switch (iChain) {
 335     /* chain A */
 336   case 0:
 337     /* check chain enabled */
 338     if (trmConfig->GetChainAFlag() != 1)
 339       return kFALSE;
 340     /* get active chip mask */
 341     activeChip = trmConfig->GetActiveChipA();
 342     /* switch TDC */
 343     switch (iTDC) {
 344     case 0: case 1: case 2:
 345       maskPB = trmConfig->GetMaskPB0();
 346       break;
 347     case 3: case 4: case 5:
 348       maskPB = trmConfig->GetMaskPB1();
 349       break;
 350     case 6: case 7: case 8:
 351       maskPB = trmConfig->GetMaskPB2();
 352       break;
 353     case 9: case 10: case 11:
 354       maskPB = trmConfig->GetMaskPB3();
 355       break;
 356     case 12: case 13: case 14:
 357       maskPB = trmConfig->GetMaskPB4();
 358       break;
 359     default:
 360       return kFALSE;
 361       break;
 362     } /* switch TDC */
 363     break; /* chain A */
 364     /* chain B */
 365   case 1:
 366     /* check chain enabled */
 367     if (trmConfig->GetChainBFlag() != 1)
 368       return kFALSE;
 369     /* get active chip mask */
 370     activeChip = trmConfig->GetActiveChipB();
 371     /* switch TDC */
 372     switch (iTDC) {
 373     case 0: case 1: case 2:
 374       maskPB = trmConfig->GetMaskPB5();
 375       break;
 376     case 3: case 4: case 5:
 377       maskPB = trmConfig->GetMaskPB6();
 378       break;
 379     case 6: case 7: case 8:
 380       maskPB = trmConfig->GetMaskPB7();
 381       break;
 382     case 9: case 10: case 11:
 383       maskPB = trmConfig->GetMaskPB8();
 384       break;
 385     case 12: case 13: case 14:
 386       maskPB = trmConfig->GetMaskPB9();
 387       break;
 388     default:
 389       return kFALSE;
 390       break;
 391     } /* switch TDC */
 392     break; /* chain B */
 393   default:
 394     return kFALSE;
 395     break;
 396   } /* switch chain */
 397
 398   /* check chip enabled */
 399   if (!(activeChip & (0x1 << iTDC)))
 400     return kFALSE;
 401
 402   /* check channel enabled */
 403   maskTDC = (maskPB & (0xFF << ((iTDC % 3) * 8))) >> ((iTDC % 3) * 8);
 404   if (maskTDC & (0x1 << iChannel))
 405     return kTRUE;
 406   else
 407     return kFALSE;
 408
 409 }
 410
 411 //_______________________________________________________________
 412
 413 Int_t
 414 AliTOFFEEReader::GetMatchingWindow(Int_t iDDL, Int_t iTRM, Int_t, Int_t, Int_t) const
 415 {
 416   /*
 417    *
 418    * get matching window
 419    *
 420    * checks whether a FEE channel is enabled using the
 421    * TOF FEE config object and return the associated
 422    * matching window
 423    *
 424    */
 425
 426   AliTOFFEEConfig *feeConfig;
 427   AliTOFCrateConfig *crateConfig;
 428   AliTOFTRMConfig *trmConfig;
 429
 430   /* get and check fee config */
 431   if (!(feeConfig = GetFEEConfig()))
 432     return 0;
 433
 434   /* get and check crate config */
 435   if (!(crateConfig = feeConfig->GetCrateConfig(iDDL)))
 436     return 0;
 437
 438   /* get and check TRM config */
 439   if (!(trmConfig = crateConfig->GetTRMConfig(iTRM - 3)))
 440     return 0;
 441
 442   /* check DRM enabled */
 443   if (!crateConfig->IsDRMEnabled())
 444     return 0;
 445
 446   /* check TRM enabled */
 447   if (!crateConfig->IsTRMEnabled(iTRM - 3))
 448     return 0;
 449
 450   return trmConfig->GetMatchingWindow();
 451 }
 452
 453
 454 void
 455 AliTOFFEEReader::DumpFEEConfig()
 456 {
 457   /*
 458    *
 459    * dump FEE config
 460    *
 461    */
 462
 463   AliTOFFEEConfig *feeConfig = GetFEEConfig();
 464   AliTOFCrateConfig *crateConfig;
 465   AliTOFDRMConfig *drmConfig;
 466   AliTOFLTMConfig *ltmConfig;
 467   AliTOFTRMConfig *trmConfig;
 468
 469   AliInfo("-------------------------------------");
 470   AliInfo("dumping TOF FEE config");
 471   AliInfo("-------------------------------------");
 472   AliInfo(Form("version: %d", feeConfig->GetVersion()));
 473   AliInfo(Form("dump time: %d", (Int_t)feeConfig->GetDumpTime()));
 474   AliInfo(Form("run number: %d", feeConfig->GetRunNumber()));
 475   AliInfo(Form("run type: %d", feeConfig->GetRunType()));
 476   AliInfo("-------------------------------------");
 477
 478   /* loop over crates */
 479   for (Int_t iCrate = 0; iCrate < AliTOFFEEConfig::GetNumberOfCrates(); iCrate++) {
 480     crateConfig = feeConfig->GetCrateConfig(iCrate);
 481
 482     /* check crate config */
 483     if (!crateConfig)
 484       continue;
 485
 486     /* check DRM enabled */
 487     if (!crateConfig->IsDRMEnabled())
 488     continue;
 489
 490     AliInfo(Form("crate id: %02d", iCrate));
 491
 492     /* dump DRM config */
 493     drmConfig = crateConfig->GetDRMConfig();
 494     AliInfo(Form("DRM is enabled: drmId=%d, slotMask=%03x", drmConfig->GetDRMId(), drmConfig->GetSlotMask()));
 495
 496     /* dump LTM config if enabled */
 497     if (crateConfig->IsLTMEnabled()) {
 498       ltmConfig = crateConfig->GetLTMConfig();
 499       AliInfo(Form("LTM is enabled: threshold=%d", ltmConfig->GetThreshold()));
 500     }
 501
 502     /* dump CPDM config if enabled */
 503     if (crateConfig->IsCPDMEnabled()) {
 504       AliInfo(Form("CPDM is enabled"));
 505     }
 506
 507     /* loop over TRMs */
 508     for (Int_t iTRM = 0; iTRM < AliTOFCrateConfig::GetNumberOfTRMs(); iTRM++) {
 509
 510       trmConfig = crateConfig->GetTRMConfig(iTRM);
 511
 512       /* check TRM config */
 513       if (!trmConfig)
 514         continue;
 515
 516       /* check TRM enabled */
 517       if (!crateConfig->IsTRMEnabled(iTRM))
 518         continue;
 519
 520       /* dump TRM config */
 521       AliInfo(Form("TRM%02d is enabled: matchWin=%d, latWin=%d, packFlag=%d", iTRM + 3, trmConfig->GetMatchingWindow(), trmConfig->GetLatencyWindow(), trmConfig->GetPackingFlag()));
 522
 523       /* check TRM chain A flag */
 524       if (trmConfig->GetChainAFlag() == 1) {
 525         AliInfo(Form("TRM%02d chainA is enabled: activeChip=%04X, PB0=%06X, PB1=%06X, PB2=%06X, PB3=%06X, PB4=%06X", iTRM + 3, trmConfig->GetActiveChipA(), trmConfig->GetMaskPB0(), trmConfig->GetMaskPB1(), trmConfig->GetMaskPB2(), trmConfig->GetMaskPB3(), trmConfig->GetMaskPB4()));
 526       }
 527
 528       /* check TRM chain B flag */
 529       if (trmConfig->GetChainBFlag() == 1) {
 530         AliInfo(Form("TRM%02d chainB is enabled: activeChip=%04X, PB5=%06X, PB6=%06X, PB7=%06X, PB8=%06X, PB9=%06X", iTRM + 3, trmConfig->GetActiveChipB(), trmConfig->GetMaskPB5(), trmConfig->GetMaskPB6(), trmConfig->GetMaskPB7(), trmConfig->GetMaskPB8(), trmConfig->GetMaskPB9()));
 531       }
 532
 533
 534
 535     } /* loop over TRMs */
 536     AliInfo("-------------------------------------");
 537   } /* loop over crates */
 538 }
 539
 540 //_______________________________________________________________
 541
 542 void
 543 AliTOFFEEReader::CreateFEElightConfig(const Char_t *filename)
 544 {
 545   /*
 546    *
 547    * create FEElight config
 548    *
 549    */
 550
 551   AliTOFFEElightConfig lightConfig;
 552
 553   for (Int_t i = 0; i < GetNumberOfIndexes(); i++) {
 554     if (fChannelEnabled[i]) {
 555       lightConfig.GetChannelConfig(i)->SetStatus(AliTOFFEEchannelConfig::kStatusEnabled);
 556       lightConfig.GetChannelConfig(i)->SetMatchingWindow(fMatchingWindow[i]);
 557       lightConfig.GetChannelConfig(i)->SetLatencyWindow(fLatencyWindow[i]);
 558     }
 559     else {
 560       lightConfig.GetChannelConfig(i)->SetStatus(0x0);
 561       lightConfig.GetChannelConfig(i)->SetMatchingWindow(0);
 562       lightConfig.GetChannelConfig(i)->SetLatencyWindow(0);
 563     }
 564   }
 565
 566   Char_t *expandedFileName = gSystem->ExpandPathName(filename);
 567   std::ofstream os;
 568   os.open(expandedFileName, std::ios::binary);
 569   os.write((Char_t *)&lightConfig, sizeof(AliTOFFEElightConfig));
 570   os.close();
 571
 572 }