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 "AliHLTPHOSRawAnalyzerComponent.h"
  20 #include <iostream>
  21 #include "stdio.h"
  22
  23 #include "AliRawReaderMemory.h"
  24 #include "AliCaloRawStream.h"
  25 #include <cstdlib>
  26 #include "AliHLTPHOSRcuCellEnergyDataStruct.h"
  27 //#include "AliHLTPHOSDataHeaderStruct.h"
  28
  29
  30 const AliHLTComponentDataType AliHLTPHOSRawAnalyzerComponent::inputDataTypes[]={kAliHLTVoidDataType,{0,"",""}}; //'zero' terminated array
  31 int   AliHLTPHOSRawAnalyzerComponent::fEventCount = 0;
  32
  33
  34 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTProcessor(),fEquippmentID(0), fRcuX(0),
  35 fRcuZ(0),fRcuRowOffeset(0), fRcuColOffeset(0),  fModuleID(0), fPHOSRawStream(0), fRawMemoryReader(0), fOutPtr(0)
  36 //AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTProcessor()
  37 {
  38
  39 }
  40
  41 AliHLTPHOSRawAnalyzerComponent::~AliHLTPHOSRawAnalyzerComponent()
  42 {
  43   if(fRawMemoryReader != 0)
  44     {
  45       delete fRawMemoryReader;
  46     }
  47     if(fPHOSRawStream != 0)
  48     {
  49       delete fPHOSRawStream;
  50     }
  51
  52 }
  53
  54
  55
  56 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent(const AliHLTPHOSRawAnalyzerComponent & ) : AliHLTProcessor(),
  57 fEquippmentID(0), fRcuX(0), fRcuZ(0),fRcuRowOffeset(0), fRcuColOffeset(0),  fModuleID(0), fPHOSRawStream(0), fRawMemoryReader(0), fOutPtr(0)
  58 {
  59 }
  60
  61
  62 int
  63 AliHLTPHOSRawAnalyzerComponent::Deinit()
  64 {
  65   return 0;
  66 }
  67
  68 int
  69 AliHLTPHOSRawAnalyzerComponent::DoDeinit()
  70 {
  71   Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRawAnalyzerComponen DoDeinit");
  72
  73   if(fRawMemoryReader !=0)
  74     {
  75       delete fRawMemoryReader;
  76     }
  77
  78   if(fPHOSRawStream != 0)
  79     {
  80       delete fPHOSRawStream;
  81     }
  82   return 0;
  83
  84 }
  85
  86 const char*
  87 AliHLTPHOSRawAnalyzerComponent::GetComponentID()
  88 {
  89   return "AliPhosTestRaw";
  90 }
  91
  92 void
  93 AliHLTPHOSRawAnalyzerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  94 {
  95   const AliHLTComponentDataType* pType=inputDataTypes;
  96   while (pType->fID!=0) {
  97     list.push_back(*pType);
  98     pType++;
  99   }
 100 }
 101
 102 AliHLTComponentDataType
 103 AliHLTPHOSRawAnalyzerComponent::GetOutputDataType()
 104 {
 105   return AliHLTPHOSDefinitions::gkCellEnergyDataType;
 106 }
 107
 108 void
 109 AliHLTPHOSRawAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
 110
 111 {
 112   constBase = 30;
 113   inputMultiplier = 0.1;
 114 }
 115
 116
 117 int AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 118                                               AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
 119                                               AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
 120 {
 121   Int_t tmpMod            = 0;
 122   Int_t tmpRow            = 0;
 123   Int_t tmpCol            = 0;
 124   Int_t tmpGain           = 0;
 125   Int_t sampleCnt         = 0;
 126   Int_t processedChannels = 0;
 127   UInt_t offset           = 0;
 128   UInt_t mysize           = 0;
 129   UInt_t tSize            = 0;
 130   Int_t tmpChannelCnt     = 0;
 131   AliHLTUInt8_t* outBPtr;
 132   outBPtr = outputPtr;
 133   const AliHLTComponentBlockData* iter = NULL;
 134   unsigned long ndx;
 135
 136   if((fEventCount % 100) == 0)
 137     {
 138       cout << "analyzing event: " << fEventCount << endl;
 139     }
 140
 141   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
 142     {
 143       iter = blocks+ndx;
 144       mysize = 0;
 145       offset = tSize;
 146
 147       if ( iter->fDataType != AliHLTPHOSDefinitions::gkDDLPackedRawDataType )
 148         {
 149           cout << "Warning: data type = is nOT gkDDLPackedRawDataType " << endl;
 150           continue;
 151         }
 152
 153       fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
 154       analyzerPtr->SetData(fTmpChannelData);
 155       fOutPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
 156       mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
 157       fOutPtr->fRcuX = fRcuX;
 158       fOutPtr->fRcuZ = fRcuZ;
 159       fOutPtr->fModuleID = fModuleID;
 160       tmpChannelCnt = 0;
 161
 162       if(fEventCount%100 ==0)
 163         {
 164           cout <<"Analyzing event: " << fEventCount << endl;
 165         }
 166
 167       while(fPHOSRawStream->Next())
 168         {
 169           if (fPHOSRawStream->IsNewHWAddress())
 170             {
 171               if(processedChannels > 0)
 172                 {
 173                   analyzerPtr->SetData(fTmpChannelData);
 174                   analyzerPtr->Evaluate(0, sampleCnt);
 175                   fOutPtr->fCellEnergies[tmpRow][tmpCol][tmpGain] =  analyzerPtr->GetEnergy();
 176                   sampleCnt = 0;
 177                   fOutPtr->fValidData[tmpChannelCnt].fGain = tmpGain;
 178                   fOutPtr->fValidData[tmpChannelCnt].fRow  = tmpRow;
 179                   fOutPtr->fValidData[tmpChannelCnt].fCol  = tmpCol;
 180                   tmpChannelCnt ++;
 181                   ResetDataPtr();
 182                   sampleCnt = 0;
 183
 184                 }
 185
 186               tmpMod  =  fPHOSRawStream->GetModule() ;
 187               tmpRow  =  fPHOSRawStream->GetRow() - fRcuRowOffeset;
 188               tmpCol  =  fPHOSRawStream->GetColumn() - fRcuColOffeset;
 189               tmpGain =  fPHOSRawStream->IsLowGain();
 190               processedChannels ++;
 191             }
 192           fTmpChannelData[fPHOSRawStream->GetTime()] =  fPHOSRawStream->GetSignal();
 193           sampleCnt ++;
 194
 195         }
 196
 197       fOutPtr->fCnt =  tmpChannelCnt;
 198       AliHLTComponentBlockData bd;
 199       FillBlockData( bd );
 200       bd.fOffset = offset;
 201       bd.fSize = mysize;
 202       bd.fDataType = AliHLTPHOSDefinitions::gkCellEnergyDataType;
 203       bd.fSpecification = 0xFFFFFFFF;
 204       outputBlocks.push_back( bd );
 205       tSize += mysize;
 206       outBPtr += mysize;
 207
 208       if( tSize > size )
 209         {
 210           Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
 211                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
 212                    , tSize, size );
 213           return EMSGSIZE;
 214         }
 215     }
 216
 217   fEventCount++;
 218   size = tSize;
 219   return 0;
 220 }//end DoEvent
 221
 222
 223
 224 int
 225 AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
 226 {
 227   int equippmentID = atoi(argv[6]);
 228   Reset();
 229   fRawMemoryReader = new AliRawReaderMemory();
 230   fPHOSRawStream = new  AliCaloRawStream(fRawMemoryReader,"PHOS");
 231   fRawMemoryReader->SetEquipmentID(equippmentID);
 232   SetEquippmentID(equippmentID);
 233   SetCoordinates(equippmentID);
 234   if (argc==0 && argv==NULL) {
 235     // this is currently just to get rid of the warning "unused parameter"
 236   }
 237   return 0;
 238 }
 239
 240 void
 241 AliHLTPHOSRawAnalyzerComponent::DumpData()
 242 {
 243   for(int mod = 0; mod <5; mod ++)
 244     {
 245       printf("\n ***********  MODULE %d ************\n", mod);
 246       for(int row = 0; row < 64; row ++)
 247         {
 248           for(int col = 0; col < 56; col ++)
 249             {
 250               if( fMaxValues[mod][row][col][0] != 0)
 251                 {
 252                   cout << fMaxValues[mod][row][col][0] << "\t";
 253                 }
 254             }
 255         }
 256     }
 257 }
 258
 259 void
 260 AliHLTPHOSRawAnalyzerComponent::DumpChannelData(Double_t *data)
 261 {
 262       cout << endl;
 263
 264       for(int i=0; i< 1008; i++)
 265         {
 266           if (data[i] != 0)
 267             {
 268               cout <<i <<"\t";
 269             }
 270         }
 271       cout << endl;
 272
 273       for(int i=0; i< 1008; i++)
 274         {
 275           if (data[i] != 0)
 276             {
 277               cout <<data[i] <<"\t";
 278             }
 279         }
 280
 281       cout << endl;
 282 }
 283
 284
 285
 286 void
 287 AliHLTPHOSRawAnalyzerComponent::Reset()
 288 {
 289   for(int mod = 0; mod <5; mod ++)
 290     {
 291       for(int row = 0; row < 64; row ++)
 292         {
 293           for(int col = 0; col < 56; col ++)
 294             {
 295               for(int gain = 0; gain <2; gain ++ )
 296                 {
 297                   fMaxValues[mod][row][col][gain] = 0;
 298                 }
 299             }
 300         }
 301     }
 302
 303   for(int i = 0 ; i< 1008; i++)
 304     {
 305       fTmpChannelData[i] = 0;
 306     }
 307 } // end Reset
 308
 309 void
 310 AliHLTPHOSRawAnalyzerComponent::ResetDataPtr()
 311 {
 312   for(int i = 0 ; i< 1008; i++)
 313     {
 314       fTmpChannelData[i] = 0;
 315     }
 316 }
 317
 318
 319 void
 320 AliHLTPHOSRawAnalyzerComponent::SetEquippmentID(AliHLTUInt32_t id)
 321 {
 322   fEquippmentID = id;
 323 }
 324
 325 int
 326 AliHLTPHOSRawAnalyzerComponent::GetEquippmentID()
 327 {
 328   return  fEquippmentID;
 329 }
 330
 331 void
 332 AliHLTPHOSRawAnalyzerComponent::SetCoordinates(AliHLTUInt32_t equippmentID)
 333 {
 334   int rcuIndex =  (fEquippmentID - 1792)%4;
 335   fModuleID = (fEquippmentID  -1792 -rcuIndex)/5;
 336
 337   if(rcuIndex == 0)
 338     {
 339       fRcuX = 0;
 340       fRcuZ = 0;
 341     }
 342
 343   if(rcuIndex == 1)
 344     {
 345       fRcuX = 0;
 346       fRcuZ = 1;
 347     }
 348
 349   if(rcuIndex == 2)
 350     {
 351       fRcuX = 1;
 352       fRcuZ = 0;
 353     }
 354
 355
 356   if(rcuIndex == 3)
 357     {
 358       fRcuX = 1;
 359       fRcuZ = 1;
 360     }
 361
 362   fRcuRowOffeset = 32*fRcuX;
 363   fRcuColOffeset = 28*fRcuZ;
 364
 365 }