HLT/EMCAL/AliHLTEMCALDigitMakerComponent.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 #include "AliHLTEMCALDigitMakerComponent.h"
  19 #include "AliHLTCaloDigitMaker.h"
  20 #include "AliHLTCaloDigitDataStruct.h"
  21 #include "AliHLTCaloChannelDataHeaderStruct.h"
  22 #include "AliHLTCaloChannelDataStruct.h"
  23 #include "AliHLTEMCALMapper.h"
  24 #include "AliHLTEMCALDefinitions.h"
  25 #include "AliCaloCalibPedestal.h"
  26 #include "AliEMCALCalibData.h"
  27 #include "AliCDBEntry.h"
  28 #include "AliCDBPath.h"
  29 #include "AliCDBManager.h"
  30 #include "TFile.h"
  31 #include <sys/stat.h>
  32 #include <sys/types.h>
  33
  34 //#include "AliHLTEMCALConstant.h"
  35 #include "AliHLTCaloConstants.h"
  36
  37 using EMCAL::NZROWSMOD;
  38 using EMCAL::NXCOLUMNSMOD;
  39
  40
  41 /**
  42  * @file   AliHLTEMCALDigitMakerComponent.cxx
  43  * @author Oystein Djuvsland
  44  * @date
  45  * @brief  A digit maker component for EMCAL HLT
  46 */
  47
  48 // see below for class documentation
  49 // or
  50 // refer to README to build package
  51 // or
  52 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  53
  54
  55 ClassImp(AliHLTEMCALDigitMakerComponent)
  56
  57 AliHLTEMCALDigitMakerComponent gAliHLTEMCALDigitMakerComponent;
  58
  59 AliHLTEMCALDigitMakerComponent::AliHLTEMCALDigitMakerComponent() :
  60   AliHLTCaloProcessor(),
  61   //  AliHLTCaloConstantsHandler("EMCAL"),
  62   fDigitMakerPtr(0),
  63   fDigitContainerPtr(0),
  64   fPedestalData(0),
  65   fCalibData(0),
  66   fBCMInitialised(true),
  67   fGainsInitialised(true)
  68 {
  69
  70   //see header file for documentation
  71 }
  72
  73
  74 AliHLTEMCALDigitMakerComponent::~AliHLTEMCALDigitMakerComponent()
  75 {
  76   //see header file for documentation
  77 }
  78
  79 int
  80 AliHLTEMCALDigitMakerComponent::Deinit()
  81 {
  82   //see header file for documentation
  83   if(fDigitMakerPtr)
  84     {
  85       delete fDigitMakerPtr;
  86       fDigitMakerPtr = 0;
  87     }
  88   return 0;
  89 }
  90
  91 const char*
  92 AliHLTEMCALDigitMakerComponent::GetComponentID()
  93 {
  94   //see header file for documentation
  95   return "EmcalDigitMaker";
  96 }
  97
  98
  99 void
 100 AliHLTEMCALDigitMakerComponent::GetInputDataTypes(vector<AliHLTComponentDataType>& list)
 101 {
 102   //see header file for documentation
 103   list.clear();
 104   list.push_back(AliHLTEMCALDefinitions::fgkChannelDataType);
 105 }
 106
 107 AliHLTComponentDataType
 108 AliHLTEMCALDigitMakerComponent::GetOutputDataType()
 109 {
 110   //see header file for documentation
 111 //  return AliHLTCaloDefinitions::fgkDigitDataType|kAliHLTDataOriginEMCAL;
 112   return AliHLTEMCALDefinitions::fgkDigitDataType;
 113 }
 114
 115
 116 void
 117 AliHLTEMCALDigitMakerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
 118 {
 119   //see header file for documentation
 120   constBase = 0;
 121   inputMultiplier = (float)sizeof(AliHLTCaloDigitDataStruct)/sizeof(AliHLTCaloChannelDataStruct) + 1;
 122 }
 123
 124
 125
 126 int
 127 AliHLTEMCALDigitMakerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 128                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
 129                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
 130 {
 131   //see header file for documentation
 132   UInt_t offset           = 0;
 133   UInt_t mysize           = 0;
 134   Int_t digitCount        = 0;
 135   Int_t ret               = 0;
 136
 137   const AliHLTComponentBlockData* iter = 0;
 138   unsigned long ndx;
 139
 140   UInt_t specification = 0;
 141   AliHLTCaloChannelDataHeaderStruct* tmpChannelData = 0;
 142
 143   //  fDigitMakerPtr->SetDigitHeaderPtr(reinterpret_cast<AliHLTCaloDigitHeaderStruct*>(outputPtr));
 144
 145   fDigitMakerPtr->SetDigitDataPtr(reinterpret_cast<AliHLTCaloDigitDataStruct*>(outputPtr));
 146
 147   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 148     {
 149       iter = blocks+ndx;
 150
 151       if(iter->fDataType != AliHLTEMCALDefinitions::fgkChannelDataType)
 152         {
 153           continue;
 154         }
 155
 156       Int_t module = 0;
 157       if(!fBCMInitialised)
 158       {
 159          AliHLTEMCALMapper mapper(iter->fSpecification);
 160          module = mapper.GetModuleFromSpec(iter->fSpecification);
 161          //      for(Int_t x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)
 162          for(Int_t x = 0; x < NXCOLUMNSMOD ; x++) // PTH
 163          {
 164            //   for(Int_t z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)
 165            for(Int_t z = 0; z <  NZROWSMOD ; z++) // PTH
 166               {
 167                fDigitMakerPtr->SetBadChannel(x, z, fPedestalData->IsBadChannel(module, z+1, x+1));
 168             }
 169          }
 170          //delete fBadChannelMap;
 171          fBCMInitialised = true;
 172       }
 173       if(!fGainsInitialised)
 174       {
 175          AliHLTEMCALMapper mapper(iter->fSpecification);;
 176          module = mapper.GetModuleFromSpec(iter->fSpecification);
 177          //      for(Int_t x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)
 178          for(Int_t x = 0; x < NXCOLUMNSMOD; x++)   //PTH
 179            {
 180              //     for(Int_t z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)
 181              for(Int_t z = 0; z < NZROWSMOD; z++)   //PTH
 182                {
 183                module = 0; //removing warning
 184                 //fDigitMakerPtr->SetGain(x, z, fCalibData->GE(module, z+1, x+1), fCalibData->GetADCchannelEmc(module, z+1, x+1));
 185             }
 186          }
 187          fGainsInitialised = true;
 188       }
 189       specification |= iter->fSpecification;
 190       tmpChannelData = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*>(iter->fPtr);
 191
 192       ret = fDigitMakerPtr->MakeDigits(tmpChannelData, size-(digitCount*sizeof(AliHLTCaloDigitDataStruct)));
 193       if(ret == -1)
 194         {
 195           HLTError("Trying to write over buffer size");
 196           return -ENOBUFS;
 197         }
 198       digitCount += ret;
 199     }
 200
 201   mysize += digitCount*sizeof(AliHLTCaloDigitDataStruct);
 202
 203   HLTDebug("# of digits: %d, used memory size: %d, available size: %d", digitCount, mysize, size);
 204
 205   if(mysize > 0)
 206     {
 207       AliHLTComponentBlockData bd;
 208       FillBlockData( bd );
 209       bd.fOffset = offset;
 210       bd.fSize = mysize;
 211       bd.fDataType = AliHLTEMCALDefinitions::fgkDigitDataType;
 212       bd.fSpecification = specification;
 213       outputBlocks.push_back(bd);
 214     }
 215
 216   fDigitMakerPtr->Reset();
 217
 218   size = mysize;
 219
 220   return 0;
 221 }
 222
 223
 224 int
 225 AliHLTEMCALDigitMakerComponent::DoInit(int argc, const char** argv )
 226 {
 227   //see header file for documentation
 228
 229   fDigitMakerPtr = new AliHLTCaloDigitMaker("EMCAL");
 230
 231   AliHLTCaloMapper *mapper = new AliHLTEMCALMapper(2);
 232   fDigitMakerPtr->SetMapper(mapper);
 233
 234   for(int i = 0; i < argc; i++)
 235     {
 236       if(!strcmp("-lowgainfactor", argv[i]))
 237         {
 238           fDigitMakerPtr->SetGlobalLowGainFactor(atof(argv[i+1]));
 239         }
 240       if(!strcmp("-highgainfactor", argv[i]))
 241         {
 242           fDigitMakerPtr->SetGlobalHighGainFactor(atof(argv[i+1]));
 243         }
 244     }
 245  GetBCMFromCDB();
 246   //fDigitMakerPtr->SetDigitThreshold(2);
 247
 248   return 0;
 249 }
 250
 251
 252 int AliHLTEMCALDigitMakerComponent::GetBCMFromCDB()
 253 {
 254    // See header file for class documentation
 255   fBCMInitialised = false;
 256   //   HLTInfo("Getting bad channel map...");
 257   AliCDBPath path("EMCAL","Calib","Pedestals");
 258   if(path.GetPath())
 259     {
 260       //      HLTInfo("configure from entry %s", path.GetPath());
 261       AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
 262         if (pEntry)
 263         {
 264             fPedestalData = (AliCaloCalibPedestal*)pEntry->GetObject();
 265         }
 266       else
 267         {
 268 //          HLTError("can not fetch object \"%s\" from CDB", path);
 269             return -1;
 270         }
 271     }
 272    if(!fPedestalData)
 273    {
 274         return -1;
 275    }
 276
 277    return 0;
 278 }
 279
 280
 281 int AliHLTEMCALDigitMakerComponent::GetGainsFromCDB()
 282 {
 283    // See header file for class documentation
 284   fGainsInitialised = false;
 285   //  HLTInfo("Getting bad channel map...");
 286
 287   AliCDBPath path("EMCAL","Calib","Data");
 288   if(path.GetPath())
 289     {
 290       //      HLTInfo("configure from entry %s", path.GetPath());
 291       AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
 292         if (pEntry)
 293         {
 294             fCalibData = (AliEMCALCalibData*)pEntry->GetObject();
 295         }
 296       else
 297         {
 298 //          HLTError("can not fetch object \"%s\" from CDB", path);
 299             return -1;
 300         }
 301     }
 302    if(!fCalibData) return -1;
 303    return 0;
 304 }
 305
 306
 307 AliHLTComponent*
 308 AliHLTEMCALDigitMakerComponent::Spawn()
 309 {
 310   //see header file for documentation
 311   return new AliHLTEMCALDigitMakerComponent();
 312 }