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