Qmax for merged clusters fixed
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCRawDataUnpackerComponent.cxx
CommitLineData
71d7c760 1// $Id$
2
3/**************************************************************************
9be2600f 4 * This file is property of and copyright by the ALICE HLT Project *
5 * ALICE Experiment at CERN, All rights reserved. *
71d7c760 6 * *
9be2600f 7 * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
8 * Timm Steinbeck <timm@kip.uni-heidelberg.de> *
9 * for The ALICE HLT Project. *
71d7c760 10 * *
11 * Permission to use, copy, modify and distribute this software and its *
12 * documentation strictly for non-commercial purposes is hereby granted *
13 * without fee, provided that the above copyright notice appears in all *
14 * copies and that both the copyright notice and this permission notice *
15 * appear in the supporting documentation. The authors make no claims *
16 * about the suitability of this software for any purpose. It is *
17 * provided "as is" without express or implied warranty. *
18 **************************************************************************/
19
20///////////////////////////////////////////////////////////////////////////////
21// //
22// a TPC cluster finder processing component for the HLT //
23// //
e67b0680 24// see header file for class documentation //
25// or //
26// refer to README to build package //
27// or //
28// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt //
29// //
71d7c760 30///////////////////////////////////////////////////////////////////////////////
31
e67b0680 32#if __GNUC__>= 3
71d7c760 33using namespace std;
34#endif
35
36#include "AliHLTTPCRawDataUnpackerComponent.h"
37#include "AliTPCRawStream.h"
38#include "AliRawDataHeader.h"
39#include "AliRawReaderMemory.h"
a6c02c85 40#include "AliHLTTPCDigitData.h"
41#include "AliHLTTPCTransform.h"
e67b0680 42#include "AliHLTTPCDefinitions.h"
43#include <cstdlib>
44#include <cerrno>
71d7c760 45
672f8b8c 46/** ROOT macro for the implementation of ROOT specific class methods */
e67b0680 47ClassImp(AliHLTTPCRawDataUnpackerComponent);
71d7c760 48
49AliHLTTPCRawDataUnpackerComponent::AliHLTTPCRawDataUnpackerComponent()
e419b223 50 :
51 fRawMemoryReader(NULL),
52 fTPCRawStream(NULL)
53{
e67b0680 54 // see header file for class documentation
55 // or
56 // refer to README to build package
57 // or
58 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
e419b223 59}
60
71d7c760 61AliHLTTPCRawDataUnpackerComponent::~AliHLTTPCRawDataUnpackerComponent()
e419b223 62{
e67b0680 63 // see header file for class documentation
e419b223 64}
71d7c760 65
66// Public functions to implement AliHLTComponent's interface.
67// These functions are required for the registration process
68
69const char* AliHLTTPCRawDataUnpackerComponent::GetComponentID()
e67b0680 70{
71 // see header file for class documentation
72 return "TPCRawDataUnpacker";
73}
71d7c760 74
8ede8717 75void AliHLTTPCRawDataUnpackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
e67b0680 76{
77 // see header file for class documentation
78 list.clear();
5dcd324a 79 list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC );
e67b0680 80}
71d7c760 81
8ede8717 82AliHLTComponentDataType AliHLTTPCRawDataUnpackerComponent::GetOutputDataType()
e67b0680 83{
84 // see header file for class documentation
85 return AliHLTTPCDefinitions::fgkUnpackedRawDataType;
86}
71d7c760 87
88void AliHLTTPCRawDataUnpackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
e67b0680 89{
90 // see header file for class documentation
91 // XXX TODO: Find more realistic values.
92 constBase = 0;
93 inputMultiplier = 6.0;
94}
71d7c760 95
96AliHLTComponent* AliHLTTPCRawDataUnpackerComponent::Spawn()
e67b0680 97{
98 // see header file for class documentation
99 return new AliHLTTPCRawDataUnpackerComponent;
100}
101
71d7c760 102int AliHLTTPCRawDataUnpackerComponent::DoInit( int argc, const char** argv )
e67b0680 103{
104 // see header file for class documentation
105 if ( fRawMemoryReader || fTPCRawStream )
106 return EINPROGRESS;
71d7c760 107
e67b0680 108 int i = 0;
109 // const char* tableFileBaseDir = NULL;
110 while ( i < argc )
111 {
112 // if ( !strcmp( argv[i], "table-dir" ) )
113 // {
114 // if ( i+1>=argc )
115 // {
116 // Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Missing Argument", "Missing -table-dir parameter");
117 // return ENOTSUP;
118 // }
119 // tableFileBaseDir = argv[i+1];
120 // i += 2;
121 // continue;
122 // }
123 Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
124 return EINVAL;
125 }
71d7c760 126
e67b0680 127 // if ( !tableFileBaseDir )
128 // {
129 // Logging(kHLTLogError, "HLT::TPCRawDataUnpacker::DoInit", "Table file directory missing ",
130 // "Table file base directory has to be set using the -table-dir component parameter." );
131 // return EINVAL;
132 // }
71d7c760 133
e67b0680 134 fRawMemoryReader = new AliRawReaderMemory;
135 //fTPCRawStream = new AliTPCRawStream( fRawMemoryReader, tableFileBaseDir );
136 fTPCRawStream = new AliTPCRawStream( fRawMemoryReader );
71d7c760 137
e67b0680 138 return 0;
139}
71d7c760 140
141int AliHLTTPCRawDataUnpackerComponent::DoDeinit()
e67b0680 142{
143 // see header file for class documentation
144 if ( fRawMemoryReader )
145 delete fRawMemoryReader;
146 fRawMemoryReader = NULL;
147 if ( fTPCRawStream )
148 delete fTPCRawStream;
149 fTPCRawStream = NULL;
150 return 0;
151}
71d7c760 152
8ede8717 153int AliHLTTPCRawDataUnpackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
5d2abf3b 154 AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
8ede8717 155 AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
e67b0680 156{
157 // see header file for class documentation
158 const AliHLTComponentBlockData* iter = NULL;
159 unsigned long ndx;
71d7c760 160
e67b0680 161 AliHLTUInt8_t* outBPtr;
162 AliHLTTPCUnpackedRawData* outPtr;
163 AliHLTTPCDigitRowData* currentRow;
164 AliHLTTPCDigitData* currentDigit;
165 unsigned long long outputSize = 0;
166 unsigned long blockOutputSize = 0;
167 unsigned long rowSize = 0;
168 Int_t slice, patch, rows[2];
169 outBPtr = outputPtr;
170 outPtr = (AliHLTTPCUnpackedRawData*)outputPtr;
171 currentRow = outPtr->fDigits;
172 currentDigit = currentRow->fDigitData;
a6c02c85 173
e67b0680 174 Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Event received",
175 "Event 0x%08LX (%Lu) received with %lu blocks. Output data size: %lu",
176 evtData.fEventID, evtData.fEventID, evtData.fBlockCnt, size);
177 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
178 {
179 iter = blocks+ndx;
5dcd324a 180 if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) )
71d7c760 181 {
e67b0680 182 continue;
183 }
184 slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
185 patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
186 rows[0] = AliHLTTPCTransform::GetFirstRow( patch );
187 rows[1] = AliHLTTPCTransform::GetLastRow( patch );
188 blockOutputSize = 0;
71d7c760 189
e67b0680 190 Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Input Raw Packed Data",
191 "Input: Slice/Patch/RowMin/RowMax: %d/%d/%d/%d.",
192 slice, patch, rows[0], rows[1] );
a6c02c85 193
e67b0680 194 fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
195 bool readValue = true;
196 readValue = fTPCRawStream->Next();
197 int row = -1, oldRow = -1;
198 Int_t rowOffset = 0;
199 if ( patch >= 2 ) // Outer sector, patches 2, 3, 4, 5
200 rowOffset = AliHLTTPCTransform::GetFirstRow( 2 );
71d7c760 201
e67b0680 202 while ( readValue )
203 {
204 row = fTPCRawStream->GetRow();
205 if ( row != oldRow )
71d7c760 206 {
e67b0680 207 if ( oldRow!=-1 && rowSize != sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData) )
71d7c760 208 {
e67b0680 209 Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Size inconsistency",
210 "Size inconsistency for row %d data: %lu != %lu (%lu digits).", oldRow, rowSize,
211 sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData), currentRow->fNDigit );
71d7c760 212 }
e67b0680 213 rowSize = 0;
214 if ( size < outputSize+sizeof(AliHLTTPCDigitRowData) )
71d7c760 215 {
e67b0680 216 Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Too much data",
217 "Output data too big, output memory full. Aborting event 0x%08lX (%lu)" ,
218 evtData.fEventID, evtData.fEventID );
219 return 0;
71d7c760 220 }
e67b0680 221 currentRow = (AliHLTTPCDigitRowData*)(outBPtr+outputSize);
222 currentDigit = currentRow->fDigitData;
223 currentRow->fRow = row+rowOffset;
224 currentRow->fNDigit = 0;
225 oldRow = row;
226 outputSize += sizeof(AliHLTTPCDigitRowData);
227 blockOutputSize += sizeof(AliHLTTPCDigitRowData);
228 rowSize += sizeof(AliHLTTPCDigitRowData);
71d7c760 229 }
e67b0680 230 if ( size < outputSize+sizeof(AliHLTTPCDigitData) )
71d7c760 231 {
e67b0680 232 Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Too much data",
233 "Output data too big, output memory full. Aborting event 0x%08lX (%lu)" ,
234 evtData.fEventID, evtData.fEventID );
235 return 0;
71d7c760 236 }
e67b0680 237 currentDigit->fCharge = fTPCRawStream->GetSignal();
238 currentDigit->fPad = fTPCRawStream->GetPad();
239 currentDigit->fTime = fTPCRawStream->GetTime();
240 currentRow->fNDigit++;
241 currentDigit++;
242 outputSize += sizeof(AliHLTTPCDigitData);
243 blockOutputSize += sizeof(AliHLTTPCDigitData);
244 rowSize += sizeof(AliHLTTPCDigitData);
245 readValue = fTPCRawStream->Next();
246 }
247 if ( oldRow!=-1 && rowSize != sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData) )
248 {
249 Logging( kHLTLogFatal, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Size inconsistency",
250 "Size inconsistency for row %d data: %lu != %lu (%lu digits).", oldRow, rowSize,
251 sizeof(AliHLTTPCDigitRowData)+currentRow->fNDigit*sizeof(AliHLTTPCDigitData), currentRow->fNDigit );
71d7c760 252 }
253
e67b0680 254 AliHLTComponentBlockData bd;
255 FillBlockData( bd );
256 bd.fOffset = outputSize-blockOutputSize;
257 bd.fSize = blockOutputSize;
258 bd.fSpecification = iter->fSpecification;
259 Logging( kHLTLogDebug, "HLT::TPCRawDataUnpackerSubscriber::DoEvent", "Event received",
260 "Event 0x%08LX (%Lu) output data block %lu of %lu bytes at offset %lu",
261 evtData.fEventID, evtData.fEventID, ndx, blockOutputSize, outputSize-blockOutputSize );
262 //AliHLTSubEventDescriptor::FillBlockAttributes( bd.fAttributes );
263 outputBlocks.push_back( bd );
71d7c760 264 }
265
e67b0680 266
267 size = outputSize;
268 return 0;
269}
270
71d7c760 271