]>
Commit | Line | Data |
---|---|---|
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 */ | |
45 | ClassImp(AliHLTTPCRawSpacePointContainer) | |
46 | ||
e18c0370 | 47 | AliHLTTPCRawSpacePointContainer::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 | ||
67 | AliHLTTPCRawSpacePointContainer::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 | ||
79 | AliHLTTPCRawSpacePointContainer& 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 | ||
91 | AliHLTTPCRawSpacePointContainer::~AliHLTTPCRawSpacePointContainer() | |
92 | { | |
93 | // destructor | |
5ecd199d | 94 | Clear(); |
e18c0370 | 95 | if (fSingleBlock.GetGrid()) delete fSingleBlock.GetGrid(); |
96 | if (fWrittenClusterIds) delete fWrittenClusterIds; | |
71510a33 | 97 | } |
98 | ||
99 | int 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; |
110 | if (pDesc->fSize<=sizeof(AliHLTTPCRawClusterData)) return 0; | |
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 | 173 | AliHLTSpacePointContainer::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 | ||
186 | int 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 | ||
204 | int 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 | ||
229 | const 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 | ||
243 | int 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 | 263 | int 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 | ||
271 | bool AliHLTTPCRawSpacePointContainer::Check(AliHLTUInt32_t clusterID) const | |
272 | { | |
273 | // check if the cluster is available | |
274 | return fClusters.find(clusterID)!=fClusters.end(); | |
275 | } | |
276 | ||
277 | const 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 | ||
316 | float 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 | ||
330 | float 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 | ||
339 | float 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 | ||
348 | float 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 | ||
357 | float 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 | ||
366 | float 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 | ||
375 | float 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 | 384 | float 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 | 393 | float 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 | 403 | void 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 | ||
426 | void 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 | ||
439 | AliHLTSpacePointContainer* 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 | ||
459 | AliHLTSpacePointContainer* 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 | ||
469 | AliHLTSpacePointContainer* 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 | ||
479 | AliHLTSpacePointContainer* 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 | ||
489 | AliHLTSpacePointContainer* 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 | ||
499 | int 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 | ||
512 | int 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 | ||
525 | int 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 | ||
533 | int 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 | 546 | int 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 | ||
561 | int 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 | ||
573 | int 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 | ||
606 | int 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 | 806 | AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::AliHLTTPCRawSpacePointProperties() |
e18c0370 | 807 | : fpCluster(NULL) |
71510a33 | 808 | , fUsed(false) |
809 | , fTrackId(-1) | |
810 | , fMCId(-1) | |
811 | { | |
812 | // constructor | |
813 | } | |
814 | ||
815 | AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties::AliHLTTPCRawSpacePointProperties(const AliHLTTPCRawCluster* pCluster) | |
e18c0370 | 816 | : fpCluster(pCluster) |
71510a33 | 817 | , fUsed(false) |
818 | , fTrackId(-1) | |
819 | , fMCId(-1) | |
820 | { | |
821 | // constructor | |
822 | } | |
823 | ||
824 | AliHLTTPCRawSpacePointContainer::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 | ||
833 | AliHLTTPCRawSpacePointContainer::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 | ||
845 | void 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 | ||
866 | ostream& operator<<(ostream &out, const AliHLTTPCRawSpacePointContainer::AliHLTTPCRawSpacePointProperties& p) | |
867 | { | |
868 | p.Print(out); | |
869 | return out; | |
870 | } |