Bug fix: AliHLTTPCRawSpacePointContainer
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCRawSpacePointContainer.cxx
CommitLineData
71510a33 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
e18c0370 19/// @file AliHLTTPCRawSpacePointContainer.cxx
20/// @author Matthias Richter, Sergey Gorbunov
21/// @date 2011-08-08
22/// @brief Helper class for handling of HLT TPC raw cluster data blocks
71510a33 23
24#include "AliHLTTPCRawSpacePointContainer.h"
e18c0370 25#include "AliHLTErrorGuard.h"
71510a33 26#include "AliHLTTPCDefinitions.h"
27#include "AliHLTTPCSpacePointData.h"
e18c0370 28#include "AliHLTTPCRawCluster.h"
71510a33 29#include "AliHLTTPCTransform.h"
30#include "AliHLTComponent.h"
31#include "AliHLTTemplates.h"
e18c0370 32#include "AliHLTDataDeflater.h"
33#include "AliRawDataHeader.h"
34#include "AliLog.h"
71510a33 35#include "TMath.h"
36#include <memory>
37#include <algorithm>
e18c0370 38#include <cmath>
39#include <iostream>
40#include <sstream>
41#include <iomanip>
42
71510a33 43
44/** ROOT macro for the implementation of ROOT specific class methods */
45ClassImp(AliHLTTPCRawSpacePointContainer)
46
e18c0370 47AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointContainer(int mode)
71510a33 48 : AliHLTSpacePointContainer()
49 , fClusters()
50 , fSelections()
e18c0370 51 , fBlocks()
52 , fSingleBlock()
53 , fMode(mode)
54 , fWrittenClusterIds(NULL)
71510a33 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
e18c0370 61 if (fMode&kModeSingle) {
62 fSingleBlock.SetDecoder(NULL);
63 fSingleBlock.SetGrid(AllocateIndexGrid());
64 }
71510a33 65}
66
67AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointContainer(const AliHLTTPCRawSpacePointContainer& c)
68 : AliHLTSpacePointContainer(c)
69 , fClusters(c.fClusters.begin(), c.fClusters.end())
70 , fSelections()
e18c0370 71 , fBlocks()
72 , fSingleBlock()
73 , fMode(c.fMode)
74 , fWrittenClusterIds(NULL)
71510a33 75{
76 /// copy constructor
77}
78
79AliHLTTPCRawSpacePointContainer& AliHLTTPCRawSpacePointContainer::operator=(const AliHLTTPCRawSpacePointContainer& c)
80{
81 /// assignment operator
82 if (&c==this) return *this;
83 AliHLTSpacePointContainer::operator=(c);
84 fClusters=c.fClusters;
e18c0370 85 fMode=c.fMode;
86 fWrittenClusterIds=NULL;
71510a33 87
88 return *this;
89}
90
91AliHLTTPCRawSpacePointContainer::~AliHLTTPCRawSpacePointContainer()
92{
93 // destructor
5ecd199d 94 Clear();
e18c0370 95 if (fSingleBlock.GetGrid()) delete fSingleBlock.GetGrid();
96 if (fWrittenClusterIds) delete fWrittenClusterIds;
71510a33 97}
98
99int AliHLTTPCRawSpacePointContainer::AddInputBlock(const AliHLTComponentBlockData* pDesc)
100{
101 // add input block to the collection
102 if (!pDesc) return -EINVAL;
e18c0370 103 int iResult=0;
71510a33 104 int count=0;
105 if (pDesc->fDataType!=AliHLTTPCDefinitions::fgkRawClustersDataType) {
106 HLTWarning("ignoring data block of type %s", AliHLTComponent::DataType2Text(pDesc->fDataType).c_str());
107 return 0;
108 }
e18c0370 109 if (!pDesc->fPtr) return -ENODATA;
ea27d6b0 110 if (pDesc->fSize<sizeof(AliHLTTPCRawClusterData)) return 0;
e18c0370 111
112 AliHLTTPCRawClusterData* rawClusters = (AliHLTTPCRawClusterData*)(pDesc->fPtr);
113
114 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( pDesc->fSpecification );
115 AliHLTUInt8_t part = AliHLTTPCDefinitions::GetMinPatchNr( pDesc->fSpecification );
116
117 AliHLTUInt32_t decoderIndex=AliHLTTPCSpacePointData::GetID(slice, part, 0);
118
119 AliHLTSpacePointPropertyGrid* pGrid=NULL;
120 if (fMode&kModeSingle) {
121 pGrid=fSingleBlock.GetGrid();
122 } else {
123 if (fBlocks.find(decoderIndex)!=fBlocks.end()) {
124 HLTError("data block of slice %d partition %d already added, skipping data block", slice, part);
125 return -EEXIST;
126 }
71510a33 127 }
128
e18c0370 129 if (fMode&kModeSingle && !pGrid) {
130 pGrid=AllocateIndexGrid();
131 if (!pGrid) {
132 return -ENOMEM;
71510a33 133 }
134 }
135
e18c0370 136 if (fMode&kModeCreateMap) { // register immediately
137
138 //UInt_t nofClusters=rawClusters->fCount;
139
140 for( UInt_t icl=0; icl<rawClusters->fCount; icl++){
141 const AliHLTTPCRawCluster &cl = rawClusters->fClusters[icl];
142 AliHLTUInt32_t clusterID=~(AliHLTUInt32_t)0;
143 // cluster ID from slice, partition and index
144 clusterID=AliHLTTPCSpacePointData::GetID(slice, part, icl);
145
146 if (fClusters.find(clusterID)==fClusters.end()) {
147 // new cluster
148 fClusters[clusterID]=AliHLTTPCRawSpacePointProperties(&cl);
149 count++;
150 } else {
151 HLTError("cluster with ID 0x%08x already existing, skipping cluster %d of data block 0x%08x",
152 clusterID, icl, pDesc->fSpecification);
153 }
154 }
155 }
156
157 if (pGrid && (iResult=PopulateAccessGrid(pGrid, rawClusters, slice, part))<0) {
158 HLTError("failed to populate access grid for block %s 0x%09x: %d",
159 AliHLTComponent::DataType2Text(pDesc->fDataType).c_str(), pDesc->fSpecification, iResult);
160 return iResult;
161 }
162
163 if (fMode&kModeSingle) {
164 fSingleBlock.SetDecoder(rawClusters);
165 fSingleBlock.SetGrid(pGrid);
166 fSingleBlock.SetId(decoderIndex);
167 } else {
168 fBlocks[decoderIndex]=AliHLTTPCRawSpacePointBlock(decoderIndex, rawClusters, pGrid);
169 }
71510a33 170 return count;
171}
172
e18c0370 173AliHLTSpacePointContainer::AliHLTSpacePointPropertyGrid* AliHLTTPCRawSpacePointContainer::AllocateIndexGrid()
174{
175 // allocate index grid, one single point to define the dimensions
176
177 // max 33 padrows, step 1 padrow
178 // max 140 pads, step 2x max delta pad
179 // max 1024 time bins, step 2x max delta time
180 return new AliHLTSpacePointPropertyGrid(33, 1.0,
181 140, 2*AliHLTTPCDefinitions::GetMaxClusterDeltaPad(),
182 1024, 2*AliHLTTPCDefinitions::GetMaxClusterDeltaTime()
183 );
184}
185
186int AliHLTTPCRawSpacePointContainer::PopulateAccessGrid(AliHLTSpacePointPropertyGrid* pGrid, AliHLTUInt32_t mask) const
187{
188 // populate an access grid
189 if (!pGrid) return -EINVAL;
190
191 pGrid->Clear();
192
193 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(mask);
194 AliHLTUInt8_t partition = AliHLTTPCDefinitions::GetMinPatchNr(mask);
195 AliHLTUInt32_t decoderIndex=AliHLTTPCSpacePointData::GetID(slice, partition, 0);
196 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointBlock>::const_iterator block=fBlocks.find(decoderIndex);
197 if (block==fBlocks.end()) {
198 HLTError("can not find data block of id 0x%08x", mask);
199 return -ENOENT;
200 }
201 return PopulateAccessGrid(pGrid, block->second.GetDecoder(), slice, partition);
202}
203
204int AliHLTTPCRawSpacePointContainer::PopulateAccessGrid(AliHLTSpacePointPropertyGrid* pGrid, AliHLTTPCRawClusterData* pDecoder,
205 int slice, int partition) const
206{
207 // populate an access grid
208 if (!pDecoder) return -EINVAL;
209 int iResult=0;
210
211 for( UInt_t icl=0; icl<pDecoder->fCount; icl++){
212 const AliHLTTPCRawCluster &cl = pDecoder->fClusters[icl];
213 iResult=pGrid->CountSpacePoint(cl.GetPadRow(), cl.GetPad(), cl.GetTime());
214 if (iResult<0)
215 HLTError("CountSpacePoint %f %f %f failed: %d", cl.GetPadRow(), cl.GetPad(), cl.GetTime(), iResult);
216 }
217
218 for( UInt_t icl=0; icl<pDecoder->fCount; icl++ ){
219 const AliHLTTPCRawCluster &cl = pDecoder->fClusters[icl];
220 AliHLTUInt32_t id=AliHLTTPCSpacePointData::GetID(slice, partition, icl);
221 iResult=pGrid->AddSpacePoint(AliHLTSpacePointProperties(id), cl.GetPadRow(), cl.GetPad(), cl.GetTime());
222 if (iResult<0)
223 HLTError("AddSpacePoint 0x%08x %f %f %f failed: %d", id, cl.GetPadRow(), cl.GetPad(), cl.GetTime(), iResult);
224 }
225
226 return 0;
227}
228
229const AliHLTSpacePointContainer::AliHLTSpacePointPropertyGrid* AliHLTTPCRawSpacePointContainer::GetSpacePointPropertyGrid(AliHLTUInt32_t mask) const
230{
231 // get the access grid for a data block
232 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(mask);
233 AliHLTUInt8_t part = AliHLTTPCDefinitions::GetMinPatchNr(mask);
234 AliHLTUInt32_t decoderIndex=AliHLTTPCSpacePointData::GetID(slice, part, 0);
235 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointBlock>::const_iterator block=fBlocks.find(decoderIndex);
236 if (block==fBlocks.end()) {
237 HLTError("can not find data block of id 0x%08x", mask);
238 return NULL;
239 }
240 return block->second.GetGrid();
241}
242
243int AliHLTTPCRawSpacePointContainer::SetSpacePointPropertyGrid(AliHLTUInt32_t mask, AliHLTSpacePointContainer::AliHLTSpacePointPropertyGrid* pGrid)
244{
245 // set the access grid for a data block
246 AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(mask);
247 AliHLTUInt8_t part = AliHLTTPCDefinitions::GetMinPatchNr(mask);
248 AliHLTUInt32_t decoderIndex=AliHLTTPCSpacePointData::GetID(slice, part, 0);
249 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointBlock>::iterator block=fBlocks.find(decoderIndex);
250 if (block==fBlocks.end()) {
251 HLTError("can not find data block of id 0x%08x", mask);
252 return -ENOENT;
253 }
254 if (block->second.GetGrid()!=NULL && pGrid!=NULL && block->second.GetGrid()!=pGrid) {
255 // there is trouble ahead because this will delete the index grid instance
256 // but it might be an external pointer supposed to be deleted by someone else
257 ALIHLTERRORGUARD(1, "overriding previous instance of index grid, potential memory leak or invalid deallocation ahead");
258 }
259 block->second.SetGrid(pGrid);
260 return 0;
261}
262
71510a33 263int AliHLTTPCRawSpacePointContainer::GetClusterIDs(vector<AliHLTUInt32_t>& tgt) const
264{
265 // get array of cluster IDs
266 tgt.clear();
267 transform(fClusters.begin(), fClusters.end(), back_inserter(tgt), HLT::AliGetKey());
268 return tgt.size();
269}
270
271bool AliHLTTPCRawSpacePointContainer::Check(AliHLTUInt32_t clusterID) const
272{
273 // check if the cluster is available
274 return fClusters.find(clusterID)!=fClusters.end();
275}
276
277const vector<AliHLTUInt32_t>* AliHLTTPCRawSpacePointContainer::GetClusterIDs(AliHLTUInt32_t mask)
278{
279 // get array of cluster IDs filtered by mask
280 if (fSelections.find(mask)!=fSelections.end()) {
281 // return existing selection
282 return fSelections.find(mask)->second;
283 }
284 // create new collection
285 vector<AliHLTUInt32_t>* selected=new vector<AliHLTUInt32_t>;
286 if (!selected) return NULL;
287 UInt_t slice=AliHLTTPCSpacePointData::GetSlice(mask);
288 UInt_t partition=AliHLTTPCSpacePointData::GetPatch(mask);
c2b3c776 289 //HLTInfo("creating collection 0x%08x", mask);
290
291 // the first cluster with number 0 has equal ID to mask unless
292 // the mask selects multiple partitions/slices
293 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(mask);
294 bool bAll=false;
295 if (slice>=(unsigned)AliHLTTPCTransform::GetNSlice() ||
296 partition>=(unsigned)AliHLTTPCTransform::GetNumberOfPatches()) {
297 cl=fClusters.begin();
298 bAll=true;
299 }
300 for (; cl!=fClusters.end(); cl++) {
71510a33 301 UInt_t s=AliHLTTPCSpacePointData::GetSlice(cl->first);
302 UInt_t p=AliHLTTPCSpacePointData::GetPatch(cl->first);
303 if ((slice>=(unsigned)AliHLTTPCTransform::GetNSlice() || s==slice) &&
304 (partition>=(unsigned)AliHLTTPCTransform::GetNumberOfPatches() || p==partition)) {
305 selected->push_back(cl->first);
c2b3c776 306 } else if (!bAll) {
307 // no need to continue, we are out of the range
308 break;
71510a33 309 }
310 }
c2b3c776 311 //HLTInfo("collection 0x%08x with %d spacepoints", mask, selected->size());
71510a33 312 fSelections[mask]=selected;
313 return selected;
314}
315
316float AliHLTTPCRawSpacePointContainer::GetX(AliHLTUInt32_t clusterID) const
317{
318 // get X coordinate
e18c0370 319 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(clusterID);
320 if (cl==fClusters.end() ||
321 cl->second.GetCluster()==NULL) return 0.0;
71510a33 322 // FIXME: understand deviation from the nominal x value
323 // there is a small deviation in the x coordinate - padrow number correlation
324 // in principle, the clusterfinder only uses the mapping to set the x parameter.
325 // now extracting the x value from the padrow no.
e18c0370 326 //return cl->second.Decoder()->fX;
327 return cl->second.GetCluster()->GetPadRow();
71510a33 328}
329
330float AliHLTTPCRawSpacePointContainer::GetXWidth(AliHLTUInt32_t clusterID) const
331{
332 // get error for X coordinate
e18c0370 333 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(clusterID);
334 if (cl==fClusters.end() ||
335 cl->second.GetCluster()==NULL) return 0.0;
71510a33 336 return 0.0; // fixed in padrow number
337}
338
339float AliHLTTPCRawSpacePointContainer::GetY(AliHLTUInt32_t clusterID) const
340{
341 // get Y coordinate
e18c0370 342 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(clusterID);
343 if (cl==fClusters.end() ||
344 cl->second.GetCluster()==NULL) return 0.0;
345 return cl->second.GetCluster()->GetPad();
71510a33 346}
347
348float AliHLTTPCRawSpacePointContainer::GetYWidth(AliHLTUInt32_t clusterID) const
349{
350 // get error for Y coordinate
e18c0370 351 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(clusterID);
352 if (cl==fClusters.end() ||
353 cl->second.GetCluster()==NULL) return 0.0;
354 return cl->second.GetCluster()->GetSigmaY2();
71510a33 355}
356
357float AliHLTTPCRawSpacePointContainer::GetZ(AliHLTUInt32_t clusterID) const
358{
359 // get Z coordinate
e18c0370 360 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(clusterID);
361 if (cl==fClusters.end() ||
362 cl->second.GetCluster()==NULL) return 0.0;
363 return cl->second.GetCluster()->GetTime();
71510a33 364}
365
366float AliHLTTPCRawSpacePointContainer::GetZWidth(AliHLTUInt32_t clusterID) const
367{
368 // get error for Z coordinate
e18c0370 369 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(clusterID);
370 if (cl==fClusters.end() ||
371 cl->second.GetCluster()==NULL) return 0.0;
372 return cl->second.GetCluster()->GetSigmaZ2();
71510a33 373}
374
375float AliHLTTPCRawSpacePointContainer::GetCharge(AliHLTUInt32_t clusterID) const
376{
377 // get charge
e18c0370 378 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(clusterID);
379 if (cl==fClusters.end() ||
380 cl->second.GetCluster()==NULL) return 0.0;
381 return cl->second.GetCluster()->GetCharge();
71510a33 382}
383
e18c0370 384float AliHLTTPCRawSpacePointContainer::GetQMax(AliHLTUInt32_t clusterID) const
5ecd199d 385{
386 // get charge
e18c0370 387 std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.find(clusterID);
388 if (cl==fClusters.end() ||
389 cl->second.GetCluster()==NULL) return 0.0;
390 return cl->second.GetCluster()->GetQMax();
5ecd199d 391}
392
71510a33 393float AliHLTTPCRawSpacePointContainer::GetPhi(AliHLTUInt32_t clusterID) const
394{
395 // get charge
396
397 // phi can be derived directly from the id, no need to search
398 // for existing cluster
399 int slice=AliHLTTPCSpacePointData::GetSlice(clusterID);
400 return ( slice + 0.5 ) * TMath::Pi() / 9.0;
401}
402
5ecd199d 403void AliHLTTPCRawSpacePointContainer::Clear(Option_t * option)
71510a33 404{
405 // clear the object and reset pointer references
5ecd199d 406 fClusters.clear();
407
408 for (std::map<AliHLTUInt32_t, vector<AliHLTUInt32_t>*>::iterator selection=fSelections.begin();
409 selection!=fSelections.end(); selection++) {
410 if (selection->second) delete selection->second;
411 }
412 fSelections.clear();
413
e18c0370 414 for (std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointBlock>::iterator block=fBlocks.begin();
415 block!=fBlocks.end(); block++) {
416 if (block->second.GetGrid()) delete block->second.GetGrid();
417 }
418 fBlocks.clear();
419
420 fSingleBlock.SetDecoder(NULL);
421 if (fSingleBlock.GetGrid()) fSingleBlock.GetGrid()->Clear();
422
5ecd199d 423 AliHLTSpacePointContainer::Clear(option);
71510a33 424}
425
426void AliHLTTPCRawSpacePointContainer::Print(ostream& out, Option_t */*option*/) const
427{
428 // print to stream
e18c0370 429 std::stringstream str;
430 str << "AliHLTTPCRawSpacePointContainer::Print" << endl;
431 str << "n clusters: " << fClusters.size() << endl;
71510a33 432 for (std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.begin();
433 cl!=fClusters.end(); cl++) {
e18c0370 434 str << " 0x" << hex << setw(8) << setfill('0') << cl->first << dec << cl->second << endl;
71510a33 435 }
2cb809a5 436 out << str.rdbuf();
71510a33 437}
438
439AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::SelectByMask(AliHLTUInt32_t mask, bool /*bAlloc*/) const
440{
441 /// create a collection of clusters for a space point mask
442 std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
443 if (!c.get()) return NULL;
444
445 UInt_t slice=AliHLTTPCSpacePointData::GetSlice(mask);
446 UInt_t partition=AliHLTTPCSpacePointData::GetPatch(mask);
447 for (std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator cl=fClusters.begin();
448 cl!=fClusters.end(); cl++) {
449 UInt_t s=AliHLTTPCSpacePointData::GetSlice(cl->first);
450 UInt_t p=AliHLTTPCSpacePointData::GetPatch(cl->first);
451 if ((slice>=(unsigned)AliHLTTPCTransform::GetNSlice() || s==slice) &&
452 (partition>=(unsigned)AliHLTTPCTransform::GetNumberOfPatches() || p==partition)) {
453 c->fClusters[cl->first]=cl->second;
454 }
455 }
456 return c.release();
457}
458
459AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::SelectByTrack(int trackId, bool /*bAlloc*/) const
460{
461 /// create a collection of clusters for a specific track
462 std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
463 if (!c.get()) return NULL;
464
465 HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties, int>(&AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::GetTrackId,trackId));
466 return c.release();
467}
468
469AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::SelectByMC(int mcId, bool /*bAlloc*/) const
470{
471 /// create a collection of clusters for a specific MC track
472 std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
473 if (!c.get()) return NULL;
474
475 HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties, int>(&AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::GetMCId,mcId));
476 return c.release();
477}
478
479AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::UsedClusters(bool /*bAlloc*/) const
480{
481 /// create a collection of all used clusters
482 std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
483 if (!c.get()) return NULL;
484
485 HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties, bool>(&AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::IsUsed,true));
486 return c.release();
487}
488
489AliHLTSpacePointContainer* AliHLTTPCRawSpacePointContainer::UnusedClusters(bool /*bAlloc*/) const
490{
491 /// create a collection of all unused clusters
492 std::auto_ptr<AliHLTTPCRawSpacePointContainer> c(new AliHLTTPCRawSpacePointContainer);
493 if (!c.get()) return NULL;
494
495 HLT::copy_map_if(fClusters.begin(), fClusters.end(), c->fClusters, HLT::AliHLTUnaryPredicate<AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties, bool>(&AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::IsUsed,false));
496 return c.release();
497}
498
499int AliHLTTPCRawSpacePointContainer::MarkUsed(const AliHLTUInt32_t* clusterIDs, int arraySize)
500{
501 /// mark the clusters with specified IDs as used
502 if (!clusterIDs) return -EINVAL;
503 int iCount=0;
504 for (int i=0; i<arraySize; i++) {
505 if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
506 fClusters[clusterIDs[i]].MarkUsed();
507 iCount++;
508 }
509 return iCount;
510}
511
512int AliHLTTPCRawSpacePointContainer::SetTrackID(int trackID, const AliHLTUInt32_t* clusterIDs, int arraySize)
513{
514 /// set track id for specified clusters
515 if (!clusterIDs) return -EINVAL;
516 int iCount=0;
517 for (int i=0; i<arraySize; i++) {
518 if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
519 fClusters[clusterIDs[i]].SetTrackId(trackID);
520 iCount++;
521 }
522 return iCount;
523}
524
525int AliHLTTPCRawSpacePointContainer::GetTrackID(AliHLTUInt32_t clusterID) const
526{
527 /// get track id for specified cluster
528 map<AliHLTUInt32_t, AliHLTTPCRawSpacePointProperties>::const_iterator element=fClusters.find(clusterID);
529 if (element==fClusters.end()) return -1;
530 return element->second.GetTrackId();
531}
532
533int AliHLTTPCRawSpacePointContainer::SetMCID(int mcID, const AliHLTUInt32_t* clusterIDs, int arraySize)
534{
535 /// set mc id for specified clusters
536 if (!clusterIDs) return -EINVAL;
537 int iCount=0;
538 for (int i=0; i<arraySize; i++) {
539 if (fClusters.find(clusterIDs[i])==fClusters.end()) continue;
540 fClusters[clusterIDs[i]].SetMCId(mcID);
541 iCount++;
542 }
543 return iCount;
544}
545
e18c0370 546int AliHLTTPCRawSpacePointContainer::Write(AliHLTUInt8_t* outputPtr,
547 AliHLTUInt32_t size,
548 AliHLTComponentBlockDataList&
549 outputBlocks,
550 AliHLTDataDeflater* pDeflater,
551 const char* option) const
552{
553 /// write blocks to HLT component output
554 AliHLTUInt32_t offset=0;
555 if (outputBlocks.size()>0) {
556 offset=outputBlocks.back().fOffset+outputBlocks.back().fSize;
557 }
558 return Write(outputPtr, size, offset, outputBlocks, pDeflater, option);
559}
560
561int AliHLTTPCRawSpacePointContainer::Write(AliHLTUInt8_t* outputPtr,
562 AliHLTUInt32_t size,
563 AliHLTUInt32_t offset,
564 AliHLTComponentBlockDataList&
565 outputBlocks,
566 AliHLTDataDeflater* pDeflater,
567 const char* option) const
568{
569 /// write blocks to HLT component output
570 return WriteSorted(outputPtr, size, offset, outputBlocks, pDeflater, option);
571}
572
573int AliHLTTPCRawSpacePointContainer::WriteSorted(AliHLTUInt8_t* outputPtr,
574 AliHLTUInt32_t size,
575 AliHLTUInt32_t offset,
576 AliHLTComponentBlockDataList&
577 outputBlocks,
578 AliHLTDataDeflater* pDeflater,
579 const char* option) const
580{
581 /// write blocks to HLT component output
582 int iResult=0;
583
584 if (fMode&kModeSingle) {
585 iResult=WriteSorted(outputPtr, size, offset, fSingleBlock.GetDecoder(), fSingleBlock.GetGrid(), fSingleBlock.GetId(), outputBlocks, pDeflater, option);
586 } else {
587 iResult=-ENOENT;
588 for (std::map<AliHLTUInt32_t, AliHLTTPCRawSpacePointBlock>::const_iterator block=fBlocks.begin();
589 block!=fBlocks.end(); block++) {
590 AliHLTTPCRawClusterData* pDecoder=block->second.GetDecoder();
591 AliHLTSpacePointPropertyGrid* pGrid=block->second.GetGrid();
592 AliHLTUInt32_t mask=block->first;
593 // FIXME: have to propagate the parameter which block is currently to be written
594 // for now the index grid is only set for that one
595 if (!pGrid) continue;
596 iResult=WriteSorted(outputPtr, size, offset, pDecoder, pGrid, mask, outputBlocks, pDeflater, option);
597 break; // only one is supposed to be written
598 }
599 if (iResult==-ENOENT) {
600 HLTError("could not find the index grid of the partition to be written");
601 }
602 }
603 return iResult;
604}
605
606int AliHLTTPCRawSpacePointContainer::WriteSorted(AliHLTUInt8_t* outputPtr,
607 AliHLTUInt32_t size,
608 AliHLTUInt32_t offset,
609 AliHLTTPCRawClusterData* pDecoder,
610 AliHLTSpacePointPropertyGrid* pGrid,
611 AliHLTUInt32_t mask,
612 AliHLTComponentBlockDataList&
613 outputBlocks,
614 AliHLTDataDeflater* pDeflater,
615 const char* option) const
c2b3c776 616{
617 /// write blocks to HLT component output
e18c0370 618 if (!outputPtr || !pDecoder || !pGrid) return -EINVAL;
619 if (pDecoder->fCount==0) return 0;
620 if (option) {
621 // this is only for sending mc labels in simulation and testing
622 // no impact to real running
623 if (!fWrittenClusterIds && strcmp(option, "write-cluster-ids")==0) {
624 const_cast<AliHLTTPCRawSpacePointContainer*>(this)->fWrittenClusterIds=new vector<AliHLTUInt32_t>;
625 }
626 }
c2b3c776 627 int iResult=0;
628 AliHLTUInt32_t capacity=size;
629 size=0;
630
e18c0370 631 int slice=AliHLTTPCSpacePointData::GetSlice(mask);
632 int part=AliHLTTPCSpacePointData::GetPatch(mask);
633
634 // Note: the offset parameter is only for the block descriptors, output pointer and size
635 // consider already the offset
636 AliHLTTPCRawClusterData* blockout=reinterpret_cast<AliHLTTPCRawClusterData*>(outputPtr+size);
637 blockout->fVersion=0;
638 blockout->fCount=0;
639
640 if (pDeflater) {
641 pDeflater->Clear();
642 pDeflater->InitBitDataOutput(reinterpret_cast<AliHLTUInt8_t*>(blockout->fClusters), capacity-size-sizeof(AliHLTTPCRawClusterData));
643 blockout->fVersion=pDeflater->GetDeflaterVersion();
644 if (fMode&kModeDifferentialPadTime) blockout->fVersion+=2;
645 }
646
647 unsigned lastPadRow=0;
648 AliHLTUInt64_t lastPad64=0;
649 AliHLTUInt64_t lastTime64=0;
650 AliHLTSpacePointPropertyGrid::iterator clusterID=pGrid->begin();
651 if (clusterID!=pGrid->end()) {
652 for (; clusterID!=pGrid->end(); clusterID++) {
653 if (clusterID.Data().fTrackId>-1) {
654 // this is an assigned cluster, skip
655 // TODO: introduce selectors into AliHLTIndexGrid::begin to loop
656 // consistently over entries, e.g. this check has to be done also
657 // in the forwarding of MC labels in
658 // AliHLTTPCDataCompressionComponent::ForwardMCLabels
659 continue;
660 }
661 if ((unsigned)slice!=AliHLTTPCSpacePointData::GetSlice(clusterID.Data().fId) ||
662 (unsigned)part!=AliHLTTPCSpacePointData::GetPatch(clusterID.Data().fId)) {
663 HLTError("cluster index 0x%08x out of slice %d partition %d", clusterID.Data().fId, slice, part);
664 }
665 int index=AliHLTTPCSpacePointData::GetNumber(clusterID.Data().fId);
666
667 if( index<0 || index>= (int)pDecoder->fCount ) continue;
668
669 const AliHLTTPCRawCluster &input = pDecoder->fClusters[index];
670
671 //const AliHLTTPCRawData::iterator& input=pDecoder->find(index);
672 //if (!(input!=pDecoder->end())) continue;
673 if (fWrittenClusterIds) fWrittenClusterIds->push_back(clusterID.Data().fId);
674
675 int padrow=input.GetPadRow();
676 if (padrow<0) {
677 // something wrong here, padrow is stored in the cluster header
678 // word which has bit pattern 0x3 in bits bit 30 and 31 which was
679 // not recognized
680 ALIHLTERRORGUARD(1, "can not read cluster header word");
681 iResult=-EBADF;
71300445 682 break;
c2b3c776 683 }
e18c0370 684
685 float pad =input.GetPad();
686 float time =input.GetTime();
687 float sigmaY2=input.GetSigmaY2();
688 float sigmaZ2=input.GetSigmaZ2();
689 if (!pDeflater) {
690 AliHLTTPCRawCluster& c=blockout->fClusters[blockout->fCount];
691 padrow+=AliHLTTPCTransform::GetFirstRow(part);
692 c.SetPadRow(padrow);
693 c.SetCharge(input.GetCharge());
694 c.SetPad(pad);
695 c.SetTime(time);
696 c.SetSigmaY2(sigmaY2);
697 c.SetSigmaZ2(sigmaZ2);
698 c.SetQMax(input.GetQMax());
699 } else {
700 AliHLTUInt64_t padrow64=input.GetPadRow();
701 if (padrow64==lastPadRow) {
702 padrow64-=lastPadRow;
703 } else if (padrow64>lastPadRow) {
704 padrow64-=lastPadRow;
705 lastPadRow+=padrow64;
706 } else {
707 AliFatal("padrows not ordered");
708 }
709
710 AliHLTUInt32_t padType=0;
711 AliHLTUInt32_t signdPad=0;
712 AliHLTUInt64_t pad64=0;
713 if ((fMode&kModeDifferentialPadTime)!=0 && sigmaY2<.00001) {
714 // single pad cluster
715 // use twice the pad position to take account for the 0.5 offset
716 // added in the AliHLTTPCRawData decoder in accordance with the
717 // offline definition. Using the factor 2, this offset is not
718 // cut off by rounding
719 pad64=(AliHLTUInt64_t)round(2*pad);
720 padType=1;
721 } else {
722 if (!isnan(pad)) pad64=(AliHLTUInt64_t)round(pad*AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kPad].fScale);
723 }
724 if (fMode&kModeDifferentialPadTime && padType==0) {
725 AliHLTUInt64_t dpad64=0;
726 if (pad64<lastPad64) {
727 dpad64=lastPad64-pad64;
728 signdPad=1;
729 } else {
730 dpad64=pad64-lastPad64;
731 signdPad=0;
732 }
733 lastPad64=pad64;
734 pad64=dpad64;
c2b3c776 735 }
e18c0370 736 AliHLTUInt32_t signdTime=0;
737 AliHLTUInt64_t time64=0;
738 if (!isnan(time)) time64=(AliHLTUInt64_t)round(time*AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kTime].fScale);
739 if (fMode&kModeDifferentialPadTime) {
740 AliHLTUInt64_t dtime64=0;
741 if (time64<lastTime64) {
742 dtime64=lastTime64-time64;
743 signdTime=1;
744 } else {
745 dtime64=time64-lastTime64;
746 signdTime=0;
747 }
748 lastTime64=time64;
749 time64=dtime64;
750 }
751 AliHLTUInt64_t sigmaY264=0;
752 if (!isnan(sigmaY2)) sigmaY264=(AliHLTUInt64_t)round(sigmaY2*AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kSigmaY2].fScale);
753 AliHLTUInt64_t sigmaZ264=0;
754 if (!isnan(sigmaZ2)) sigmaZ264=(AliHLTUInt64_t)round(sigmaZ2*AliHLTTPCDefinitions::fgkClusterParameterDefinitions[AliHLTTPCDefinitions::kSigmaZ2].fScale);
755 pDeflater->OutputParameterBits(AliHLTTPCDefinitions::kPadRow , padrow64);
756 pDeflater->OutputParameterBits(AliHLTTPCDefinitions::kPad , pad64);
757 if (fMode&kModeDifferentialPadTime) pDeflater->OutputBit(padType);
758 if (fMode&kModeDifferentialPadTime && padType==0) pDeflater->OutputBit(signdPad);
759 pDeflater->OutputParameterBits(AliHLTTPCDefinitions::kTime , time64);
760 if (fMode&kModeDifferentialPadTime) pDeflater->OutputBit(signdTime);
761 if (padType==0) pDeflater->OutputParameterBits(AliHLTTPCDefinitions::kSigmaY2, sigmaY264);
762 pDeflater->OutputParameterBits(AliHLTTPCDefinitions::kSigmaZ2, sigmaZ264);
763 pDeflater->OutputParameterBits(AliHLTTPCDefinitions::kCharge , input.GetCharge());
764 pDeflater->OutputParameterBits(AliHLTTPCDefinitions::kQMax , input.GetQMax());
c2b3c776 765 }
e18c0370 766 blockout->fCount++;
767 }
768 }
769 AliHLTComponent_BlockData bd;
770 AliHLTComponent::FillBlockData(bd);
771 bd.fOffset = size+offset;
772 if (!pDeflater) {
773 bd.fSize = sizeof(AliHLTTPCRawClusterData)+blockout->fCount*sizeof(AliHLTTPCRawCluster);
774 bd.fDataType = AliHLTTPCDefinitions::fgkRawClustersDataType;
775 } else {
776 pDeflater->Pad8Bits();
777 bd.fSize = sizeof(AliHLTTPCRawClusterData)+pDeflater->GetBitDataOutputSizeBytes();
778 pDeflater->CloseBitDataOutput();
779 bd.fDataType = AliHLTTPCDefinitions::RemainingClustersCompressedDataType();
780 }
781 bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(slice, slice, part, part);
782 outputBlocks.push_back(bd);
783
784 size += bd.fSize;
785
786 if (fWrittenClusterIds && fWrittenClusterIds->size()>0) {
787 AliHLTComponent::FillBlockData(bd);
788 bd.fOffset = size+offset;
789 bd.fSize = fWrittenClusterIds->size()*sizeof(vector<AliHLTUInt32_t>::value_type);
790 if (bd.fSize+size<=capacity) {
791 memcpy(outputPtr+size, &(*fWrittenClusterIds)[0], bd.fSize);
792 bd.fDataType = AliHLTTPCDefinitions::RemainingClusterIdsDataType();
c2b3c776 793 bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(slice, slice, part, part);
e18c0370 794 outputBlocks.push_back(bd);
c2b3c776 795 size += bd.fSize;
e18c0370 796 } else {
797 iResult=-ENOSPC;
c2b3c776 798 }
e18c0370 799 fWrittenClusterIds->clear();
c2b3c776 800 }
801
802 if (iResult<0) return iResult;
803 return size;
804}
805
71510a33 806AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::AliHLTTPCRawSpacePointProperties()
e18c0370 807 : fpCluster(NULL)
71510a33 808 , fUsed(false)
809 , fTrackId(-1)
810 , fMCId(-1)
811{
812 // constructor
813}
814
815AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::AliHLTTPCRawSpacePointProperties(const AliHLTTPCRawCluster* pCluster)
e18c0370 816 : fpCluster(pCluster)
71510a33 817 , fUsed(false)
818 , fTrackId(-1)
819 , fMCId(-1)
820{
821 // constructor
822}
823
824AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::AliHLTTPCRawSpacePointProperties(const AliHLTTPCRawSpacePointProperties& src)
e18c0370 825 : fpCluster(src.fpCluster)
71510a33 826 , fUsed(src.fUsed)
827 , fTrackId(src.fTrackId)
828 , fMCId(src.fMCId)
829{
830 // copy constructor
831}
832
833AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties& AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::operator=(const AliHLTTPCRawSpacePointProperties& src)
834{
835 // assignment operator
836 if (&src==this) return *this;
e18c0370 837 fpCluster=src.fpCluster;
71510a33 838 fUsed=src.fUsed;
839 fTrackId=src.fTrackId;
840 fMCId=src.fMCId;
841
842 return *this;
843}
844
845void AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::Print(ostream& out, Option_t */*option*/) const
846{
847 // print info
e18c0370 848 if (!fpCluster) {
71510a33 849 out << "no data";
850 return;
851 }
e18c0370 852 std::stringstream str;
853
854 str.setf(ios::fixed,ios::floatfield);
855 str << " " << setfill(' ') << setw(3) << fpCluster->GetPadRow()
856 << " " << setw(8) << setprecision(3) << fpCluster->GetPad()
857 << " " << setw(8) << setprecision(3) << fpCluster->GetTime()
858 << " " << setw(8) << setprecision(1) << fpCluster->GetSigmaY2()
859 << " " << setw(9) << setprecision(1) << fpCluster->GetSigmaZ2()
860 << " " << setw(5) << fpCluster->GetCharge()
861 << " " << setw(5) << fpCluster->GetQMax()
71510a33 862 << " " << fTrackId << " " << fMCId << " " << fUsed;
2cb809a5 863 out << str.rdbuf();
71510a33 864}
865
866ostream& operator<<(ostream &out, const AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties& p)
867{
868 p.Print(out);
869 return out;
870}