Adding processing component to translate dHLT internal raw data blocks into ROOT...
[u/mrichter/AliRoot.git] / HLT / MUON / OfflineInterface / AliHLTMUONRootifierComponent.cxx
CommitLineData
9acda34c 1/**************************************************************************
2 * This file is property of and copyright by the ALICE HLT Project *
3 * All rights reserved. *
4 * *
5 * Primary Authors: *
6 * Artur Szostak <artursz@iafrica.com> *
7 * *
8 * Permission to use, copy, modify and distribute this software and its *
9 * documentation strictly for non-commercial purposes is hereby granted *
10 * without fee, provided that the above copyright notice appears in all *
11 * copies and that both the copyright notice and this permission notice *
12 * appear in the supporting documentation. The authors make no claims *
13 * about the suitability of this software for any purpose. It is *
14 * provided "as is" without express or implied warranty. *
15 **************************************************************************/
16
17/* $Id$ */
18
19/**
20 * @file AliHLTMUONRootifierComponent.cxx
21 * @author Artur Szostak <artursz@iafrica.com>
22 * @date
23 * @brief Implementation of the AliHLTMUONRootifierComponent component.
24 */
25
26#include "AliHLTMUONRootifierComponent.h"
27#include "AliHLTMUONConstants.h"
28#include "AliHLTMUONUtils.h"
29#include "AliHLTMUONDataBlockReader.h"
30#include "AliHLTMUONRecHit.h"
31#include "AliHLTMUONTriggerRecord.h"
32#include "AliHLTMUONMansoTrack.h"
33#include "TObjArray.h"
34#include <cassert>
35
36namespace
37{
38 // The global object used for automatic component registration.
39 // Note DO NOT use this component for calculation!
40 AliHLTMUONRootifierComponent gAliHLTMUONRootifierComponent;
41}
42
43ClassImp(AliHLTMUONEvent);
44ClassImp(AliHLTMUONRootifierComponent);
45
46
47AliHLTMUONRootifierComponent::AliHLTMUONRootifierComponent() :
48 AliHLTProcessor()
49{
50}
51
52
53AliHLTMUONRootifierComponent::~AliHLTMUONRootifierComponent()
54{
55}
56
57
58int AliHLTMUONRootifierComponent::DoInit(int argc, const char** argv)
59{
60 return 0;
61}
62
63
64int AliHLTMUONRootifierComponent::DoDeinit()
65{
66 return 0;
67}
68
69
70const char* AliHLTMUONRootifierComponent::GetComponentID()
71{
72 return "MUONRootifier";
73}
74
75
76AliHLTComponentDataType AliHLTMUONRootifierComponent::GetOutputDataType()
77{
78 return kAliHLTAnyDataType;
79}
80
81
82void AliHLTMUONRootifierComponent::GetInputDataTypes(
83 vector<AliHLTComponentDataType>& list
84 )
85{
86 list.push_back(kAliHLTAnyDataType);
87}
88
89
90void AliHLTMUONRootifierComponent::GetOutputDataSize(
91 unsigned long& constBase, double& inputMultiplier
92 )
93{
94 constBase = 10000;
95 inputMultiplier = 5;
96}
97
98
99AliHLTComponent* AliHLTMUONRootifierComponent::Spawn()
100{
101 return new AliHLTMUONRootifierComponent();
102}
103
104
105int AliHLTMUONRootifierComponent::DoEvent(
106 const AliHLTComponentEventData& evtData,
107 AliHLTComponentTriggerData& trigData
108 )
109{
110 AliHLTMUONEvent event(evtData.fEventID);
111
112 // First process the blocks of reconstructed hits and trigger records.
113 for (int i = 0; i < GetNumberOfInputBlocks(); i++)
114 {
115 const AliHLTComponentBlockData* block = GetInputBlock(i);
116 assert( block != NULL );
117 if (block->fDataType == AliHLTMUONConstants::RecHitsBlockDataType())
118 {
119 AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
120 ptr += block->fOffset;
121 AliHLTMUONRecHitsBlockReader inblock(ptr, block->fSize);
122 if (not inblock.BufferSizeOk())
123 {
124 size_t headerSize = sizeof(AliHLTMUONRecHitsBlockReader::HeaderType);
125 if (block->fSize < headerSize)
126 {
127 HLTError("Received a reconstructed hits data block with a size of %d bytes,"
128 " which is smaller than the minimum valid header size of %d bytes."
129 " The block must be corrupt.",
130 block->fSize, headerSize
131 );
132 continue;
133 }
134
135 size_t expectedWidth = sizeof(AliHLTMUONRecHitsBlockReader::ElementType);
136 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
137 {
138 HLTError("Received a reconstructed hits data block with a record"
139 " width of %d bytes, but the expected value is %d bytes."
140 " The block might be corrupt.",
141 block->fSize, headerSize
142 );
143 continue;
144 }
145
146 HLTError("Received a reconstructed hits data block with a size of %d bytes,"
147 " but the block header claims the block should be %d bytes."
148 " The block might be corrupt.",
149 block->fSize, inblock.BytesUsed()
150 );
151 continue;
152 }
153
154 // Decode the source DDL from the specification bits.
155 Int_t sourceDDL = -1;
156 bool ddl[22];
157 AliHLTMUONUtils::UnpackSpecBits(block->fSpecification, ddl);
158 for (int k = 0; k < 22; k++)
159 {
160 if (ddl[k])
161 {
162 if (sourceDDL == -1)
163 {
164 sourceDDL = k+1;
165 }
166 else
167 {
168 HLTWarning("The input data block %d contains"
169 " data from multiple DDL sources.", i
170 );
171 }
172 }
173 }
174 if (sourceDDL > 20)
175 {
176 HLTWarning("The source DDL for input data block %d is %d."
177 " The expected range for the DDL is [1..20].",
178 i, sourceDDL
179 );
180 }
181
182 for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
183 {
184 const AliHLTMUONRecHitStruct& h = inblock[n];
185 //AliHLTMUONRecHit rh(h.fX, h.fY, h.fZ, sourceDDL);
186 //PushBack(&rh, "ROOTHITS", "MUON");
187 event.Add(new AliHLTMUONRecHit(h.fX, h.fY, h.fZ, sourceDDL));
188 }
189 }
190 else if (block->fDataType == AliHLTMUONConstants::TriggerRecordsBlockDataType())
191 {
192 AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
193 ptr += block->fOffset;
194 AliHLTMUONTriggerRecordsBlockReader inblock(ptr, block->fSize);
195 if (not inblock.BufferSizeOk())
196 {
197 size_t headerSize = sizeof(AliHLTMUONTriggerRecordsBlockReader::HeaderType);
198 if (block->fSize < headerSize)
199 {
200 HLTError("Received a trigger records data block with a size of %d bytes,"
201 " which is smaller than the minimum valid header size of %d bytes."
202 " The block must be corrupt.",
203 block->fSize, headerSize
204 );
205 continue;
206 }
207
208 size_t expectedWidth = sizeof(AliHLTMUONTriggerRecordsBlockReader::ElementType);
209 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
210 {
211 HLTError("Received a trigger records data block with a record"
212 " width of %d bytes, but the expected value is %d bytes."
213 " The block might be corrupt.",
214 block->fSize, headerSize
215 );
216 continue;
217 }
218
219 HLTError("Received a trigger records data block with a size of %d bytes,"
220 " but the block header claims the block should be %d bytes."
221 " The block might be corrupt.",
222 block->fSize, inblock.BytesUsed()
223 );
224 continue;
225 }
226
227 // Decode the source DDL from the specification bits.
228 Int_t sourceDDL = -1;
229 bool ddl[22];
230 AliHLTMUONUtils::UnpackSpecBits(block->fSpecification, ddl);
231 for (int k = 0; k < 22; k++)
232 {
233 if (ddl[k])
234 {
235 if (sourceDDL == -1)
236 {
237 sourceDDL = k+1;
238 }
239 else
240 {
241 HLTWarning("The input data block %d contains"
242 " data from multiple DDL sources.", i
243 );
244 }
245 }
246 }
247 if (sourceDDL < 21 or sourceDDL > 22)
248 {
249 HLTWarning("The source DDL for input data block %d is %d."
250 " The expected range for the DDL is [21..22].",
251 i, sourceDDL
252 );
253 }
254
255 for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
256 {
257 const AliHLTMUONTriggerRecordStruct& t = inblock[n];
258
259 AliHLTMUONParticleSign sign;
260 bool hitset[4];
261 AliHLTMUONUtils::UnpackTriggerRecordFlags(
262 t.fFlags, sign, hitset
263 );
264
265 AliHLTMUONTriggerRecord* tr = new AliHLTMUONTriggerRecord(
266 t.fId, sign, t.fPx, t.fPy, t.fPz, sourceDDL
267 );
268 for (int k = 0; k < 4; k++)
269 tr->SetHit(k+11, t.fHit[k].fX, t.fHit[k].fY, t.fHit[k].fZ);
270 event.Add(tr);
271 }
272 }
273 else
274 {
275 // TODO: ignore for now, but should log an optional message.
276 }
277 }
278
279 // Now we can look for tracks to add. We needed the ROOT trigger records
280 // and reco hits created before we can create track objects.
281 for (int i = 0; i < GetNumberOfInputBlocks(); i++)
282 {
283 const AliHLTComponentBlockData* block = GetInputBlock(i);
284 assert( block != NULL );
285 if (block->fDataType == AliHLTMUONConstants::MansoTracksBlockDataType())
286 {
287 AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
288 ptr += block->fOffset;
289 AliHLTMUONMansoTracksBlockReader inblock(ptr, block->fSize);
290 if (not inblock.BufferSizeOk())
291 {
292 size_t headerSize = sizeof(AliHLTMUONMansoTracksBlockReader::HeaderType);
293 if (block->fSize < headerSize)
294 {
295 HLTError("Received a Manso tracks data block with a size of %d bytes,"
296 " which is smaller than the minimum valid header size of %d bytes."
297 " The block must be corrupt.",
298 block->fSize, headerSize
299 );
300 continue;
301 }
302
303 size_t expectedWidth = sizeof(AliHLTMUONMansoTracksBlockReader::ElementType);
304 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
305 {
306 HLTError("Received a Manso tracks data block with a record"
307 " width of %d bytes, but the expected value is %d bytes."
308 " The block might be corrupt.",
309 block->fSize, headerSize
310 );
311 continue;
312 }
313
314 HLTError("Received a Manso tracks data block with a size of %d bytes,"
315 " but the block header claims the block should be %d bytes."
316 " The block might be corrupt.",
317 block->fSize, inblock.BytesUsed()
318 );
319 continue;
320 }
321
322 for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
323 {
324 const AliHLTMUONMansoTrackStruct& t = inblock[n];
325
326 AliHLTMUONParticleSign sign;
327 bool hitset[4];
328 AliHLTMUONUtils::UnpackMansoTrackFlags(
329 t.fFlags, sign, hitset
330 );
331
332 // Try find the trigger record in 'event'.
333 const AliHLTMUONTriggerRecord* trigrec = NULL;
334 for (Int_t k = 0; k < event.Array().GetEntriesFast(); k++)
335 {
336 if (event.Array()[k]->IsA() != AliHLTMUONTriggerRecord::Class())
337 continue;
338 const AliHLTMUONTriggerRecord* tk =
339 static_cast<const AliHLTMUONTriggerRecord*>(event.Array()[k]);
340 if (tk->Id() == t.fTrigRec)
341 {
342 trigrec = tk;
343 break;
344 }
345 }
346
347 // Now try find the hits in 'event'.
348 // If they cannot be found then create new ones.
349 const AliHLTMUONRecHit* hit7 = NULL;
350 const AliHLTMUONRecHit* hit8 = NULL;
351 const AliHLTMUONRecHit* hit9 = NULL;
352 const AliHLTMUONRecHit* hit10 = NULL;
353 for (Int_t k = 0; k < event.Array().GetEntriesFast(); k++)
354 {
355 if (event.Array()[k]->IsA() != AliHLTMUONRecHit::Class())
356 continue;
357 const AliHLTMUONRecHit* h =
358 static_cast<const AliHLTMUONRecHit*>(event.Array()[k]);
359
360 if (hitset[0] and h->X() == t.fHit[0].fX and h->Y() == t.fHit[0].fY
361 and h->Z() == t.fHit[0].fZ)
362 {
363 hit7 = h;
364 }
365 if (hitset[1] and h->X() == t.fHit[1].fX and h->Y() == t.fHit[1].fY
366 and h->Z() == t.fHit[1].fZ)
367 {
368 hit8 = h;
369 }
370 if (hitset[2] and h->X() == t.fHit[2].fX and h->Y() == t.fHit[2].fY
371 and h->Z() == t.fHit[2].fZ)
372 {
373 hit9 = h;
374 }
375 if (hitset[3] and h->X() == t.fHit[3].fX and h->Y() == t.fHit[3].fY
376 and h->Z() == t.fHit[3].fZ)
377 {
378 hit10 = h;
379 }
380 }
381 AliHLTMUONRecHit* newhit;
382 if (hitset[0] and hit7 == NULL)
383 {
384 newhit = new AliHLTMUONRecHit(t.fHit[0].fX, t.fHit[0].fY, t.fHit[0].fZ);
385 event.Add(newhit);
386 hit7 = newhit;
387 }
388 if (hitset[1] and hit8 == NULL)
389 {
390 newhit = new AliHLTMUONRecHit(t.fHit[1].fX, t.fHit[1].fY, t.fHit[1].fZ);
391 event.Add(newhit);
392 hit8 = newhit;
393 }
394 if (hitset[2] and hit9 == NULL)
395 {
396 newhit = new AliHLTMUONRecHit(t.fHit[2].fX, t.fHit[2].fY, t.fHit[2].fZ);
397 event.Add(newhit);
398 hit9 = newhit;
399 }
400 if (hitset[3] and hit10 == NULL)
401 {
402 newhit = new AliHLTMUONRecHit(t.fHit[3].fX, t.fHit[3].fY, t.fHit[3].fZ);
403 event.Add(newhit);
404 hit10 = newhit;
405 }
406
407 AliHLTMUONMansoTrack* tr = new AliHLTMUONMansoTrack(
408 t.fId, sign, t.fPx, t.fPy, t.fPz, t.fChi2,
409 trigrec, hit7, hit8, hit9, hit10
410 );
411 event.Add(tr);
412 }
413 }
414 else
415 {
416 // TODO: ignore for now, but should log an optional message.
417 }
418 }
419
420 PushBack(&event, "ROOTEVNT", "MUON");
421
422 return 0;
423}