HLT/RCU/AliHLTAltroTimebinAverageComponent.cxx

   1 // $Id$
   2
   3 //**************************************************************************
   4 //* This file is property of and copyright by the ALICE HLT Project        *
   5 //* ALICE Experiment at CERN, All rights reserved.                         *
   6 //*                                                                        *
   7 //* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no>          *
   8 //*                  Oystein Djuvsland
   9 //*                  Matthias Richter                                      *
  10 //*                  for The ALICE HLT Project.                            *
  11 //*                                                                        *
  12 //* Permission to use, copy, modify and distribute this software and its   *
  13 //* documentation strictly for non-commercial purposes is hereby granted   *
  14 //* without fee, provided that the above copyright notice appears in all   *
  15 //* copies and that both the copyright notice and this permission notice   *
  16 //* appear in the supporting documentation. The authors make no claims     *
  17 //* about the suitability of this software for any purpose. It is          *
  18 //* provided "as is" without express or implied warranty.                  *
  19 //**************************************************************************
  20
  21 /** @file   AliHLTAltroTimebinAverageComponent.cxx
  22     @author Kalliopi Kanaki, Oystein Djuvsland, Matthias Richter
  23     @date   26.08.2008
  24     @brief
  25 */
  26
  27 #include "AliHLTAltroTimebinAverageComponent.h"
  28 #include "AliHLTErrorGuard.h"
  29 #include "AliAltroRawStreamV3.h"
  30 #include "AliHLTAltroEncoder.h"
  31 #include "AliRawReaderMemory.h"
  32 #include "AliRawDataHeader.h"
  33 #include <memory>
  34
  35 using namespace std;
  36
  37 /** ROOT macro for the implementation of ROOT specific class methods */
  38 ClassImp(AliHLTAltroTimebinAverageComponent)
  39
  40 AliHLTAltroTimebinAverageComponent::AliHLTAltroTimebinAverageComponent()
  41     :
  42     fStartTimeBin(0),
  43     fEndTimeBin(1024),
  44     fNTimeBins(1024)
  45 {
  46   // see header file for class documentation
  47   // or
  48   // refer to README to build package
  49   // or
  50   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  51 }
  52
  53 AliHLTAltroTimebinAverageComponent::~AliHLTAltroTimebinAverageComponent()
  54 {
  55   // see header file for class documentation
  56 }
  57
  58 // Public functions to implement AliHLTComponent's interface.
  59 // These functions are required for the registration process
  60
  61 const char* AliHLTAltroTimebinAverageComponent::GetComponentID()
  62 {
  63   // see header file for class documentation
  64   return "AltroTimebinAverager";
  65 }
  66
  67 void AliHLTAltroTimebinAverageComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  68 {
  69   // see header file for class documentation
  70   list.clear();
  71   list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
  72   list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginPHOS );
  73 }
  74
  75 AliHLTComponentDataType AliHLTAltroTimebinAverageComponent::GetOutputDataType()
  76 {
  77   // see header file for class documentation
  78   return kAliHLTDataTypeDDLRaw;
  79 }
  80
  81 int AliHLTAltroTimebinAverageComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
  82 {
  83   // see header file for class documentation
  84   tgtList.clear();
  85   tgtList.push_back(kAliHLTDataTypeDDLRaw);
  86   return tgtList.size();
  87 }
  88
  89 void AliHLTAltroTimebinAverageComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  90 {
  91   // see header file for class documentation
  92   constBase=0;
  93   inputMultiplier=1.0;
  94 }
  95
  96 AliHLTComponent* AliHLTAltroTimebinAverageComponent::Spawn()
  97 {
  98   // see header file for class documentation
  99   return new AliHLTAltroTimebinAverageComponent;
 100 }
 101
 102 int AliHLTAltroTimebinAverageComponent::DoInit( int argc, const char** argv )
 103 {
 104   // see header file for class documentation
 105
 106   Int_t i = 0;
 107   Char_t* cpErr;
 108
 109   while ( i < argc ) {
 110
 111     // -- number of timebins
 112     if ( !strcmp( argv[i], "ntimebins" ) ) {
 113       fNTimeBins = strtoul( argv[i+1], &cpErr ,0);
 114       if ( *cpErr ) {
 115         HLTError("Cannot convert ntimebins specifier '%s'.", argv[i+1]);
 116         return EINVAL;
 117       }
 118       i+=2;
 119       continue;
 120     }
 121
 122     // -- first timebin
 123     if ( !strcmp( argv[i], "start-timebin" ) ) {
 124       fStartTimeBin = strtoul( argv[i+1], &cpErr ,0);
 125       if ( *cpErr ) {
 126         HLTError("Cannot convert start-timebin specifier '%s'.", argv[i+1]);
 127         return EINVAL;
 128       }
 129       i+=2;
 130       continue;
 131     }
 132
 133     // -- last timebin
 134     if ( !strcmp( argv[i], "end-timebin" ) ) {
 135       if(strtoul( argv[i+1], &cpErr ,0)<=1024){
 136         fEndTimeBin = strtoul( argv[i+1], &cpErr ,0);
 137       }
 138       if ( *cpErr ) {
 139         HLTError("Cannot convert end-timebin specifier '%s'.", argv[i+1]);
 140         return EINVAL;
 141       }
 142       i+=2;
 143       continue;
 144     }
 145
 146     HLTError("Unknown option '%s'", argv[i]);
 147     return -EINVAL;
 148
 149   }
 150
 151   return 0;
 152 }
 153
 154 int AliHLTAltroTimebinAverageComponent::DoDeinit()
 155 {
 156   // see header file for class documentation
 157   return 0;
 158 }
 159
 160 int AliHLTAltroTimebinAverageComponent::DoEvent( const AliHLTComponentEventData& evtData,
 161                                                 const AliHLTComponentBlockData* blocks,
 162                                                 AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
 163                                                 AliHLTUInt32_t& size,
 164                                                 vector<AliHLTComponentBlockData>& outputBlocks )
 165 {
 166   // see header file for class documentation
 167   int iResult=0;
 168   AliHLTUInt32_t capacity=size;
 169   size=0;
 170   AliHLTUInt32_t offset=0;
 171
 172   const AliHLTComponentBlockData* iter = NULL;
 173   unsigned long ndx;
 174
 175   std::auto_ptr<AliRawReaderMemory> pRawReader(new AliRawReaderMemory);
 176   if (pRawReader.get()) return -ENOMEM;
 177
 178   for(ndx = 0; ndx < evtData.fBlockCnt; ndx++) {
 179     iter = blocks+ndx;
 180
 181     if ( iter->fDataType != kAliHLTDataTypeDDLRaw) {
 182       continue;
 183     }
 184
 185     static AliHLTErrorGuard required("AliHLTAltroTimebinAverageComponent", "DoEvent", "component commission required after major changes, need to extract equipment id from data specification");
 186     (++required).Throw(1);
 187
 188     pRawReader->Reset();
 189     // FIXME: set ddl no
 190     if (!pRawReader->AddBuffer((UChar_t*)iter->fPtr,iter->fSize, 768)) {
 191       ALIHLTERRORGUARD(1, "can not set up AltroDecoder for data block %s 0x%08x,"
 192                        " skipping data block and suppressing further messages",
 193                        DataType2Text(iter->fDataType).c_str(), iter->fSpecification);
 194       continue;
 195     }
 196
 197     std::auto_ptr<AliAltroRawStreamV3> altroRawStream(new AliAltroRawStreamV3(pRawReader.get()));
 198     std::auto_ptr<AliHLTAltroEncoder> altroEncoder(new AliHLTAltroEncoder);
 199
 200     if (!altroRawStream.get() || !altroEncoder.get()) {
 201       iResult=-ENOMEM;
 202       break;
 203     }
 204
 205     altroRawStream->Reset();
 206     if (!altroRawStream->NextDDL()) {
 207       ALIHLTERRORGUARD(1, "internal error, can not read data from AliRawReaderMemory");
 208       continue;
 209     }
 210
 211     UChar_t *RCUTrailer=NULL;
 212     Int_t RCUTrailerSize=altroRawStream->GetRCUTrailerSize();
 213     if (RCUTrailerSize<=0 || !altroRawStream->GetRCUTrailerData(RCUTrailer) || RCUTrailer==NULL) {
 214       ALIHLTERRORGUARD(1, "can not find RCU trailer for data block %s 0x%08x: skipping data block",
 215                        DataType2Text(iter->fDataType).c_str(), iter->fSpecification);
 216       continue;
 217     }
 218
 219     altroEncoder->SetBuffer(outputPtr+offset,capacity-offset);
 220     AliRawDataHeader cdh;
 221     altroEncoder->SetCDH((AliHLTUInt8_t*)iter->fPtr,sizeof(AliRawDataHeader));
 222
 223     altroEncoder->SetRCUTrailer(RCUTrailer, RCUTrailerSize);
 224
 225     while (iResult>=0 && altroRawStream->NextChannel()) {
 226       int hwadd=altroRawStream->GetHWAddress();
 227
 228       while (iResult>=0 && altroRawStream->NextBunch()) {
 229         int bunchLength=altroRawStream->GetBunchLength();
 230         int time=altroRawStream->GetStartTimeBin();
 231         const  UShort_t* bunchData=altroRawStream->GetSignals();
 232         for (int bin=bunchLength && iResult>=0; bin>0; ) {
 233           bin--;
 234           if(bunchData[bin]>0){// disregarding 0 data.
 235
 236             if(time+bin>=fStartTimeBin && time+bin<=fEndTimeBin){
 237               AliHLTUInt16_t signal=bunchData[bin];
 238               if (bin-1>=0) signal+=bunchData[bin-1];
 239               altroEncoder->AddSignal((time+bin)/2,signal/2);
 240               bin--;
 241             } // end if between start and end time bin
 242           } // end if bunchData[i]>0
 243         } // for loop
 244       } //while loop over bunches
 245       if (true/*condition deprecated but keep formatting*/) {
 246         altroEncoder->SetChannel(hwadd);
 247       }
 248     } // while loop over channels
 249
 250     if (true/*condition deprecated but keep formatting*/) {
 251      int sizeOfData=altroEncoder->SetLength();
 252
 253      if (sizeOfData<0) {
 254        HLTError("data encoding failed");
 255        return sizeOfData;
 256      }
 257      if(sizeOfData>(int)capacity){
 258        HLTWarning("Buffer too small to add the altrodata: %d of %d byte(s) already used", sizeOfData, size);
 259        return -ENOSPC;
 260      }
 261
 262      AliHLTComponentBlockData bd;
 263      FillBlockData( bd );
 264      bd.fOffset = offset;
 265      bd.fSize = sizeOfData;
 266      bd.fDataType = iter->fDataType;
 267      bd.fSpecification = iter->fSpecification;
 268      outputBlocks.push_back( bd );
 269
 270      offset+=bd.fSize;
 271     }
 272
 273   } // while over data blocks
 274
 275   if (iResult>=0) size=offset;
 276   return iResult;
 277 }
 278