PHOS/AliPHOSAltroMapping.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 // This class handles the mapping of the Altro channels in the PHOS
  17 // The mapping is read from an external mapping files
  18 // Author: C.Cheshkov
  19
  20 #include "AliPHOSAltroMapping.h"
  21 #include "AliLog.h"
  22 #include <Riostream.h>
  23 //#include <stdlib.h>
  24
  25
  26 ClassImp(AliPHOSAltroMapping)
  27
  28 //_____________________________________________________________________________
  29 AliPHOSAltroMapping::AliPHOSAltroMapping(const char *mappingFile):
  30   AliAltroMapping(mappingFile),
  31   fMinRow(0),
  32   fMaxRow(0),
  33   fMinCol(0),
  34   fMaxCol(0),
  35   fMapping(NULL),
  36   fInvMappingLow(NULL),
  37   fInvMappingHigh(NULL)
  38 {
  39   // Constructor
  40   ReadMapping();
  41   CloseMappingFile();
  42 }
  43
  44 //_____________________________________________________________________________
  45 AliPHOSAltroMapping::~AliPHOSAltroMapping()
  46 {
  47   // destructor
  48   DeleteMappingArrays();
  49 }
  50
  51 //_____________________________________________________________________________
  52 AliPHOSAltroMapping::AliPHOSAltroMapping(const AliPHOSAltroMapping& mapping):
  53   AliAltroMapping(mapping),
  54   fMinRow(mapping.fMinRow),
  55   fMaxRow(mapping.fMaxRow),
  56   fMinCol(mapping.fMinCol),
  57   fMaxCol(mapping.fMaxCol),
  58   fMapping(mapping.fMapping),
  59   fInvMappingLow(mapping.fInvMappingLow),
  60   fInvMappingHigh(mapping.fInvMappingHigh)
  61 {
  62 // Copy Constructor
  63
  64   Fatal("AliPHOSAltroMapping", "copy constructor not implemented");
  65 }
  66
  67 //_____________________________________________________________________________
  68 AliPHOSAltroMapping& AliPHOSAltroMapping::operator = (const AliPHOSAltroMapping& /*mapping*/)
  69 {
  70 //Assigment operator
  71
  72   Fatal("operator =", "assignment operator not implemented");
  73   return *this;
  74 }
  75
  76 //_____________________________________________________________________________
  77 Bool_t AliPHOSAltroMapping::ReadMapping()
  78 {
  79   // Initalizes the ALTRO mapping from a file
  80   // Look at the PHOS module for the format of
  81   // the mapping file
  82   if (!fIn) {
  83     AliFatal("Mapping file has not been opened !");
  84     return kFALSE;
  85   }
  86
  87   fMinRow = 0x7fffffff;
  88   fMaxRow = 0;
  89   fMinCol = 0x7fffffff;
  90   fMaxCol = 0;
  91   fMapping = new Short_t*[fMaxHWAddress+1];
  92   for (Int_t i = 0; i <= fMaxHWAddress; i++) {
  93     fMapping[i] = new Short_t[3];
  94     fMapping[i][0] = fMapping[i][1] = fMapping[i][2] = -1;
  95   }
  96
  97   for(Int_t i = 0; i < fNumberOfChannels ; i++) { // 1792 = 2*896 channels connected to each RCU
  98     Int_t hwAddress;
  99     if (!(*fIn >> hwAddress)) {
 100       AliFatal("Syntax of the mapping file is wrong !");
 101       return kFALSE;
 102     }
 103     if (hwAddress > fMaxHWAddress) {
 104       AliFatal(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
 105       return kFALSE;
 106     }
 107     Int_t row,col,gain;
 108     if (!(*fIn >> row >> col >> gain)) {
 109       AliFatal("Syntax of the mapping file is wrong !");
 110       return kFALSE;
 111     }
 112
 113     if (gain < 0 || gain > 1) {
 114       AliFatal(Form("Wrong gain value found (%d)! Should be 0 or 1 !",gain));
 115       return kFALSE;
 116     }
 117
 118     fMapping[hwAddress][0] = row;
 119     fMapping[hwAddress][1] = col;
 120     fMapping[hwAddress][2] = gain;
 121
 122     if (row > fMaxRow) fMaxRow = row;
 123     if (row < fMinRow) fMinRow = row;
 124     if (col > fMaxCol) fMaxCol = col;
 125     if (col < fMinCol) fMinCol = col;
 126
 127   }
 128
 129   fInvMappingLow  = new Short_t*[fMaxRow - fMinRow + 1];
 130   fInvMappingHigh = new Short_t*[fMaxRow - fMinRow + 1];
 131   for (Int_t i = 0; i <= (fMaxRow - fMinRow); i++) {
 132     fInvMappingLow[i]  = new Short_t[fMaxCol - fMinCol + 1];
 133     fInvMappingHigh[i] = new Short_t[fMaxCol - fMinCol + 1];
 134     for (Int_t j = 0; j <= (fMaxCol - fMinCol); j++) {
 135       fInvMappingLow[i][j]  = -1;
 136       fInvMappingHigh[i][j] = -1;
 137     }
 138   }
 139
 140   for(Int_t i = 0; i <= fMaxHWAddress; i++) {
 141     Int_t row = fMapping[i][0];
 142     Int_t col = fMapping[i][1];
 143     Int_t gain = fMapping[i][2];
 144     if(row != -1 && col != -1) {
 145       if (gain == 0)
 146         fInvMappingLow[row-fMinRow][col-fMinCol] = i;
 147       if (gain == 1)
 148         fInvMappingHigh[row-fMinRow][col-fMinCol] = i;
 149     }
 150   }
 151
 152   return kTRUE;
 153 }
 154
 155 //_____________________________________________________________________________
 156 Int_t AliPHOSAltroMapping::GetHWAddress(Int_t row, Int_t col, Int_t gain) const
 157 {
 158   // Get the content of the mapping array
 159   // return -1 in case there is no hardware
 160   // adress defined for these row-column-gain
 161   if (!fInvMappingLow || !fInvMappingHigh) {
 162     AliWarning("Mapping array was not initalized correctly !");
 163     return -1;
 164   }
 165   if (row < fMinRow || row > fMaxRow) {
 166     AliWarning(Form("Index of row (%d) outside the range (%d -> %d) !",row,fMinRow,fMaxRow));
 167     return -1;
 168   }
 169   if (col < fMinCol || col > fMaxCol) {
 170     AliWarning(Form("Index of column (%d) outside the range (0 -> %d) !",col,fMinCol,fMaxCol));
 171     return -1;
 172   }
 173   if (gain < 0 || gain > 1) {
 174     AliWarning(Form("Invalid gain (%d)! Should be 0 or 1 !",gain));
 175     return -1;
 176   }
 177   Int_t hwAddress = -1;
 178   if (gain == 0)
 179     hwAddress = fInvMappingLow[row-fMinRow][col-fMinCol];
 180   if (gain == 1)
 181     hwAddress = fInvMappingHigh[row-fMinRow][col-fMinCol];
 182
 183   if (hwAddress == -1)
 184     AliWarning(Form("Hardware (ALTRO) adress is not defined for these row (%d), column (%d) and gain (%d) !",row,col,gain));
 185
 186   return hwAddress;
 187 }
 188
 189 //_____________________________________________________________________________
 190 Int_t AliPHOSAltroMapping::GetPadRow(Int_t hwAddress) const
 191 {
 192   // Return the row index
 193   // Note the difference w.r.t to the base class notation
 194   if (!fMapping) {
 195     AliWarning("Mapping array was not initalized correctly !");
 196     return -1;
 197   }
 198   if (hwAddress > fMaxHWAddress) {
 199     AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
 200     return -1;
 201   }
 202   Int_t row = fMapping[hwAddress][0];
 203   if (row == -1)
 204     AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));
 205
 206   return row;
 207 }
 208
 209 //_____________________________________________________________________________
 210 Int_t AliPHOSAltroMapping::GetPad(Int_t hwAddress) const
 211 {
 212   // Return the column index
 213   // Note the difference w.r.t to the base class notation
 214   if (!fMapping) {
 215     AliWarning("Mapping array was not initalized correctly !");
 216     return -1;
 217   }
 218   if (hwAddress > fMaxHWAddress) {
 219     AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
 220     return -1;
 221   }
 222   Int_t col = fMapping[hwAddress][1];
 223   if (col == -1)
 224     AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));
 225
 226   return col;
 227 }
 228
 229 //_____________________________________________________________________________
 230 Int_t AliPHOSAltroMapping::GetSector(Int_t hwAddress) const
 231 {
 232   // Return the gain factor (0/1)
 233   // Note the difference w.r.t to the base class notation
 234   if (!fMapping) {
 235     AliWarning("Mapping array was not initalized correctly !");
 236     return -1;
 237   }
 238   if (hwAddress > fMaxHWAddress) {
 239     AliWarning(Form("Hardware (ALTRO) adress (%d) outside the range (0 -> %d) !",hwAddress,fMaxHWAddress));
 240     return -1;
 241   }
 242   Int_t gain = fMapping[hwAddress][2];
 243   if (gain == -1)
 244     AliWarning(Form("Hardware (ALTRO) adress (%d) is not defined !",hwAddress));
 245
 246   return gain;
 247 }
 248
 249 //_____________________________________________________________________________
 250 void AliPHOSAltroMapping::DeleteMappingArrays()
 251 {
 252   // Deletes the arrays which have been
 253   // allocated during the reading of the
 254   // mapping file
 255   if (fMapping) {
 256     for (Int_t i = 0; i <= fMaxHWAddress; i++) delete [] fMapping[i];
 257     delete [] fMapping;
 258   }
 259
 260   if (fInvMappingLow) {
 261     for (Int_t i = 0; i <= (fMaxRow - fMinRow); i++)
 262       delete [] fInvMappingLow[i];
 263     delete [] fInvMappingLow;
 264   }
 265
 266   if (fInvMappingHigh) {
 267     for (Int_t i = 0; i <= (fMaxRow - fMinRow); i++)
 268       delete [] fInvMappingHigh[i];
 269     delete [] fInvMappingHigh;
 270   }
 271 }