HLT/PHOS/AliHLTPHOSRawAnalyzerComponent.cxx

   1 /**************************************************************************
   2  * This file is property of and copyright by the Experimental Nuclear     *
   3  * Physics Group, Dep. of Physics                                         *
   4  * University of Oslo, Norway, 2007                                       *
   5  *                                                                        *
   6  * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
   7  * Contributors are mentioned in the code where appropriate.              *
   8  * Please report bugs to perthi@fys.uio.no                                *
   9  *                                                                        *
  10  * Permission to use, copy, modify and distribute this software and its   *
  11  * documentation strictly for non-commercial purposes is hereby granted   *
  12  * without fee, provided that the above copyright notice appears in all   *
  13  * copies and that both the copyright notice and this permission notice   *
  14  * appear in the supporting documentation. The authors make no claims     *
  15  * about the suitability of this software for any purpose. It is          *
  16  * provided "as is" without express or implied warranty.                  *
  17  **************************************************************************/
  18
  19 #include "AliHLTPHOSRawAnalyzer.h"
  20 #include "AliHLTPHOSRawAnalyzerComponent.h"
  21 #include "AliHLTPHOSRcuCellEnergyDataStruct.h"
  22 #include "AliHLTPHOSRcuChannelDataStruct.h"
  23 #include "AliHLTDDLDecoder.h"
  24 #include "AliHLTAltroData.h"
  25 #include "AliHLTPHOSMapper.h"
  26 #include "AliHLTAltroBunch.h"
  27
  28 //using namespace std;
  29
  30 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTPHOSRcuProcessor(), fAnalyzerPtr(0),
  31                                                                  fSendChannelData(kFALSE),fOutPtr(0), fMapperPtr(0), fDecoderPtr(0),
  32                                                                  fAltroDataPtr(0), fAltroBunchPtr(0)
  33 {
  34   fMapperPtr = new AliHLTPHOSMapper();
  35
  36 }
  37
  38
  39 AliHLTPHOSRawAnalyzerComponent::~AliHLTPHOSRawAnalyzerComponent()
  40 {
  41   delete  fMapperPtr;
  42 }
  43
  44
  45 int
  46 AliHLTPHOSRawAnalyzerComponent::Deinit()
  47 {
  48   Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRawAnalyzerComponen Deinit");
  49   return 0;
  50 }
  51
  52
  53 const char*
  54 AliHLTPHOSRawAnalyzerComponent::GetComponentID()
  55 {
  56   return "AliPhosTestRaw";
  57 }
  58
  59
  60 void
  61 AliHLTPHOSRawAnalyzerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  62 {
  63   const AliHLTComponentDataType* pType=fgkInputDataTypes;
  64   while (pType->fID!=0) {
  65     list.push_back(*pType);
  66     pType++;
  67   }
  68 }
  69
  70
  71 AliHLTComponentDataType
  72 AliHLTPHOSRawAnalyzerComponent::GetOutputDataType()
  73 {
  74   return AliHLTPHOSDefinitions::fgkCellEnergyDataType;
  75 }
  76
  77
  78 void
  79 AliHLTPHOSRawAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
  80
  81 {
  82   constBase = 30;
  83   inputMultiplier = 1;
  84 }
  85
  86
  87 int
  88 AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
  89 {
  90   UInt_t offset           = 0;
  91   UInt_t mysize           = 0;
  92   UInt_t tSize            = 0;
  93   //  Int_t tmpChannelCnt     = 0;
  94   AliHLTUInt8_t* outBPtr;
  95
  96   AliHLTAltroBunch *bunchPtr;
  97   outBPtr = outputPtr;
  98   const AliHLTComponentBlockData* iter = NULL;
  99   unsigned long ndx;
 100   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 101     {
 102
 103
 104     Int_t tmpChannelCnt     = 0;
 105       iter = blocks+ndx;
 106       mysize = 0;
 107       offset = tSize;
 108
 109       if ( iter->fDataType != AliHLTPHOSDefinitions::fgkDDLPackedRawDataType )
 110         {
 111           //      cout <<"WARNING: not AliHLTPHOSDefinitions::fgkDDLPackedRawDataType  "  << endl;
 112           continue; //!!!!! Commented out to read TPC data, remember to put back
 113         }
 114
 115        fDecoderPtr->SetMemory(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
 116       //    fDecoderPtr->SetMemory2(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
 117       fDecoderPtr->Decode();
 118       fOutPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
 119       fOutPtr->fRcuX = fRcuX;
 120       fOutPtr->fRcuZ = fRcuZ;
 121       fOutPtr->fModuleID =fModuleID;
 122       while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
 123         {
 124           fAnalyzerPtr->SetData(fAltroDataPtr->fData);
 125           fAnalyzerPtr->Evaluate(0, fAltroDataPtr->fDataSize -2);
 126
 127           fOutPtr->fValidData[tmpChannelCnt].fZ  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].zRow;
 128           fOutPtr->fValidData[tmpChannelCnt].fX  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].xCol;
 129           fOutPtr->fValidData[tmpChannelCnt].fGain  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].gain;
 130           fOutPtr->fValidData[tmpChannelCnt].fEnergy  = (float)fAnalyzerPtr->GetEnergy();
 131           fOutPtr->fValidData[tmpChannelCnt].fTime    = (float)fAnalyzerPtr->GetTiming();
 132           tmpChannelCnt ++;
 133         }
 134
 135
 136       fOutPtr->fCnt =  tmpChannelCnt;
 137       mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
 138
 139       AliHLTComponentBlockData bd;
 140       FillBlockData( bd );
 141       bd.fOffset = offset;
 142       bd.fSize = mysize;
 143
 144       bd.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
 145       bd.fSpecification = 0xFFFFFFFF;
 146       outputBlocks.push_back( bd );
 147
 148       tSize += mysize;
 149       outBPtr += mysize;
 150
 151       if( tSize > size )
 152         {
 153           cout <<"kHLTLogFatal, HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent Too much dataData written over allowed buffer. Amount written:"
 154                << tSize << " allowed" << size << endl;
 155           Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
 156                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
 157                    , tSize, size );
 158           return EMSGSIZE;
 159         }
 160       //   fDecoderPtr->GetFailureRate();
 161
 162     }
 163
 164   fPhosEventCount++;
 165
 166   if(fPrintInfo == kTRUE)
 167     {
 168       if(fPhosEventCount%fPrintInfoFrequncy == 0)
 169         {
 170           cout <<"Analyzing event " <<  fPhosEventCount  << "for Equippment " << fkEquippmentID << endl;
 171         }
 172     }
 173   size = tSize;
 174
 175   return 0;
 176 }//end DoEvent
 177
 178
 179 int
 180 AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
 181 {
 182   cout <<"AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv ) "<< endl;
 183   fAltroDataPtr = new AliHLTAltroData();
 184   fAltroBunchPtr = new AliHLTAltroBunch();
 185   fDecoderPtr = new AliHLTDDLDecoder();
 186   fSendChannelData = kFALSE;
 187   fPrintInfo = kFALSE;
 188   Reset();
 189   int iResult=0;
 190   TString argument="";
 191   iResult = ScanArguments(argc, argv);
 192
 193   if(fIsSetEquippmentID == kFALSE)
 194     {
 195       cout << "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID  <number>" << endl;
 196       Logging( kHLTLogFatal, "HLT::AliHLTPHOSRcuHistogramProducerComponent::DoInt( int argc, const char** argv )", "Missing argument",
 197                "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID  <number>");
 198       iResult = -3;
 199     }
 200   else
 201     {
 202       iResult = 0;
 203       //      fRawMemoryReader->SetEquipmentID(fkEquippmentID);
 204     }
 205
 206   //  return iResult;
 207   //  return 0;
 208   return iResult;
 209 }
 210
 211
 212 void
 213 AliHLTPHOSRawAnalyzerComponent::Reset()
 214 {
 215   for(int mod = 0; mod < N_MODULES; mod ++)
 216     {
 217       for(int row = 0; row < N_ZROWS_MOD; row ++)
 218         {
 219           for(int col = 0; col < N_XCOLUMNS_MOD; col ++)
 220             {
 221               for(int gain = 0; gain < N_GAINS; gain ++ )
 222                 {
 223                   fMaxValues[mod][row][col][gain] = 0;
 224                 }
 225             }
 226         }
 227     }
 228
 229   ResetDataPtr(0, ALTRO_MAX_SAMPLES);
 230
 231 } // end Reset
 232
 233
 234 void
 235 AliHLTPHOSRawAnalyzerComponent::ResetDataPtr(int startindex, int sampleCnt)
 236 {
 237   for(int i = startindex ; i< sampleCnt; i++)
 238     {
 239       fTmpChannelData[i] = 0;
 240     }
 241 }
 242