Cleanup of documentation and code.
[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
cb35e21b 19///
20/// @file AliHLTMUONRootifierComponent.cxx
21/// @author Artur Szostak <artursz@iafrica.com>
450e0b36 22/// @date 29 Sep 2007
cb35e21b 23/// @brief Implementation of the AliHLTMUONRootifierComponent component.
24///
9acda34c 25
26#include "AliHLTMUONRootifierComponent.h"
450e0b36 27#include "AliHLTMUONEvent.h"
9acda34c 28#include "AliHLTMUONConstants.h"
29#include "AliHLTMUONUtils.h"
30#include "AliHLTMUONDataBlockReader.h"
31#include "AliHLTMUONRecHit.h"
32#include "AliHLTMUONTriggerRecord.h"
33#include "AliHLTMUONMansoTrack.h"
450e0b36 34#include "AliHLTMUONDecision.h"
35#include "TClonesArray.h"
9acda34c 36#include <cassert>
37
9acda34c 38ClassImp(AliHLTMUONRootifierComponent);
39
40
41AliHLTMUONRootifierComponent::AliHLTMUONRootifierComponent() :
450e0b36 42 AliHLTProcessor(),
43 fWarnForUnexpecedBlock(false)
9acda34c 44{
6253e09b 45 ///
46 /// Default constructor.
47 ///
9acda34c 48}
49
50
51AliHLTMUONRootifierComponent::~AliHLTMUONRootifierComponent()
52{
6253e09b 53 ///
54 /// Default destructor.
55 ///
9acda34c 56}
57
58
450e0b36 59int AliHLTMUONRootifierComponent::DoInit(int argc, const char** argv)
9acda34c 60{
6253e09b 61 ///
62 /// Inherited from AliHLTComponent.
63 /// Parses the command line parameters and initialises the component.
64 ///
65
450e0b36 66 HLTInfo("Initialising dHLT rootifier component.");
67
68 fWarnForUnexpecedBlock = false;
69
70 for (int i = 0; i < argc; i++)
71 {
72 if (strcmp(argv[i], "-warn_on_unexpected_block") == 0)
73 {
74 fWarnForUnexpecedBlock = true;
75 continue;
76 }
77
78 HLTError("Unknown option '%s'.", argv[i]);
79 return -EINVAL;
80 }
81
9acda34c 82 return 0;
83}
84
85
86int AliHLTMUONRootifierComponent::DoDeinit()
87{
6253e09b 88 ///
89 /// Inherited from AliHLTComponent. Performs a cleanup of the component.
90 ///
91
450e0b36 92 HLTInfo("Deinitialising dHLT rootifier component.");
9acda34c 93 return 0;
94}
95
96
97const char* AliHLTMUONRootifierComponent::GetComponentID()
98{
6253e09b 99 ///
100 /// Inherited from AliHLTComponent. Returns the component ID.
101 ///
102
450e0b36 103 return AliHLTMUONConstants::RootifierComponentId();
9acda34c 104}
105
106
107AliHLTComponentDataType AliHLTMUONRootifierComponent::GetOutputDataType()
108{
bb14e9db 109 /// Inherited from AliHLTComponent. Returns kAliHLTMultipleDataType
110 /// refer to GetOutputDataTypes for all returned data types.
111
112 return kAliHLTMultipleDataType;
113}
114
115
116int AliHLTMUONRootifierComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
117{
118 /// Inherited from AliHLTComponent. Returns the output data types.
6253e09b 119
bb14e9db 120 tgtList.push_back(kAliHLTAnyDataType);
121 return 1;
9acda34c 122}
123
124
125void AliHLTMUONRootifierComponent::GetInputDataTypes(
126 vector<AliHLTComponentDataType>& list
127 )
128{
6253e09b 129 ///
130 /// Inherited from AliHLTProcessor. Returns the list of expected input data types.
131 ///
132
9acda34c 133 list.push_back(kAliHLTAnyDataType);
134}
135
136
137void AliHLTMUONRootifierComponent::GetOutputDataSize(
138 unsigned long& constBase, double& inputMultiplier
139 )
140{
6253e09b 141 ///
142 /// Inherited from AliHLTComponent. Returns an estimate of the expected output data size.
143 ///
144
477135e2 145 constBase = 1024*1024;
146 inputMultiplier = 100;
9acda34c 147}
148
149
150AliHLTComponent* AliHLTMUONRootifierComponent::Spawn()
151{
6253e09b 152 ///
153 /// Inherited from AliHLTComponent. Creates a new object instance.
154 ///
155
9acda34c 156 return new AliHLTMUONRootifierComponent();
157}
158
159
160int AliHLTMUONRootifierComponent::DoEvent(
161 const AliHLTComponentEventData& evtData,
6253e09b 162 AliHLTComponentTriggerData& /*trigData*/
9acda34c 163 )
164{
6253e09b 165 ///
166 /// Inherited from AliHLTProcessor. Processes the new event data.
167 ///
168
9acda34c 169 AliHLTMUONEvent event(evtData.fEventID);
450e0b36 170 const AliHLTComponentBlockData* block = NULL;
9acda34c 171
172 // First process the blocks of reconstructed hits and trigger records.
173 for (int i = 0; i < GetNumberOfInputBlocks(); i++)
174 {
450e0b36 175 block = GetInputBlock(i);
9acda34c 176 assert( block != NULL );
450e0b36 177
178 HLTDebug("Handling block: %u, with fDataType = '%s', fPtr = %p and fSize = %u bytes.",
179 n, DataType2Text(block->fDataType).c_str(), block->fPtr, block->fSize
180 );
181
9acda34c 182 if (block->fDataType == AliHLTMUONConstants::RecHitsBlockDataType())
183 {
184 AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
185 ptr += block->fOffset;
186 AliHLTMUONRecHitsBlockReader inblock(ptr, block->fSize);
187 if (not inblock.BufferSizeOk())
188 {
189 size_t headerSize = sizeof(AliHLTMUONRecHitsBlockReader::HeaderType);
190 if (block->fSize < headerSize)
191 {
192 HLTError("Received a reconstructed hits data block with a size of %d bytes,"
193 " which is smaller than the minimum valid header size of %d bytes."
194 " The block must be corrupt.",
195 block->fSize, headerSize
196 );
197 continue;
198 }
199
200 size_t expectedWidth = sizeof(AliHLTMUONRecHitsBlockReader::ElementType);
201 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
202 {
203 HLTError("Received a reconstructed hits data block with a record"
204 " width of %d bytes, but the expected value is %d bytes."
205 " The block might be corrupt.",
206 block->fSize, headerSize
207 );
208 continue;
209 }
210
211 HLTError("Received a reconstructed hits data block with a size of %d bytes,"
212 " but the block header claims the block should be %d bytes."
213 " The block might be corrupt.",
214 block->fSize, inblock.BytesUsed()
215 );
216 continue;
217 }
218
219 // Decode the source DDL from the specification bits.
220 Int_t sourceDDL = -1;
221 bool ddl[22];
222 AliHLTMUONUtils::UnpackSpecBits(block->fSpecification, ddl);
223 for (int k = 0; k < 22; k++)
224 {
225 if (ddl[k])
226 {
227 if (sourceDDL == -1)
228 {
229 sourceDDL = k+1;
230 }
231 else
232 {
233 HLTWarning("The input data block %d contains"
234 " data from multiple DDL sources.", i
235 );
236 }
237 }
238 }
239 if (sourceDDL > 20)
240 {
241 HLTWarning("The source DDL for input data block %d is %d."
242 " The expected range for the DDL is [1..20].",
243 i, sourceDDL
244 );
245 }
246
247 for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
248 {
249 const AliHLTMUONRecHitStruct& h = inblock[n];
9acda34c 250 event.Add(new AliHLTMUONRecHit(h.fX, h.fY, h.fZ, sourceDDL));
251 }
252 }
253 else if (block->fDataType == AliHLTMUONConstants::TriggerRecordsBlockDataType())
254 {
255 AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
256 ptr += block->fOffset;
257 AliHLTMUONTriggerRecordsBlockReader inblock(ptr, block->fSize);
258 if (not inblock.BufferSizeOk())
259 {
260 size_t headerSize = sizeof(AliHLTMUONTriggerRecordsBlockReader::HeaderType);
261 if (block->fSize < headerSize)
262 {
263 HLTError("Received a trigger records data block with a size of %d bytes,"
264 " which is smaller than the minimum valid header size of %d bytes."
265 " The block must be corrupt.",
266 block->fSize, headerSize
267 );
268 continue;
269 }
270
271 size_t expectedWidth = sizeof(AliHLTMUONTriggerRecordsBlockReader::ElementType);
272 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
273 {
274 HLTError("Received a trigger records data block with a record"
275 " width of %d bytes, but the expected value is %d bytes."
276 " The block might be corrupt.",
277 block->fSize, headerSize
278 );
279 continue;
280 }
281
282 HLTError("Received a trigger records data block with a size of %d bytes,"
283 " but the block header claims the block should be %d bytes."
284 " The block might be corrupt.",
285 block->fSize, inblock.BytesUsed()
286 );
287 continue;
288 }
289
290 // Decode the source DDL from the specification bits.
291 Int_t sourceDDL = -1;
292 bool ddl[22];
293 AliHLTMUONUtils::UnpackSpecBits(block->fSpecification, ddl);
294 for (int k = 0; k < 22; k++)
295 {
296 if (ddl[k])
297 {
298 if (sourceDDL == -1)
299 {
300 sourceDDL = k+1;
301 }
302 else
303 {
304 HLTWarning("The input data block %d contains"
305 " data from multiple DDL sources.", i
306 );
307 }
308 }
309 }
bb14e9db 310 if (sourceDDL != -1 and (sourceDDL < 21 or sourceDDL > 22))
9acda34c 311 {
312 HLTWarning("The source DDL for input data block %d is %d."
313 " The expected range for the DDL is [21..22].",
314 i, sourceDDL
315 );
316 }
317
318 for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
319 {
320 const AliHLTMUONTriggerRecordStruct& t = inblock[n];
321
322 AliHLTMUONParticleSign sign;
323 bool hitset[4];
324 AliHLTMUONUtils::UnpackTriggerRecordFlags(
325 t.fFlags, sign, hitset
326 );
327
328 AliHLTMUONTriggerRecord* tr = new AliHLTMUONTriggerRecord(
329 t.fId, sign, t.fPx, t.fPy, t.fPz, sourceDDL
330 );
331 for (int k = 0; k < 4; k++)
332 tr->SetHit(k+11, t.fHit[k].fX, t.fHit[k].fY, t.fHit[k].fZ);
333 event.Add(tr);
334 }
335 }
336 else
337 {
450e0b36 338 if (block->fDataType != AliHLTMUONConstants::MansoTracksBlockDataType() and
339 block->fDataType != AliHLTMUONConstants::SinglesDecisionBlockDataType() and
340 block->fDataType != AliHLTMUONConstants::PairsDecisionBlockDataType()
341 )
342 {
343 // Log a message indicating that we got a data block that we
344 // do not know how to handle.
345 if (fWarnForUnexpecedBlock)
346 HLTWarning("Received a data block of a type we cannot handle: '%s', spec: 0x%X",
347 DataType2Text(block->fDataType).c_str(), block->fSpecification
348 );
349 else
350 HLTDebug("Received a data block of a type we cannot handle: '%s', spec: 0x%X",
351 DataType2Text(block->fDataType).c_str(), block->fSpecification
352 );
353 }
9acda34c 354 }
355 }
356
357 // Now we can look for tracks to add. We needed the ROOT trigger records
358 // and reco hits created before we can create track objects.
450e0b36 359 for (block = GetFirstInputBlock(AliHLTMUONConstants::MansoTracksBlockDataType());
360 block != NULL;
361 block = GetNextInputBlock()
362 )
9acda34c 363 {
450e0b36 364 AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
365 ptr += block->fOffset;
366 AliHLTMUONMansoTracksBlockReader inblock(ptr, block->fSize);
367 if (not inblock.BufferSizeOk())
9acda34c 368 {
450e0b36 369 size_t headerSize = sizeof(AliHLTMUONMansoTracksBlockReader::HeaderType);
370 if (block->fSize < headerSize)
9acda34c 371 {
9acda34c 372 HLTError("Received a Manso tracks data block with a size of %d bytes,"
450e0b36 373 " which is smaller than the minimum valid header size of %d bytes."
374 " The block must be corrupt.",
375 block->fSize, headerSize
376 );
377 continue;
378 }
379
380 size_t expectedWidth = sizeof(AliHLTMUONMansoTracksBlockReader::ElementType);
381 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
382 {
383 HLTError("Received a Manso tracks data block with a record"
384 " width of %d bytes, but the expected value is %d bytes."
9acda34c 385 " The block might be corrupt.",
450e0b36 386 block->fSize, headerSize
9acda34c 387 );
388 continue;
389 }
390
450e0b36 391 HLTError("Received a Manso tracks data block with a size of %d bytes,"
392 " but the block header claims the block should be %d bytes."
393 " The block might be corrupt.",
394 block->fSize, inblock.BytesUsed()
395 );
396 continue;
397 }
398
399 for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
400 {
401 const AliHLTMUONMansoTrackStruct& t = inblock[n];
402
403 AliHLTMUONParticleSign sign;
404 bool hitset[4];
405 AliHLTMUONUtils::UnpackMansoTrackFlags(
406 t.fFlags, sign, hitset
407 );
408
409 // Try find the trigger record in 'event'.
410 const AliHLTMUONTriggerRecord* trigrec = NULL;
411 for (Int_t k = 0; k < event.Array().GetEntriesFast(); k++)
9acda34c 412 {
450e0b36 413 if (event.Array()[k]->IsA() != AliHLTMUONTriggerRecord::Class())
414 continue;
415 const AliHLTMUONTriggerRecord* tk =
416 static_cast<const AliHLTMUONTriggerRecord*>(event.Array()[k]);
417 if (tk->Id() == t.fTrigRec)
9acda34c 418 {
450e0b36 419 trigrec = tk;
420 break;
9acda34c 421 }
450e0b36 422 }
423
424 // Now try find the hits in 'event'.
425 // If they cannot be found then create new ones.
426 const AliHLTMUONRecHit* hit7 = NULL;
427 const AliHLTMUONRecHit* hit8 = NULL;
428 const AliHLTMUONRecHit* hit9 = NULL;
429 const AliHLTMUONRecHit* hit10 = NULL;
430 for (Int_t k = 0; k < event.Array().GetEntriesFast(); k++)
431 {
432 if (event.Array()[k]->IsA() != AliHLTMUONRecHit::Class())
433 continue;
434 const AliHLTMUONRecHit* h =
435 static_cast<const AliHLTMUONRecHit*>(event.Array()[k]);
9acda34c 436
450e0b36 437 if (hitset[0] and h->X() == t.fHit[0].fX and h->Y() == t.fHit[0].fY
438 and h->Z() == t.fHit[0].fZ)
9acda34c 439 {
450e0b36 440 hit7 = h;
9acda34c 441 }
450e0b36 442 if (hitset[1] and h->X() == t.fHit[1].fX and h->Y() == t.fHit[1].fY
443 and h->Z() == t.fHit[1].fZ)
9acda34c 444 {
450e0b36 445 hit8 = h;
9acda34c 446 }
450e0b36 447 if (hitset[2] and h->X() == t.fHit[2].fX and h->Y() == t.fHit[2].fY
448 and h->Z() == t.fHit[2].fZ)
9acda34c 449 {
450e0b36 450 hit9 = h;
9acda34c 451 }
450e0b36 452 if (hitset[3] and h->X() == t.fHit[3].fX and h->Y() == t.fHit[3].fY
453 and h->Z() == t.fHit[3].fZ)
9acda34c 454 {
450e0b36 455 hit10 = h;
9acda34c 456 }
450e0b36 457 }
458 AliHLTMUONRecHit* newhit;
459 if (hitset[0] and hit7 == NULL)
460 {
461 newhit = new AliHLTMUONRecHit(t.fHit[0].fX, t.fHit[0].fY, t.fHit[0].fZ);
462 event.Add(newhit);
463 hit7 = newhit;
464 }
465 if (hitset[1] and hit8 == NULL)
466 {
467 newhit = new AliHLTMUONRecHit(t.fHit[1].fX, t.fHit[1].fY, t.fHit[1].fZ);
468 event.Add(newhit);
469 hit8 = newhit;
470 }
471 if (hitset[2] and hit9 == NULL)
472 {
473 newhit = new AliHLTMUONRecHit(t.fHit[2].fX, t.fHit[2].fY, t.fHit[2].fZ);
474 event.Add(newhit);
475 hit9 = newhit;
476 }
477 if (hitset[3] and hit10 == NULL)
478 {
479 newhit = new AliHLTMUONRecHit(t.fHit[3].fX, t.fHit[3].fY, t.fHit[3].fZ);
480 event.Add(newhit);
481 hit10 = newhit;
482 }
483
484 AliHLTMUONMansoTrack* tr = new AliHLTMUONMansoTrack(
485 t.fId, sign, t.fPx, t.fPy, t.fPz, t.fChi2,
486 trigrec, hit7, hit8, hit9, hit10
487 );
488 event.Add(tr);
489 }
490 }
491
492 UInt_t numLowPt = 0;
493 UInt_t numHighPt = 0;
494 TClonesArray singlesDecisions("AliHLTMUONDecision::AliTrackDecision");
495
496 // Find the single tracks decision blocks and add their information.
497 // We just sum the trigger scalars and single decisions.
498 for (block = GetFirstInputBlock(AliHLTMUONConstants::SinglesDecisionBlockDataType());
499 block != NULL;
500 block = GetNextInputBlock()
501 )
502 {
503 AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
504 ptr += block->fOffset;
505 AliHLTMUONSinglesDecisionBlockReader inblock(ptr, block->fSize);
506 if (not inblock.BufferSizeOk())
507 {
508 size_t headerSize = sizeof(AliHLTMUONSinglesDecisionBlockReader::HeaderType);
509 if (block->fSize < headerSize)
510 {
511 HLTError("Received a single tracks trigger decision data block with a size of %d bytes,"
512 " which is smaller than the minimum valid header size of %d bytes."
513 " The block must be corrupt.",
514 block->fSize, headerSize
515 );
516 continue;
517 }
518
519 size_t expectedWidth = sizeof(AliHLTMUONSinglesDecisionBlockReader::ElementType);
520 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
521 {
522 HLTError("Received a single tracks trigger decision data block with a record"
523 " width of %d bytes, but the expected value is %d bytes."
524 " The block might be corrupt.",
525 block->fSize, headerSize
526 );
527 continue;
528 }
529
530 HLTError("Received a single tracks trigger decision data block with a size of %d bytes,"
531 " but the block header claims the block should be %d bytes."
532 " The block might be corrupt.",
533 block->fSize, inblock.BytesUsed()
534 );
535 continue;
536 }
537
538 numLowPt += inblock.BlockHeader().fNlowPt;
539 numHighPt += inblock.BlockHeader().fNhighPt;
540
541 for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
542 {
543 const AliHLTMUONTrackDecisionStruct& t = inblock[n];
544
545 bool highPt, lowPt;
546 AliHLTMUONUtils::UnpackTrackDecisionBits(t.fTriggerBits, highPt, lowPt);
547
548 // Try find the corresponding track in the 'event'.
549 const AliHLTMUONMansoTrack* track = NULL;
550 for (Int_t k = 0; k < event.Array().GetEntriesFast(); k++)
551 {
552 if (event.Array()[k]->IsA() != AliHLTMUONMansoTrack::Class())
553 continue;
554 const AliHLTMUONMansoTrack* tk =
555 static_cast<const AliHLTMUONMansoTrack*>(event.Array()[k]);
556 if (tk->Id() == t.fTrackId)
9acda34c 557 {
450e0b36 558 track = tk;
559 break;
9acda34c 560 }
450e0b36 561 }
9acda34c 562
450e0b36 563 // If the track was not found then create a dummy one.
564 if (track == NULL)
565 {
566 AliHLTMUONMansoTrack* tr = new AliHLTMUONMansoTrack(t.fTrackId);
9acda34c 567 event.Add(tr);
450e0b36 568 track = tr;
9acda34c 569 }
450e0b36 570
571 new (singlesDecisions[singlesDecisions.GetEntriesFast()])
572 AliHLTMUONDecision::AliTrackDecision(t.fPt, lowPt, highPt, track);
9acda34c 573 }
450e0b36 574 }
575
576 UInt_t numUnlikeAnyPt = 0;
577 UInt_t numUnlikeLowPt = 0;
578 UInt_t numUnlikeHighPt = 0;
579 UInt_t numLikeAnyPt = 0;
580 UInt_t numLikeLowPt = 0;
581 UInt_t numLikeHighPt = 0;
582 UInt_t numAnyMass = 0;
583 UInt_t numLowMass = 0;
584 UInt_t numHighMass = 0;
585 TClonesArray pairsDecisions("AliHLTMUONDecision::AliPairDecision");
586
587 // Find the track pairs decision blocks and add their information.
588 // We just sum the trigger scalars and track pair decisions.
589 for (block = GetFirstInputBlock(AliHLTMUONConstants::PairsDecisionBlockDataType());
590 block != NULL;
591 block = GetNextInputBlock()
592 )
593 {
594 AliHLTUInt8_t* ptr = reinterpret_cast<AliHLTUInt8_t*>(block->fPtr);
595 ptr += block->fOffset;
596 AliHLTMUONPairsDecisionBlockReader inblock(ptr, block->fSize);
597 if (not inblock.BufferSizeOk())
9acda34c 598 {
450e0b36 599 size_t headerSize = sizeof(AliHLTMUONPairsDecisionBlockReader::HeaderType);
600 if (block->fSize < headerSize)
601 {
602 HLTError("Received a track pairs trigger decision data block with a size of %d bytes,"
603 " which is smaller than the minimum valid header size of %d bytes."
604 " The block must be corrupt.",
605 block->fSize, headerSize
606 );
607 continue;
608 }
609
610 size_t expectedWidth = sizeof(AliHLTMUONPairsDecisionBlockReader::ElementType);
611 if (inblock.CommonBlockHeader().fRecordWidth != expectedWidth)
612 {
613 HLTError("Received a track pairs trigger decision data block with a record"
614 " width of %d bytes, but the expected value is %d bytes."
615 " The block might be corrupt.",
616 block->fSize, headerSize
617 );
618 continue;
619 }
620
621 HLTError("Received a track pairs trigger decision data block with a size of %d bytes,"
622 " but the block header claims the block should be %d bytes."
623 " The block might be corrupt.",
624 block->fSize, inblock.BytesUsed()
625 );
626 continue;
9acda34c 627 }
450e0b36 628
629 numUnlikeAnyPt += inblock.BlockHeader().fNunlikeAnyPt;
630 numUnlikeLowPt += inblock.BlockHeader().fNunlikeLowPt;
631 numUnlikeHighPt += inblock.BlockHeader().fNunlikeHighPt;
632 numLikeAnyPt += inblock.BlockHeader().fNlikeAnyPt;
633 numLikeLowPt += inblock.BlockHeader().fNlikeLowPt;
634 numLikeHighPt += inblock.BlockHeader().fNlikeHighPt;
635 numAnyMass += inblock.BlockHeader().fNmassAny;
636 numLowMass += inblock.BlockHeader().fNmassLow;
637 numHighMass += inblock.BlockHeader().fNmassHigh;
638
639 for (AliHLTUInt32_t n = 0; n < inblock.Nentries(); n++)
640 {
641 const AliHLTMUONPairDecisionStruct& t = inblock[n];
642
643 bool highMass, lowMass, unlike;
644 AliHLTUInt8_t highPtCount, lowPtCount;
645 AliHLTMUONUtils::UnpackPairDecisionBits(
646 t.fTriggerBits, highMass, lowMass, unlike,
647 highPtCount, lowPtCount
648 );
649
650 // Try find the corresponding tracks in the 'event'.
651 const AliHLTMUONMansoTrack* trackA = NULL;
652 const AliHLTMUONMansoTrack* trackB = NULL;
653 for (Int_t k = 0; k < event.Array().GetEntriesFast(); k++)
654 {
655 if (event.Array()[k]->IsA() != AliHLTMUONMansoTrack::Class())
656 continue;
657 const AliHLTMUONMansoTrack* tk =
658 static_cast<const AliHLTMUONMansoTrack*>(event.Array()[k]);
659 if (tk->Id() == t.fTrackAId) trackA = tk;
660 if (tk->Id() == t.fTrackBId) trackB = tk;
661 if (trackA != NULL and trackB != NULL) break;
662 }
663
664 // If either of the tracks was not found then create a dummy one.
665 if (trackA == NULL)
666 {
667 AliHLTMUONMansoTrack* tr = new AliHLTMUONMansoTrack(t.fTrackAId);
668 event.Add(tr);
669 trackA = tr;
670 }
671 if (trackB == NULL)
672 {
673 AliHLTMUONMansoTrack* tr = new AliHLTMUONMansoTrack(t.fTrackBId);
674 event.Add(tr);
675 trackB = tr;
676 }
677
678 new (pairsDecisions[pairsDecisions.GetEntriesFast()])
679 AliHLTMUONDecision::AliPairDecision(
680 t.fInvMass, lowMass, highMass, unlike,
681 lowPtCount, highPtCount, trackA, trackB
682 );
683 }
684 }
685
686 AliHLTMUONDecision* triggerDecision = new AliHLTMUONDecision(
687 numLowPt, numHighPt, numUnlikeAnyPt, numUnlikeLowPt,
688 numUnlikeHighPt, numLikeAnyPt, numLikeLowPt,
689 numLikeHighPt, numAnyMass, numLowMass, numHighMass
690 );
691 for (Int_t i = 0; i < singlesDecisions.GetEntriesFast(); i++)
692 {
693 AliHLTMUONDecision::AliTrackDecision* decision =
694 static_cast<AliHLTMUONDecision::AliTrackDecision*>( singlesDecisions[i] );
695 triggerDecision->AddDecision(decision);
9acda34c 696 }
450e0b36 697 for (Int_t j = 0; j < pairsDecisions.GetEntriesFast(); j++)
698 {
699 AliHLTMUONDecision::AliPairDecision* decision =
700 static_cast<AliHLTMUONDecision::AliPairDecision*>( pairsDecisions[j] );
701 triggerDecision->AddDecision(decision);
702 }
703 event.Add(triggerDecision);
9acda34c 704
705 PushBack(&event, "ROOTEVNT", "MUON");
706
707 return 0;
708}
6253e09b 709