]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HLT/TPCLib/AliHLTTPCClusterAccessHLTOUT.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bugfix: correct calculation of remaining payload to detect decoding errors
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCClusterAccessHLTOUT.cxx
CommitLineData
c54aa300 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: Matthias Richter <Matthias.Richter@ift.uib.no> *
8//* for The ALICE HLT Project. *
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/// @file AliHLTTPCClusterAccessHLTOUT.h
20/// @author Matthias Richter
21/// @date 2011-06-06
22/// @brief Interface to HLT TPC clusters
23///
24
25#include "AliHLTTPCClusterAccessHLTOUT.h"
b60d3f6a 26#include "AliHLTTPCDataCompressionDecoder.h"
c54aa300 27#include "AliHLTTPCDefinitions.h"
28#include "AliHLTTPCClusterDataFormat.h"
5e75f4e0 29#include "AliHLTTPCRawCluster.h"
61e66346 30#include "AliHLTTPCTransform.h"
c54aa300 31#include "AliHLTOUT.h"
81e7f739 32#include "AliHLTComponent.h"
73db5fa6 33#include "AliHLTErrorGuard.h"
61e66346 34#include "AliHLTDataInflater.h"
35#include "AliHLTTPCDefinitions.h"
c54aa300 36#include "AliLog.h"
37#include "AliHLTSystem.h"
38#include "AliHLTPluginBase.h"
39#include "AliTPCclusterMI.h"
40#include "TClonesArray.h"
81e7f739 41#include <cstdlib>
42#include <string>
43#include <memory>
b60d3f6a 44#include <iostream>
45#include <iomanip>
c54aa300 46
47/** ROOT macro for the implementation of ROOT specific class methods */
48ClassImp(AliHLTTPCClusterAccessHLTOUT)
49
50AliHLTTPCClusterAccessHLTOUT::AliHLTTPCClusterAccessHLTOUT()
51 : TObject()
81e7f739 52 , fVerbosity(0)
c54aa300 53 , fClusters(NULL)
b60d3f6a 54 , fCurrentSector(-1)
c54aa300 55{
56 // see header file for class documentation
57 // or
58 // refer to README to build package
59 // or
60 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
61}
62
63AliHLTTPCClusterAccessHLTOUT::~AliHLTTPCClusterAccessHLTOUT()
64{
65 // destructor
66 if (fClusters) {
67 fClusters->Clear();
68 delete fClusters;
69 fClusters=NULL;
70 }
71}
72
81e7f739 73void AliHLTTPCClusterAccessHLTOUT::Execute(const char *method, const char *params, Int_t *error)
c54aa300 74{
75 /// inherited from TObject: abstract command interface
76 if (strcmp(method, "read")==0) {
81e7f739 77 int iResult=ProcessClusters(params);
78 if (error) *error=iResult;
79 return;
80 }
81 if (strcmp(method, "verbosity")==0) {
82 int iResult=0;
83 if (params) {
84 char* dummy;
85 int value=strtol(params, &dummy, 0);
86 if (dummy==NULL) {
87 fVerbosity=value;
88 } else {
89 AliError("invalid argument for command 'verbosity', expecting string with number");
90 }
91 } else {
92 iResult=-EINVAL;
93 }
c54aa300 94 if (error) *error=iResult;
95 return;
96 }
97}
98
99TObject* AliHLTTPCClusterAccessHLTOUT::FindObject(const char *name) const
100{
101 /// inherited from TObject: return the cluster array if name id "clusterarray"
b60d3f6a 102 if (strcmp(name, "clusterarray")==0) {
103 if (fCurrentSector<0) return NULL;
104 return fClusters->GetSectorArray(fCurrentSector);
105 }
c54aa300 106 return TObject::FindObject(name);
107}
108
b60d3f6a 109void AliHLTTPCClusterAccessHLTOUT::Clear(Option_t * option)
c54aa300 110{
111 /// inherited from TObject: cleanup
b60d3f6a 112 if (strcmp(option, "event")==0) {
113 if (fClusters) fClusters->Clear();
114 fCurrentSector=-1;
115 }
c54aa300 116}
117
b60d3f6a 118void AliHLTTPCClusterAccessHLTOUT::Print(Option_t *option) const
c54aa300 119{
120 /// inherited from TObject
b60d3f6a 121 if (fClusters) fClusters->Print(option);
c54aa300 122}
123
81e7f739 124int AliHLTTPCClusterAccessHLTOUT::ProcessClusters(const char* params)
c54aa300 125{
126 /// process the cluster data from HLTOUT and fill array
127 /// the cluster data can be in many different formats, e.g.
128 /// raw or compressed
129 int iResult=0;
81e7f739 130 TString strparams(params);
b60d3f6a 131 int sector=-1;
81e7f739 132 std::auto_ptr<TObjArray> tokens(strparams.Tokenize(" "));
133 if (!tokens.get()) return -ENOMEM;
134 for (int i=0; i< tokens->GetEntriesFast(); i++) {
135 if (!tokens->At(i)) continue;
136 TString argument=tokens->At(i)->GetName();
b60d3f6a 137 // the offline code enumerates first the 36 inner (partitions 0+1) and then 36 outer
138 // sectors (partitions 2-5)
81e7f739 139 if (argument.BeginsWith("sector=")) {
140 argument.ReplaceAll("sector=", "");
b60d3f6a 141 sector=argument.Atoi();
81e7f739 142 }
143 }
b60d3f6a 144 if (sector<0) {
145 AliError("invalid argument, please specify \"sector=sectorno\"");
146 return -EINVAL;
147 }
148 if (sector>=76) {
149 AliError(Form("invalid sector number %d", sector));
150 return -EINVAL;
151 }
81e7f739 152
c54aa300 153 if (!fClusters) {
b60d3f6a 154 fClusters=new AliTPCclusterMIContainer;
c54aa300 155 }
156 if (!fClusters) return -ENOMEM;
157
b60d3f6a 158 if (fCurrentSector>=0) {
159 // cluster container already filled
160 fCurrentSector=sector;
161 TObjArray* pArray=fClusters->GetSectorArray(fCurrentSector);
162 if (!pArray) {
163 AliError(Form("can not get cluster array for sector %d", sector));
164 return -ENOBUFS;
165 }
af9e48d7 166 if (fVerbosity>0) AliInfo(Form("converted %d cluster(s) for sector %d", pArray->GetEntriesFast() ,sector));
b60d3f6a 167 return pArray->GetEntriesFast();
168 }
169
170 // fill the cluster container
c54aa300 171 AliHLTSystem* pSystem=AliHLTPluginBase::GetInstance();
172 if (!pSystem) {
173 AliError("can not access HLT system");
174 return -ENODEV;
175 }
176 AliHLTOUT* pHLTOUT=pSystem->RequestHLTOUT();
177 if (!pHLTOUT) {
178 AliError("can not access HLTOUT");
b60d3f6a 179 return -EACCES;
c54aa300 180 }
181
b60d3f6a 182 bool bNextBlock=false;
183 bool bHaveLabels=false;
184 bool bHaveIds=false;
185 // add cluster id and mc information data blocks
186 for (bNextBlock=(pHLTOUT->SelectFirstDataBlock()>=0);
187 bNextBlock; bNextBlock=(pHLTOUT->SelectNextDataBlock()>=0)) {
188 AliHLTComponentBlockData desc;
189 // FIXME: extend HLTOUT to get the full descriptor
190 const AliHLTUInt8_t* buffer=NULL;
191 if ((iResult=pHLTOUT->GetDataBuffer(buffer, desc.fSize))<0) {
192 continue;
193 }
194 desc.fPtr=(void*)buffer;
195 if (pHLTOUT->GetDataBlockDescription(desc.fDataType, desc.fSpecification)<0) {
196 continue;
197 }
198 if (desc.fDataType==AliHLTTPCDefinitions::AliHLTDataTypeClusterMCInfo()) {
199 // add mc information
200 if ((iResult=fClusters->AddClusterMCData(&desc))<0) {
201 return iResult;
81e7f739 202 }
b60d3f6a 203 bHaveLabels=true;
204 }
205 if (desc.fDataType==AliHLTTPCDefinitions::RemainingClusterIdsDataType() ||
206 desc.fDataType==AliHLTTPCDefinitions::ClusterIdTracksDataType()) {
207 // add cluster ids
208 if ((iResult=fClusters->AddClusterIds(&desc))<0) {
209 return iResult;
81e7f739 210 }
b60d3f6a 211 bHaveIds=true;
212 }
213 }
214
14f37d68 215 bool bHavePartitionRawData=false;
216 bool bHavePartitionCompressedData=false;
217 vector<bool> bHavePartitionData(216, false);
218
b60d3f6a 219 // read data
220 iResult=-ENODATA;
221 AliHLTTPCDataCompressionDecoder decoder;
af9e48d7 222 decoder.SetVerbosity(fVerbosity);
223 int nExtractedClusters=0;
b60d3f6a 224 for (bNextBlock=(pHLTOUT->SelectFirstDataBlock()>=0);
225 bNextBlock; bNextBlock=(pHLTOUT->SelectNextDataBlock()>=0)) {
14f37d68 226 decoder.SetPadShift(0.0);
b60d3f6a 227 AliHLTComponentBlockData desc;
228 // FIXME: extend HLTOUT to get the full descriptor with one call
229 const AliHLTUInt8_t* buffer=NULL;
230 if ((iResult=pHLTOUT->GetDataBuffer(buffer, desc.fSize))<0) {
231 continue;
232 }
233 desc.fPtr=(void*)buffer;
234 if (pHLTOUT->GetDataBlockDescription(desc.fDataType, desc.fSpecification)<0) {
235 continue;
236 }
237 if (!TestBit(kSkipPartitionClusters) &&
14f37d68 238 (desc.fDataType==AliHLTTPCDefinitions::RawClustersDataType())) {
239 // This is a special handling of data blocks produced with v5-01-Release
240 // The pad shift by 0.5 was not included in the data but was applied in the
241 // unpacking in this class. Changed in r51306, the next tag containing this
242 // change in the online system is v5-01-Rev-07. There are only very few runs
243 // of Sep 2011 with recorded clusters not containing the 0.5 shift
244 // There was also a chenge in the data type of the compressed partition
245 // cluster blocks which helps to identify the blocks which need the pad shift
246 // here
247 if (desc.fSize<sizeof(AliHLTTPCRawClusterData)) continue;
248 const AliHLTTPCRawClusterData* clusterData = reinterpret_cast<const AliHLTTPCRawClusterData*>(buffer);
249 if (!clusterData) continue;
250 if (clusterData->fVersion==1) {
251 // compressed clusters without the pad shift
252 // no raw clusters (version==0) have ever been recorded
253 decoder.SetPadShift(0.5);
254 }
255 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(desc.fSpecification);
256 AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(desc.fSpecification);
257 if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr(desc.fSpecification) ||
258 partition!=AliHLTTPCDefinitions::GetMaxPatchNr(desc.fSpecification)) {
259 AliFatal(Form("inconsistent cluster data: can not handle blocks containing multiple partitions, "
260 "block specification 0x%08x", desc.fSpecification));
261 }
262 iResult=decoder.ReadClustersPartition(fClusters->BeginRemainingClusterBlock(0, desc.fSpecification),
263 reinterpret_cast<AliHLTUInt8_t*>(desc.fPtr),
264 desc.fSize,
265 desc.fSpecification);
266 if (iResult>0) nExtractedClusters+=iResult;
267 unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
268 if (index>=bHavePartitionData.size()) bHavePartitionData.resize(index, false);
269 if (bHavePartitionData[index]) {
270 AliFatal(Form("inconsistent cluster data: multiple data blocks of identical specification indicate a failure "
271 "in the production of the data. Probably an HLT emulation chain is executed in the reconstruction "
272 "and produces data in addition to HLTOUT. Option 'ignore-hltout' is required in that case; "
273 "block specification 0x%08x", desc.fSpecification));
274 }
275 bHavePartitionData[index]=true;
276 if (bHavePartitionCompressedData) {
277 AliFatal(Form("inconsistent cluster data: both compressed and raw cluster blocks present in HLTOUT, indicates a failure "
278 "in the production of the data. Probably an HLT emulation chain is executed in the reconstruction "
279 "and produces data in addition to HLTOUT. Option 'ignore-hltout' is required in that case; "
280 "block specification 0x%08x", desc.fSpecification));
281 }
282 bHavePartitionRawData=true;
283 continue;
284 } else if (!TestBit(kSkipPartitionClusters) &&
285 (desc.fDataType==AliHLTTPCDefinitions::RemainingClustersCompressedDataType())) {
286 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(desc.fSpecification);
287 AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(desc.fSpecification);
288 if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr(desc.fSpecification) ||
289 partition!=AliHLTTPCDefinitions::GetMaxPatchNr(desc.fSpecification)) {
290 AliFatal(Form("inconsistent cluster data: can not handle blocks containing multiple partitions, "
291 "block specification 0x%08x", desc.fSpecification));
292 }
b60d3f6a 293 iResult=decoder.ReadClustersPartition(fClusters->BeginRemainingClusterBlock(0, desc.fSpecification),
294 reinterpret_cast<AliHLTUInt8_t*>(desc.fPtr),
295 desc.fSize,
296 desc.fSpecification);
af9e48d7 297 if (iResult>0) nExtractedClusters+=iResult;
14f37d68 298 unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
299 if (index>=bHavePartitionData.size()) bHavePartitionData.resize(index, false);
300 if (bHavePartitionData[index]) {
301 AliFatal(Form("inconsistent cluster data: multiple data blocks of identical specification indicate a failure "
302 "in the production of the data. Probably an HLT emulation chain is executed in the reconstruction "
303 "and produces data in addition to HLTOUT. Option 'ignore-hltout' is required in that case; "
304 "block specification 0x%08x", desc.fSpecification));
305 }
306 bHavePartitionData[index]=true;
307 bHavePartitionData[index]=true;
308 if (bHavePartitionRawData) {
309 AliFatal(Form("inconsistent cluster data: both compressed and raw cluster blocks present in HLTOUT, indicates a failure "
310 "in the production of the data. Probably an HLT emulation chain is executed in the reconstruction "
311 "and produces data in addition to HLTOUT. Option 'ignore-hltout' is required in that case; "
312 "block specification 0x%08x", desc.fSpecification));
313 }
314 bHavePartitionCompressedData=true;
b60d3f6a 315 continue;
316 } else if (!TestBit(kSkipTrackClusters) &&
317 desc.fDataType==AliHLTTPCDefinitions::ClusterTracksCompressedDataType()) {
318 iResult=decoder.ReadTrackModelClustersCompressed(fClusters->BeginTrackModelClusterBlock(0),
319 reinterpret_cast<AliHLTUInt8_t*>(desc.fPtr),
320 desc.fSize,
321 desc.fSpecification);
322 continue;
81e7f739 323 }
c54aa300 324 }
325
326 pSystem->ReleaseHLTOUT(pHLTOUT);
b60d3f6a 327
328 if (iResult<0) return iResult;
af9e48d7 329 if (fVerbosity>0) {
330 int nConvertedClusters=0;
331 for (int s=0; s<72; s++) {
332 TObjArray* pArray=fClusters->GetSectorArray(s);
333 if (!pArray) continue;
334 nConvertedClusters+=pArray->GetEntriesFast();
335 }
336 AliInfo(Form("extracted HLT clusters: %d, converted HLT clusters: %d", nExtractedClusters, nConvertedClusters));
337 }
338
b60d3f6a 339 fCurrentSector=sector;
340 TObjArray* pArray=fClusters->GetSectorArray(fCurrentSector);
341 if (!pArray) {
342 AliError(Form("can not get cluster array for sector %d", sector));
343 return -ENOBUFS;
344 }
af9e48d7 345 if (fVerbosity>0) AliInfo(Form("converted %d cluster(s) for sector %d", pArray->GetEntriesFast() ,sector));
b60d3f6a 346 return pArray->GetEntriesFast();
c54aa300 347}
348
81e7f739 349int AliHLTTPCClusterAccessHLTOUT::ReadAliHLTTPCClusterMCData(AliHLTOUT* pHLTOUT, AliHLTTPCClusterMCDataList &tpcClusterLabels) const
350{
351 // read cluster data from AliHLTTPCClusterData
352 int iResult=0;
353 if (!pHLTOUT) return -EINVAL;
354 do {
355 const AliHLTUInt8_t* pBuffer=NULL;
356 AliHLTUInt32_t size=0;
357 if ((iResult=pHLTOUT->GetDataBuffer(pBuffer, size))<0) {
358 continue;
359 }
360 if (pBuffer==NULL || size<4) {
361 AliError("invalid cluster mc data block");
362 continue;
363 }
364 const AliHLTTPCClusterMCData* clusterMCData = reinterpret_cast<const AliHLTTPCClusterMCData*>(pBuffer);
365 Int_t nLabels = (Int_t) clusterMCData->fCount;
366 if (nLabels*sizeof(AliHLTTPCClusterMCLabel) + sizeof(AliHLTTPCClusterMCData) != size) {
367 AliError("inconsistent cluster mc data block size, skipping block");
368 continue;
369 }
370 // id of the cluster is
371 AliHLTComponentDataType dt=kAliHLTVoidDataType;
372 AliHLTUInt32_t specification=kAliHLTVoidDataSpec;
373 if (pHLTOUT->GetDataBlockDescription(dt, specification)<0) {
374 AliError("failed to retrieve data block description, skipping mc cluster data block ...");
375 continue;
376 }
377 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(specification);
378 AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(specification);
379 if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr(specification) ||
380 partition!=AliHLTTPCDefinitions::GetMaxPatchNr(specification)) {
381 AliError(Form("can not read cluster mc data block with data of multiple partitions, skipping block %s %08x",
382 AliHLTComponent::DataType2Text(dt).c_str(), specification));
383 continue;
384 }
385 const AliHLTTPCClusterMCLabel *labels = clusterMCData->fLabels;
386 for (int i=0; i<nLabels; i++) {
387 AliHLTUInt32_t id=AliHLTTPCSpacePointData::GetID(slice, partition, i);
388 if (tpcClusterLabels.find(id)==tpcClusterLabels.end()) {
389 // new cluster
390 tpcClusterLabels[id]=labels[i];
391 } else {
392 AliError(Form("cluster with ID 0x%08x already existing, skipping cluster %d of data block 0x%08x",
393 id, i, specification));
394 }
395 }
396 } while (pHLTOUT->SelectNextDataBlock()>=0);
397 return iResult;
398}
399
400int AliHLTTPCClusterAccessHLTOUT::ReadAliHLTTPCClusterData(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels) const
c54aa300 401{
402 // read cluster data from AliHLTTPCClusterData
403 int iResult=0;
404 if (!pHLTOUT || !pClusters) return -EINVAL;
405 do {
406 const AliHLTUInt8_t* pBuffer=NULL;
407 AliHLTUInt32_t size=0;
408 if ((iResult=pHLTOUT->GetDataBuffer(pBuffer, size))<0) {
409 continue;
410 }
411 if (pBuffer==NULL || size<4) {
412 AliError("invalid cluster data block");
413 continue;
414 }
81e7f739 415 AliHLTComponentDataType dt=kAliHLTVoidDataType;
416 AliHLTUInt32_t specification=kAliHLTVoidDataSpec;
417 if (pHLTOUT->GetDataBlockDescription(dt, specification)<0) {
418 AliError("failed to retrieve data block description, skipping mc cluster data block ...");
419 continue;
420 }
c54aa300 421 const AliHLTTPCClusterData* clusterData = reinterpret_cast<const AliHLTTPCClusterData*>(pBuffer);
422 Int_t nSpacepoints = (Int_t) clusterData->fSpacePointCnt;
423 if (nSpacepoints*sizeof(AliHLTTPCSpacePointData) + sizeof(AliHLTTPCClusterData) != size) {
424 AliError("inconsistent cluster data block size, skipping block");
425 continue;
426 }
427 const AliHLTTPCSpacePointData *clusters = clusterData->fSpacePoints;
81e7f739 428 int offset=pClusters->GetEntries();
429 pClusters->ExpandCreate(offset+nSpacepoints);
0e63cf4a 430 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(specification);
431 AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(specification);
432 // FIXME: get first row number of outer sectors from a common definition instead using number
80874dc5 433 unsigned rowOffset=partition<2?0:63;
c54aa300 434 for (int i=0; i<nSpacepoints; i++) {
81e7f739 435 if (!pClusters->At(offset+i)) continue;
436 AliTPCclusterMI* pCluster=dynamic_cast<AliTPCclusterMI*>(pClusters->At(offset+i));
c54aa300 437 if (!pCluster) {
438 AliError("invalid object type, expecting AliTPCclusterMI");
439 break; // this is a problem of all objects
440 }
0e63cf4a 441 if (clusters[i].fPadRow<rowOffset) {
442 AliError(Form("invalid row number %d, expecting minimum row number %d for slice %d partition %d", clusters[i].fPadRow, rowOffset, slice, partition));
443 } else {
444 pCluster->SetRow(clusters[i].fPadRow-rowOffset);
445 }
81e7f739 446 pCluster->SetPad(clusters[i].fY);
5e75f4e0 447 pCluster->SetTimeBin(clusters[i].fZ);
81e7f739 448 pCluster->SetSigmaY2(clusters[i].fSigmaY2);
449 pCluster->SetSigmaZ2(clusters[i].fSigmaZ2);
c54aa300 450 pCluster->SetQ(clusters[i].fCharge);
451 pCluster->SetMax(clusters[i].fQMax);
81e7f739 452 if (tpcClusterLabels) {
453 if (tpcClusterLabels->find(clusters[i].fID)!=tpcClusterLabels->end()) {
454 const AliHLTTPCClusterMCWeight* mcWeights=tpcClusterLabels->find(clusters[i].fID)->second.fClusterID;
455 for (int k=0; k<3; k++) {
456 // TODO: sort the labels according to the weight in order to assign the most likely mc label
457 // to the first component
458 pCluster->SetLabel(mcWeights[k].fMCID, k);
459 }
460 } else {
461 AliError(Form("can not find mc label of cluster with id %0x08x", clusters[i].fID));
462 }
463 }
c54aa300 464 }
1214ab89 465 if (fVerbosity>0) AliInfo(Form("converted %d cluster(s) from block %s 0x%08x", nSpacepoints, AliHLTComponent::DataType2Text(dt).c_str(), specification));
c54aa300 466 } while (pHLTOUT->SelectNextDataBlock()>=0);
467 return iResult;
468}
5e75f4e0 469
470int AliHLTTPCClusterAccessHLTOUT::ReadAliHLTTPCRawClusterData(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels)
471{
472 // read cluster data from AliHLTTPCClusterData
473
474 // FIXME: this is in large parts like ReadAliHLTTPCClusterData,
475 // make a common method
476 int iResult=0;
477 if (!pHLTOUT || !pClusters) return -EINVAL;
478 do {
479 const AliHLTUInt8_t* pBuffer=NULL;
480 AliHLTUInt32_t size=0;
481 if ((iResult=pHLTOUT->GetDataBuffer(pBuffer, size))<0) {
482 continue;
483 }
484 if (pBuffer==NULL || size<4) {
485 AliError("invalid cluster data block");
486 continue;
487 }
488 AliHLTComponentDataType dt=kAliHLTVoidDataType;
489 AliHLTUInt32_t specification=kAliHLTVoidDataSpec;
490 if (pHLTOUT->GetDataBlockDescription(dt, specification)<0) {
491 AliError("failed to retrieve data block description, skipping mc cluster data block ...");
492 continue;
493 }
494 const AliHLTTPCRawClusterData* clusterData = reinterpret_cast<const AliHLTTPCRawClusterData*>(pBuffer);
495 Int_t nCount = (Int_t) clusterData->fCount;
61e66346 496 if (clusterData->fVersion!=0) {
497 // this is encoded data of different formats
498 switch (clusterData->fVersion) {
499 case 1:
500 iResult=ReadAliHLTTPCRawClusterDataDeflateSimple(reinterpret_cast<const AliHLTUInt8_t*>(clusterData->fClusters),
501 size-sizeof(AliHLTTPCRawClusterData), nCount, specification,
502 pClusters, tpcClusterLabels);
503 break;
504 default:
505 iResult=-EPROTO;
506 }
507 return iResult;
508 }
509
5e75f4e0 510 if (nCount*sizeof(AliHLTTPCRawCluster) + sizeof(AliHLTTPCRawClusterData) != size) {
511 AliError("inconsistent cluster data block size, skipping block");
512 continue;
513 }
514 const AliHLTTPCRawCluster *clusters = clusterData->fClusters;
515 int offset=pClusters->GetEntries();
516 pClusters->ExpandCreate(offset+nCount);
0e63cf4a 517 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(specification);
518 AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(specification);
519 // FIXME: get first row number of outer sectors from a common definition instead using number
80874dc5 520 int rowOffset=partition<2?0:63;
5e75f4e0 521 for (int i=0; i<nCount; i++) {
522 if (!pClusters->At(offset+i)) continue;
523 AliTPCclusterMI* pCluster=dynamic_cast<AliTPCclusterMI*>(pClusters->At(offset+i));
524 if (!pCluster) {
525 AliError("invalid object type, expecting AliTPCclusterMI");
526 break; // this is a problem of all objects
527 }
1214ab89 528 if (fVerbosity>1) AliInfo(Form("cluster padrow %d (slice %d partition %d)", clusters[i].GetPadRow(), slice, partition));
0e63cf4a 529 if (clusters[i].GetPadRow()<rowOffset) {
530 AliError(Form("invalid row number %d, expecting minimum row number %d for slice %d partition %d", clusters[i].GetPadRow(), rowOffset, slice, partition));
531 } else {
532 pCluster->SetRow(clusters[i].GetPadRow()-rowOffset);
533 }
1b9cc91a 534 pCluster->SetPad(clusters[i].GetPad());
5e75f4e0 535 pCluster->SetTimeBin(clusters[i].GetTime());
536 pCluster->SetSigmaY2(clusters[i].GetSigmaY2());
537 pCluster->SetSigmaZ2(clusters[i].GetSigmaZ2());
538 pCluster->SetQ(clusters[i].GetCharge());
539 pCluster->SetMax(clusters[i].GetQMax());
540 if (tpcClusterLabels) {
5e75f4e0 541 UInt_t clusterID=AliHLTTPCSpacePointData::GetID(slice, partition, i);
542 if (tpcClusterLabels->find(clusterID)!=tpcClusterLabels->end()) {
543 const AliHLTTPCClusterMCWeight* mcWeights=tpcClusterLabels->find(clusterID)->second.fClusterID;
544 for (int k=0; k<3; k++) {
545 // TODO: sort the labels according to the weight in order to assign the most likely mc label
546 // to the first component
547 pCluster->SetLabel(mcWeights[k].fMCID, k);
548 }
549 } else {
550 AliError(Form("can not find mc label of cluster with id %0x08x", clusterID));
551 }
552 }
553 }
554 if (fVerbosity>0) AliInfo(Form("converted %d cluster(s) from block %s 0x%08x", nCount, AliHLTComponent::DataType2Text(dt).c_str(), specification));
555 } while (pHLTOUT->SelectNextDataBlock()>=0);
556 return iResult;
557}
61e66346 558
2827cd62 559int AliHLTTPCClusterAccessHLTOUT::ReadRemainingClustersCompressed(AliHLTOUT* pHLTOUT, TClonesArray* pClusters, const AliHLTTPCClusterMCDataList *tpcClusterLabels)
560{
561 // read cluster data from AliHLTTPCClusterData
562 int iResult=0;
563 if (!pHLTOUT || !pClusters) return -EINVAL;
564 do {
565 const AliHLTUInt8_t* pBuffer=NULL;
566 AliHLTUInt32_t size=0;
567 if ((iResult=pHLTOUT->GetDataBuffer(pBuffer, size))<0) {
568 continue;
569 }
570 if (pBuffer==NULL || size<4) {
571 AliError("invalid cluster data block");
572 continue;
573 }
574 AliHLTComponentDataType dt=kAliHLTVoidDataType;
575 AliHLTUInt32_t specification=kAliHLTVoidDataSpec;
576 if (pHLTOUT->GetDataBlockDescription(dt, specification)<0) {
577 AliError("failed to retrieve data block description, skipping mc cluster data block ...");
578 continue;
579 }
580 const AliHLTTPCRawClusterData* clusterData = reinterpret_cast<const AliHLTTPCRawClusterData*>(pBuffer);
581 Int_t nCount = (Int_t) clusterData->fCount;
582
583 // this is encoded data of different formats
584 switch (clusterData->fVersion) {
585 case 1:
586 iResult=ReadAliHLTTPCRawClusterDataDeflateSimple(reinterpret_cast<const AliHLTUInt8_t*>(clusterData->fClusters),
587 size-sizeof(AliHLTTPCRawClusterData), nCount, specification,
588 pClusters, tpcClusterLabels);
589 break;
590 default:
591 AliError(Form("invalid cluster format version %d", clusterData->fVersion));
592 iResult=-EPROTO;
593 }
594
595 if (fVerbosity>0) AliInfo(Form("converted %d cluster(s) from block %s 0x%08x", nCount, AliHLTComponent::DataType2Text(dt).c_str(), specification));
596 } while (pHLTOUT->SelectNextDataBlock()>=0 && iResult>=0);
597
598 return iResult;
599}
600
61e66346 601int AliHLTTPCClusterAccessHLTOUT::ReadAliHLTTPCRawClusterDataDeflateSimple(const AliHLTUInt8_t* pData, int dataSize,
602 int nofClusters, AliHLTUInt32_t specification,
603 TClonesArray* pClusters,
604 const AliHLTTPCClusterMCDataList *tpcClusterLabels)
605{
606 // read cluster data from AliHLTTPCClusterData
607
608 // FIXME: quick implementation to read the compressed cluster data from HLTOUT
609 // the data definition below is the same as in AliHLTTPCDataCompressionComponent
610 // but needs to be moved to a common class (AliHLTTPCDefinitions?)
611 // Think about a decoder class supporting iterator objects for various types
612 // of cluster data
613 int iResult=0;
614 if (!pData || !pClusters) return -EINVAL;
615 AliHLTDataInflater inflater;
616 if ((iResult=inflater.InitBitDataInput(pData, dataSize))<0) {
617 return iResult;
618 }
619
620 int offset=pClusters->GetEntries();
621 pClusters->ExpandCreate(offset+nofClusters);
622 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(specification);
623 AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(specification);
624 // the compressed format stores the difference of the local row number in
625 // the partition to the row of the last cluster
626 // add the first row in the partition to get global row number
627 // offline uses row number in physical sector, inner sector consists of
628 // partitions 0 and 1, outer sector of partition 2-5
629 int rowOffset=AliHLTTPCTransform::GetFirstRow(partition)-(partition<2?0:AliHLTTPCTransform::GetFirstRow(2));
630
631 int parameterId=0;
632 int outClusterCnt=0;
633 AliHLTUInt8_t switchBit=0;
634 AliHLTUInt64_t value=0;
635 AliTPCclusterMI* pCluster=NULL;
636 AliHLTUInt32_t lastPadRow=0;
637 while (outClusterCnt<nofClusters && inflater.InputBit(switchBit)) {
638 const AliHLTTPCDefinitions::AliClusterParameter& parameter
639 =AliHLTTPCDefinitions::fgkClusterParameterDefinitions[parameterId];
640 // in mode DeflaterSimple, the optional parameter of the cluster parameter definition
641 // corresponds to the number bits of the reduced format
642 if (!inflater.InputBits(value, switchBit?parameter.fBitLength:parameter.fOptional)) {
643 break;
644 }
645
646 if (!pCluster) {
647 if (!pClusters->At(offset+outClusterCnt)) {
648 // here we should not get anymore because of the condition outClusterCnt<nofClusters
649 return -ENOSPC;
650 }
651 pCluster=dynamic_cast<AliTPCclusterMI*>(pClusters->At(offset+outClusterCnt));
652 if (!pCluster) {
653 AliError("invalid object type, expecting AliTPCclusterMI");
654 iResult=-EBADF; // this is a problem of all objects
655 break;
656 }
657 }
658 switch (parameterId) {
659 case AliHLTTPCDefinitions::kPadRow:
660 {pCluster->SetRow(value+lastPadRow+rowOffset); lastPadRow+=value;break;}
661 case AliHLTTPCDefinitions::kPad:
662 {float pad=value; pad/=parameter.fScale; pCluster->SetPad(pad); break;}
663 case AliHLTTPCDefinitions::kTime:
664 {float time=value; time/=parameter.fScale; pCluster->SetTimeBin(time); break;}
665 case AliHLTTPCDefinitions::kSigmaY2:
666 {float sigmaY2=value; sigmaY2/=parameter.fScale; pCluster->SetSigmaY2(sigmaY2); break;}
667 case AliHLTTPCDefinitions::kSigmaZ2:
668 {float sigmaZ2=value; sigmaZ2/=parameter.fScale; pCluster->SetSigmaZ2(sigmaZ2); break;}
669 case AliHLTTPCDefinitions::kCharge:
670 {pCluster->SetQ(value); break;}
671 case AliHLTTPCDefinitions::kQMax:
672 {pCluster->SetMax(value); break;}
673 }
674 if (parameterId>=AliHLTTPCDefinitions::kLast) {
675 // switch to next cluster
676 if (tpcClusterLabels) {
677 UInt_t clusterID=AliHLTTPCSpacePointData::GetID(slice, partition, outClusterCnt);
678 if (tpcClusterLabels->find(clusterID)!=tpcClusterLabels->end()) {
679 const AliHLTTPCClusterMCWeight* mcWeights=tpcClusterLabels->find(clusterID)->second.fClusterID;
680 for (int k=0; k<3; k++) {
681 // TODO: sort the labels according to the weight in order to assign the most likely mc label
682 // to the first component
683 pCluster->SetLabel(mcWeights[k].fMCID, k);
684 }
685 } else {
2827cd62 686 AliError(Form("can not find mc label of cluster with id 0x%08x", clusterID));
61e66346 687 }
688 }
689 outClusterCnt++;
690 pCluster=NULL;
691 parameterId=-1;
692 }
693 parameterId++;
694 }
695 inflater.Pad8Bits();
696 if (inflater.InputBit(switchBit)) {
697 AliWarning("format error of compressed clusters, there is more data than expected");
698 }
699 inflater.CloseBitDataInput();
700 if (iResult>=0 && nofClusters!=outClusterCnt) {
701 // is this a Fatal?
702 AliError(Form("error reading compressed cluster format: expected %d, read only %d cluster(s)", nofClusters, outClusterCnt));
703 return -EPROTO;
704 }
705 return iResult;
706}
b60d3f6a 707
708AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::AliTPCclusterMIContainer()
709 : fClusterArrays()
710 , fRemainingClusterIds()
711 , fTrackModelClusterIds()
712 , fCurrentClusterIds(NULL)
713 , fClusterMCData()
714 , fIterator()
715
716{
717 /// constructor
718 for (int i=0; i<72; i++) {
719 fClusterArrays.push_back(new TClonesArray("AliTPCclusterMI"));
720 }
721}
722
723AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::~AliTPCclusterMIContainer()
724{
725 /// dectructor
726 for (vector<TClonesArray*>::iterator i=fClusterArrays.begin(); i!=fClusterArrays.end(); i++) {
727 if (*i) {
728 (*i)->Clear();
729 delete *i;
730 }
731 }
732}
733
734AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::iterator& AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::BeginRemainingClusterBlock(int /*count*/, AliHLTUInt32_t specification)
735{
736 /// iterator of remaining clusters block of specification
737 AliHLTUInt8_t slice=AliHLTTPCDefinitions::GetMinSliceNr(specification);
738 AliHLTUInt8_t partition=AliHLTTPCDefinitions::GetMinPatchNr(specification);
739 unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
740 if (index<fRemainingClusterIds.size())
741 fCurrentClusterIds=&fRemainingClusterIds[index];
742 else
743 fCurrentClusterIds=NULL;
744 fIterator=iterator(this);
745 return fIterator;
746}
747
748AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::iterator& AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::BeginTrackModelClusterBlock(int /*count*/)
749{
750 /// iterator of track model clusters
751 if (fTrackModelClusterIds.fIds && fTrackModelClusterIds.fSize>0)
752 fCurrentClusterIds=&fTrackModelClusterIds;
753 else
754 fCurrentClusterIds=NULL;
755 fIterator=iterator(this);
756 return fIterator;
757}
758
759int AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::AddClusterMCData(const AliHLTComponentBlockData* pDesc)
760{
761 /// add cluster mc data block
762 if (!pDesc) return -EINVAL;
763 if (pDesc->fDataType==AliHLTTPCDefinitions::AliHLTDataTypeClusterMCInfo()) {
764 AliHLTUInt8_t slice=AliHLTTPCDefinitions::GetMinSliceNr(pDesc->fSpecification);
765 AliHLTUInt8_t partition=AliHLTTPCDefinitions::GetMinPatchNr(pDesc->fSpecification);
766 unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
767 if (fClusterMCData.size()<=index) {
768 if ((int)fClusterMCData.size()<AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches()) {
769 fClusterMCData.resize(AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches(), NULL);
770 } else {
771 fClusterMCData.resize(index+1, NULL);
772 }
773 }
774 if (pDesc->fSize<sizeof(AliHLTTPCClusterMCData)) return -EINVAL;
775 const AliHLTTPCClusterMCData* pData=reinterpret_cast<const AliHLTTPCClusterMCData*>(pDesc->fPtr);
776 unsigned nLabels = pData->fCount;
777 if (nLabels*sizeof(AliHLTTPCClusterMCLabel) + sizeof(AliHLTTPCClusterMCData) != pDesc->fSize) {
778 return -EINVAL;
779 }
780 fClusterMCData[index]=pData;
781 return 0;
782 }
783 return -ENODATA;
784}
785
786int AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::AddClusterIds(const AliHLTComponentBlockData* pDesc)
787{
788 /// add cluster id block for remaining or track model clusters
789 if (!pDesc) return -EINVAL;
790 if (pDesc->fDataType==AliHLTTPCDefinitions::ClusterIdTracksDataType()) {
791 fTrackModelClusterIds.fIds=reinterpret_cast<AliHLTUInt32_t*>(pDesc->fPtr);
792 fTrackModelClusterIds.fSize=pDesc->fSize/sizeof(AliHLTUInt32_t);
793 return 0;
794 }
795 if (pDesc->fDataType==AliHLTTPCDefinitions::RemainingClusterIdsDataType()) {
796 AliHLTUInt8_t slice=AliHLTTPCDefinitions::GetMinSliceNr(pDesc->fSpecification);
797 AliHLTUInt8_t partition=AliHLTTPCDefinitions::GetMinPatchNr(pDesc->fSpecification);
798 unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
799 if (fRemainingClusterIds.size()<=index) {
800 if ((int)fRemainingClusterIds.size()<AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches()) {
801 fRemainingClusterIds.resize(AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches());
802 } else {
803 fRemainingClusterIds.resize(index+1);
804 }
805 }
806 fRemainingClusterIds[index].fIds=reinterpret_cast<AliHLTUInt32_t*>(pDesc->fPtr);
807 fRemainingClusterIds[index].fSize=pDesc->fSize/sizeof(AliHLTUInt32_t);
808 return 0;
809 }
810 return -ENODATA;
811}
812
813AliHLTUInt32_t AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::GetClusterId(int clusterNo) const
814{
815 /// get the cluster id from the current cluster id block (optional)
816 if (!fCurrentClusterIds ||
ebba640a 817 (int)fCurrentClusterIds->fSize<=clusterNo ||
818 clusterNo<0)
b60d3f6a 819 return kAliHLTVoidDataSpec;
820 return fCurrentClusterIds->fIds[clusterNo];
821}
822
823AliTPCclusterMI* AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::NextCluster(int slice, int partition)
824{
825 /// load next cluster from array of the sepcific sector
826 unsigned sector=partition<2?slice:slice+36;
827 if (fClusterArrays.size()<=sector ||
828 fClusterArrays[sector]==NULL) {
829 AliErrorClass(Form("no cluster array available for sector %d", sector));
830 return NULL;
831 }
832 TClonesArray& array=*(fClusterArrays[sector]);
833 int count=array.GetEntriesFast();
834 return new (array[count]) AliTPCclusterMI;
835}
836
837int AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::SetMC(AliTPCclusterMI* pCluster, AliHLTUInt32_t clusterId)
838{
839 /// set MC data for the cluster
840 if (!pCluster) return -EINVAL;
841 if (clusterId==kAliHLTVoidDataSpec) return 0;
842
843 unsigned slice=AliHLTTPCSpacePointData::GetSlice(clusterId);
844 unsigned partition=AliHLTTPCSpacePointData::GetPatch(clusterId);
845 unsigned number=AliHLTTPCSpacePointData::GetNumber(clusterId);
846 if ((int)slice>=AliHLTTPCTransform::GetNSlice() ||
847 (int)partition>=AliHLTTPCTransform::GetNumberOfPatches()) return -EDOM;
848 unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
849 if (fClusterMCData.size()<=index ||
850 fClusterMCData[index]==NULL ||
851 fClusterMCData[index]->fCount<=number) return 0;
852 const AliHLTTPCClusterMCWeight* mcWeights=fClusterMCData[index]->fLabels[number].fClusterID;
853 for (int k=0; k<3; k++) {
854 // TODO: sort the labels according to the weight in order to assign the most likely mc label
855 // to the first component
856 pCluster->SetLabel(mcWeights[k].fMCID, k);
857 }
858
859 return 0;
860}
861
862void AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::Clear(Option_t* /*option*/)
863{
864 /// internal cleanup
865 {
866 for (vector<TClonesArray*>::iterator i=fClusterArrays.begin(); i!=fClusterArrays.end(); i++)
867 if (*i) (*i)->Clear();
868 }
869 {
870 for (vector<AliClusterIdBlock>::iterator i=fRemainingClusterIds.begin(); i!=fRemainingClusterIds.end(); i++)
871 {i->fIds=NULL; i->fSize=0;}
872 }
873 fTrackModelClusterIds.fIds=NULL; fTrackModelClusterIds.fSize=0;
874 fCurrentClusterIds=NULL;
875 {
876 for (vector<const AliHLTTPCClusterMCData*>::iterator i=fClusterMCData.begin(); i!=fClusterMCData.end(); i++)
877 *i=NULL;
878 }
879}
880
881TObjArray* AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::GetSectorArray(unsigned sector) const
882{
883 /// get the cluster array for a sector
884 if (fClusterArrays.size()<=sector) return NULL;
885 return fClusterArrays[sector];
886}
887
888void AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::Print(Option_t *option) const
889{
890 /// inherited from TObject
891 cout << "AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer" << endl;
892 ios::fmtflags coutflags=cout.flags(); // backup cout status flags
893 bool bAll=false;
894 if ((bAll=(strcmp(option, "full")==0)) ||
895 strcmp(option, "short")==0) {
896 for (unsigned iArray=0; iArray<fClusterArrays.size(); iArray++) {
897 if (fClusterArrays[iArray]) {
898 TClonesArray* pArray=fClusterArrays[iArray];
899 cout << " sector " << setfill(' ') << setw(2) << iArray << ": " << pArray->GetEntriesFast() << endl;
900 if (bAll) {
901 for (int iCluster=0; iCluster<pArray->GetEntriesFast(); iCluster++) {
902 if (!pArray->At(iCluster)) continue;
903 AliTPCclusterMI* pCluster=dynamic_cast<AliTPCclusterMI*>(pArray->At(iCluster));
904 if (!pCluster) break;
905 cout << " AliTPCclusterMI:"
906 << " row=" << pCluster->GetRow()
907 << " pad=" << pCluster->GetPad()
908 << " time=" << pCluster->GetTimeBin()
909 << " charge=" << pCluster->GetQ()
910 << " maxq=" << pCluster->GetMax()
911 << endl;
912 }
913 }
914 }
915 }
916 }
917 cout.flags(coutflags); // restore the original flags
918}
919
920AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::iterator& AliHLTTPCClusterAccessHLTOUT::AliTPCclusterMIContainer::iterator::Next(int slice, int partition)
921{
922 // switch to next cluster
923 if (!fData) {
924 fCluster=NULL;
925 fClusterId=kAliHLTVoidDataSpec;
926 return *this;
927 }
928 if (fClusterNo>=0 && !fCluster) {
929 // end was reached before
930 return *this;
931 }
932 fCluster=fData->NextCluster(slice, partition);
933 fClusterId=fData->GetClusterId(++fClusterNo);
934 if (fCluster && fClusterId!=kAliHLTVoidDataSpec) {
935 fData->SetMC(fCluster, fClusterId);
936 }
937 // offline uses row number in physical sector, inner sector consists of
938 // partitions 0 and 1, outer sector of partition 2-5
939 fRowOffset=partition<2?0:AliHLTTPCTransform::GetFirstRow(2);
940 return *this;
941}