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