HLT/PHOS/AliHLTPHOSDigitMaker.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * This file is property of and copyright by the ALICE HLT Project        *
   5  * All rights reserved.                                                   *
   6  *                                                                        *
   7  * Primary Authors: Oystein Djuvsland                                     *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17  /**
  18  * @file   AliHLTPHOSDigitMaker.cxx
  19  * @author Oystein Djuvsland
  20  * @date
  21  * @brief  Digit maker for PHOS HLT
  22  */
  23
  24
  25
  26
  27 // see header file for class documentation
  28 // or
  29 // refer to README to build package
  30 // or
  31 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  32
  33 #include "AliHLTPHOSDigitMaker.h"
  34
  35 #include "AliHLTPHOSConstants.h"
  36 #include "AliHLTPHOSMapper.h"
  37
  38 #include "AliHLTPHOSChannelDataStruct.h"
  39 #include "AliHLTPHOSChannelDataHeaderStruct.h"
  40 #include "AliHLTPHOSDigitDataStruct.h"
  41 #include "AliHLTPHOSSharedMemoryInterfacev2.h" // added by PTH
  42 #include "AliPHOSEMCAGeometry.h"
  43 #include "TH2F.h"
  44
  45 ClassImp(AliHLTPHOSDigitMaker);
  46
  47 using namespace PhosHLTConst;
  48
  49 AliHLTPHOSDigitMaker::AliHLTPHOSDigitMaker() :
  50   AliHLTPHOSBase(),
  51   fShmPtr(0),
  52   fDigitStructPtr(0),
  53   fDigitCount(0),
  54   fOrdered(true),
  55   fMapperPtr(0)
  56 {
  57   // See header file for documentation
  58
  59   fShmPtr = new AliHLTPHOSSharedMemoryInterfacev2();
  60
  61   for(int x = 0; x < NXCOLUMNSMOD; x++)
  62     {
  63       for(int z = 0; z < NZROWSMOD; z++)
  64         {
  65           fHighGainFactors[x][z] = 0.005;
  66           fLowGainFactors[x][z] = 0.08;
  67           fBadChannelMask[x][z][HIGHGAIN] = 1;
  68           fBadChannelMask[x][z][LOWGAIN] = 1;
  69         }
  70     }
  71   fMapperPtr = new AliHLTPHOSMapper();
  72 }
  73
  74 AliHLTPHOSDigitMaker::~AliHLTPHOSDigitMaker()
  75 {
  76   //See header file for documentation
  77 }
  78
  79 Int_t
  80 AliHLTPHOSDigitMaker::MakeDigits(AliHLTPHOSChannelDataHeaderStruct* channelDataHeader, AliHLTUInt32_t availableSize)
  81 {
  82   //See header file for documentation
  83
  84   Int_t j = 0;
  85   UInt_t totSize = sizeof(AliHLTPHOSDigitDataStruct);
  86
  87 //   Int_t xMod = -1;
  88 //   Int_t zMod = -1;
  89
  90   UShort_t coord1[4];
  91   UShort_t coord2[4];
  92   Float_t locCoord[3];
  93
  94
  95   AliHLTPHOSChannelDataStruct* currentchannel = 0;
  96   AliHLTPHOSChannelDataStruct* currentchannelLG = 0;
  97   AliHLTPHOSChannelDataStruct* tmpchannel = 0;
  98
  99   fShmPtr->SetMemory(channelDataHeader);
 100   currentchannel = fShmPtr->NextChannel();
 101
 102   while(currentchannel != 0)
 103     {
 104       if(availableSize < totSize) return -1;
 105
 106       AliHLTPHOSMapper::GetChannelCoord(currentchannel->fChannelID, coord1);
 107
 108       if(fOrdered) // High gain comes before low gain
 109         {
 110           tmpchannel = currentchannel;
 111
 112           if(coord1[2] == HIGHGAIN) // We got a completely new crystal
 113             {
 114
 115               if(currentchannel->fEnergy < MAXBINVALUE) // Make sure we don't have signal overflow
 116                 {
 117                   AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 118                   AddDigit(currentchannel, coord1, locCoord);
 119                   j++;
 120                   totSize += sizeof(AliHLTPHOSDigitDataStruct);
 121
 122                   currentchannel = fShmPtr->NextChannel(); // Get the next channel
 123
 124                   if(currentchannel != 0) // There was a next channel!
 125                     {
 126                       AliHLTPHOSMapper::GetChannelCoord(currentchannel->fChannelID, coord2);
 127                       if(coord1[0] == coord2[0] && coord1[1] == coord2[1]) // Did we get the low gain channel for this crystal?
 128                         {
 129                           currentchannel = fShmPtr->NextChannel(); // In that case, jump to next channel
 130                         }
 131                     }
 132                 }
 133
 134               else // Ooops, overflow, we try the next channel...
 135                 {
 136
 137                   currentchannel = fShmPtr->NextChannel();
 138                   if(currentchannel != 0) // There was a next channel
 139                     {
 140                       AliHLTPHOSMapper::GetChannelCoord(currentchannel->fChannelID, coord2);
 141                       if(coord2[0] == coord1[0] && coord2[1] == coord1[1]) // It is a low gain channel with the same coordinates, we may use it
 142                         {
 143                           AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 144                           AddDigit(currentchannel, coord2, locCoord);
 145                           j++;
 146                           totSize += sizeof(AliHLTPHOSDigitDataStruct);
 147                           currentchannel = fShmPtr->NextChannel();
 148                         }
 149
 150                       else // No low gain channel with information about the overflow channel so we just use the overflowed one...
 151                         {
 152                           AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 153                           AddDigit(tmpchannel, coord1, locCoord);
 154                           j++;
 155                           totSize += sizeof(AliHLTPHOSDigitDataStruct);
 156                           // no need to get the next channel here, we already did...
 157                         }
 158
 159                     }
 160                 }
 161             }
 162           else // Well, there seem to be missing a high gain channel for this crystal, let's use the low gain one
 163             {
 164               AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 165               AddDigit(tmpchannel, coord1, locCoord);
 166               j++;
 167               totSize += sizeof(AliHLTPHOSDigitDataStruct);
 168               currentchannel = fShmPtr->NextChannel();
 169             }
 170
 171         }
 172       else  //Reversed ordered (low gain before high gain)
 173         {
 174           if(coord1[2] == LOWGAIN) // We got a new channel!
 175             {
 176               currentchannelLG = currentchannel; // Ok, let's back up the low gain channel and look for the fancy high gain one
 177               currentchannel = fShmPtr->NextChannel();
 178
 179               if(currentchannel != 0) //There was another channel in the event
 180                 {
 181                   AliHLTPHOSMapper::GetChannelCoord(currentchannel->fChannelID, coord2);
 182
 183                   if(coord1[0] == coord2[0] && coord1[1] == coord2[1]) // Aha! Found the high gain channel
 184                     {
 185                       if(currentchannel->fEnergy < MAXBINVALUE)  // To overflow or not to overflow?
 186                         {
 187                           AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 188                           AddDigit(currentchannel, coord2, locCoord);
 189                           j++;
 190                           totSize += sizeof(AliHLTPHOSDigitDataStruct);
 191                           currentchannel = fShmPtr->NextChannel();
 192                         }
 193                       else // Oh well, better use the low gain channel then
 194                         {
 195                           //                      cout << "Reverse: Overflow!" << endl;
 196                           AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 197                           AddDigit(currentchannelLG, coord1, locCoord);
 198                           j++;
 199                           totSize += sizeof(AliHLTPHOSDigitDataStruct);
 200                           currentchannel = fShmPtr->NextChannel();
 201                         }
 202                     }
 203                   else // No available high gain channel for this crystal, adding the low gain one
 204                     {
 205                       AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 206                       AddDigit(currentchannelLG, coord1, locCoord);
 207                       j++;
 208                       totSize += sizeof(AliHLTPHOSDigitDataStruct);
 209                     }
 210                 }
 211               else //Fine, no more channels, better add this one...
 212                 {
 213                   AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 214                   AddDigit(currentchannelLG, coord1, locCoord);
 215                   j++;
 216                   totSize += sizeof(AliHLTPHOSDigitDataStruct);
 217                 }
 218             }
 219           else // Cool, no annoying low gain channel for this channel
 220             {
 221               AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord);
 222               AddDigit(currentchannel, coord1, locCoord);
 223               j++;
 224               currentchannel = fShmPtr->NextChannel();
 225             }
 226         }
 227     }
 228
 229   fDigitCount += j;
 230   return fDigitCount;
 231 }
 232
 233 void
 234 AliHLTPHOSDigitMaker::SetGlobalHighGainFactor(Float_t factor)
 235 {
 236   //See header file for documentation
 237   for(int x = 0; x < NXCOLUMNSMOD; x++)
 238     {
 239       for(int z = 0; z < NZROWSMOD; z++)
 240         {
 241           fHighGainFactors[x][z] = factor;
 242         }
 243     }
 244 }
 245
 246 void
 247 AliHLTPHOSDigitMaker::SetGlobalLowGainFactor(Float_t factor)
 248 {
 249   //See header file for documentation
 250   for(int x = 0; x < NXCOLUMNSMOD; x++)
 251     {
 252       for(int z = 0; z < NZROWSMOD; z++)
 253         {
 254           fLowGainFactors[x][z] = factor;
 255         }
 256     }
 257 }
 258
 259 void
 260 AliHLTPHOSDigitMaker::SetBadChannelMask(TH2F* badChannelHGHist, TH2F* badChannelLGHist, Float_t qCut)
 261 {
 262  for(int x = 0; x < NXCOLUMNSMOD; x++)
 263     {
 264       for(int z = 0; z < NZROWSMOD; z++)
 265         {
 266           if(badChannelHGHist->GetBinContent(x, z) < qCut && badChannelHGHist->GetBinContent(x, z) > 0)
 267             {
 268               fBadChannelMask[x][z][HIGHGAIN] = 1;
 269             }
 270           else
 271             {
 272               fBadChannelMask[x][z][HIGHGAIN] = 0;
 273             }
 274           if(badChannelLGHist->GetBinContent(x, z) < qCut && badChannelLGHist->GetBinContent(x, z) > 0)
 275             {
 276               fBadChannelMask[x][z][LOWGAIN] = 0;
 277             }
 278           else
 279             {
 280               fBadChannelMask[x][z][LOWGAIN] = 0;
 281             }
 282         }
 283     }
 284 }
 285