]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HLT/MUON/utils/AliHLTMUONDataCheckerComponent.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Input data block type is now declared with origin == MUON.
[u/mrichter/AliRoot.git] / HLT / MUON / utils / AliHLTMUONDataCheckerComponent.cxx
CommitLineData
dba14d7d 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
1d8ae082 17// $Id: AliHLTMUONDataCheckerComponent.cxx 26179 2008-05-29 22:27:27Z aszostak $
dba14d7d 18
19///
20/// @file AliHLTMUONDataCheckerComponent.cxx
21/// @author Artur Szostak <artursz@iafrica.com>
887a669c 22/// @date 27 May 2008
dba14d7d 23/// @brief Implementation of the dHLT data integrity checker component.
24///
25/// This component is used to check the data integrity of dHLT raw internal data
26/// blocks. If there are any problems found then an appropriate error message is
27/// logged.
28///
29
30#include "AliHLTMUONDataCheckerComponent.h"
31#include "AliHLTMUONConstants.h"
32#include "AliHLTLogging.h"
33#include "AliHLTSystem.h"
34#include "AliHLTDefinitions.h"
35#include "AliRawDataHeader.h"
36#include "AliMUONConstants.h"
37#include "AliMUONTrackerDDLDecoder.h"
38#include "AliMUONTrackerDDLDecoderEventHandler.h"
39#include "AliMUONTriggerDDLDecoder.h"
40#include "AliMUONTriggerDDLDecoderEventHandler.h"
41#include "AliMpDDLStore.h"
42#include "AliMpDEStore.h"
43#include "AliMpDEManager.h"
44#include "AliMpBusPatch.h"
45#include "AliMpDetElement.h"
46#include "AliMpSegmentation.h"
47#include "AliMpVSegmentation.h"
48#include "AliMpPad.h"
49#include <cstring>
50#include <cstdlib>
51#include <cmath>
52#include <cerrno>
53#include <cassert>
54
55
56namespace
57{
58 /**
59 * Routine to check if at least one corresponding DDL has been marked
60 * for a particular chamber.
61 */
62 bool ChamberMarkedInDDLList(AliHLTInt32_t chamber, bool ddl[22])
63 {
64 if (chamber < 0 or chamber > 21) return false;
65 switch (chamber)
66 {
67 case 0: return ddl[0] or ddl[1];
68 case 1: return ddl[2] or ddl[3];
69 case 2: return ddl[4] or ddl[5];
70 case 3: return ddl[6] or ddl[7];
71 case 4: return ddl[8] or ddl[9] or ddl[10] or ddl[11];
72 case 5: return ddl[8] or ddl[9] or ddl[10] or ddl[11];
73 case 6: return ddl[12] or ddl[13];
74 case 7: return ddl[14] or ddl[15];
75 case 8: return ddl[16] or ddl[17];
76 case 9: return ddl[18] or ddl[19];
77 case 10: return ddl[20] or ddl[21];
78 case 11: return ddl[20] or ddl[21];
79 case 12: return ddl[20] or ddl[21];
80 case 13: return ddl[20] or ddl[21];
81 default: return false;
82 }
83 }
84
85} // end of namespace
86
87
88ClassImp(AliHLTMUONDataCheckerComponent)
89
90
91AliHLTMUONDataCheckerComponent::AliHLTMUONDataCheckerComponent() :
92 AliHLTMUONProcessor(),
93 fIgnoreType(false),
94 fIgnoreSpec(false),
95 fDontForward(false),
96 fFilterBadBlocks(false),
97 fNoGlobalChecks(false),
887a669c 98 fWarnForUnexpecedBlock(false),
99 fReturnError(false)
dba14d7d 100{
101 /// Default constructor.
102}
103
104
105AliHLTMUONDataCheckerComponent::~AliHLTMUONDataCheckerComponent()
106{
107 /// Default destructor.
108}
109
110const char* AliHLTMUONDataCheckerComponent::GetComponentID()
111{
112 /// Inherited from AliHLTComponent. Returns the component ID.
113
114 return AliHLTMUONConstants::DataCheckerComponentId();
115}
116
117
ffb64d3e 118void AliHLTMUONDataCheckerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
dba14d7d 119{
120 /// Inherited from AliHLTProcessor. Returns the list of expected input data types.
b610bbfa 121 /// At the moment this list is "any data type" origin MUON since it is not known
122 /// before hand what kind of input blocks we will get.
dba14d7d 123
124 assert( list.empty() );
b610bbfa 125 list.push_back( kAliHLTAnyDataType | kAliHLTDataOriginMUON );
dba14d7d 126}
127
128
129AliHLTComponentDataType AliHLTMUONDataCheckerComponent::GetOutputDataType()
130{
131 /// Inherited from AliHLTComponent. Returns the output data type of
132 /// "any data type" with MUON origin.
133
134 return kAliHLTAnyDataType | kAliHLTDataOriginMUON;
135}
136
137
138void AliHLTMUONDataCheckerComponent::GetOutputDataSize(
139 unsigned long& constBase, double& inputMultiplier
140 )
141{
142 /// Inherited from AliHLTComponent.
143 /// Returns an estimate of the expected output data size.
144
145 // Both of these are zero because we will only ever pass on input data blocks
146 // and never generate data in this component.
147 constBase = 0;
148 inputMultiplier = 0;
149}
150
151
152AliHLTComponent* AliHLTMUONDataCheckerComponent::Spawn()
153{
154 /// Inherited from AliHLTComponent. Creates a new object instance.
155
156 return new AliHLTMUONDataCheckerComponent;
157}
158
159
1d8ae082 160bool AliHLTMUONDataCheckerComponent::IgnoreArgument(const char* arg) const
161{
162 /// Return true if the argument is -delaysetup
163 /// to prevent the parent class from parsing these arguments in DoInit.
164
165 if (strcmp(arg, "-delaysetup") == 0)
166 {
167 return true;
168 }
169 else
170 {
171 return false;
172 }
173}
174
175
dba14d7d 176int AliHLTMUONDataCheckerComponent::DoInit(int argc, const char** argv)
177{
178 /// Inherited from AliHLTComponent.
179 /// Parses the command line parameters and initialises the component.
180
181 HLTInfo("Initialising dHLT data checker component.");
ffb64d3e 182
183 // Inherit the parents functionality.
184 int result = AliHLTMUONProcessor::DoInit(argc, argv);
185 if (result != 0) return result;
dba14d7d 186
187 // Initialise flags with default values.
188 fIgnoreType = false;
189 fIgnoreSpec = false;
190 fDontForward = false;
191 fFilterBadBlocks = false;
192 fNoGlobalChecks = false;
193 fWarnForUnexpecedBlock = false;
887a669c 194 fReturnError = false;
dba14d7d 195
196 for (int i = 0; i < argc; i++)
197 {
ffb64d3e 198 if (ArgumentAlreadyHandled(i, argv[i])) continue;
199
dba14d7d 200 if (strcmp(argv[i], "-ignoretype") == 0)
201 {
202 fIgnoreType = true;
203 HLTInfo("Ignoring data type of data blocks as given by framework.");
204 continue;
205 }
206 if (strcmp(argv[i], "-ignorespec") == 0)
207 {
208 fIgnoreSpec = true;
209 HLTInfo("Ignoring data specification of data blocks as given by framework.");
210 continue;
211 }
212 if (strcmp(argv[i], "-dontforward") == 0)
213 {
214 fDontForward = true;
215 HLTInfo("Not forwarding input data blocks.");
216 continue;
217 }
218 if (strcmp(argv[i], "-filter") == 0)
219 {
220 fFilterBadBlocks = true;
221 HLTInfo("Passing only bad blocks to output.");
222 continue;
223 }
887a669c 224 if (strcmp(argv[i], "-no_global_check") == 0)
dba14d7d 225 {
226 fNoGlobalChecks = true;
227 HLTInfo("Only per block data consistancy checks will be applied,"
887a669c 228 " but no global checks will be made."
dba14d7d 229 );
230 continue;
231 }
232 if (strcmp(argv[i], "-warn_on_unexpected_block") == 0)
233 {
234 fWarnForUnexpecedBlock = true;
235 continue;
236 }
887a669c 237 if (strcmp(argv[i], "-return_error") == 0)
238 {
239 fReturnError = true;
240 continue;
241 }
dba14d7d 242
243 HLTError("Unknown option '%s'.", argv[i]);
244 return -EINVAL;
245 }
246
247 return 0;
248}
249
250
251int AliHLTMUONDataCheckerComponent::DoDeinit()
252{
253 /// Inherited from AliHLTComponent. Performs a cleanup of the component.
254
255 HLTInfo("Deinitialising dHLT data checker component.");
256 return 0;
257}
258
259
260int AliHLTMUONDataCheckerComponent::DoEvent(
261 const AliHLTComponentEventData& evtData,
262 const AliHLTComponentBlockData* blocks,
ffb64d3e 263 AliHLTComponentTriggerData& trigData,
dba14d7d 264 AliHLTUInt8_t* /*outputPtr*/,
265 AliHLTUInt32_t& size,
ffb64d3e 266 AliHLTComponentBlockDataList& outputBlocks
dba14d7d 267 )
268{
269 /// Inherited from AliHLTProcessor. Processes the new event data.
270 /// Here we go through the list of input data blocks and apply extensive
271 /// data integrity checking on the data found.
272
83d66053 273 if (not IsDataEvent()) return 0;
274
dba14d7d 275 HLTDebug("Processing event %llu with %u input data blocks.",
276 evtData.fEventID, evtData.fBlockCnt
277 );
278
279 // Allocate an array of flags indicating if the data block is OK or not,
887a669c 280 // also arrays to store specific.
281 bool dataProblems = false;
dba14d7d 282 bool* blockOk = NULL;
283 typedef const AliHLTComponentBlockData* PAliHLTComponentBlockData;
284 PAliHLTComponentBlockData* trigRecBlocks = NULL;
285 PAliHLTComponentBlockData* trigRecDebugBlocks = NULL;
286 PAliHLTComponentBlockData* hitBlocks = NULL;
287 PAliHLTComponentBlockData* clusterBlocks = NULL;
288 PAliHLTComponentBlockData* channelBlocks = NULL;
289 PAliHLTComponentBlockData* mansoTrackBlocks = NULL;
290 PAliHLTComponentBlockData* mansoCandidateBlocks = NULL;
a8982f78 291 PAliHLTComponentBlockData* trackBlocks = NULL;
dba14d7d 292 PAliHLTComponentBlockData* singleDecisionBlocks = NULL;
293 PAliHLTComponentBlockData* pairDecisionBlocks = NULL;
294 AliHLTUInt32_t trigRecBlocksCount = 0;
295 AliHLTUInt32_t trigRecDebugBlocksCount = 0;
296 AliHLTUInt32_t hitBlocksCount = 0;
297 AliHLTUInt32_t clusterBlocksCount = 0;
298 AliHLTUInt32_t channelBlocksCount = 0;
299 AliHLTUInt32_t mansoTrackBlocksCount = 0;
300 AliHLTUInt32_t mansoCandidateBlocksCount = 0;
a8982f78 301 AliHLTUInt32_t trackBlocksCount = 0;
dba14d7d 302 AliHLTUInt32_t singleDecisionBlocksCount = 0;
303 AliHLTUInt32_t pairDecisionBlocksCount = 0;
304 try
305 {
306 blockOk = new bool[evtData.fBlockCnt];
307 trigRecBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
308 trigRecDebugBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
309 hitBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
310 clusterBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
311 channelBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
312 mansoTrackBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
313 mansoCandidateBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
a8982f78 314 trackBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
dba14d7d 315 singleDecisionBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
316 pairDecisionBlocks = new PAliHLTComponentBlockData[evtData.fBlockCnt];
317 }
318 catch (const std::bad_alloc&)
319 {
320 HLTError("Could not allocate more memory for internal arrays.");
321 // Make sure to clean up if partially allocated memory.
322 if (blockOk != NULL) delete [] blockOk;
323 if (trigRecBlocks != NULL) delete [] trigRecBlocks;
324 if (trigRecDebugBlocks != NULL) delete [] trigRecDebugBlocks;
325 if (hitBlocks != NULL) delete [] hitBlocks;
326 if (clusterBlocks != NULL) delete [] clusterBlocks;
327 if (channelBlocks != NULL) delete [] channelBlocks;
328 if (mansoTrackBlocks != NULL) delete [] mansoTrackBlocks;
329 if (mansoCandidateBlocks != NULL) delete [] mansoCandidateBlocks;
a8982f78 330 if (trackBlocks != NULL) delete [] trackBlocks;
dba14d7d 331 if (singleDecisionBlocks != NULL) delete [] singleDecisionBlocks;
332 if (pairDecisionBlocks != NULL) delete [] pairDecisionBlocks;
333 return -ENOMEM;
334 }
335
83d66053 336 AliHLTComponentDataType anyPrivateType = AliHLTComponentDataTypeInitializer(
337 kAliHLTAnyDataType, kAliHLTDataOriginPrivate
338 );
339
dba14d7d 340 try
341 {
342 // Clear all the flags indicating if the blocks are ok.
343 for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
344 {
345 blockOk[n] = false;
346 }
347
348 for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
349 {
350 HLTDebug("Handling block: %u, with fDataType = '%s', fPtr = %p and fSize = %u bytes.",
351 n, DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fPtr, blocks[n].fSize
352 );
353
354 AliHLTMUONDataBlockType blockType = kUnknownDataBlock;
355
356 if (fIgnoreType)
357 {
83d66053 358 // Decode the block type if we must ignore the block type
dba14d7d 359 // as given by the HLT framework.
360 if (blocks[n].fSize >= sizeof(AliHLTMUONDataBlockHeader))
361 {
362 const AliHLTMUONDataBlockHeader* header =
363 reinterpret_cast<const AliHLTMUONDataBlockHeader*>(blocks[n].fPtr);
364 blockType = AliHLTMUONDataBlockType(header->fType);
365 }
366 }
367 else
368 {
83d66053 369 if (blocks[n].fDataType == anyPrivateType)
370 {
371 // Completely ignore any private HLT internal block types.
372 blockOk[n] = true;
373 continue;
374 }
375 else if (blocks[n].fDataType == AliHLTMUONConstants::DDLRawDataType())
dba14d7d 376 {
377 blockOk[n] = CheckRawDataBlock(blocks[n], n);
378 continue;
379 }
380 else if (blocks[n].fDataType == AliHLTMUONConstants::TriggerRecordsBlockDataType())
381 {
382 blockType = kTriggerRecordsDataBlock;
383 }
384 else if (blocks[n].fDataType == AliHLTMUONConstants::TrigRecsDebugBlockDataType())
385 {
386 blockType = kTrigRecsDebugDataBlock;
387 }
388 else if (blocks[n].fDataType == AliHLTMUONConstants::RecHitsBlockDataType())
389 {
390 blockType = kRecHitsDataBlock;
391 }
392 else if (blocks[n].fDataType == AliHLTMUONConstants::ClusterBlockDataType())
393 {
394 blockType = kClustersDataBlock;
395 }
396 else if (blocks[n].fDataType == AliHLTMUONConstants::ChannelBlockDataType())
397 {
398 blockType = kChannelsDataBlock;
399 }
400 else if (blocks[n].fDataType == AliHLTMUONConstants::MansoTracksBlockDataType())
401 {
402 blockType = kMansoTracksDataBlock;
403 }
404 else if (blocks[n].fDataType == AliHLTMUONConstants::MansoCandidatesBlockDataType())
405 {
406 blockType = kMansoCandidatesDataBlock;
407 }
a8982f78 408 else if (blocks[n].fDataType == AliHLTMUONConstants::TracksBlockDataType())
409 {
410 blockType = kTracksDataBlock;
411 }
dba14d7d 412 else if (blocks[n].fDataType == AliHLTMUONConstants::SinglesDecisionBlockDataType())
413 {
414 blockType = kSinglesDecisionDataBlock;
415 }
416 else if (blocks[n].fDataType == AliHLTMUONConstants::PairsDecisionBlockDataType())
417 {
418 blockType = kPairsDecisionDataBlock;
419 }
420 else
421 {
422 // Log a message indicating that we got a data block that we
423 // do not know how to handle.
424 if (fWarnForUnexpecedBlock)
425 HLTWarning("Received a data block of a type we cannot"
426 " handle: '%s', spec: 0x%8.8X",
427 DataType2Text(blocks[n].fDataType).c_str(),
428 blocks[n].fSpecification
429 );
4e22efc4 430#ifdef __DEBUG
dba14d7d 431 else
432 HLTDebug("Received a data block of a type we cannot"
433 " handle: '%s', spec: 0x%8.8X",
434 DataType2Text(blocks[n].fDataType).c_str(),
435 blocks[n].fSpecification
436 );
4e22efc4 437#endif
dba14d7d 438 }
439 }
440
441 switch (blockType)
442 {
443 case kTriggerRecordsDataBlock:
444 blockOk[n] = CheckTriggerRecordsBlock(blocks[n], n);
445 trigRecBlocks[trigRecBlocksCount++] = &blocks[n];
446 break;
447 case kTrigRecsDebugDataBlock:
448 blockOk[n] = CheckTrigRecsDebugBlock(blocks[n], n);
449 trigRecDebugBlocks[trigRecDebugBlocksCount++] = &blocks[n];
450 break;
451 case kRecHitsDataBlock:
452 blockOk[n] = CheckRecHitsBlock(blocks[n], n);
453 hitBlocks[hitBlocksCount++] = &blocks[n];
454 break;
455 case kClustersDataBlock:
456 blockOk[n] = CheckClustersBlock(blocks[n], n);
457 clusterBlocks[clusterBlocksCount++] = &blocks[n];
458 break;
459 case kChannelsDataBlock:
460 blockOk[n] = CheckChannelsBlock(blocks[n], n);
461 channelBlocks[channelBlocksCount++] = &blocks[n];
462 break;
463 case kMansoTracksDataBlock:
464 blockOk[n] = CheckMansoTracksBlock(blocks[n], n);
465 mansoTrackBlocks[mansoTrackBlocksCount++] = &blocks[n];
466 break;
467 case kMansoCandidatesDataBlock:
468 blockOk[n] = CheckMansoCandidatesBlock(blocks[n], n);
469 mansoCandidateBlocks[mansoCandidateBlocksCount++] = &blocks[n];
470 break;
a8982f78 471 case kTracksDataBlock:
472 blockOk[n] = CheckTracksBlock(blocks[n], n);
473 trackBlocks[trackBlocksCount++] = &blocks[n];
474 break;
dba14d7d 475 case kSinglesDecisionDataBlock:
476 blockOk[n] = CheckSinglesDecisionBlock(blocks[n], n);
477 singleDecisionBlocks[singleDecisionBlocksCount++] = &blocks[n];
478 break;
479 case kPairsDecisionDataBlock:
480 blockOk[n] = CheckPairsDecisionBlock(blocks[n], n);
481 pairDecisionBlocks[pairDecisionBlocksCount++] = &blocks[n];
482 break;
483 default:
484 HLTDebug("Received a data block for which we could not decode the data type."
485 " fDataType = '%s', fSpecification = 0x%8.8X, fSize = %u bytes.",
486 DataType2Text(blocks[n].fDataType).c_str(),
487 blocks[n].fSpecification,
488 blocks[n].fSize
489 );
490 break;
491 }
492 }
493
494 // Apply the global data consistancy checks if not suppressed by the user.
495 if (not fNoGlobalChecks)
496 {
497 MakeGlobalChecks(
498 blocks, blockOk, evtData.fBlockCnt,
499 trigRecBlocks, trigRecBlocksCount,
500 trigRecDebugBlocks, trigRecDebugBlocksCount,
501 hitBlocks, hitBlocksCount,
502 clusterBlocks, clusterBlocksCount,
503 channelBlocks, channelBlocksCount,
504 mansoTrackBlocks, mansoTrackBlocksCount,
505 mansoCandidateBlocks, mansoCandidateBlocksCount,
a8982f78 506 trackBlocks, trackBlocksCount,
dba14d7d 507 singleDecisionBlocks, singleDecisionBlocksCount,
508 pairDecisionBlocks, pairDecisionBlocksCount
509 );
510 }
511
512 // Forward the input data blocks if we have not been asked to drop them.
513 // Also remember to filter for bad blocks if so specified.
514 if (not fDontForward)
515 {
516 for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
517 {
518 if (fFilterBadBlocks and blockOk[n]) continue;
519 outputBlocks.push_back(blocks[n]);
520 }
521 }
887a669c 522
523 // Set dataProblems flag is there was at least one block with problems.
524 for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++)
525 {
526 if (not blockOk[n]) dataProblems = true;
527 }
dba14d7d 528 }
529 finally
530 (
531 // make sure to cleanup memory
532 delete [] blockOk;
533 delete [] trigRecBlocks;
534 delete [] trigRecDebugBlocks;
535 delete [] hitBlocks;
536 delete [] clusterBlocks;
537 delete [] channelBlocks;
538 delete [] mansoTrackBlocks;
539 delete [] mansoCandidateBlocks;
a8982f78 540 delete [] trackBlocks;
dba14d7d 541 delete [] singleDecisionBlocks;
542 delete [] pairDecisionBlocks;
543 )
544
545 // Finally we set the total size of output memory we consumed, which is
546 // zero since we just copied the input descriptors to output if anything.
547 size = 0;
ffb64d3e 548
549 if (dataProblems and DumpDataOnError()) DumpEvent(evtData, trigData);
887a669c 550
551 if (fReturnError)
552 {
553 // If we were requested to return errors if there were integrity
554 // problems then check if any data blocks had problems and return
555 // an error code.
556 if (dataProblems) return -EFAULT;
557 }
dba14d7d 558 return 0;
559}
560
561
562bool AliHLTMUONDataCheckerComponent::IsSpecificationValid(
563 const AliHLTComponentBlockData& block,
564 AliHLTUInt32_t blockNumber,
565 const char* name
566 ) const
567{
568 /// Checks if the specification bits are valid.
569 /// \param block The block whose specification should be checked.
570 /// \param blockNumber The block index number being checked.
571 /// \param name The name of the type of block being checked.
572 /// \returns true if the specification is valid and false otherwise.
573
574 if (AliHLTMUONUtils::IsSpecValid(block.fSpecification))
575 return true;
576
577 HLTError("Problem found with data block %d, fDataType = '%s',"
578 " fPtr = %p and fSize = %u bytes."
579 " Assuming this is a %s data block."
580 " Problem: The specification does not contain a valid pattern,"
581 " received 0x%8.8X for the specification.",
582 blockNumber,
583 DataType2Text(block.fDataType).c_str(),
584 block.fPtr,
585 block.fSize,
586 name,
587 block.fSpecification
588 );
589 return false;
590}
591
592
593bool AliHLTMUONDataCheckerComponent::IsFromTrackerOnly(
594 const AliHLTComponentBlockData& block,
595 AliHLTUInt32_t blockNumber,
596 const char* name
597 ) const
598{
599 /// Checks if the specification bits are valid and indicate the block
600 /// contains data or information only from the tracker DDLs.
601 /// \param block The block whose specification should be checked.
602 /// \param blockNumber The block index number being checked.
603 /// \param name The name of the type of block being checked.
604 /// \returns true if the specification indicates data is only from tracker.
605
606 bool result = IsSpecificationValid(block, blockNumber, name);
607
608 if (AliHLTMUONUtils::ContainsDataFromTracker(block.fSpecification) and
609 not AliHLTMUONUtils::ContainsDataFromTrigger(block.fSpecification)
610 )
611 {
612 return result;
613 }
614
615 HLTError("Problem found with data block %d, fDataType = '%s',"
616 " fPtr = %p and fSize = %u bytes."
617 " Assuming this is a %s data block."
618 " Problem: The data block does not contain data only from the"
619 " tracker DDLs as expected."
620 " Received 0x%8.8X for the specification.",
621 blockNumber,
622 DataType2Text(block.fDataType).c_str(),
623 block.fPtr,
624 block.fSize,
625 name,
626 block.fSpecification
627 );
628 return false;
629}
630
631
632bool AliHLTMUONDataCheckerComponent::IsFromTriggerOnly(
633 const AliHLTComponentBlockData& block,
634 AliHLTUInt32_t blockNumber,
635 const char* name
636 ) const
637{
638 /// Checks if the specification bits are valid and indicate the block
639 /// contains data or information only from the trigger DDLs.
640 /// \param block The block whose specification should be checked.
641 /// \param blockNumber The block index number being checked.
642 /// \param name The name of the type of block being checked.
643 /// \returns true if the specification indicates data is only from trigger.
644
645 bool result = IsSpecificationValid(block, blockNumber, name);
646
647 if (AliHLTMUONUtils::ContainsDataFromTrigger(block.fSpecification) and
648 not AliHLTMUONUtils::ContainsDataFromTracker(block.fSpecification)
649 )
650 {
651 return result;
652 }
653
654 HLTError("Problem found with data block %d, fDataType = '%s',"
655 " fPtr = %p and fSize = %u bytes."
656 " Assuming this is a %s data block."
657 " Problem: The data block does not contain data only from the"
658 " trigger DDLs as expected."
659 " Received 0x%8.8X for the specification.",
660 blockNumber,
661 DataType2Text(block.fDataType).c_str(),
662 block.fPtr,
663 block.fSize,
664 name,
665 block.fSpecification
666 );
667 return false;
668}
669
670
671bool AliHLTMUONDataCheckerComponent::IsMomentumVectorOk(
672 const AliHLTComponentBlockData& block,
673 AliHLTUInt32_t blockNumber,
674 const char* name,
675 AliHLTUInt32_t entryNumber,
676 AliHLTFloat32_t px,
677 AliHLTFloat32_t py,
678 AliHLTFloat32_t pz
679 ) const
680{
681 /// Checks if the momentum vector is reasonable.
682 /// \param block The block from which the momentum vector data comes from.
683 /// \param blockNumber The block index number.
684 /// \param name The name of the type of block.
685 /// \param entryNumber The entry index number of the structure holding
686 /// the momentum vector data.
687 /// \param px The X coordinate of the momentum vector (GeV/c).
688 /// \param py The Y coordinate of the momentum vector (GeV/c).
689 /// \param pz The Z coordinate of the momentum vector (GeV/c).
690 /// \returns true if the momentum vector is valid and false otherwise.
691
692 // If the momentum vector is nil then ignore it.
693 if (px == 0 and py == 0 and pz == 0) return true;
694
695 bool result = true;
696
697 // If the momentum vector is sane then we should not have a particle with
698 // more energy than 14 TeV and momentum should be in the negative direction.
699 double momentum = sqrt(px*px + py*py + pz*pz);
700 if (momentum > 14e3)
701 {
702 // Just warn since this is a data sanity problem rather
703 // than a data integrity problem.
704 HLTWarning("Problem found with data block %d, fDataType = '%s',"
705 " fPtr = %p and fSize = %u bytes."
706 " Assuming this is a %s data block."
707 " Problem with entry %d in block: The momentum vector"
708 " p = {%f, %f, %f}, |p| = %f looks too big.",
709 blockNumber,
710 DataType2Text(block.fDataType).c_str(),
711 block.fPtr,
712 block.fSize,
713 name,
714 entryNumber,
715 px, py, pz,
716 momentum
717 );
718 result = false;
719 }
720
721 if (pz > 0.)
722 {
723 // Just warn since this is a data sanity problem rather
724 // than a data integrity problem.
725 HLTWarning("Problem found with data block %d, fDataType = '%s',"
726 " fPtr = %p and fSize = %u bytes."
727 " Assuming this is a %s data block."
728 " Problem with entry %d in block: The momentum vector"
729 " p = {%f, %f, %f} points away from the dimuon"
730 " spectrometer (p_z > 0).",
731 blockNumber,
732 DataType2Text(block.fDataType).c_str(),
733 block.fPtr,
734 block.fSize,
735 name,
736 entryNumber,
737 px, py, pz
738 );
739 result = false;
740 }
741
742 return result;
743}
744
745
746bool AliHLTMUONDataCheckerComponent::AreMomentumCalcParamsOk(
747 const AliHLTComponentBlockData& block,
748 AliHLTUInt32_t blockNumber,
749 const char* name,
750 AliHLTUInt32_t entryNumber,
751 AliHLTFloat32_t zmiddle,
752 AliHLTFloat32_t bl
753 ) const
754{
755 /// Checks if the parameters for the momentum calculation are reasonable.
756 /// \param block The block from which the parameter data comes from.
757 /// \param blockNumber The block index number.
758 /// \param name The name of the type of block.
759 /// \param entryNumber The entry index number of the structure holding
760 /// the parameter data data.
761 /// \param zmiddle The z-coordinate of the middle of the magnetic field (cm).
762 /// \param bl The integrated magnetic field (T.m).
763 /// \returns true if the parameters are valid and false otherwise.
764
765 bool result = true;
766
767 // Check that the value of the fZmiddle value is somewhere
768 // within the tracking / dipole magnetic field area.
769 if (zmiddle < AliMUONConstants::AbsZEnd() or
770 zmiddle < AliMUONConstants::MuonFilterZBeg()
771 )
772 {
773 // Just warn since this is a data sanity problem rather
774 // than a data integrity problem.
775 HLTWarning("Problem found with data block %d, fDataType = '%s',"
776 " fPtr = %p and fSize = %u bytes."
777 " Assuming this is a %s data block."
778 " Problem with entry %d in block: The Z coordinate %f cm"
779 " used as the middle of the magnetic field in the momentum"
780 " calculation is outside the dimuon spectrometers dipole"
781 " magnetic field volume.",
782 blockNumber,
783 DataType2Text(block.fDataType).c_str(),
784 block.fPtr,
785 block.fSize,
786 name,
787 entryNumber,
788 zmiddle
789 );
790 result = false;
791 }
792
793 // Also check that the value of the 'bl' value is within a
794 // reasonable range: |bl| < Lmax * Bmax, where
795 // Lmax = max length from vertex to end of spectrometer, and
796 // Bmax = max magnetic field of dipole, taken as 1 tesla.
797 // Approximating Lmax * Bmax as 20 T.m
798 if (fabs(bl) > 20.)
799 {
800 // Just warn since this is a data sanity problem rather
801 // than a data integrity problem.
802 HLTWarning("Problem found with data block %d, fDataType = '%s',"
803 " fPtr = %p and fSize = %u bytes."
804 " Assuming this is a %s data block."
805 " Problem with entry %d in block: The integrated magnetic"
806 " field value %f T.m used in the momentum calculation"
807 " has an unreasonably large absolute value.",
808 blockNumber,
809 DataType2Text(block.fDataType).c_str(),
810 block.fPtr,
811 block.fSize,
812 name,
813 entryNumber,
814 bl
815 );
816 result = false;
817 }
818
819 return result;
820}
821
822
823bool AliHLTMUONDataCheckerComponent::IsHitCoordinateOk(
824 const AliHLTComponentBlockData& block,
825 AliHLTUInt32_t blockNumber,
826 const char* name,
827 AliHLTUInt32_t entryNumber,
828 const AliHLTMUONRecHitStruct& hit,
829 AliHLTInt32_t minChamber,
830 AliHLTInt32_t maxChamber,
831 AliHLTInt32_t expectedChamber,
832 bool ddl[22]
833 ) const
834{
835 /// Checks if the hit coordinate is compatible with a the location of a
836 /// dimuon spectrometer chamber. Also, if expectedChamber is not -1, then
837 /// the hit coordinate is checked if to comes from that chamber.
a090ff22 838 /// We also check if the fFlags containing the chamber number and detector
839 /// element ID are correct.
dba14d7d 840 /// \param block The block from which the hit data comes from.
841 /// \param blockNumber The block index number.
842 /// \param name The name of the type of block.
843 /// \param entryNumber The entry index number of the hit.
844 /// \param hit The hit data being checked.
845 /// \param minChamber The minimum valid chamber number to check for.
846 /// \param maxChamber The maximum valid chamber number to check for.
847 /// \param expectedChamber If not -1 then this is the chamber number to
848 /// check against.
849 /// \param ddl The array decoded by AliHLTMUONUtils::UnpackSpecBits.
850 /// \returns true if the hit is valid and false otherwise.
851
852 assert( 0 <= minChamber and minChamber < 14 );
853 assert( 0 <= maxChamber and maxChamber < 14 );
854
855 bool result = true;
856
a090ff22 857 AliHLTUInt8_t chNum = 0xFF;
858 AliHLTUInt16_t detElemId = 0xFFFF;
859 AliHLTMUONUtils::UnpackRecHitFlags(hit.fFlags, chNum, detElemId);
860
dba14d7d 861 Int_t chamber = AliMUONConstants::ChamberNumber(hit.fZ, false); // false = do not warn.
862 if (chamber < minChamber or maxChamber < chamber)
863 {
864 HLTError("Problem found with data block %d, fDataType = '%s',"
865 " fPtr = %p and fSize = %u bytes."
866 " Assuming this is a %s data block."
867 " Problem with entry %d in block: The hit {x = %f, y = %f,"
868 " z = %f} cm has a z-coordinate that does not correspond"
869 " to the nominal position of any chambers in the range"
870 " [%d..%d].",
871 blockNumber,
872 DataType2Text(block.fDataType).c_str(),
873 block.fPtr,
874 block.fSize,
875 name,
876 entryNumber,
877 hit.fX, hit.fY, hit.fZ,
878 minChamber+1,
879 maxChamber+1
880 );
881 return false;
882 }
883
a090ff22 884 if (chNum != chamber)
885 {
886 HLTError("Problem found with data block %d, fDataType = '%s',"
887 " fPtr = %p and fSize = %u bytes."
888 " Assuming this is a %s data block."
889 " Problem with entry %d in block: The hit {x = %f, y = %f,"
890 " z = %f} cm has a chamber number %d that does not correspond"
891 " to the expected chamber %d given by the z-coordinate.",
892 blockNumber,
893 DataType2Text(block.fDataType).c_str(),
894 block.fPtr,
895 block.fSize,
896 name,
897 entryNumber,
898 hit.fX, hit.fY, hit.fZ,
899 chNum+1,
900 chamber+1
901 );
902 result = false;
8a9e21f6 903 if (minChamber <= Int_t(chNum) and Int_t(chNum) <= maxChamber)
a090ff22 904 {
905 // Rather use the explicit value in the data if it
906 // is in range.
907 chamber = chNum;
908 }
909 }
910
dba14d7d 911 if (expectedChamber != -1 and chamber != expectedChamber)
912 {
913 HLTError("Problem found with data block %d, fDataType = '%s',"
914 " fPtr = %p and fSize = %u bytes."
915 " Assuming this is a %s data block."
916 " Problem with entry %d in block: The hit {x = %f, y = %f,"
917 " z = %f} cm has a position that corresponds to chamber %d,"
918 " but expected it to be on chamber %d.",
919 blockNumber,
920 DataType2Text(block.fDataType).c_str(),
921 block.fPtr,
922 block.fSize,
923 name,
924 entryNumber,
925 hit.fX, hit.fY, hit.fZ,
926 chamber+1,
927 expectedChamber+1
928 );
929 result = false;
930 }
931
932 AliHLTFloat32_t rmin = AliMUONConstants::Rmin(chamber / 2);
933 AliHLTFloat32_t rmax = AliMUONConstants::Rmax(chamber / 2);
934 AliHLTFloat32_t radius = sqrt(hit.fX*hit.fX + hit.fY*hit.fY);
935 if (radius < rmin or rmax < radius)
936 {
937 HLTError("Problem found with data block %d, fDataType = '%s',"
938 " fPtr = %p and fSize = %u bytes."
939 " Assuming this is a %s data block."
940 " Problem with entry %d in block: The hit {x = %f, y = %f,"
941 " z = %f} cm has a position in the X-Y plane that does not"
942 " correspond to the nominal position of chamber %d.",
943 blockNumber,
944 DataType2Text(block.fDataType).c_str(),
945 block.fPtr,
946 block.fSize,
947 name,
948 entryNumber,
949 hit.fX, hit.fY, hit.fZ,
950 chamber+1
951 );
952 result = false;
953 }
954
955 if (not fIgnoreSpec and not ChamberMarkedInDDLList(chamber, ddl))
956 {
957 HLTError("Problem found with data block %d, fDataType = '%s',"
958 " fPtr = %p and fSize = %u bytes."
959 " Assuming this is a %s data block."
960 " Problem with entry %d in block: The hit {x = %f, y = %f,"
961 " z = %f} cm has a position that corresponds to chamber %d"
962 " but the data block specification 0x%8.8X does have a"
963 " corresponding DDL bit set.",
964 blockNumber,
965 DataType2Text(block.fDataType).c_str(),
966 block.fPtr,
967 block.fSize,
968 name,
969 entryNumber,
970 hit.fX, hit.fY, hit.fZ,
971 chamber+1,
972 block.fSpecification
973 );
974 result = false;
975 }
976
a090ff22 977 // Check that the detector element ID is valid and it corresponds to
978 // the chamber number.
979 if (FetchMappingStores() == 0) // are stores loaded?
980 {
981 Bool_t warn = kFALSE;
982 AliMpDEStore* store = AliMpDEStore::Instance(warn);
983 AliMpDetElement* de = store->GetDetElement(Int_t(detElemId), warn);
984 if (de == NULL)
985 {
986 HLTError("Problem found with data block %d, fDataType = '%s',"
987 " fPtr = %p and fSize = %u bytes."
988 " Assuming this is a %s data block."
989 " Problem with entry %d in block: The hit {x = %f, y = %f,"
990 " z = %f} cm has a detector element ID %d,"
991 " which is not valid.",
992 blockNumber,
993 DataType2Text(block.fDataType).c_str(),
994 block.fPtr,
995 block.fSize,
996 name,
997 entryNumber,
998 hit.fX, hit.fY, hit.fZ,
999 detElemId
1000 );
1001 result = false;
1002 }
1003
1004 // Check that the chamber number from the detector element number
1005 // has the expected value.
1006 Int_t ch = AliMpDEManager::GetChamberId(Int_t(detElemId), warn);
1007 if (ch != chamber)
1008 {
1009 HLTError("Problem found with data block %d, fDataType = '%s',"
1010 " fPtr = %p and fSize = %u bytes."
1011 " Assuming this is a %s data block."
1012 " Problem with entry %d in block: The hit {x = %f, y = %f,"
1013 " z = %f} cm has a detector element ID %d,"
1014 " which does not correspond to the chamber %d.",
1015 blockNumber,
1016 DataType2Text(block.fDataType).c_str(),
1017 block.fPtr,
1018 block.fSize,
1019 name,
1020 entryNumber,
1021 hit.fX, hit.fY, hit.fZ,
8a9e21f6 1022 detElemId,
a090ff22 1023 chamber+1
1024 );
1025 result = false;
1026 }
1027 }
1028 else
1029 {
1030 HLTWarning("Cannot check a hit's detector element ID information"
1031 " without being able to load the mapping from CDB."
1032 );
1033 result = false;
1034 }
1035
dba14d7d 1036 return result;
1037}
1038
1039
1040bool AliHLTMUONDataCheckerComponent::IsMansoTrackOk(
1041 const AliHLTComponentBlockData& block,
1042 AliHLTUInt32_t blockNumber,
1043 const char* name,
1044 AliHLTUInt32_t entryNumber,
1045 const AliHLTMUONMansoTrackStruct& track,
1046 bool ddl[22]
1047 ) const
1048{
1049 /// Checks if the Manso track structure is Ok.
1050 /// \param block The block from which the track data comes from.
1051 /// \param blockNumber The block index number.
1052 /// \param name The name of the type of block.
1053 /// \param entryNumber The entry index number of the structure in the
1054 /// block being checked.
1055 /// \param track The Manso track data being checked.
1056 /// \param ddl The array decoded by AliHLTMUONUtils::UnpackSpecBits.
a8982f78 1057 /// \returns true if the Manso track is valid and false otherwise.
dba14d7d 1058
1059 bool result = true;
1060
1061 // Chi^2 should not be greater than the worst fit possible, estimated
1062 // as the diameter of largest chamber times the number of points
1063 // findable in a track. Max points is 10 tracker chambers times
1064 // 2 cathodes + 4 trigger chambers.
1065 if (track.fChi2 > AliMUONConstants::Dmax(6)*AliMUONConstants::Dmax(6)*(10*2+4))
1066 {
1067 // Just a warning since this is not technically an
1068 // integrity problem.
1069 HLTWarning("Problem found with data block %d, fDataType = '%s',"
1070 " fPtr = %p and fSize = %u bytes."
1071 " Assuming this is a %s data block."
1072 " Problem with entry %d in block: The Manso track has"
a8982f78 1073 " the chi squared value of %f that is unreasonably big.",
dba14d7d 1074 blockNumber,
1075 DataType2Text(block.fDataType).c_str(),
1076 block.fPtr,
1077 block.fSize,
1078 name,
1079 entryNumber,
1080 track.fChi2
1081 );
1082 result = false;
1083 }
1084
1085 // Check if the momentum vector is reasonable.
1086 bool momOk = IsMomentumVectorOk(
1087 block, blockNumber, name, entryNumber,
1088 track.fPx, track.fPy, track.fPz
1089 );
1090 if (not momOk) result = false;
1091
1092 AliHLTMUONParticleSign sign;
1093 bool hitset[4];
1094 AliHLTMUONUtils::UnpackMansoTrackFlags(track.fFlags, sign, hitset);
1095
1096 // Min and max allowed chamber numbers for hits:
1097 Int_t minCh = 0;
1098 Int_t maxCh = AliMUONConstants::NTrackingCh() - 1;
1099
1100 // Check that this hit coordinates are OK.
1101 for (AliHLTUInt32_t i = 0; i < 4; i++)
1102 {
1103 if (not hitset[i]) continue; // ignore hits that are not initialised.
1104 bool hitOk = IsHitCoordinateOk(
1105 block, blockNumber, name, entryNumber, track.fHit[i],
1106 minCh, maxCh, i+6, ddl
1107 );
1108 if (not hitOk) result = false;
1109 }
1110
1111 return result;
1112}
1113
1114
a8982f78 1115bool AliHLTMUONDataCheckerComponent::IsTrackOk(
1116 const AliHLTComponentBlockData& block,
1117 AliHLTUInt32_t blockNumber,
1118 const char* name,
1119 AliHLTUInt32_t entryNumber,
1120 const AliHLTMUONTrackStruct& track,
1121 bool ddl[22]
1122 ) const
1123{
1124 /// Checks if the full track structure is Ok.
1125 /// \param block The block from which the track data comes from.
1126 /// \param blockNumber The block index number.
1127 /// \param name The name of the type of block.
1128 /// \param entryNumber The entry index number of the structure in the
1129 /// block being checked.
1130 /// \param track The track data being checked.
1131 /// \param ddl The array decoded by AliHLTMUONUtils::UnpackSpecBits.
1132 /// \returns true if the full track structure is valid and false otherwise.
1133
1134 bool result = true;
1135
1136 // Chi^2 should not be greater than the worst fit possible, estimated
1137 // as the diameter of largest chamber times the number of points
1138 // findable in a track. Max points is 10 tracker chambers times
1139 // 2 cathodes + 4 trigger chambers.
1140 if (track.fChi2 > AliMUONConstants::Dmax(6)*AliMUONConstants::Dmax(6)*(10*2+4))
1141 {
1142 // Just a warning since this is not technically an
1143 // integrity problem.
1144 HLTWarning("Problem found with data block %d, fDataType = '%s',"
1145 " fPtr = %p and fSize = %u bytes."
1146 " Assuming this is a %s data block."
1147 " Problem with entry %d in block: The track has"
1148 " the chi squared value of %f that is unreasonably big.",
1149 blockNumber,
1150 DataType2Text(block.fDataType).c_str(),
1151 block.fPtr,
1152 block.fSize,
1153 name,
1154 entryNumber,
1155 track.fChi2
1156 );
1157 result = false;
1158 }
1159
1160 // Check if the momentum vector is reasonable.
1161 bool momOk = IsMomentumVectorOk(
1162 block, blockNumber, name, entryNumber,
1163 track.fPx, track.fPy, track.fPz
1164 );
1165 if (not momOk) result = false;
1166
1167 // Check that the momentum parameters correspond to the momentum vector.
1168 double momvalue = sqrt(track.fPy*track.fPy + track.fPz*track.fPz);
1169 double invMom = (momvalue != 0 ? 1. / momvalue : 0);
1170 if (TMath::Abs(invMom - TMath::Abs(track.fInverseBendingMomentum)) > 1e-12)
1171 {
1172 HLTError("Problem found with data block %d, fDataType = '%s',"
1173 " fPtr = %p and fSize = %u bytes."
1174 " Assuming this is a %s data block."
1175 " Problem with entry %d in block: The track's inverse bending"
1176 " momentum %f does not correspond to the momentum vector.",
1177 blockNumber,
1178 DataType2Text(block.fDataType).c_str(),
1179 block.fPtr,
1180 block.fSize,
1181 name,
1182 entryNumber,
1183 track.fInverseBendingMomentum
1184 );
1185 result = false;
1186 }
1187 if (track.fPz != 0 and TMath::Abs(track.fPx/track.fPz - track.fThetaX) > 1e-12)
1188 {
1189 HLTError("Problem found with data block %d, fDataType = '%s',"
1190 " fPtr = %p and fSize = %u bytes."
1191 " Assuming this is a %s data block."
1192 " Problem with entry %d in block: The track's non-bending plane"
1193 " slope parameter %f does not correspond to the momentum vector.",
1194 blockNumber,
1195 DataType2Text(block.fDataType).c_str(),
1196 block.fPtr,
1197 block.fSize,
1198 name,
1199 entryNumber,
1200 track.fThetaX
1201 );
1202 result = false;
1203 }
1204 if (track.fPz != 0 and TMath::Abs(track.fPy/track.fPz - track.fThetaY) > 1e-12)
1205 {
1206 HLTError("Problem found with data block %d, fDataType = '%s',"
1207 " fPtr = %p and fSize = %u bytes."
1208 " Assuming this is a %s data block."
1209 " Problem with entry %d in block: The track's bending plane"
1210 " slope parameter %f does not correspond to the momentum vector.",
1211 blockNumber,
1212 DataType2Text(block.fDataType).c_str(),
1213 block.fPtr,
1214 block.fSize,
1215 name,
1216 entryNumber,
1217 track.fThetaY
1218 );
1219 result = false;
1220 }
1221
1222 // Check that the DCA vertex is reasonable. i.e. the vertex is within
1223 // a 1 meter cube of the origin.
1224 if (TMath::Abs(track.fX) > 100 or TMath::Abs(track.fY) > 100 or TMath::Abs(track.fZ) > 100)
1225 {
1226 // Just a warning since this is not technically an integrity problem.
1227 HLTWarning("Problem found with data block %d, fDataType = '%s',"
1228 " fPtr = %p and fSize = %u bytes."
1229 " Assuming this is a %s data block."
1230 " Problem with entry %d in block: The track's distance of closest"
1231 " approach (DCA) vertex (x, y, z) = (%f, %f, %f) is not a reasonable value.",
1232 blockNumber,
1233 DataType2Text(block.fDataType).c_str(),
1234 block.fPtr,
1235 block.fSize,
1236 name,
1237 entryNumber,
1238 track.fX, track.fY, track.fZ
1239 );
1240 result = false;
1241 }
1242
1243 AliHLTMUONParticleSign sign;
1244 bool hitset[16];
1245 AliHLTMUONUtils::UnpackTrackFlags(track.fFlags, sign, hitset);
1246
1247 // Min and max allowed chamber numbers for hits:
1248 Int_t minCh = 0;
1249 Int_t maxCh = AliMUONConstants::NTrackingCh() - 1;
1250
1251 // Check that this hit coordinates are OK.
1252 for (AliHLTUInt32_t i = 0; i < 16; i++)
1253 {
1254 if (not hitset[i]) continue; // ignore hits that are not initialised.
1255 bool hitOk = IsHitCoordinateOk(
1256 block, blockNumber, name, entryNumber, track.fHit[i],
1257 minCh, maxCh, -1, ddl
1258 );
1259 if (not hitOk) result = false;
1260 }
1261
1262 return result;
1263}
1264
1265
a090ff22 1266bool AliHLTMUONDataCheckerComponent::CheckDetElemIds(
1267 const AliHLTComponentBlockData& infoBlock,
1268 AliHLTUInt32_t infoBlockNumber,
1269 AliHLTUInt32_t infoEntryNumber,
1270 const AliHLTMUONTrigRecInfoStruct& info,
1271 const AliHLTComponentBlockData& trBlock,
1272 AliHLTUInt32_t trBlockNumber,
1273 AliHLTUInt32_t trEntryNumber,
1274 const AliHLTMUONTriggerRecordStruct& tr
1275 ) const
1276{
1277 /// Checks if the detector element IDs are the same in the debug
1278 /// information structure and the trigger record structure.
1279 /// \param infoBlock The debug information block from which the 'info'
1280 /// data comes from.
1281 /// \param infoBlockNumber The debug information block index number.
1282 /// \param infoEntryNumber The entry index number of the 'info'
1283 /// structure in the debug information data block.
1284 /// \param info The debug information structure being checked.
1285 /// \param trBlock The trigger record block from which the 'tr' data
1286 /// comes from.
1287 /// \param trBlockNumber The trigger record block index number.
1288 /// \param trEntryNumber The entry index number of the 'tr' structure
1289 /// in the trigger record data block.
1290 /// \param tr The trigger record structure being checked.
1291 /// \returns true if the detector element IDs are the same and false
1292 /// otherwise.
1293
1294 bool result = true;
1295
1296 for (int i = 0; i < 4; i++)
1297 {
1298 AliHLTUInt8_t chamber = 0xFF;
1299 AliHLTUInt16_t detElemId = 0xFFFF;
1300 AliHLTMUONUtils::UnpackRecHitFlags(tr.fHit[i].fFlags, chamber, detElemId);
1301 if (info.fDetElemId[i] == detElemId) continue;
1302
1303 HLTError("Problem found with trigger record debug information %d"
1304 " in data block %d (fDataType = '%s', fPtr = %p, fSize"
1305 " = %u bytes) and trigger record %d in data block %d"
1306 " (fDataType = '%s', fPtr = %p, fSize = %u bytes):"
1307 " The detection element ID %d for chamber %d in the debug"
1308 " information, is not the same as %d"
1309 " found in the trigger record.",
1310 infoEntryNumber,
1311 infoBlockNumber,
1312 DataType2Text(infoBlock.fDataType).c_str(),
1313 infoBlock.fPtr,
1314 infoBlock.fSize,
1315 trEntryNumber,
1316 trBlockNumber,
1317 DataType2Text(trBlock.fDataType).c_str(),
1318 trBlock.fPtr,
1319 trBlock.fSize,
1320 info.fDetElemId[i],
1321 i+11,
1322 detElemId
1323 );
1324 result = false;
1325 }
1326
1327 return result;
1328}
1329
1330
1331bool AliHLTMUONDataCheckerComponent::CheckDetElemIds(
1332 const AliHLTComponentBlockData& clusterBlock,
1333 AliHLTUInt32_t clusterBlockNumber,
1334 AliHLTUInt32_t clusterEntryNumber,
1335 const AliHLTMUONClusterStruct& cluster,
1336 const AliHLTComponentBlockData& hitBlock,
1337 AliHLTUInt32_t hitBlockNumber,
1338 AliHLTUInt32_t hitEntryNumber,
1339 const AliHLTMUONRecHitStruct& hit
1340 ) const
1341{
1342 /// Checks if the detector element IDs are the same in the cluster
1343 /// structure and the reconstructed hit structure.
1344 /// \param clusterBlock The cluster block from which the 'cluster' data
1345 /// comes from.
1346 /// \param clusterBlockNumber The cluster block index number.
1347 /// \param clusterEntryNumber The entry index number of the 'cluster'
1348 /// structure in the cluster data block.
1349 /// \param cluster The cluster structure being checked.
1350 /// \param hitBlock The reconstructed hit block from which the 'hit'
1351 /// data comes from.
1352 /// \param hitBlockNumber The reconstructed hit block index number.
1353 /// \param hitEntryNumber The entry index number of the 'hit' structure
1354 /// in the reconstructed hit data block.
1355 /// \param hit The trigger record structure being checked.
1356 /// \returns true if the detector element IDs are the same and false
1357 /// otherwise.
1358
1359 bool result = true;
1360
1361 AliHLTUInt8_t chamber = 0xFF;
1362 AliHLTUInt16_t detElemId = 0xFFFF;
1363 AliHLTMUONUtils::UnpackRecHitFlags(hit.fFlags, chamber, detElemId);
1364 if (cluster.fDetElemId != detElemId)
1365 {
1366 HLTError("Problem found with cluster %d in data block %d"
1367 " (fDataType = '%s', fPtr = %p, fSize = %u bytes)"
1368 " and reconstructed hit %d in data block %d"
1369 " (fDataType = '%s', fPtr = %p, fSize = %u bytes):"
1370 " The detection element ID %d in the cluster, is not"
1371 " the same as %d found in the reconstructed hit.",
1372 clusterEntryNumber,
1373 clusterBlockNumber,
1374 DataType2Text(clusterBlock.fDataType).c_str(),
1375 clusterBlock.fPtr,
1376 clusterBlock.fSize,
1377 hitEntryNumber,
1378 hitBlockNumber,
1379 DataType2Text(hitBlock.fDataType).c_str(),
1380 hitBlock.fPtr,
1381 hitBlock.fSize,
1382 cluster.fDetElemId,
1383 detElemId
1384 );
1385 result = false;
1386 }
1387
1388 return result;
1389}
1390
1391
dba14d7d 1392namespace
1393{
1394 /**
1395 * Class for logging errors found in raw DDL data.
1396 */
1397 class AliHLTMUONDecoderHandler : public AliHLTLogging
1398 {
1399 public:
1400
1401 /// Default constructor
1402 AliHLTMUONDecoderHandler() :
1403 AliHLTLogging(),
1404 fBufferStart(NULL),
1405 fDescriptor(NULL),
1406 fBlockNumber(0)
1407 {
1408 }
1409
1410 /// Default destructor.
1411 virtual ~AliHLTMUONDecoderHandler() {}
1412
1413 /// Sets the DDL raw data block descriptor.
1414 void SetDescriptor(const AliHLTComponentBlockData* b) { fDescriptor = b; }
1415
1416 /// Sets the block number of the raw data block descriptor.
1417 void SetBlockNumber(AliHLTUInt32_t n) { fBlockNumber = n; }
1418
1419 /// Logs an error message describing the problem with the DDL raw data.
1420 template <typename ErrorCode, class DecoderHandler>
1421 void LogError(ErrorCode code, const void* location, DecoderHandler& handler);
1422
1423 protected:
1424 // Do not allow copying of this class.
1425 /// Not implemented
1426 AliHLTMUONDecoderHandler(const AliHLTMUONDecoderHandler& rhs); // copy constructor
1427 /// Not implemented
1428 AliHLTMUONDecoderHandler& operator = (const AliHLTMUONDecoderHandler& rhs); // assignment operator
1429
1430 const void* fBufferStart; ///< Pointer to the start of the current DDL payload buffer.
1431 const AliHLTComponentBlockData* fDescriptor; ///< Descriptor for the DDL raw data block corresponding to the buffer.
1432 AliHLTUInt32_t fBlockNumber; ///< The number / index of the block descriptor.
1433 };
1434
1435
1436 template <typename ErrorCode, class DecoderHandler>
1437 void AliHLTMUONDecoderHandler::LogError(ErrorCode code, const void* location, DecoderHandler& handler)
1438 {
1439 /// Logs a HLT error message describing the problem with the raw DDL data.
1440 /// \param code The error code describing the problem.
1441 /// \param location A pointer to the location in the raw data buffer
1442 /// where the problem was found.
1443 /// \param handler The decoder handler object.
1444
1445 long bytepos = long(location) - long(fBufferStart) + sizeof(AliRawDataHeader);
1446
1447 // create data type string.
1448 char dataType[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2];
1449 memset( dataType, 0, kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2 );
1450 strncat( dataType, fDescriptor->fDataType.fOrigin, kAliHLTComponentDataTypefOriginSize );
1451 strcat( dataType, ":" );
1452 strncat( dataType, fDescriptor->fDataType.fID, kAliHLTComponentDataTypefIDsize );
1453
1454 HLTError("Problem found with data block %d, fDataType = '%s',"
1455 " fPtr = %p and fSize = %u bytes."
1456 " Assuming this is a DDL raw data block."
1457 " Problem: %s (Error code: %d, at byte %d)",
1458 fBlockNumber,
1459 &dataType[0],
1460 fDescriptor->fPtr,
1461 fDescriptor->fSize,
1462 handler.ErrorCodeToMessage(code),
1463 code,
1464 bytepos
1465 );
1466 };
1467
1468
1469 /**
1470 * Class for logging decoding errors when checking tracker raw DDL data.
1471 * Used in the AliHLTMUONDataCheckerComponent::CheckRawDataBlock method.
1472 */
1473 class AliHLTMUONTrackerDecoderHandler :
1474 public AliMUONTrackerDDLDecoderEventHandler, public AliHLTMUONDecoderHandler
1475 {
1476 public:
1477 AliHLTMUONTrackerDecoderHandler() :
1478 AliMUONTrackerDDLDecoderEventHandler(),
1479 AliHLTMUONDecoderHandler(),
1480 fMaxDigits(0),
1481 fDigitCount(0),
1482 fDigits(NULL),
1483 fCurrentBusPatch(0),
1484 fDataProblems(false)
1485 {}
1486
1487 virtual ~AliHLTMUONTrackerDecoderHandler()
1488 {
1489 if (fDigits != NULL) delete [] fDigits;
1490 }
1491
1492 /// Structure to store raw data words found in the raw data.
1493 struct AliDigit
1494 {
1495 UInt_t fBusPatchId; ///< Bus patch ID for the data word.
1496 UInt_t fDataWord; ///< Raw data word found in the DDL payload.
1497 };
1498
1499 /// Returns the number of digits found.
1500 UInt_t DigitCount() const { return fDigitCount; }
1501
1502 /// Returns the array of digits found.
1503 const AliDigit* Digits() const { return fDigits; }
1504
1505 /// Returns true if there were problems with the data.
1506 bool DataProblems() const { return fDataProblems; }
1507
1508 // Methods inherited from AliMUONTrackerDDLDecoderEventHandler:
1509
1510 /// Called for each new buffer.
1511 void OnNewBuffer(const void* buffer, UInt_t bufferSize);
1512
a090ff22 1513 /// Called for each new DSP header.
1514 void OnNewDSP(const AliMUONDSPHeaderStruct* header, const void* /*data*/);
1515
dba14d7d 1516 /// Called for each new bus patch. Just marks the current bus patch ID.
1517 void OnNewBusPatch(const AliMUONBusPatchHeaderStruct* header, const void* /*data*/)
1518 {
1519 fCurrentBusPatch = header->fBusPatchId;
1520 }
1521
1522 /// Called for each new data word found.
1523 void OnData(UInt_t data, bool /*parityError*/);
1524
1525 /// Logs an error message if there was a decoding problem with the DDL payload.
1526 void OnError(ErrorCode code, const void* location)
1527 {
1528 fDataProblems = true;
1529 LogError(code, location, *this);
1530 }
1531
1532 private:
1533
1534 // Do not allow copying of this object.
1535 /// Not implemented.
1536 AliHLTMUONTrackerDecoderHandler(const AliHLTMUONTrackerDecoderHandler& obj);
1537 /// Not implemented.
1538 AliHLTMUONTrackerDecoderHandler& operator = (const AliHLTMUONTrackerDecoderHandler& obj);
1539
1540 UInt_t fMaxDigits; ///< Maximum number of digits that can be stored in fDigits.
1541 UInt_t fDigitCount; ///< The number of digits currently stored in fDigits.
1542 AliDigit* fDigits; ///< The array of digits found in the DDL data.
1543 UInt_t fCurrentBusPatch; ///< The current bus patch ID being processed.
1544 bool fDataProblems; ///< flag indicating there were problems with the data.
1545 };
1546
1547
1548 void AliHLTMUONTrackerDecoderHandler::OnNewBuffer(const void* buffer, UInt_t bufferSize)
1549 {
1550 /// Called for a new buffer. It will reset internal counters and
1551 /// resize the digits array if necessary.
1552
1553 fDataProblems = false;
1554 fDigitCount = 0;
1555 fBufferStart = buffer;
1556
1557 // Resize the fDigits array to be able to store
1558 // all the digits in the data buffer.
1559 UInt_t maxSize = bufferSize / sizeof(UInt_t) + 1;
1560 if (maxSize > fMaxDigits)
1561 {
1562 if (fDigits != NULL)
1563 {
1564 delete [] fDigits;
1565 fDigits = NULL;
1566 fMaxDigits = 0;
1567 }
1568 try
1569 {
1570 fDigits = new AliDigit[maxSize];
1571 fMaxDigits = maxSize;
1572 }
1573 catch (const std::bad_alloc&)
1574 {
1575 HLTError("Could not allocate enough buffer space for internal arrays.");
1576 return;
1577 }
1578 }
1579 }
1580
1581
a090ff22 1582 void AliHLTMUONTrackerDecoderHandler::OnNewDSP(
1583 const AliMUONDSPHeaderStruct* header, const void* /*data*/
1584 )
1585 {
1586 if (header->fPaddingWord != 0 and header->fPaddingWord != 1)
1587 {
1588 // create data type string.
1589 char dataType[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2];
1590 memset( dataType, 0, kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2 );
1591 strncat( dataType, fDescriptor->fDataType.fOrigin, kAliHLTComponentDataTypefOriginSize );
1592 strcat( dataType, ":" );
1593 strncat( dataType, fDescriptor->fDataType.fID, kAliHLTComponentDataTypefIDsize );
1594
1595 HLTError("Problem found with data block %d, fDataType = '%s',"
1596 " fPtr = %p and fSize = %u bytes."
1597 " Assuming this is a tracker DDL raw data block."
1598 " Problem: Found padding word marker 0x%8.8X in DSP"
1599 " header with DSP ID %d which has an invalid value.",
1600 fBlockNumber,
1601 &dataType[0],
1602 fDescriptor->fPtr,
1603 fDescriptor->fSize,
1604 header->fPaddingWord,
1605 header->fDSPId
1606 );
1607 fDataProblems = true;
1608 return;
1609 }
1610 }
1611
1612
dba14d7d 1613 void AliHLTMUONTrackerDecoderHandler::OnData(UInt_t data, bool /*parityError*/)
1614 {
1615 /// Called for each new data word found. This method will add
1616 /// these to the list of digits and check if they are not duplicated.
1617
1618 assert( fDigits != NULL );
1619
a090ff22 1620 if ((data & 0x60000000) != 0)
1621 {
1622 // create data type string.
1623 char dataType[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2];
1624 memset( dataType, 0, kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2 );
1625 strncat( dataType, fDescriptor->fDataType.fOrigin, kAliHLTComponentDataTypefOriginSize );
1626 strcat( dataType, ":" );
1627 strncat( dataType, fDescriptor->fDataType.fID, kAliHLTComponentDataTypefIDsize );
1628
1629 HLTError("Problem found with data block %d, fDataType = '%s',"
1630 " fPtr = %p and fSize = %u bytes."
1631 " Assuming this is a tracker DDL raw data block."
1632 " Problem: Found a data word 0x%8.8X for bus patch %d"
1633 " whose bits 29 or 30 are not zero.",
1634 fBlockNumber,
1635 &dataType[0],
1636 fDescriptor->fPtr,
1637 fDescriptor->fSize,
1638 data,
1639 fCurrentBusPatch
1640 );
1641 fDataProblems = true;
1642 return;
1643 }
1644
dba14d7d 1645 // Check if the data word + bus patch have been duplicated.
1646 for (UInt_t i = 0; i < fDigitCount; i++)
1647 {
1648 if (fDigits[i].fDataWord == data and fDigits[i].fBusPatchId == fCurrentBusPatch)
1649 {
1650 // create data type string.
1651 char dataType[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2];
1652 memset( dataType, 0, kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2 );
1653 strncat( dataType, fDescriptor->fDataType.fOrigin, kAliHLTComponentDataTypefOriginSize );
1654 strcat( dataType, ":" );
1655 strncat( dataType, fDescriptor->fDataType.fID, kAliHLTComponentDataTypefIDsize );
1656
1657 HLTError("Problem found with data block %d, fDataType = '%s',"
1658 " fPtr = %p and fSize = %u bytes."
1659 " Assuming this is a tracker DDL raw data block."
1660 " Problem: Found a duplicate data word 0x%8.8X for bus patch %d.",
1661 fBlockNumber,
1662 &dataType[0],
1663 fDescriptor->fPtr,
1664 fDescriptor->fSize,
1665 data,
1666 fCurrentBusPatch
1667 );
1668 fDataProblems = true;
1669 return;
1670 }
1671 }
1672
1673 // Add the data word + bus patch to the list of decoded digits.
1674 if (fDigitCount < fMaxDigits)
1675 {
1676 fDigits[fDigitCount].fBusPatchId = fCurrentBusPatch;
1677 fDigits[fDigitCount].fDataWord = data;
1678 fDigitCount++;
1679 }
1680 }
1681
1682 /**
1683 * Class for logging decoding errors when checking trigger raw DDL data.
1684 * Used in the AliHLTMUONDataCheckerComponent::CheckRawDataBlock method.
1685 */
1686 class AliHLTMUONTriggerDecoderHandler :
1687 public AliMUONTriggerDDLDecoderEventHandler, public AliHLTMUONDecoderHandler
1688 {
1689 public:
1690 // Methods inherited from AliMUONTriggerDDLDecoderEventHandler:
1691
1692 /// Called for each new buffer.
1693 void OnNewBuffer(const void* buffer, UInt_t /*bufferSize*/)
1694 {
1695 fBufferStart = buffer;
1696 }
1697
1698 /// Logs an error message if there was a decoding problem with the DDL payload.
1699 void OnError(ErrorCode code, const void* location)
1700 {
1701 LogError(code, location, *this);
1702 }
1703 };
1704
1705} // end of namespace
1706
1707
1708bool AliHLTMUONDataCheckerComponent::CheckRawDataBlock(
1709 const AliHLTComponentBlockData& block,
1710 AliHLTUInt32_t blockNumber
1711 ) const
1712{
1713 /// Checks the validity of a raw data block.
1714
1715 bool result = true;
1716
1717 if (fIgnoreSpec)
1718 {
1719 HLTWarning("Not able to check DDL raw data if -ignorespec is specified.");
1720 return false;
1721 }
1722
1723 bool ddl[22];
1724 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
1725
1726 // Check that only one DDL was marked in the specification.
1727 int ddlIndex = -1;
1728 for (int i = 0; i < 22; i++)
1729 {
1730 if (not ddl[i]) continue;
1731
1732 if (ddlIndex == -1)
1733 {
1734 ddlIndex = i;
1735 continue;
1736 }
1737
1738 HLTError("Problem found with data block %d, fDataType = '%s',"
1739 " fPtr = %p and fSize = %u bytes."
1740 " Assuming this is a DDL raw data block."
1741 " Problem: The specification indicates multiple"
1742 " DDL sources, DDL %d and %d.",
1743 blockNumber,
1744 DataType2Text(block.fDataType).c_str(),
1745 block.fPtr,
1746 block.fSize,
1747 ddlIndex,
1748 i
1749 );
1750 result = false;
1751 }
1752
1753 // Check the DDL common data header.
1754 AliHLTUInt32_t totalDDLSize = block.fSize;
1755 if (totalDDLSize < sizeof(AliRawDataHeader))
1756 {
1757 HLTError("Problem found with data block %d, fDataType = '%s',"
1758 " fPtr = %p and fSize = %u bytes."
1759 " Assuming this is a DDL raw data block."
1760 " Problem: The size of the data block is too short to contain"
1761 " a valid common DDL data header. Size of buffer is only %d"
1762 " bytes, but expected at least %d bytes.",
1763 blockNumber,
1764 DataType2Text(block.fDataType).c_str(),
1765 block.fPtr,
1766 block.fSize,
1767 totalDDLSize,
1768 sizeof(AliRawDataHeader)
1769 );
1770 return false;
1771 }
1772
1773 const AliRawDataHeader* header =
1774 reinterpret_cast<const AliRawDataHeader*>(block.fPtr);
1775
887a669c 1776 if (header->GetVersion() != 2)
1777 {
1778 HLTError("Problem found with data block %d, fDataType = '%s',"
1779 " fPtr = %p and fSize = %u bytes."
1780 " Assuming this is a DDL raw data block."
1781 " Problem: The common DDL data header indicates an"
1782 " incorrect version number. Expected 2 but got %d.",
1783 blockNumber,
1784 DataType2Text(block.fDataType).c_str(),
1785 block.fPtr,
1786 block.fSize,
1787 int( header->GetVersion() )
1788 );
1789 result = false;
1790 }
1791
1792 if (header->fSize != 0xFFFFFFFF and header->fSize != block.fSize)
1793 {
1794 HLTError("Problem found with data block %d, fDataType = '%s',"
1795 " fPtr = %p and fSize = %u bytes."
1796 " Assuming this is a DDL raw data block."
1797 " Problem: The common DDL data header indicates an"
1798 " incorrect DDL buffer size. Expected %d bytes but"
1799 " size reported in header is %d bytes.",
1800 blockNumber,
1801 DataType2Text(block.fDataType).c_str(),
1802 block.fPtr,
1803 block.fSize,
1804 block.fSize,
1805 header->fSize
1806 );
1807 result = false;
1808 }
1809
1810 if (header->fSize != 0xFFFFFFFF and header->fSize != block.fSize)
1811 {
1812 HLTError("Problem found with data block %d, fDataType = '%s',"
1813 " fPtr = %p and fSize = %u bytes."
1814 " Assuming this is a DDL raw data block."
1815 " Problem: The common DDL data header indicates an"
1816 " incorrect DDL buffer size. Expected %d bytes but"
1817 " size reported in header is %d bytes.",
1818 blockNumber,
1819 DataType2Text(block.fDataType).c_str(),
1820 block.fPtr,
1821 block.fSize,
1822 block.fSize,
1823 header->fSize
1824 );
1825 result = false;
1826 }
1827
1828 // Check that the bits that should be zero in the CDH are infact zero.
1829 if ((header->fWord2 & 0x00C03000) != 0 or
1830 (header->fEventID2 & 0xFF000000) != 0 or
1831 (header->fStatusMiniEventID & 0xF0000000) != 0 or
1832 (header->fROILowTriggerClassHigh & 0x0FFC0000) != 0
1833 )
1834 {
1835 HLTError("Problem found with data block %d, fDataType = '%s',"
1836 " fPtr = %p and fSize = %u bytes."
1837 " Assuming this is a DDL raw data block."
1838 " Problem: The common DDL data header has non-zero"
1839 " bits that are reserved and must be set to zero.",
1840 blockNumber,
1841 DataType2Text(block.fDataType).c_str(),
1842 block.fPtr,
1843 block.fSize
1844 );
1845 result = false;
1846 }
1847
dba14d7d 1848 AliHLTUInt32_t payloadSize = block.fSize - sizeof(AliRawDataHeader);
1849 const AliHLTUInt8_t* payload =
1850 reinterpret_cast<const AliHLTUInt8_t*>(header + 1);
1851
1852 if (AliHLTMUONUtils::IsTriggerDDL(block.fSpecification))
1853 {
a090ff22 1854 bool scalarEvent = ((header->GetL1TriggerMessage() & 0x1) == 0x1);
dba14d7d 1855 AliMUONTriggerDDLDecoder<AliHLTMUONTriggerDecoderHandler> decoder;
1856 decoder.ExitOnError(false);
1857 decoder.TryRecover(false);
1858 decoder.AutoDetectScalars(false);
1859 decoder.GetHandler().SetDescriptor(&block);
1860 decoder.GetHandler().SetBlockNumber(blockNumber);
1861 result = decoder.Decode(payload, payloadSize, scalarEvent);
1862 }
1863 else if (AliHLTMUONUtils::IsTrackerDDL(block.fSpecification))
1864 {
1865 AliMUONTrackerDDLDecoder<AliHLTMUONTrackerDecoderHandler> decoder;
1866 decoder.ExitOnError(false);
1867 decoder.TryRecover(false);
1868 decoder.SendDataOnParityError(true);
1869 decoder.AutoDetectTrailer(true);
1870 decoder.CheckForTrailer(true);
1871 decoder.GetHandler().SetDescriptor(&block);
1872 decoder.GetHandler().SetBlockNumber(blockNumber);
1873 result = decoder.Decode(payload, payloadSize);
1874 if (decoder.GetHandler().DataProblems()) result = false;
1875
1876 if (FetchMappingStores() == 0) // are stores loaded?
1877 {
1878 Bool_t warn = kFALSE;
1879 AliMpDDLStore* ddlStore = AliMpDDLStore::Instance(warn);
1880
1881 // Check that the bus patch, manu ID and channel addresses are valid
1882 // for each raw data word.
1883 for (UInt_t i = 0; i < decoder.GetHandler().DigitCount(); i++)
1884 {
1885 UInt_t busPatchId = decoder.GetHandler().Digits()[i].fBusPatchId;
1886 UInt_t dataWord = decoder.GetHandler().Digits()[i].fDataWord;
1887
1888 UShort_t manuId; UChar_t channelId; UShort_t adc;
1889 AliMUONTrackerDDLDecoderEventHandler::UnpackADC(
1890 dataWord, manuId, channelId, adc
1891 );
1892
1893 // Check if the bus patch is valid.
1894 AliMpBusPatch* busPatch = ddlStore->GetBusPatch(busPatchId, warn);
1895 if (busPatch == NULL)
1896 {
1897 HLTError("Problem found with data block %d, fDataType = '%s',"
1898 " fPtr = %p and fSize = %u bytes."
1899 " Assuming this is a tracker DDL raw data block."
1900 " Problem: Found a bus patch identifier %d that"
1901 " is not valid.",
1902 blockNumber,
1903 DataType2Text(block.fDataType).c_str(),
1904 block.fPtr,
1905 block.fSize,
1906 busPatchId
1907 );
1908 result = false;
1909 continue;
1910 }
1911
1912 // We can check that the bus patch is for the DDL
1913 // which is also indicated by the specification bits.
1914 if (not fIgnoreSpec and busPatch->GetDdlId() != ddlIndex)
1915 {
1916 HLTError("Problem found with data block %d, fDataType = '%s',"
1917 " fPtr = %p and fSize = %u bytes."
1918 " Assuming this is a tracker DDL raw data block."
1919 " Problem: Found a bus patch identifier %d for"
1920 " DDL %d, but the data block specification 0x%8.8X"
1921 " indicates a different DDL of %d.",
1922 blockNumber,
1923 DataType2Text(block.fDataType).c_str(),
1924 block.fPtr,
1925 block.fSize,
1926 busPatchId,
1927 busPatch->GetDdlId(),
1928 block.fSpecification,
1929 ddlIndex
1930 );
1931 result = false;
1932 continue;
1933 }
1934
1935 // Check if the MANU ID is valid.
1936 if (not busPatch->HasManu(manuId))
1937 {
1938 HLTError("Problem found with data block %d, fDataType = '%s',"
1939 " fPtr = %p and fSize = %u bytes."
1940 " Assuming this is a tracker DDL raw data block."
1941 " Problem: Found a MANU identifier %d on bus patch %d"
1942 " that is not valid.",
1943 blockNumber,
1944 DataType2Text(block.fDataType).c_str(),
1945 block.fPtr,
1946 block.fSize,
1947 manuId,
1948 busPatchId
1949 );
1950 result = false;
1951 continue;
1952 }
1953
1954 // Now try to fetch the detector element to check the MANU channel.
1955 AliMpDetElement* de = ddlStore->GetDetElement(busPatch->GetDEId(), warn);
1956 if (de == NULL)
1957 {
1958 HLTError("Problem found with data block %d, fDataType = '%s',"
1959 " fPtr = %p and fSize = %u bytes."
1960 " Assuming this is a tracker DDL raw data block."
1961 " Problem: Found a bus patch identifier %d that"
1962 " does not correspond to a detector element.",
1963 blockNumber,
1964 DataType2Text(block.fDataType).c_str(),
1965 block.fPtr,
1966 block.fSize,
1967 busPatchId
1968 );
1969 result = false;
1970 continue;
1971 }
1972
1973 if (not de->IsConnectedChannel(manuId, channelId))
1974 {
1975 // Just a warning because this is marked not
1976 // to be an error in the AliMUONDigitMaker.
1977 HLTWarning("Problem found with data block %d, fDataType = '%s',"
1978 " fPtr = %p and fSize = %u bytes."
1979 " Assuming this is a tracker DDL raw data block."
1980 " Problem: Found a channel with address %d on"
1981 " MANU ID %d and bus patch %d that is not connected.",
1982 blockNumber,
1983 DataType2Text(block.fDataType).c_str(),
1984 block.fPtr,
1985 block.fSize,
1986 channelId,
1987 manuId,
1988 busPatchId
1989 );
1990 result = false;
1991 continue;
1992 }
1993
1994 // Need to also load the correct segmentation to check the channel.
1995 const AliMpVSegmentation* seg =
1996 AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(
1997 busPatch->GetDEId(), manuId
1998 );
1999 if (seg == NULL)
2000 {
2001 HLTError("Could not load segmentation for detector element %d"
2002 " and MANU ID %d.",
2003 busPatch->GetDEId(), manuId
2004 );
2005 result = false;
2006 continue;
2007 }
2008
53eb3786 2009#ifndef HAVE_NOT_MUON_ALIMPPAD_GETPOSITION
168e9c4d 2010 AliMpPad pad = seg->PadByLocation(manuId, channelId, warn);
53eb3786 2011#else // old AliMpPad functionality < r 31742
2012 AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId, channelId), warn);
2013#endif //HAVE_NOT_MUON_ALIMPPAD_GETPOSITION
dba14d7d 2014 if (not pad.IsValid())
2015 {
2016 HLTError("Problem found with data block %d, fDataType = '%s',"
2017 " fPtr = %p and fSize = %u bytes."
2018 " Assuming this is a tracker DDL raw data block."
2019 " Problem: Found a channel with address %d on"
2020 " MANU ID %d and bus patch %d that is not valid.",
2021 blockNumber,
2022 DataType2Text(block.fDataType).c_str(),
2023 block.fPtr,
2024 block.fSize,
2025 channelId,
2026 manuId,
2027 busPatchId
2028 );
2029 result = false;
2030 continue;
2031 }
2032 }
2033 }
2034 else
2035 {
2036 HLTWarning("Cannot check if the bus patch IDs, MANU ID and"
2037 " channel addresses for DDL raw data are valid without"
2038 " being able to load the mapping from CDB."
2039 );
2040 result = false;
2041 }
2042 }
2043 else
2044 {
2045 HLTError("Problem found with data block %d, fDataType = '%s',"
2046 " fPtr = %p and fSize = %u bytes."
2047 " Assuming this is a DDL raw data block."
2048 " Problem: The specification does not contain a valid pattern,"
2049 " received 0x%8.8X for the specification.",
2050 blockNumber,
2051 DataType2Text(block.fDataType).c_str(),
2052 block.fPtr,
2053 block.fSize,
2054 block.fSpecification
2055 );
2056 result = false;
2057 }
2058
2059 return result;
2060}
2061
2062
2063bool AliHLTMUONDataCheckerComponent::CheckTriggerRecordsBlock(
2064 const AliHLTComponentBlockData& block,
2065 AliHLTUInt32_t blockNumber
2066 ) const
2067{
2068 /// Checks the validity of a trigger records block.
2069
2070 bool result = true;
2071 const char* name = "trigger records";
2072
2073 if (not fIgnoreSpec)
2074 {
2075 if (not IsFromTriggerOnly(block, blockNumber, name))
2076 result = false;
2077 }
2078
2079 AliHLTMUONTriggerRecordsBlockReader inblock(block.fPtr, block.fSize);
2080 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
2081 return false;
2082
2083 bool ddl[22];
2084 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
2085
2086 // Min and max allowed chamber numbers for hits:
2087 Int_t minCh = AliMUONConstants::NCh() - AliMUONConstants::NTriggerCh();
2088 Int_t maxCh = AliMUONConstants::NCh() - 1;
2089
2090 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2091 {
2092 // Check that each hit in each trigger record has a reasonable coordinate.
2093 AliHLTMUONParticleSign sign;
2094 bool hitset[4];
2095 AliHLTMUONUtils::UnpackTriggerRecordFlags(inblock[i].fFlags, sign, hitset);
2096
2097 for (Int_t j = 0; j < 4; j++) // loop over 4 trigger chamber hits.
2098 {
2099 if (not hitset[i]) continue; // ignore hits that are not initialised.
2100 bool hitOk = IsHitCoordinateOk(
2101 block, blockNumber, name, i, inblock[i].fHit[j],
2102 minCh, maxCh, j+10, ddl
2103 );
2104 if (not hitOk) result = false;
2105 }
2106
2107 // We can also check the momentum vector.
2108 bool momOk = IsMomentumVectorOk(
2109 block, blockNumber, name, i,
2110 inblock[i].fPx, inblock[i].fPy, inblock[i].fPz
2111 );
2112 if (not momOk) result = false;
2113 }
2114
2115 // Need to check that no entries have duplicated data but with a different
2116 // ID number.
2117 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2118 {
2119 AliHLTMUONTriggerRecordStruct ti = inblock[i];
2120 ti.fId = -1;
2121 for (AliHLTUInt32_t j = i+1; j < inblock.Nentries(); j++)
2122 {
2123 AliHLTMUONTriggerRecordStruct tj = inblock[j];
2124 tj.fId = ti.fId;
2125
2126 if (ti == tj)
2127 {
2128 HLTError("Problem found with data block %d, fDataType = '%s',"
2129 " fPtr = %p and fSize = %u bytes."
2130 " Assuming this is a %s data block."
2131 " Problem: The trigger records %d and %d contain the"
2132 " same data. The data might have been duplicated.",
2133 blockNumber,
2134 DataType2Text(block.fDataType).c_str(),
2135 block.fPtr,
2136 block.fSize,
2137 name,
2138 i, j
2139 );
2140 result = false;
2141 }
2142 }
2143 }
2144
2145 return result;
2146}
2147
2148
2149bool AliHLTMUONDataCheckerComponent::CheckTrigRecsDebugBlock(
2150 const AliHLTComponentBlockData& block,
2151 AliHLTUInt32_t blockNumber
2152 ) const
2153{
2154 /// Checks the validity of a trigger records debug block.
2155
2156 bool result = true;
2157 const char* name = "trigger records debug information";
2158
2159 if (not fIgnoreSpec)
2160 {
2161 if (not IsFromTriggerOnly(block, blockNumber, name))
2162 result = false;
2163 }
2164
2165 AliHLTMUONTrigRecsDebugBlockReader inblock(block.fPtr, block.fSize);
2166 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
2167 return false;
2168
2169 bool ddl[22];
2170 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
2171
2172 // Check that each detector element ID is valid and the corresponding DDL
2173 // bit is set in the data block specification.
2174 if (FetchMappingStores() == 0) // are stores loaded?
2175 {
2176 Bool_t warn = kFALSE;
2177 AliMpDEStore* store = AliMpDEStore::Instance(warn);
2178 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2179 for (AliHLTUInt32_t j = 0; j < 4; j++)
2180 {
2181 const AliHLTMUONTrigRecInfoStruct& trig = inblock[i];
2182 AliMpDetElement* de = store->GetDetElement(trig.fDetElemId[j], warn);
2183 if (de == NULL)
2184 {
2185 HLTError("Problem found with data block %d, fDataType = '%s',"
2186 " fPtr = %p and fSize = %u bytes."
2187 " Assuming this is a %s data block."
2188 " Problem: The detector element number %d on chamber"
2189 " %d for trigger record debug structure %d is not valid.",
2190 blockNumber,
2191 DataType2Text(block.fDataType).c_str(),
2192 block.fPtr,
2193 block.fSize,
2194 name,
2195 trig.fDetElemId[j],
2196 j+11,
2197 i
2198 );
2199 result = false;
2200 continue;
2201 }
2202
2203 // Check that the chamber number from the detector element number
2204 // has the expected value.
2205 Int_t chamber = AliMpDEManager::GetChamberId(trig.fDetElemId[j], warn);
2206 if (chamber != Int_t(j+10))
2207 {
2208 HLTError("Problem found with data block %d, fDataType = '%s',"
2209 " fPtr = %p and fSize = %u bytes."
2210 " Assuming this is a %s data block."
2211 " Problem: The detector element number %d for trigger"
2212 " record debug structure %d, corresponds to chamber"
2213 " %d, but we expected a hit for chamber %d.",
2214 blockNumber,
2215 DataType2Text(block.fDataType).c_str(),
2216 block.fPtr,
2217 block.fSize,
2218 name,
2219 trig.fDetElemId[j],
2220 i,
2221 chamber+1,
2222 j+11
2223 );
2224 result = false;
2225 }
2226
2227 if (fIgnoreSpec) continue;
83d66053 2228 if (0 <= de->GetDdlId() and de->GetDdlId() < 22 and not ddl[de->GetDdlId()])
dba14d7d 2229 {
2230 HLTError("Problem found with data block %d, fDataType = '%s',"
2231 " fPtr = %p and fSize = %u bytes."
2232 " Assuming this is a %s data block."
2233 " Problem: The detector element number %d for trigger"
2234 " record %d corresponds to DDL number %d, but the"
2235 " data block specification 0x%8.8X does not have the"
2236 " corresponding bit set.",
2237 blockNumber,
2238 DataType2Text(block.fDataType).c_str(),
2239 block.fPtr,
2240 block.fSize,
2241 name,
2242 trig.fDetElemId[j],
2243 i,
2244 de->GetDdlId(),
2245 block.fSpecification
2246 );
2247 result = false;
2248 }
2249 }
2250 }
2251 else
2252 {
2253 HLTWarning("Cannot check trigger record debug information without"
2254 " being able to load the mapping from CDB."
2255 );
2256 result = false;
2257 }
2258
2259 // Need to check that no entries have duplicated data but with a different
2260 // ID number.
2261 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2262 {
2263 AliHLTMUONTrigRecInfoStruct ti = inblock[i];
2264 ti.fTrigRecId = -1;
2265 for (AliHLTUInt32_t j = i+1; j < inblock.Nentries(); j++)
2266 {
2267 AliHLTMUONTrigRecInfoStruct tj = inblock[j];
2268 tj.fTrigRecId = ti.fTrigRecId;
2269
2270 if (ti == tj)
2271 {
2272 HLTError("Problem found with data block %d, fDataType = '%s',"
2273 " fPtr = %p and fSize = %u bytes."
2274 " Assuming this is a %s data block."
2275 " Problem: The trigger record debug information"
2276 " structures %d and %d contain the same data."
2277 " The data might have been duplicated.",
2278 blockNumber,
2279 DataType2Text(block.fDataType).c_str(),
2280 block.fPtr,
2281 block.fSize,
2282 name,
2283 i, j
2284 );
2285 result = false;
2286 }
2287 }
2288
2289 // Can also check that the value of the fZmiddle and fBl.
2290 bool paramsOk = AreMomentumCalcParamsOk(
2291 block, blockNumber, name, i, ti.fZmiddle, ti.fBl
2292 );
2293 if (not paramsOk) result = false;
2294 }
2295
2296 return result;
2297}
2298
2299
2300bool AliHLTMUONDataCheckerComponent::CheckRecHitsBlock(
2301 const AliHLTComponentBlockData& block,
2302 AliHLTUInt32_t blockNumber
2303 ) const
2304{
2305 /// Checks the validity of a reconstructed hits block.
2306
2307 bool result = true;
2308 const char* name = "reconstructed hits";
2309
2310 if (not fIgnoreSpec)
2311 {
2312 if (not IsFromTrackerOnly(block, blockNumber, name))
2313 result = false;
2314 }
2315
2316 AliHLTMUONRecHitsBlockReader inblock(block.fPtr, block.fSize);
a090ff22 2317 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
dba14d7d 2318 return false;
2319
2320 bool ddl[22];
2321 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
2322
2323 // Check that each hit has a reasonable coordinate.
2324 Int_t minCh = 0;
2325 Int_t maxCh = AliMUONConstants::NTrackingCh() - 1;
2326 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2327 {
2328 bool hitOk = IsHitCoordinateOk(
2329 block, blockNumber, name, i, inblock[i],
2330 minCh, maxCh, -1, ddl
2331 );
2332 if (not hitOk) result = false;
2333 }
2334
2335 return result;
2336}
2337
2338
2339bool AliHLTMUONDataCheckerComponent::CheckClustersBlock(
2340 const AliHLTComponentBlockData& block,
2341 AliHLTUInt32_t blockNumber
2342 ) const
2343{
2344 /// Checks the validity of a clusters block.
2345
2346 bool result = true;
2347 const char* name = "clusters";
2348
2349 if (not fIgnoreSpec)
2350 {
2351 if (not IsFromTrackerOnly(block, blockNumber, name))
2352 result = false;
2353 }
2354
2355 AliHLTMUONClustersBlockReader inblock(block.fPtr, block.fSize);
2356 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
2357 return false;
2358
2359 bool ddl[22];
2360 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
2361
2362 if (FetchMappingStores() == 0) // are stores loaded?
2363 {
2364 Bool_t warn = kFALSE;
2365 AliMpDEStore* store = AliMpDEStore::Instance(warn);
2366 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2367 {
2368 const AliHLTMUONClusterStruct& cluster = inblock[i];
2369
2370 // Check that the detector element ID is valid.
2371 AliMpDetElement* de = store->GetDetElement(cluster.fDetElemId, warn);
2372 if (de == NULL)
2373 {
2374 HLTError("Problem found with data block %d, fDataType = '%s',"
2375 " fPtr = %p and fSize = %u bytes."
2376 " Assuming this is a %s data block."
2377 " Problem: The detector element number %d for cluster"
2378 " %d is not valid.",
2379 blockNumber,
2380 DataType2Text(block.fDataType).c_str(),
2381 block.fPtr,
2382 block.fSize,
2383 name,
2384 cluster.fDetElemId,
2385 i
2386 );
2387 result = false;
2388 continue;
2389 }
2390
2391 // Check that the chamber number found from the hit coordinate and
2392 // that from the detector element number are the same.
2393 Int_t chamberFromHit = AliMUONConstants::ChamberNumber(cluster.fHit.fZ, warn);
2394 Int_t chamberFromDE = AliMpDEManager::GetChamberId(cluster.fDetElemId, warn);
2395 if (chamberFromHit != chamberFromDE)
2396 {
2397 HLTError("Problem found with data block %d, fDataType = '%s',"
2398 " fPtr = %p and fSize = %u bytes."
2399 " Assuming this is a %s data block."
2400 " Problem: The detector element number %d for"
2401 " cluster %d, corresponds to chamber %d, but"
2402 " found a different chamber number %d for the"
2403 " corresponding hit coordinate {x = %f, y = %f,"
2404 " z = %f}.",
2405 blockNumber,
2406 DataType2Text(block.fDataType).c_str(),
2407 block.fPtr,
2408 block.fSize,
2409 name,
2410 cluster.fDetElemId,
2411 i,
2412 chamberFromDE+1,
2413 chamberFromHit+1,
2414 cluster.fHit.fX,
2415 cluster.fHit.fY,
2416 cluster.fHit.fZ
2417 );
2418 result = false;
2419 }
2420
2421 // Make sure the corresponding DDL bit is set in the data
2422 // block specification.
2423 if (fIgnoreSpec) continue;
83d66053 2424 if (0 <= de->GetDdlId() and de->GetDdlId() < 22 and not ddl[de->GetDdlId()])
dba14d7d 2425 {
2426 HLTError("Problem found with data block %d, fDataType = '%s',"
2427 " fPtr = %p and fSize = %u bytes."
2428 " Assuming this is a %s data block."
2429 " Problem: The detector element number %d for cluster"
2430 " %d corresponds to DDL number %d, but the data"
2431 " block specification 0x%8.8X does not have the"
2432 " corresponding bit set.",
2433 blockNumber,
2434 DataType2Text(block.fDataType).c_str(),
2435 block.fPtr,
2436 block.fSize,
2437 name,
2438 cluster.fDetElemId,
2439 i,
2440 de->GetDdlId(),
2441 block.fSpecification
2442 );
2443 result = false;
2444 }
83d66053 2445
2446 // Check that the total cluster charge is a reasonable value.
66622a82 2447 if ((cluster.fChargeB + cluster.fChargeNB)< 0 and 1e4 < (cluster.fChargeB + cluster.fChargeNB))
83d66053 2448 {
2449 HLTError("Problem found with data block %d, fDataType = '%s',"
2450 " fPtr = %p and fSize = %u bytes."
2451 " Assuming this is a %s data block."
2452 " Problem: The total charge %f for the cluster"
2453 " %d is not in a reasonable range [0..1e4].",
2454 blockNumber,
2455 DataType2Text(block.fDataType).c_str(),
2456 block.fPtr,
2457 block.fSize,
2458 name,
66622a82 2459 (cluster.fChargeB + cluster.fChargeNB),
83d66053 2460 i
2461 );
2462 result = false;
2463 continue;
2464 }
dba14d7d 2465 }
2466 }
2467 else
2468 {
2469 HLTWarning("Cannot check cluster information without being able"
2470 " to load the mapping from CDB."
2471 );
2472 result = false;
2473 }
2474
2475 // Min and max chamber numbers allowed for the cluster hits.
2476 Int_t minCh = 0;
2477 Int_t maxCh = AliMUONConstants::NTrackingCh() - 1;
2478
2479 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2480 {
2481 // Need to check that no cluster data has duplicated data but with
2482 // a different ID number.
2483 AliHLTMUONClusterStruct ci = inblock[i];
2484 ci.fId = -1;
2485 for (AliHLTUInt32_t j = i+1; j < inblock.Nentries(); j++)
2486 {
2487 AliHLTMUONClusterStruct cj = inblock[j];
2488 cj.fId = ci.fId;
2489
2490 if (ci == cj)
2491 {
2492 HLTError("Problem found with data block %d, fDataType = '%s',"
2493 " fPtr = %p and fSize = %u bytes."
2494 " Assuming this is a %s data block."
2495 " Problem: The cluster structures %d and %d contain"
2496 " the same data. The data might have been duplicated.",
2497 blockNumber,
2498 DataType2Text(block.fDataType).c_str(),
2499 block.fPtr,
2500 block.fSize,
2501 name,
2502 i, j
2503 );
2504 result = false;
2505 }
2506 }
2507
2508 // Check that the hit structure in the cluster corresponds
2509 // to a tracker chamber.
2510 bool hitOk = IsHitCoordinateOk(
2511 block, blockNumber, name, i, ci.fHit,
2512 minCh, maxCh, -1, ddl
2513 );
2514 if (not hitOk) result = false;
2515 }
2516
2517 return result;
2518}
2519
2520
2521bool AliHLTMUONDataCheckerComponent::CheckChannelsBlock(
2522 const AliHLTComponentBlockData& block,
2523 AliHLTUInt32_t blockNumber
2524 ) const
2525{
2526 /// Checks the validity of a channels block.
2527
2528 bool result = true;
2529 const char* name = "channels";
2530
2531 if (not fIgnoreSpec)
2532 {
2533 if (not IsFromTrackerOnly(block, blockNumber, name))
2534 result = false;
2535 }
2536
2537 AliHLTMUONChannelsBlockReader inblock(block.fPtr, block.fSize);
2538 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
2539 return false;
2540
2541 bool ddl[22];
2542 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
2543
2544 if (FetchMappingStores() == 0) // are stores loaded?
2545 {
2546 Bool_t warn = kFALSE;
2547 AliMpDDLStore* store = AliMpDDLStore::Instance(warn);
2548
2549 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2550 {
2551 const AliHLTMUONChannelStruct& channel = inblock[i];
2552
2553 // Check if the bus patch is valid.
2554 AliMpBusPatch* busPatch = store->GetBusPatch(channel.fBusPatch, warn);
2555 if (busPatch == NULL)
2556 {
2557 HLTError("Problem found with data block %d, fDataType = '%s',"
2558 " fPtr = %p and fSize = %u bytes."
2559 " Assuming this is a %s data block."
2560 " Problem: Found a bus patch identifier %d that"
2561 " is not valid.",
2562 blockNumber,
2563 DataType2Text(block.fDataType).c_str(),
2564 block.fPtr,
2565 block.fSize,
2566 name,
2567 channel.fBusPatch
2568 );
2569 result = false;
2570 continue;
2571 }
2572
2573 // We can check that the bus patch is for a DDL
2574 // which is also indicated by the specification bits.
2575 if (not fIgnoreSpec and (
2576 not (0 <= busPatch->GetDdlId() and busPatch->GetDdlId() < 20)
2577 or (0 <= busPatch->GetDdlId() and busPatch->GetDdlId() < 20
2578 and not ddl[busPatch->GetDdlId()])
2579 ))
2580 {
2581 HLTError("Problem found with data block %d, fDataType = '%s',"
2582 " fPtr = %p and fSize = %u bytes."
2583 " Assuming this is a %s data block."
2584 " Problem: Found a bus patch identifier %d for"
2585 " DDL %d, but the data block specification 0x%8.8X"
2586 " does not have the corresponding bit set.",
2587 blockNumber,
2588 DataType2Text(block.fDataType).c_str(),
2589 block.fPtr,
2590 block.fSize,
2591 name,
2592 channel.fBusPatch,
2593 busPatch->GetDdlId(),
2594 block.fSpecification
2595 );
2596 result = false;
2597 continue;
2598 }
2599
2600 // Check if the MANU ID is valid.
2601 if (not busPatch->HasManu(channel.fManu))
2602 {
2603 HLTError("Problem found with data block %d, fDataType = '%s',"
2604 " fPtr = %p and fSize = %u bytes."
2605 " Assuming this is a %s data block."
2606 " Problem: Found a MANU identifier %d on bus patch %d"
2607 " that is not valid.",
2608 blockNumber,
2609 DataType2Text(block.fDataType).c_str(),
2610 block.fPtr,
2611 block.fSize,
2612 name,
2613 channel.fManu,
2614 channel.fBusPatch
2615 );
2616 result = false;
2617 continue;
2618 }
2619
2620 // Now try to fetch the detector element to check the MANU channel.
2621 AliMpDetElement* de = store->GetDetElement(busPatch->GetDEId(), warn);
2622 if (de == NULL)
2623 {
2624 HLTError("Problem found with data block %d, fDataType = '%s',"
2625 " fPtr = %p and fSize = %u bytes."
2626 " Assuming this is a %s data block."
2627 " Problem: Found a bus patch identifier %d that"
2628 " does not correspond to a detector element.",
2629 blockNumber,
2630 DataType2Text(block.fDataType).c_str(),
2631 block.fPtr,
2632 block.fSize,
2633 name,
2634 channel.fBusPatch
2635 );
2636 result = false;
2637 continue;
2638 }
2639
2640 if (not de->IsConnectedChannel(channel.fManu, channel.fChannelAddress))
2641 {
2642 // Just a warning because this is marked not
2643 // to be an error in the AliMUONDigitMaker.
2644 HLTWarning("Problem found with data block %d, fDataType = '%s',"
2645 " fPtr = %p and fSize = %u bytes."
2646 " Assuming this is a %s data block."
2647 " Problem: Found a channel with address %d on"
2648 " MANU ID %d and bus patch %d that is not connected.",
2649 blockNumber,
2650 DataType2Text(block.fDataType).c_str(),
2651 block.fPtr,
2652 block.fSize,
2653 name,
2654 channel.fChannelAddress,
2655 channel.fManu,
2656 channel.fBusPatch
2657 );
2658 result = false;
2659 continue;
2660 }
2661
2662 // Need to also load the correct segmentation to check the channel.
2663 const AliMpVSegmentation* seg =
2664 AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(
2665 busPatch->GetDEId(), channel.fManu
2666 );
2667 if (seg == NULL)
2668 {
2669 HLTError("Could not load segmentation for detector element %d"
2670 " and MANU ID %d.",
2671 busPatch->GetDEId(), channel.fManu
2672 );
2673 result = false;
2674 continue;
2675 }
2676
2677 AliMpPad pad = seg->PadByLocation(
53eb3786 2678#ifndef HAVE_NOT_MUON_ALIMPPAD_GETPOSITION
168e9c4d 2679 channel.fManu, channel.fChannelAddress,
53eb3786 2680#else // old AliMpPad functionality < r 31742
2681 AliMpIntPair(channel.fManu, channel.fChannelAddress),
2682#endif //HAVE_NOT_MUON_ALIMPPAD_GETPOSITION
dba14d7d 2683 warn
2684 );
2685 if (not pad.IsValid())
2686 {
2687 HLTError("Problem found with data block %d, fDataType = '%s',"
2688 " fPtr = %p and fSize = %u bytes."
2689 " Assuming this is a %s data block."
2690 " Problem: Found a channel with address %d on"
2691 " MANU ID %d and bus patch %d that is not valid.",
2692 blockNumber,
2693 DataType2Text(block.fDataType).c_str(),
2694 block.fPtr,
2695 block.fSize,
2696 name,
2697 channel.fChannelAddress,
2698 channel.fManu,
2699 channel.fBusPatch
2700 );
2701 result = false;
2702 continue;
2703 }
2704 }
2705 }
2706 else
2707 {
2708 HLTWarning("Cannot check channel information without being able"
2709 " to load the mapping from CDB."
2710 );
2711 result = false;
2712 }
2713
2714 // Need to check that no channel data has duplicated data but with
2715 // a different cluster ID number.
2716 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2717 {
2718 AliHLTMUONChannelStruct ci = inblock[i];
2719 ci.fClusterId = -1;
2720 for (AliHLTUInt32_t j = i+1; j < inblock.Nentries(); j++)
2721 {
2722 AliHLTMUONChannelStruct cj = inblock[j];
2723 cj.fClusterId = ci.fClusterId;
2724
2725 if (ci == cj)
2726 {
2727 HLTError("Problem found with data block %d, fDataType = '%s',"
2728 " fPtr = %p and fSize = %u bytes."
2729 " Assuming this is a %s data block."
2730 " Problem: The channel structures %d and %d contain"
2731 " the same data. The data might have been duplicated.",
2732 blockNumber,
2733 DataType2Text(block.fDataType).c_str(),
2734 block.fPtr,
2735 block.fSize,
2736 name,
2737 i, j
2738 );
2739 result = false;
2740 }
2741 }
2742 }
2743
2744 return result;
2745}
2746
2747
2748bool AliHLTMUONDataCheckerComponent::CheckMansoTracksBlock(
2749 const AliHLTComponentBlockData& block,
2750 AliHLTUInt32_t blockNumber
2751 ) const
2752{
2753 /// Checks the validity of a Manso tracks block.
2754
2755 bool result = true;
2756 const char* name = "Manso tracks";
2757
2758 if (not fIgnoreSpec)
2759 {
2760 if (not IsSpecificationValid(block, blockNumber, name))
2761 result = false;
2762 }
2763
2764 AliHLTMUONMansoTracksBlockReader inblock(block.fPtr, block.fSize);
2765 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
2766 return false;
2767
2768 bool ddl[22];
2769 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
2770
2771 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2772 {
2773 // Need to check that no entries have duplicated data but with
2774 // a different track ID number.
2775 AliHLTMUONMansoTrackStruct ti = inblock[i];
2776 ti.fId = -1;
2777 for (AliHLTUInt32_t j = i+1; j < inblock.Nentries(); j++)
2778 {
2779 AliHLTMUONMansoTrackStruct tj = inblock[j];
2780 tj.fId = ti.fId;
2781
2782 if (ti == tj)
2783 {
2784 HLTError("Problem found with data block %d, fDataType = '%s',"
2785 " fPtr = %p and fSize = %u bytes."
2786 " Assuming this is a %s data block."
2787 " Problem: The Manso tracks %d and %d contain the"
2788 " same data. The data might have been duplicated.",
2789 blockNumber,
2790 DataType2Text(block.fDataType).c_str(),
2791 block.fPtr,
2792 block.fSize,
2793 name,
2794 i, j
2795 );
2796 result = false;
2797 }
2798 }
2799
2800 bool trackOk = IsMansoTrackOk(block, blockNumber, name, i, ti, ddl);
2801 if (not trackOk) result = false;
2802 }
2803
2804 return result;
2805}
2806
2807
2808bool AliHLTMUONDataCheckerComponent::CheckMansoCandidatesBlock(
2809 const AliHLTComponentBlockData& block,
2810 AliHLTUInt32_t blockNumber
2811 ) const
2812{
2813 /// Checks the validity of a Manso candidates block.
2814
2815 bool result = true;
2816 const char* name = "Manso track candidates";
2817
2818 if (not fIgnoreSpec)
2819 {
2820 if (not IsSpecificationValid(block, blockNumber, name))
2821 result = false;
2822 }
2823
2824 AliHLTMUONMansoCandidatesBlockReader inblock(block.fPtr, block.fSize);
2825 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
2826 return false;
2827
2828 bool ddl[22];
2829 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
2830
2831 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2832 {
2833 // Need to check that no entries have duplicated data but with a
2834 // different track ID number.
2835 AliHLTMUONMansoCandidateStruct ti = inblock[i];
2836 ti.fTrack.fId = -1;
2837 for (AliHLTUInt32_t j = i+1; j < inblock.Nentries(); j++)
2838 {
2839 AliHLTMUONMansoCandidateStruct tj = inblock[j];
2840 tj.fTrack.fId = ti.fTrack.fId;
2841
2842 if (ti == tj)
2843 {
2844 HLTError("Problem found with data block %d, fDataType = '%s',"
2845 " fPtr = %p and fSize = %u bytes."
2846 " Assuming this is a %s data block."
2847 " Problem: The Manso track candidates %d and %d"
2848 " contain the same data."
2849 " The data might have been duplicated.",
2850 blockNumber,
2851 DataType2Text(block.fDataType).c_str(),
2852 block.fPtr,
2853 block.fSize,
2854 name,
2855 i, j
2856 );
2857 result = false;
2858 }
2859 }
2860
2861 bool trackOk = IsMansoTrackOk(block, blockNumber, name, i, ti.fTrack, ddl);
2862 if (not trackOk) result = false;
2863
2864 // Check that each ROI has a centre point somewhere on the correct
2865 // corresponding chamber and that the Radius is not bigger thant
2866 // the diameter of the chamber which would be pointless.
2867 for (AliHLTInt32_t j = 0; j < 4; j++)
2868 {
2869 if (ti.fRoI[j].fRadius == -1) continue; // Ignore invalid ROIs
2870
2871 Int_t chamber = AliMUONConstants::ChamberNumber(
2872 ti.fRoI[j].fZ, false // false = do not warn.
2873 );
2874 if (chamber != j+6)
2875 {
2876 HLTError("Problem found with data block %d, fDataType = '%s',"
2877 " fPtr = %p and fSize = %u bytes."
2878 " Assuming this is a %s data block."
2879 " Problem: The region of interest on chamber %d for"
2880 " Manso track candidate %d has a z-coordinate of %f"
2881 " cm that does not correspond to that chamber.",
2882 blockNumber,
2883 DataType2Text(block.fDataType).c_str(),
2884 block.fPtr,
2885 block.fSize,
2886 name,
2887 j+6+1,
2888 i,
2889 ti.fRoI[j].fZ
2890 );
2891 result = false;
2892 }
2893
2894 double x = ti.fRoI[j].fX;
2895 double y = ti.fRoI[j].fY;
2896 double r = sqrt(x*x + y*y);
2897 if (r > AliMUONConstants::Dmax((j+6)/2))
2898 {
2899 // Just a warning since this is not a data integrity problem
2900 // but rather just a data sanity problem.
2901 HLTWarning("Problem found with data block %d, fDataType = '%s',"
2902 " fPtr = %p and fSize = %u bytes."
2903 " Assuming this is a %s data block."
2904 " Problem: The region of interest coordinate {x = %f,"
2905 " y = %f} cm on chamber %d for Manso track candidate %d"
2906 " does not correspond to that chamber.",
2907 blockNumber,
2908 DataType2Text(block.fDataType).c_str(),
2909 block.fPtr,
2910 block.fSize,
2911 name,
2912 ti.fRoI[j].fX,
2913 ti.fRoI[j].fY,
2914 j+6+1,
2915 i
2916 );
2917 result = false;
2918 }
2919
2920 if (ti.fRoI[j].fRadius > AliMUONConstants::Dmax((j+6)/2))
2921 {
2922 // Just a warning since this is not a data integrity problem
2923 // but rather just a data sanity problem.
2924 HLTWarning("Problem found with data block %d, fDataType = '%s',"
2925 " fPtr = %p and fSize = %u bytes."
2926 " Assuming this is a %s data block."
2927 " Problem: The region of interest radius of %f cm"
2928 " on chamber %d for Manso track candidate %d"
2929 " is bigger than the chamber diameter %f cm.",
2930 blockNumber,
2931 DataType2Text(block.fDataType).c_str(),
2932 block.fPtr,
2933 block.fSize,
2934 name,
2935 ti.fRoI[j].fRadius,
2936 j+6+1,
2937 i,
2938 AliMUONConstants::Dmax((j+6)/2)
2939 );
2940 result = false;
2941 }
2942 }
2943 }
2944
2945 return result;
2946}
2947
2948
a8982f78 2949bool AliHLTMUONDataCheckerComponent::CheckTracksBlock(
2950 const AliHLTComponentBlockData& block,
2951 AliHLTUInt32_t blockNumber
2952 ) const
2953{
2954 /// Checks the validity of a tracks block.
2955
2956 bool result = true;
2957 const char* name = "tracks";
2958
2959 if (not fIgnoreSpec)
2960 {
2961 if (not IsSpecificationValid(block, blockNumber, name))
2962 result = false;
2963 }
2964
2965 AliHLTMUONTracksBlockReader inblock(block.fPtr, block.fSize);
2966 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
2967 return false;
2968
2969 bool ddl[22];
2970 AliHLTMUONUtils::UnpackSpecBits(block.fSpecification, ddl);
2971
2972 for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++)
2973 {
2974 // Need to check that no entries have duplicated data but with
2975 // a different track ID number.
2976 AliHLTMUONTrackStruct ti = inblock[i];
2977 ti.fId = -1;
2978 for (AliHLTUInt32_t j = i+1; j < inblock.Nentries(); j++)
2979 {
2980 AliHLTMUONTrackStruct tj = inblock[j];
2981 tj.fId = ti.fId;
2982
2983 if (ti == tj)
2984 {
2985 HLTError("Problem found with data block %d, fDataType = '%s',"
2986 " fPtr = %p and fSize = %u bytes."
2987 " Assuming this is a %s data block."
2988 " Problem: The track structures %d and %d contain the"
2989 " same data. The data might have been duplicated.",
2990 blockNumber,
2991 DataType2Text(block.fDataType).c_str(),
2992 block.fPtr,
2993 block.fSize,
2994 name,
2995 i, j
2996 );
2997 result = false;
2998 }
2999 }
3000
3001 bool trackOk = IsTrackOk(block, blockNumber, name, i, ti, ddl);
3002 if (not trackOk) result = false;
3003 }
3004
3005 return result;
3006}
3007
3008
dba14d7d 3009bool AliHLTMUONDataCheckerComponent::CheckSinglesDecisionBlock(
3010 const AliHLTComponentBlockData& block,
3011 AliHLTUInt32_t blockNumber
3012 ) const
3013{
3014 /// Checks the validity of a single tracks trigger decision block.
3015
3016 bool result = true;
3017 const char* name = "singles decision";
3018
3019 if (not fIgnoreSpec)
3020 {
3021 if (not IsSpecificationValid(block, blockNumber, name))
3022 result = false;
3023 }
3024
3025 AliHLTMUONSinglesDecisionBlockReader inblock(block.fPtr, block.fSize);
3026 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
3027 return false;
3028
3029 return result;
3030}
3031
3032
3033bool AliHLTMUONDataCheckerComponent::CheckPairsDecisionBlock(
3034 const AliHLTComponentBlockData& block,
3035 AliHLTUInt32_t blockNumber
3036 ) const
3037{
3038 /// Checks the validity of a track pairs trigger decision block.
3039
3040 bool result = true;
3041 const char* name = "pairs decision";
3042
3043 if (not fIgnoreSpec)
3044 {
3045 if (not IsSpecificationValid(block, blockNumber, name))
3046 result = false;
3047 }
3048
3049 AliHLTMUONPairsDecisionBlockReader inblock(block.fPtr, block.fSize);
3050 if (not CheckBlockIntegrity(block, blockNumber, inblock, name))
3051 return false;
3052
3053 return result;
3054}
3055
3056
3057bool AliHLTMUONDataCheckerComponent::AreMomentaCompatible(
3058 AliHLTFloat32_t px1,
3059 AliHLTFloat32_t py1,
3060 AliHLTFloat32_t pz1,
3061 AliHLTFloat32_t px2,
3062 AliHLTFloat32_t py2,
3063 AliHLTFloat32_t pz2
3064 ) const
3065{
3066 /// Checks to see if the two momenta vectors are compatible or not.
3067 /// The vectors should not have an angle more than 10 degrees between
3068 /// them and their magnitudes should not be more different than 50%.
3069
a3d4b6ba 3070 double p1 = sqrt(double(px1)*double(px1) + double(py1)*double(py1) + double(pz1)*double(pz1));
3071 double p2 = sqrt(double(px2)*double(px2) + double(py2)*double(py2) + double(pz2)*double(pz2));
dba14d7d 3072 if (p1 == 0 and p2 == 0) return true;
3073 if (fabs(p1 - p2) / ((p1 + p2)*0.5) > 0.5) return false;
3074 double denom = p1 * p2;
3075 if (denom == 0) return false;
a3d4b6ba 3076 double ratio = (double(px1)*double(px2) + double(py1)*double(py2) + double(pz1)*double(pz2)) / denom;
3077 if (ratio < -1) return true;
3078 if (ratio > 1) return true;
3079 double angle = acos(ratio);
dba14d7d 3080 if (angle > 3.14159265358979323846 * 10. / 180.) return false;
3081 return true;
3082}
3083
3084
3085bool AliHLTMUONDataCheckerComponent::IsScalarTooLarge(
3086 const AliHLTComponentBlockData* block,
3087 AliHLTUInt32_t blockNumber,
3088 const char* blockTypeName,
3089 const char* scalarName,
3090 AliHLTUInt32_t scalarValue,
3091 AliHLTUInt32_t totalTrackCount
3092 ) const
3093{
a8982f78 3094 /// Checks if the scalar value is larger than the number of
dba14d7d 3095 /// tracks in the event.
3096
3097 if (scalarValue > totalTrackCount)
3098 {
3099 HLTError("Problem found with %s trigger decision"
3100 " data block %d, fDataType = '%s', fPtr = %p and"
3101 " fSize = %u bytes."
3102 " Problem: The %s scalar with value %d is larger"
a8982f78 3103 " than the total number of tracks found for the"
dba14d7d 3104 " event (%d tracks).",
3105 blockTypeName,
3106 blockNumber,
3107 DataType2Text(block->fDataType).c_str(),
3108 block->fPtr,
3109 block->fSize,
3110 scalarName,
3111 scalarValue,
3112 totalTrackCount
3113 );
3114 return true;
3115 }
3116 else
3117 {
3118 return false;
3119 }
3120}
3121
3122
a8982f78 3123bool AliHLTMUONDataCheckerComponent::IsScalarTooLargePairs(
3124 const AliHLTComponentBlockData* block,
3125 AliHLTUInt32_t blockNumber,
3126 const char* blockTypeName,
3127 const char* scalarName,
3128 AliHLTUInt32_t scalarValue,
3129 AliHLTUInt32_t trackPairsCount
3130 ) const
3131{
3132 /// Checks if the scalar value is larger than the number of
3133 /// track pairs in the event.
3134
3135 if (scalarValue > trackPairsCount)
3136 {
3137 HLTError("Problem found with %s trigger decision"
3138 " data block %d, fDataType = '%s', fPtr = %p and"
3139 " fSize = %u bytes."
3140 " Problem: The %s scalar with value %d is larger"
3141 " than the total number of track pairs found for the"
3142 " event (%d track pairs).",
3143 blockTypeName,
3144 blockNumber,
3145 DataType2Text(block->fDataType).c_str(),
3146 block->fPtr,
3147 block->fSize,
3148 scalarName,
3149 scalarValue,
3150 trackPairsCount
3151 );
3152 return true;
3153 }
3154 else
3155 {
3156 return false;
3157 }
3158}
3159
3160
dba14d7d 3161bool AliHLTMUONDataCheckerComponent::IsScalarALargerThanB(
3162 const AliHLTComponentBlockData* block,
3163 AliHLTUInt32_t blockNumber,
3164 const char* blockTypeName,
3165 const char* scalarAName,
3166 AliHLTUInt32_t scalarAValue,
3167 const char* scalarBName,
3168 AliHLTUInt32_t scalarBValue
3169 ) const
3170{
3171 /// Checks if the scalar value is larger than the number of Manso
3172 /// tracks in the event.
3173
3174 if (scalarAValue > scalarBValue)
3175 {
3176 HLTError("Problem found with %s trigger decision"
3177 " data block %d, fDataType = '%s', fPtr = %p and"
3178 " fSize = %u bytes."
3179 " Problem: The %s scalar with value %d is larger"
3180 " than scalar %s with value %d, but is should not be.",
3181 blockTypeName,
3182 blockNumber,
3183 DataType2Text(block->fDataType).c_str(),
3184 block->fPtr,
3185 block->fSize,
3186 scalarAName,
3187 scalarAValue,
3188 scalarBName,
3189 scalarBValue
3190 );
3191 return true;
3192 }
3193 else
3194 {
3195 return false;
3196 }
3197}
3198
3199
3200void AliHLTMUONDataCheckerComponent::MarkBlock(
3201 const AliHLTComponentBlockData* blocks,
3202 bool* blockOk,
3203 AliHLTUInt32_t blockCount,
3204 const AliHLTComponentBlockData* blockToMark
3205 ) const
3206{
3207 /// Tries to find the 'blockToMark' in the list of blocks and sets the
3208 /// corresponding 'blockOk' flag to false.
3209
3210 for (AliHLTUInt32_t i = 0; i < blockCount; i++)
3211 {
3212 if (&blocks[i] == blockToMark)
3213 {
3214 blockOk[i] = false;
3215 return;
3216 }
3217 }
3218}
3219
3220
3221void AliHLTMUONDataCheckerComponent::MakeGlobalChecks(
3222 const AliHLTComponentBlockData* blocks,
3223 bool* blockOk,
3224 AliHLTUInt32_t blockCount,
3225 const AliHLTComponentBlockData** trigRecBlocks,
3226 AliHLTUInt32_t trigRecBlocksCount,
3227 const AliHLTComponentBlockData** trigRecDebugBlocks,
3228 AliHLTUInt32_t trigRecDebugBlocksCount,
3229 const AliHLTComponentBlockData** hitBlocks,
3230 AliHLTUInt32_t hitBlocksCount,
3231 const AliHLTComponentBlockData** clusterBlocks,
3232 AliHLTUInt32_t clusterBlocksCount,
3233 const AliHLTComponentBlockData** channelBlocks,
3234 AliHLTUInt32_t channelBlocksCount,
3235 const AliHLTComponentBlockData** mansoTrackBlocks,
3236 AliHLTUInt32_t mansoTrackBlocksCount,
3237 const AliHLTComponentBlockData** mansoCandidateBlocks,
3238 AliHLTUInt32_t mansoCandidateBlocksCount,
a8982f78 3239 const AliHLTComponentBlockData** trackBlocks,
3240 AliHLTUInt32_t trackBlocksCount,
dba14d7d 3241 const AliHLTComponentBlockData** singleDecisionBlocks,
3242 AliHLTUInt32_t singleDecisionBlocksCount,
3243 const AliHLTComponentBlockData** pairDecisionBlocks,
3244 AliHLTUInt32_t pairDecisionBlocksCount
3245 ) const
3246{
3247 /// The following set of global checks are performed:
3248 /// 1) Checks if all the ID numbers in all the blocks are unique.
3249 /// 2) Check if all the structures are unique up to their ID numbers,
3250 /// that it, make sure there are no structures with the same data but
3251 /// for a different ID number.
3252 /// 3) Check if the reference ID numbers are correct, i.e. are the
3253 /// trigger record ID numbers in the track structures found in any of
3254 /// the trigger record data blocks.
3255 /// 4) Do the number of channels claimed in the cluster correspond to
3256 /// the number of channel structures.
a8982f78 3257 /// 5) Check that the momentum vectors between the Manso and full tracks,
3258 /// and the corresponding trigger record are compatible.
dba14d7d 3259 /// 6) Check that the trigger decision scalars are reasonable.
a090ff22 3260 /// 7) Check that the detector element IDs are the same between rec
3261 /// hits and clusters / trigger record debug blocks.
dba14d7d 3262
3263 // Check if all the trigger record identifiers and data are unique.
3264 for (AliHLTUInt32_t bi = 0; bi < trigRecBlocksCount; bi++)
3265 {
3266 AliHLTMUONTriggerRecordsBlockReader inblocki(trigRecBlocks[bi]->fPtr, trigRecBlocks[bi]->fSize);
3267 if (not inblocki.BufferSizeOk()) continue;
3268 for (AliHLTUInt32_t bj = bi+1; bj < trigRecBlocksCount; bj++)
3269 {
3270 AliHLTMUONTriggerRecordsBlockReader inblockj(trigRecBlocks[bj]->fPtr, trigRecBlocks[bj]->fSize);
3271 if (not inblockj.BufferSizeOk()) continue;
3272
3273 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3274 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3275 {
3276 if (inblocki[i].fId == inblockj[j].fId)
3277 {
3278 HLTError("Problem found with trigger record data block %d,"
3279 " fDataType = '%s', fPtr = %p and fSize = %u bytes,"
3280 " and trigger record data block %d,"
3281 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3282 " Problem: Trigger record %d in block %d and entry"
3283 " %d in block %d have the same identfier, but they"
3284 " should be unique.",
3285 bi,
3286 DataType2Text(trigRecBlocks[bi]->fDataType).c_str(),
3287 trigRecBlocks[bi]->fPtr,
3288 trigRecBlocks[bi]->fSize,
3289 bj,
3290 DataType2Text(trigRecBlocks[bj]->fDataType).c_str(),
3291 trigRecBlocks[bj]->fPtr,
3292 trigRecBlocks[bj]->fSize,
3293 bi, i,
3294 bj, j
3295 );
3296 MarkBlock(blocks, blockOk, blockCount, trigRecBlocks[bi]);
3297 MarkBlock(blocks, blockOk, blockCount, trigRecBlocks[bj]);
3298 }
3299
3300 AliHLTMUONTriggerRecordStruct a = inblocki[i];
3301 AliHLTMUONTriggerRecordStruct b = inblockj[j];
3302 a.fId = b.fId = -1;
3303 if (a == b)
3304 {
3305 HLTError("Problem found with trigger record data block %d,"
3306 " fDataType = '%s', fPtr = %p and fSize = %u bytes,"
3307 " and trigger record data block %d,"
3308 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3309 " Problem: Trigger record %d in block %d and entry"
3310 " %d in block %d have the same data."
3311 " The data may have been duplicated.",
3312 bi,
3313 DataType2Text(trigRecBlocks[bi]->fDataType).c_str(),
3314 trigRecBlocks[bi]->fPtr,
3315 trigRecBlocks[bi]->fSize,
3316 bj,
3317 DataType2Text(trigRecBlocks[bj]->fDataType).c_str(),
3318 trigRecBlocks[bj]->fPtr,
3319 trigRecBlocks[bj]->fSize,
3320 bi, i,
3321 bj, j
3322 );
3323 MarkBlock(blocks, blockOk, blockCount, trigRecBlocks[bi]);
3324 MarkBlock(blocks, blockOk, blockCount, trigRecBlocks[bj]);
3325 }
3326 }
3327 }
3328 }
3329
3330 for (AliHLTUInt32_t bi = 0; bi < trigRecDebugBlocksCount; bi++)
3331 {
3332 AliHLTMUONTrigRecsDebugBlockReader inblocki(trigRecDebugBlocks[bi]->fPtr, trigRecDebugBlocks[bi]->fSize);
3333 if (not inblocki.BufferSizeOk()) continue;
3334
dba14d7d 3335 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3336 {
a090ff22 3337 // Check if all the trigger record IDs in the debug information structures exist.
dba14d7d 3338 bool found = false;
3339
3340 for (AliHLTUInt32_t bj = 0; bj < trigRecBlocksCount and not found; bj++)
3341 {
3342 AliHLTMUONTriggerRecordsBlockReader inblockj(trigRecBlocks[bj]->fPtr, trigRecBlocks[bj]->fSize);
3343 if (not inblockj.BufferSizeOk()) continue;
3344
3345 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3346 {
3347 if (inblocki[i].fTrigRecId == inblockj[j].fId)
3348 {
3349 found = true;
a090ff22 3350
3351 // Since we found the corresponding trigger record,
3352 // check if the detector element IDs are the same.
3353 bool deOk = CheckDetElemIds(
3354 *trigRecDebugBlocks[bi], bi, i, inblocki[i],
3355 *trigRecBlocks[bj], bj, j, inblockj[j]
3356 );
3357 if (not deOk)
3358 {
3359 MarkBlock(blocks, blockOk, blockCount, trigRecDebugBlocks[bi]);
3360 MarkBlock(blocks, blockOk, blockCount, trigRecBlocks[bj]);
3361 }
3362
dba14d7d 3363 break;
3364 }
3365 }
3366 }
3367
3368 if (not found)
3369 {
3370 HLTError("Problem found with trigger record debug information"
3371 " data block %d, fDataType = '%s', fPtr = %p and"
3372 " fSize = %u bytes."
3373 " Problem with entry %d in block: The trigger record"
3374 " identifier %d does not exist in any trigger record"
3375 " data block.",
3376 bi,
3377 DataType2Text(trigRecDebugBlocks[bi]->fDataType).c_str(),
3378 trigRecDebugBlocks[bi]->fPtr,
3379 trigRecDebugBlocks[bi]->fSize,
3380 i, inblocki[i].fTrigRecId
3381 );
3382 MarkBlock(blocks, blockOk, blockCount, trigRecDebugBlocks[bi]);
3383 }
3384 }
3385
3386 // Check if all the trigger record debug information structures are unique.
3387 for (AliHLTUInt32_t bj = bi+1; bj < trigRecDebugBlocksCount; bj++)
3388 {
3389 AliHLTMUONTrigRecsDebugBlockReader inblockj(trigRecDebugBlocks[bj]->fPtr, trigRecDebugBlocks[bj]->fSize);
3390 if (not inblockj.BufferSizeOk()) continue;
3391
3392 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3393 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3394 {
3395 AliHLTMUONTrigRecInfoStruct a = inblocki[i];
3396 AliHLTMUONTrigRecInfoStruct b = inblockj[j];
3397 a.fTrigRecId = b.fTrigRecId = -1;
3398 if (a == b)
3399 {
3400 HLTError("Problem found with trigger record debug information"
3401 " data block %d, fDataType = '%s', fPtr = %p and"
3402 " fSize = %u bytes, and trigger record debug"
3403 " information data block %d,"
3404 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3405 " Problem: The trigger record debug inforamtion"
3406 " structure %d in block %d and entry"
3407 " %d in block %d have the same data."
3408 " The data may have been duplicated.",
3409 bi,
3410 DataType2Text(trigRecDebugBlocks[bi]->fDataType).c_str(),
3411 trigRecDebugBlocks[bi]->fPtr,
3412 trigRecDebugBlocks[bi]->fSize,
3413 bj,
3414 DataType2Text(trigRecDebugBlocks[bj]->fDataType).c_str(),
3415 trigRecDebugBlocks[bj]->fPtr,
3416 trigRecDebugBlocks[bj]->fSize,
3417 bi, i,
3418 bj, j
3419 );
3420 MarkBlock(blocks, blockOk, blockCount, trigRecDebugBlocks[bi]);
3421 MarkBlock(blocks, blockOk, blockCount, trigRecDebugBlocks[bj]);
3422 }
3423 }
3424 }
3425 }
3426
3427 // Check that all the reconstructed hits are unique.
3428 for (AliHLTUInt32_t bi = 0; bi < hitBlocksCount; bi++)
3429 {
3430 AliHLTMUONRecHitsBlockReader inblocki(hitBlocks[bi]->fPtr, hitBlocks[bi]->fSize);
3431 if (not inblocki.BufferSizeOk()) continue;
3432 for (AliHLTUInt32_t bj = bi+1; bj < hitBlocksCount; bj++)
3433 {
3434 AliHLTMUONRecHitsBlockReader inblockj(hitBlocks[bj]->fPtr, hitBlocks[bj]->fSize);
3435 if (not inblockj.BufferSizeOk()) continue;
3436
3437 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3438 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3439 {
3440 if (inblocki[i] == inblockj[j])
3441 {
3442 HLTError("Problem found with reconstructed hit data block %d,"
3443 " fDataType = '%s', fPtr = %p and fSize = %u bytes,"
3444 " and reconstructed hit data block %d,"
3445 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3446 " Problem: Reconstructed hit %d in block %d and entry"
3447 " %d in block %d are the same, but all hits"
3448 " should be unique.",
3449 bi,
3450 DataType2Text(hitBlocks[bi]->fDataType).c_str(),
3451 hitBlocks[bi]->fPtr,
3452 hitBlocks[bi]->fSize,
3453 bj,
3454 DataType2Text(hitBlocks[bj]->fDataType).c_str(),
3455 hitBlocks[bj]->fPtr,
3456 hitBlocks[bj]->fSize,
3457 bi, i,
3458 bj, j
3459 );
3460 MarkBlock(blocks, blockOk, blockCount, hitBlocks[bi]);
3461 MarkBlock(blocks, blockOk, blockCount, hitBlocks[bj]);
3462 }
3463 }
3464 }
3465 }
3466
3467 for (AliHLTUInt32_t bi = 0; bi < clusterBlocksCount; bi++)
3468 {
3469 AliHLTMUONClustersBlockReader inblocki(clusterBlocks[bi]->fPtr, clusterBlocks[bi]->fSize);
3470 if (not inblocki.BufferSizeOk()) continue;
3471
3472 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3473 {
3474 // Check if all the reconstructed hit coordinates in the cluster structures exist.
3475 bool found = false;
3476
3477 for (AliHLTUInt32_t bj = 0; bj < hitBlocksCount and not found; bj++)
3478 {
3479 AliHLTMUONRecHitsBlockReader inblockj(hitBlocks[bj]->fPtr, hitBlocks[bj]->fSize);
3480 if (not inblockj.BufferSizeOk()) continue;
3481
3482 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3483 {
3484 if (inblocki[i].fHit == inblockj[j])
3485 {
3486 found = true;
a090ff22 3487
3488 // Since we found the corresponding cluster,
3489 // check if the detector element IDs are the same.
3490 bool deOk = CheckDetElemIds(
3491 *clusterBlocks[bi], bi, i, inblocki[i],
3492 *hitBlocks[bj], bj, j, inblockj[j]
3493 );
3494 if (not deOk)
3495 {
3496 MarkBlock(blocks, blockOk, blockCount, clusterBlocks[bi]);
3497 MarkBlock(blocks, blockOk, blockCount, hitBlocks[bj]);
3498 }
3499
dba14d7d 3500 break;
3501 }
3502 }
3503 }
3504
3505 // If the hit was not found then it should be nil.
3506 if (not found and (inblocki[i].fHit != AliHLTMUONConstants::NilRecHitStruct()))
3507 {
3508 HLTError("Problem found with cluster data block %d,"
3509 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3510 " Problem with entry %d in block: The cluster hit"
3511 " coordinate {x = %f, y = %f, z = %f} does not exist"
3512 " in any reconstructed hit data block.",
3513 bi,
3514 DataType2Text(clusterBlocks[bi]->fDataType).c_str(),
3515 clusterBlocks[bi]->fPtr,
3516 clusterBlocks[bi]->fSize,
3517 i,
3518 inblocki[i].fHit.fX,
3519 inblocki[i].fHit.fY,
3520 inblocki[i].fHit.fZ
3521 );
3522 MarkBlock(blocks, blockOk, blockCount, clusterBlocks[bi]);
3523 }
3524
66622a82 3525 // Check that the fNchannelsB value is correct.
3526 // First count the number of channels found in the channels block that
3527 // correspond to the cluster. Do this for the bending and non-bending planes.
3528 AliHLTUInt32_t countB = 0;
3529 AliHLTUInt32_t countNB = 0;
dba14d7d 3530 for (AliHLTUInt32_t bj = 0; bj < channelBlocksCount and not found; bj++)
3531 {
3532 AliHLTMUONChannelsBlockReader inblockj(channelBlocks[bj]->fPtr, channelBlocks[bj]->fSize);
3533 if (not inblockj.BufferSizeOk()) continue;
3534
3535 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3536 {
66622a82 3537 if (inblocki[i].fId != inblockj[j].fClusterId) continue;
3538 if ((inblockj[j].fRawDataWord & (1 << 28)) == 0)
3539 countB++;
3540 else
3541 countNB++;
dba14d7d 3542 }
3543 }
3544
66622a82 3545 if (inblocki[i].fNchannelsB != countB)
3546 {
3547 HLTWarning("Problem found with cluster data block %d,"
3548 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3549 " Problem with entry %d in block: The number of bending plane"
3550 " channels in the cluster is reported as %d,"
3551 " but %d channel structures were found.",
3552 bi,
3553 DataType2Text(clusterBlocks[bi]->fDataType).c_str(),
3554 clusterBlocks[bi]->fPtr,
3555 clusterBlocks[bi]->fSize,
3556 i,
3557 inblocki[i].fNchannelsB,
3558 countB
3559 );
3560 MarkBlock(blocks, blockOk, blockCount, clusterBlocks[bi]);
3561 }
3562
3563 if (inblocki[i].fNchannelsNB != countNB)
dba14d7d 3564 {
83d66053 3565 HLTWarning("Problem found with cluster data block %d,"
dba14d7d 3566 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3567 " Problem with entry %d in block: The number of"
66622a82 3568 " channels in the cluster of non-bending plane is reported as %d,"
3569 " but %d channel structures were found.",
dba14d7d 3570 bi,
3571 DataType2Text(clusterBlocks[bi]->fDataType).c_str(),
3572 clusterBlocks[bi]->fPtr,
3573 clusterBlocks[bi]->fSize,
3574 i,
66622a82 3575 inblocki[i].fNchannelsNB,
3576 countNB
dba14d7d 3577 );
3578 MarkBlock(blocks, blockOk, blockCount, clusterBlocks[bi]);
3579 }
3580 }
3581
3582 // Check if all the cluster structures are unique up to the identifier
3583 // and have unique identifiers.
3584 for (AliHLTUInt32_t bj = bi+1; bj < clusterBlocksCount; bj++)
3585 {
3586 AliHLTMUONClustersBlockReader inblockj(clusterBlocks[bj]->fPtr, clusterBlocks[bj]->fSize);
3587 if (not inblockj.BufferSizeOk()) continue;
3588
3589 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3590 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3591 {
3592 if (inblocki[i].fId == inblockj[j].fId)
3593 {
3594 HLTError("Problem found with cluster"
3595 " data block %d, fDataType = '%s', fPtr = %p and"
3596 " fSize = %u bytes, and cluster data block %d,"
3597 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3598 " Problem: The cluster %d in block %d and entry"
3599 " %d in block %d have the same identifier, but they"
3600 " should be unique.",
3601 bi,
3602 DataType2Text(clusterBlocks[bi]->fDataType).c_str(),
3603 clusterBlocks[bi]->fPtr,
3604 clusterBlocks[bi]->fSize,
3605 bj,
3606 DataType2Text(clusterBlocks[bj]->fDataType).c_str(),
3607 clusterBlocks[bj]->fPtr,
3608 clusterBlocks[bj]->fSize,
3609 bi, i,
3610 bj, j
3611 );
3612 MarkBlock(blocks, blockOk, blockCount, clusterBlocks[bi]);
3613 MarkBlock(blocks, blockOk, blockCount, clusterBlocks[bj]);
3614 }
3615
3616 AliHLTMUONClusterStruct a = inblocki[i];
3617 AliHLTMUONClusterStruct b = inblockj[j];
3618 a.fId = b.fId = -1;
3619 if (a == b)
3620 {
3621 HLTError("Problem found with cluster"
3622 " data block %d, fDataType = '%s', fPtr = %p and"
3623 " fSize = %u bytes, and cluster data block %d,"
3624 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3625 " Problem: The cluster %d in block %d and entry"
3626 " %d in block %d have the same data."
3627 " The data may have been duplicated.",
3628 bi,
3629 DataType2Text(clusterBlocks[bi]->fDataType).c_str(),
3630 clusterBlocks[bi]->fPtr,
3631 clusterBlocks[bi]->fSize,
3632 bj,
3633 DataType2Text(clusterBlocks[bj]->fDataType).c_str(),
3634 clusterBlocks[bj]->fPtr,
3635 clusterBlocks[bj]->fSize,
3636 bi, i,
3637 bj, j
3638 );
3639 MarkBlock(blocks, blockOk, blockCount, clusterBlocks[bi]);
3640 MarkBlock(blocks, blockOk, blockCount, clusterBlocks[bj]);
3641 }
3642 }
3643 }
3644 }
3645
3646 for (AliHLTUInt32_t bi = 0; bi < channelBlocksCount; bi++)
3647 {
3648 AliHLTMUONChannelsBlockReader inblocki(channelBlocks[bi]->fPtr, channelBlocks[bi]->fSize);
3649 if (not inblocki.BufferSizeOk()) continue;
3650
3651 // Check if all the cluster IDs in the channel structures exist.
3652 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3653 {
3654 bool found = false;
3655
3656 for (AliHLTUInt32_t bj = 0; bj < clusterBlocksCount and not found; bj++)
3657 {
3658 AliHLTMUONClustersBlockReader inblockj(clusterBlocks[bj]->fPtr, clusterBlocks[bj]->fSize);
3659 if (not inblockj.BufferSizeOk()) continue;
3660
3661 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3662 {
3663 if (inblocki[i].fClusterId == inblockj[j].fId)
3664 {
3665 found = true;
3666 break;
3667 }
3668 }
3669 }
3670
3671 if (not found)
3672 {
3673 HLTError("Problem found with channel"
3674 " data block %d, fDataType = '%s', fPtr = %p and"
3675 " fSize = %u bytes."
3676 " Problem with entry %d in block: The cluster"
3677 " identifier %d does not exist in any cluster"
3678 " data block.",
3679 bi,
3680 DataType2Text(channelBlocks[bi]->fDataType).c_str(),
3681 channelBlocks[bi]->fPtr,
3682 channelBlocks[bi]->fSize,
3683 i, inblocki[i].fClusterId
3684 );
3685 MarkBlock(blocks, blockOk, blockCount, channelBlocks[bi]);
3686 }
3687 }
3688
3689 // Check if all the channel structures are unique up to the cluster ID.
3690 for (AliHLTUInt32_t bj = bi+1; bj < channelBlocksCount; bj++)
3691 {
3692 AliHLTMUONChannelsBlockReader inblockj(channelBlocks[bj]->fPtr, channelBlocks[bj]->fSize);
3693 if (not inblockj.BufferSizeOk()) continue;
3694
3695 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3696 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3697 {
3698 AliHLTMUONChannelStruct a = inblocki[i];
3699 AliHLTMUONChannelStruct b = inblockj[j];
3700 a.fClusterId = b.fClusterId = -1;
3701 if (a == b)
3702 {
3703 HLTError("Problem found with channel"
3704 " data block %d, fDataType = '%s', fPtr = %p and"
3705 " fSize = %u bytes, and channel data block %d,"
3706 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3707 " Problem: The channel %d in block %d and entry"
3708 " %d in block %d have the same data."
3709 " The data may have been duplicated.",
3710 bi,
3711 DataType2Text(channelBlocks[bi]->fDataType).c_str(),
3712 channelBlocks[bi]->fPtr,
3713 channelBlocks[bi]->fSize,
3714 bj,
3715 DataType2Text(channelBlocks[bj]->fDataType).c_str(),
3716 channelBlocks[bj]->fPtr,
3717 channelBlocks[bj]->fSize,
3718 bi, i,
3719 bj, j
3720 );
3721 MarkBlock(blocks, blockOk, blockCount, channelBlocks[bi]);
3722 MarkBlock(blocks, blockOk, blockCount, channelBlocks[bj]);
3723 }
3724 }
3725 }
3726 }
3727
3728 // Will need the total number of tracks later for comparison to trigger scalars.
3729 AliHLTUInt32_t totalTrackCount = 0;
3730
3731 for (AliHLTUInt32_t bi = 0; bi < mansoTrackBlocksCount; bi++)
3732 {
3733 AliHLTMUONMansoTracksBlockReader inblocki(mansoTrackBlocks[bi]->fPtr, mansoTrackBlocks[bi]->fSize);
3734 if (not inblocki.BufferSizeOk()) continue;
3735
3736 totalTrackCount += inblocki.Nentries();
3737
3738 // Check if all the trigger record IDs in the Manso track structures exist.
3739 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3740 {
3741 bool found = false;
3742
3743 for (AliHLTUInt32_t bj = 0; bj < trigRecBlocksCount and not found; bj++)
3744 {
3745 AliHLTMUONTriggerRecordsBlockReader inblockj(trigRecBlocks[bj]->fPtr, trigRecBlocks[bj]->fSize);
3746 if (not inblockj.BufferSizeOk()) continue;
3747
3748 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3749 {
3750 if (inblocki[i].fTrigRec == inblockj[j].fId)
3751 {
3752 // At this point we can check if the momentum
3753 // is compatible with the trigger record.
3754 if (not AreMomentaCompatible(
3755 inblocki[i].fPx, inblocki[i].fPy, inblocki[i].fPz,
3756 inblockj[j].fPx, inblockj[j].fPy, inblockj[j].fPz
3757 )
3758 )
3759 {
3760 HLTWarning("Problem found with Manso track"
3761 " data block %d, fDataType = '%s', fPtr = %p and"
3762 " fSize = %u bytes."
3763 " Problem with Manso track %d in block: The momentum"
3764 " vector of the track p = {%f, %f, %f} GeV/c is not"
3765 " compatible with the momentum vector of the trigger"
3766 " record with p = {%f, %f, %f} GeV/c.",
3767 bi,
3768 DataType2Text(mansoTrackBlocks[bi]->fDataType).c_str(),
3769 mansoTrackBlocks[bi]->fPtr,
3770 mansoTrackBlocks[bi]->fSize,
3771 i, inblocki[i].fPx, inblocki[i].fPy, inblocki[i].fPz,
3772 inblockj[j].fPx, inblockj[j].fPy, inblockj[j].fPz
3773 );
3774 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bi]);
3775 }
3776
3777 found = true;
3778 break;
3779 }
3780 }
3781 }
3782
3783 if (not found)
3784 {
3785 HLTError("Problem found with Manso track"
3786 " data block %d, fDataType = '%s', fPtr = %p and"
3787 " fSize = %u bytes."
3788 " Problem with Manso track %d in block: The trigger"
3789 " record identifier %d does not exist in any trigger"
3790 " record data block.",
3791 bi,
3792 DataType2Text(mansoTrackBlocks[bi]->fDataType).c_str(),
3793 mansoTrackBlocks[bi]->fPtr,
3794 mansoTrackBlocks[bi]->fSize,
3795 i, inblocki[i].fTrigRec
3796 );
3797 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bi]);
3798 }
3799 }
3800
3801 // Check if all the hits in the Manso track structures exist.
3802 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3803 {
3804 AliHLTMUONParticleSign sign;
3805 bool hitset[4];
3806 AliHLTMUONUtils::UnpackMansoTrackFlags(inblocki[i].fFlags, sign, hitset);
3807
3808 for (AliHLTUInt32_t n = 0; n < 4; n++)
3809 {
3810 if (not hitset[n]) continue;
3811 bool found = false;
3812
3813 for (AliHLTUInt32_t bj = 0; bj < hitBlocksCount and not found; bj++)
3814 {
3815 AliHLTMUONRecHitsBlockReader inblockj(hitBlocks[bj]->fPtr, hitBlocks[bj]->fSize);
3816 if (not inblockj.BufferSizeOk()) continue;
3817
3818 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3819 {
3820 if (inblocki[i].fHit[n] == inblockj[j])
3821 {
3822 found = true;
3823 break;
3824 }
3825 }
3826 }
3827
3828 if (not found)
3829 {
3830 HLTError("Problem found with Manso track"
3831 " data block %d, fDataType = '%s', fPtr = %p and"
3832 " fSize = %u bytes."
3833 " Problem with Manso track %d in block: The hit"
3834 " for chamber %d does not exist in any"
3835 " reconstructed hits data block.",
3836 bi,
3837 DataType2Text(mansoTrackBlocks[bi]->fDataType).c_str(),
3838 mansoTrackBlocks[bi]->fPtr,
3839 mansoTrackBlocks[bi]->fSize,
3840 i, n+6+1
3841 );
3842 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bi]);
3843 }
3844 }
3845 }
3846
3847 // Check if all the Manso track structures are unique up to the ID and
3848 // have unique identifiers.
3849 for (AliHLTUInt32_t bj = bi+1; bj < mansoTrackBlocksCount; bj++)
3850 {
3851 AliHLTMUONMansoTracksBlockReader inblockj(mansoTrackBlocks[bj]->fPtr, mansoTrackBlocks[bj]->fSize);
3852 if (not inblockj.BufferSizeOk()) continue;
3853
3854 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3855 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3856 {
3857 if (inblocki[i].fId == inblockj[j].fId)
3858 {
3859 HLTError("Problem found with Manso track"
3860 " data block %d, fDataType = '%s', fPtr = %p and"
3861 " fSize = %u bytes, and Manso track data block %d,"
3862 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3863 " Problem: The Manso track %d in block %d and entry"
3864 " %d in block %d have the same identifier, but they"
3865 " should be unique.",
3866 bi,
3867 DataType2Text(mansoTrackBlocks[bi]->fDataType).c_str(),
3868 mansoTrackBlocks[bi]->fPtr,
3869 mansoTrackBlocks[bi]->fSize,
3870 bj,
3871 DataType2Text(mansoTrackBlocks[bj]->fDataType).c_str(),
3872 mansoTrackBlocks[bj]->fPtr,
3873 mansoTrackBlocks[bj]->fSize,
3874 bi, i,
3875 bj, j
3876 );
3877 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bi]);
3878 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bj]);
3879 }
3880
3881 AliHLTMUONMansoTrackStruct a = inblocki[i];
3882 AliHLTMUONMansoTrackStruct b = inblockj[j];
3883 a.fId = b.fId = -1;
3884 if (a == b)
3885 {
3886 HLTError("Problem found with Manso track"
3887 " data block %d, fDataType = '%s', fPtr = %p and"
3888 " fSize = %u bytes, and Manso track data block %d,"
3889 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
3890 " Problem: The Manso track %d in block %d and entry"
3891 " %d in block %d have the same data."
3892 " The data may have been duplicated.",
3893 bi,
3894 DataType2Text(mansoTrackBlocks[bi]->fDataType).c_str(),
3895 mansoTrackBlocks[bi]->fPtr,
3896 mansoTrackBlocks[bi]->fSize,
3897 bj,
3898 DataType2Text(mansoTrackBlocks[bj]->fDataType).c_str(),
3899 mansoTrackBlocks[bj]->fPtr,
3900 mansoTrackBlocks[bj]->fSize,
3901 bi, i,
3902 bj, j
3903 );
3904 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bi]);
3905 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bj]);
3906 }
3907 }
3908 }
3909 }
3910
3911 for (AliHLTUInt32_t bi = 0; bi < mansoCandidateBlocksCount; bi++)
3912 {
3913 AliHLTMUONMansoCandidatesBlockReader inblocki(mansoCandidateBlocks[bi]->fPtr, mansoCandidateBlocks[bi]->fSize);
3914 if (not inblocki.BufferSizeOk()) continue;
3915
3916 // Check if all the trigger record IDs in the Manso track candidate structures exist.
3917 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3918 {
3919 bool found = false;
3920
3921 for (AliHLTUInt32_t bj = 0; bj < trigRecBlocksCount and not found; bj++)
3922 {
3923 AliHLTMUONTriggerRecordsBlockReader inblockj(trigRecBlocks[bj]->fPtr, trigRecBlocks[bj]->fSize);
3924 if (not inblockj.BufferSizeOk()) continue;
3925
3926 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3927 {
3928 if (inblocki[i].fTrack.fTrigRec == inblockj[j].fId)
3929 {
3930 // At this point we can check if the momentum
3931 // is compatible with the trigger record.
3932 if (not AreMomentaCompatible(
3933 inblocki[i].fTrack.fPx, inblocki[i].fTrack.fPy, inblocki[i].fTrack.fPz,
3934 inblockj[j].fPx, inblockj[j].fPy, inblockj[j].fPz
3935 )
3936 )
3937 {
3938 HLTWarning("Problem found with Manso track candidate"
3939 " data block %d, fDataType = '%s', fPtr = %p and"
3940 " fSize = %u bytes."
3941 " Problem with track candidate %d in block: The momentum"
3942 " vector of the candidate p = {%f, %f, %f} GeV/c is not"
3943 " compatible with the momentum vector of the trigger"
3944 " record with p = {%f, %f, %f} GeV/c.",
3945 bi,
3946 DataType2Text(mansoTrackBlocks[bi]->fDataType).c_str(),
3947 mansoTrackBlocks[bi]->fPtr,
3948 mansoTrackBlocks[bi]->fSize,
3949 i,
3950 inblocki[i].fTrack.fPx, inblocki[i].fTrack.fPy, inblocki[i].fTrack.fPz,
3951 inblockj[j].fPx, inblockj[j].fPy, inblockj[j].fPz
3952 );
3953 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bi]);
3954 }
3955
3956 found = true;
3957 break;
3958 }
3959 }
3960 }
3961
3962 if (not found)
3963 {
3964 HLTError("Problem found with Manso track candidate"
3965 " data block %d, fDataType = '%s', fPtr = %p and"
3966 " fSize = %u bytes."
3967 " Problem with track candidate %d in block: The trigger"
3968 " record identifier %d does not exist in any trigger"
3969 " record data block.",
3970 bi,
3971 DataType2Text(mansoCandidateBlocks[bi]->fDataType).c_str(),
3972 mansoCandidateBlocks[bi]->fPtr,
3973 mansoCandidateBlocks[bi]->fSize,
3974 i, inblocki[i].fTrack.fTrigRec
3975 );
3976 MarkBlock(blocks, blockOk, blockCount, mansoCandidateBlocks[bi]);
3977 }
3978 }
3979
3980 // Check if all the hits in the Manso track candidate structures exist.
3981 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
3982 {
3983 AliHLTMUONParticleSign sign;
3984 bool hitset[4];
3985 AliHLTMUONUtils::UnpackMansoTrackFlags(inblocki[i].fTrack.fFlags, sign, hitset);
3986
3987 for (AliHLTUInt32_t n = 0; n < 4; n++)
3988 {
3989 if (not hitset[n]) continue;
3990 bool found = false;
3991
3992 for (AliHLTUInt32_t bj = 0; bj < hitBlocksCount and not found; bj++)
3993 {
3994 AliHLTMUONRecHitsBlockReader inblockj(hitBlocks[bj]->fPtr, hitBlocks[bj]->fSize);
3995 if (not inblockj.BufferSizeOk()) continue;
3996
3997 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
3998 {
3999 if (inblocki[i].fTrack.fHit[n] == inblockj[j])
4000 {
4001 found = true;
4002 break;
4003 }
4004 }
4005 }
4006
4007 if (not found)
4008 {
4009 HLTError("Problem found with Manso track candidate"
4010 " data block %d, fDataType = '%s', fPtr = %p and"
4011 " fSize = %u bytes."
4012 " Problem with track candidate %d in block: The hit"
4013 " for chamber %d does not exist in any"
4014 " reconstructed hits data block.",
4015 bi,
4016 DataType2Text(mansoTrackBlocks[bi]->fDataType).c_str(),
4017 mansoTrackBlocks[bi]->fPtr,
4018 mansoTrackBlocks[bi]->fSize,
4019 i, n+6+1
4020 );
4021 MarkBlock(blocks, blockOk, blockCount, mansoTrackBlocks[bi]);
4022 }
4023 }
4024 }
4025
4026 // Check if all the Manso track candidate structures are unique up to the
4027 // track ID and have unique identifiers.
4028 for (AliHLTUInt32_t bj = bi+1; bj < mansoCandidateBlocksCount; bj++)
4029 {
4030 AliHLTMUONMansoCandidatesBlockReader inblockj(mansoCandidateBlocks[bj]->fPtr, mansoCandidateBlocks[bj]->fSize);
4031 if (not inblockj.BufferSizeOk()) continue;
4032
4033 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
4034 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4035 {
4036 if (inblocki[i].fTrack.fId == inblockj[j].fTrack.fId)
4037 {
4038 HLTError("Problem found with Manso track candidate"
4039 " data block %d, fDataType = '%s', fPtr = %p and"
4040 " fSize = %u bytes, and Manso track candidate data block %d,"
4041 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
4042 " Problem: The track candidate %d in block %d and entry"
4043 " %d in block %d have the same identifier, but they"
4044 " should be unique.",
4045 bi,
4046 DataType2Text(mansoCandidateBlocks[bi]->fDataType).c_str(),
4047 mansoCandidateBlocks[bi]->fPtr,
4048 mansoCandidateBlocks[bi]->fSize,
4049 bj,
4050 DataType2Text(mansoCandidateBlocks[bj]->fDataType).c_str(),
4051 mansoCandidateBlocks[bj]->fPtr,
4052 mansoCandidateBlocks[bj]->fSize,
4053 bi, i,
4054 bj, j
4055 );
4056 MarkBlock(blocks, blockOk, blockCount, mansoCandidateBlocks[bi]);
4057 MarkBlock(blocks, blockOk, blockCount, mansoCandidateBlocks[bj]);
4058 }
4059
4060 AliHLTMUONMansoCandidateStruct a = inblocki[i];
4061 AliHLTMUONMansoCandidateStruct b = inblockj[j];
4062 a.fTrack.fId = b.fTrack.fId = -1;
4063 if (a == b)
4064 {
4065 HLTError("Problem found with Manso track candidate"
4066 " data block %d, fDataType = '%s', fPtr = %p and"
4067 " fSize = %u bytes, and Manso track candidate data block %d,"
4068 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
4069 " Problem: The track candidate %d in block %d and entry"
4070 " %d in block %d have the same data."
4071 " The data may have been duplicated.",
4072 bi,
4073 DataType2Text(mansoCandidateBlocks[bi]->fDataType).c_str(),
4074 mansoCandidateBlocks[bi]->fPtr,
4075 mansoCandidateBlocks[bi]->fSize,
4076 bj,
4077 DataType2Text(mansoCandidateBlocks[bj]->fDataType).c_str(),
4078 mansoCandidateBlocks[bj]->fPtr,
4079 mansoCandidateBlocks[bj]->fSize,
4080 bi, i,
4081 bj, j
4082 );
4083 MarkBlock(blocks, blockOk, blockCount, mansoCandidateBlocks[bi]);
4084 MarkBlock(blocks, blockOk, blockCount, mansoCandidateBlocks[bj]);
4085 }
4086 }
4087 }
4088 }
4089
a8982f78 4090 for (AliHLTUInt32_t bi = 0; bi < trackBlocksCount; bi++)
4091 {
4092 AliHLTMUONTracksBlockReader inblocki(trackBlocks[bi]->fPtr, trackBlocks[bi]->fSize);
4093 if (not inblocki.BufferSizeOk()) continue;
4094
4095 totalTrackCount += inblocki.Nentries();
4096
4097 // Check if all the trigger record IDs in the track structures exist.
4098 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
4099 {
4100 bool found = false;
4101
4102 for (AliHLTUInt32_t bj = 0; bj < trigRecBlocksCount and not found; bj++)
4103 {
4104 AliHLTMUONTriggerRecordsBlockReader inblockj(trigRecBlocks[bj]->fPtr, trigRecBlocks[bj]->fSize);
4105 if (not inblockj.BufferSizeOk()) continue;
4106
4107 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4108 {
4109 if (inblocki[i].fTrigRec == inblockj[j].fId)
4110 {
4111 // At this point we can check if the momentum
4112 // is compatible with the trigger record.
4113 if (not AreMomentaCompatible(
4114 inblocki[i].fPx, inblocki[i].fPy, inblocki[i].fPz,
4115 inblockj[j].fPx, inblockj[j].fPy, inblockj[j].fPz
4116 )
4117 )
4118 {
4119 HLTWarning("Problem found with track"
4120 " data block %d, fDataType = '%s', fPtr = %p and"
4121 " fSize = %u bytes."
4122 " Problem with track structure %d in block: The momentum"
4123 " vector of the track p = {%f, %f, %f} GeV/c is not"
4124 " compatible with the momentum vector of the trigger"
4125 " record with p = {%f, %f, %f} GeV/c.",
4126 bi,
4127 DataType2Text(trackBlocks[bi]->fDataType).c_str(),
4128 trackBlocks[bi]->fPtr,
4129 trackBlocks[bi]->fSize,
4130 i, inblocki[i].fPx, inblocki[i].fPy, inblocki[i].fPz,
4131 inblockj[j].fPx, inblockj[j].fPy, inblockj[j].fPz
4132 );
4133 MarkBlock(blocks, blockOk, blockCount, trackBlocks[bi]);
4134 }
4135
4136 found = true;
4137 break;
4138 }
4139 }
4140 }
4141
4142 if (not found)
4143 {
4144 HLTError("Problem found with track"
4145 " data block %d, fDataType = '%s', fPtr = %p and"
4146 " fSize = %u bytes."
4147 " Problem with track structure %d in block: The trigger"
4148 " record identifier %d does not exist in any trigger"
4149 " record data block.",
4150 bi,
4151 DataType2Text(trackBlocks[bi]->fDataType).c_str(),
4152 trackBlocks[bi]->fPtr,
4153 trackBlocks[bi]->fSize,
4154 i, inblocki[i].fTrigRec
4155 );
4156 MarkBlock(blocks, blockOk, blockCount, trackBlocks[bi]);
4157 }
4158 }
4159
4160 // Check if all the hits in the track structures exist.
4161 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
4162 {
4163 AliHLTMUONParticleSign sign;
4164 bool hitset[16];
4165 AliHLTMUONUtils::UnpackTrackFlags(inblocki[i].fFlags, sign, hitset);
4166
4167 for (AliHLTUInt32_t n = 0; n < 16; n++)
4168 {
4169 if (not hitset[n]) continue;
4170 bool found = false;
4171
4172 for (AliHLTUInt32_t bj = 0; bj < hitBlocksCount and not found; bj++)
4173 {
4174 AliHLTMUONRecHitsBlockReader inblockj(hitBlocks[bj]->fPtr, hitBlocks[bj]->fSize);
4175 if (not inblockj.BufferSizeOk()) continue;
4176
4177 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4178 {
4179 if (inblocki[i].fHit[n] == inblockj[j])
4180 {
4181 found = true;
4182 break;
4183 }
4184 }
4185 }
4186
4187 if (not found)
4188 {
4189 HLTError("Problem found with track"
4190 " data block %d, fDataType = '%s', fPtr = %p and"
4191 " fSize = %u bytes."
4192 " Problem with track structure %d in block: The hit"
4193 " for chamber %d does not exist in any"
4194 " reconstructed hits data block.",
4195 bi,
4196 DataType2Text(trackBlocks[bi]->fDataType).c_str(),
4197 trackBlocks[bi]->fPtr,
4198 trackBlocks[bi]->fSize,
4199 i, n+6+1
4200 );
4201 MarkBlock(blocks, blockOk, blockCount, trackBlocks[bi]);
4202 }
4203 }
4204 }
4205
4206 // Check if all the track structures are unique up to the ID and
4207 // have unique identifiers.
4208 for (AliHLTUInt32_t bj = bi+1; bj < trackBlocksCount; bj++)
4209 {
4210 AliHLTMUONTracksBlockReader inblockj(trackBlocks[bj]->fPtr, trackBlocks[bj]->fSize);
4211 if (not inblockj.BufferSizeOk()) continue;
4212
4213 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
4214 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4215 {
4216 if (inblocki[i].fId == inblockj[j].fId)
4217 {
4218 HLTError("Problem found with track"
4219 " data block %d, fDataType = '%s', fPtr = %p and"
4220 " fSize = %u bytes, and track data block %d,"
4221 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
4222 " Problem: The track structure %d in block %d and entry"
4223 " %d in block %d have the same identifier, but they"
4224 " should be unique.",
4225 bi,
4226 DataType2Text(trackBlocks[bi]->fDataType).c_str(),
4227 trackBlocks[bi]->fPtr,
4228 trackBlocks[bi]->fSize,
4229 bj,
4230 DataType2Text(trackBlocks[bj]->fDataType).c_str(),
4231 trackBlocks[bj]->fPtr,
4232 trackBlocks[bj]->fSize,
4233 bi, i,
4234 bj, j
4235 );
4236 MarkBlock(blocks, blockOk, blockCount, trackBlocks[bi]);
4237 MarkBlock(blocks, blockOk, blockCount, trackBlocks[bj]);
4238 }
4239
4240 AliHLTMUONTrackStruct a = inblocki[i];
4241 AliHLTMUONTrackStruct b = inblockj[j];
4242 a.fId = b.fId = -1;
4243 if (a == b)
4244 {
4245 HLTError("Problem found with track"
4246 " data block %d, fDataType = '%s', fPtr = %p and"
4247 " fSize = %u bytes, and track data block %d,"
4248 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
4249 " Problem: The track structure %d in block %d and entry"
4250 " %d in block %d have the same data."
4251 " The data may have been duplicated.",
4252 bi,
4253 DataType2Text(trackBlocks[bi]->fDataType).c_str(),
4254 trackBlocks[bi]->fPtr,
4255 trackBlocks[bi]->fSize,
4256 bj,
4257 DataType2Text(trackBlocks[bj]->fDataType).c_str(),
4258 trackBlocks[bj]->fPtr,
4259 trackBlocks[bj]->fSize,
4260 bi, i,
4261 bj, j
4262 );
4263 MarkBlock(blocks, blockOk, blockCount, trackBlocks[bi]);
4264 MarkBlock(blocks, blockOk, blockCount, trackBlocks[bj]);
4265 }
4266 }
4267 }
4268 }
4269
dba14d7d 4270 for (AliHLTUInt32_t bi = 0; bi < singleDecisionBlocksCount; bi++)
4271 {
4272 AliHLTMUONSinglesDecisionBlockReader inblocki(singleDecisionBlocks[bi]->fPtr, singleDecisionBlocks[bi]->fSize);
4273 if (not inblocki.BufferSizeOk()) continue;
4274
4275 // Check that the scalars are within reasonable limits.
4276 const AliHLTMUONSinglesDecisionBlockStruct& hdr = inblocki.BlockHeader();
4277 const AliHLTComponentBlockData* block = singleDecisionBlocks[bi];
4278 if (IsScalarTooLarge(block, bi, "single track", "fNlowPt", hdr.fNlowPt, totalTrackCount) or
4279 IsScalarTooLarge(block, bi, "single track", "fNhighPt", hdr.fNhighPt, totalTrackCount) or
210736fa 4280 IsScalarALargerThanB(block, bi, "single track", "fNhighPt", hdr.fNhighPt, "fNlowPt", hdr.fNlowPt)
dba14d7d 4281 )
4282 {
4283 MarkBlock(blocks, blockOk, blockCount, block);
4284 }
4285
4286 // Check if all the Manso track IDs in the trigger decision structures exist.
4287 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
4288 {
4289 bool found = false;
4290
4291 for (AliHLTUInt32_t bj = 0; bj < mansoTrackBlocksCount and not found; bj++)
4292 {
4293 AliHLTMUONMansoTracksBlockReader inblockj(mansoTrackBlocks[bj]->fPtr, mansoTrackBlocks[bj]->fSize);
4294 if (not inblockj.BufferSizeOk()) continue;
4295
4296 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4297 {
4298 if (inblocki[i].fTrackId == inblockj[j].fId)
4299 {
4300 found = true;
4301 break;
4302 }
4303 }
4304 }
4305
4306 if (not found)
4307 {
4308 HLTError("Problem found with single track trigger decision"
4309 " data block %d, fDataType = '%s', fPtr = %p and"
4310 " fSize = %u bytes."
4311 " Problem with decision %d in block: The track"
4312 " identifier %d does not exist in any Manso tracks"
4313 " data block.",
4314 bi,
4315 DataType2Text(singleDecisionBlocks[bi]->fDataType).c_str(),
4316 singleDecisionBlocks[bi]->fPtr,
4317 singleDecisionBlocks[bi]->fSize,
4318 i, inblocki[i].fTrackId
4319 );
4320 MarkBlock(blocks, blockOk, blockCount, singleDecisionBlocks[bi]);
4321 }
4322 }
4323
4324 // Check if all the trigger decision structures are unique up to the ID and
4325 // have unique Manso track identifiers.
4326 for (AliHLTUInt32_t bj = bi+1; bj < singleDecisionBlocksCount; bj++)
4327 {
4328 AliHLTMUONSinglesDecisionBlockReader inblockj(singleDecisionBlocks[bj]->fPtr, singleDecisionBlocks[bj]->fSize);
4329 if (not inblockj.BufferSizeOk()) continue;
4330
4331 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
4332 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4333 {
4334 if (inblocki[i].fTrackId == inblockj[j].fTrackId)
4335 {
4336 HLTError("Problem found with single track trigger decision"
4337 " data block %d, fDataType = '%s', fPtr = %p and"
4338 " fSize = %u bytes, and single track trigger decision"
4339 " data block %d,"
4340 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
4341 " Problem: The trigger decision %d in block %d and entry"
4342 " %d in block %d have the same Manso track identifier,"
4343 " but they should be unique.",
4344 bi,
4345 DataType2Text(singleDecisionBlocks[bi]->fDataType).c_str(),
4346 singleDecisionBlocks[bi]->fPtr,
4347 singleDecisionBlocks[bi]->fSize,
4348 bj,
4349 DataType2Text(singleDecisionBlocks[bj]->fDataType).c_str(),
4350 singleDecisionBlocks[bj]->fPtr,
4351 singleDecisionBlocks[bj]->fSize,
4352 bi, i,
4353 bj, j
4354 );
4355 MarkBlock(blocks, blockOk, blockCount, singleDecisionBlocks[bi]);
4356 MarkBlock(blocks, blockOk, blockCount, singleDecisionBlocks[bj]);
4357 }
4358
4359 AliHLTMUONTrackDecisionStruct a = inblocki[i];
4360 AliHLTMUONTrackDecisionStruct b = inblockj[j];
4361 a.fTrackId = b.fTrackId = -1;
4362 if (a == b)
4363 {
4364 HLTError("Problem found with single track trigger decision"
4365 " data block %d, fDataType = '%s', fPtr = %p and"
4366 " fSize = %u bytes, and single track trigger decision"
4367 " data block %d,"
4368 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
4369 " Problem: The trigger decision %d in block %d and entry"
4370 " %d in block %d have the same data."
4371 " The data may have been duplicated.",
4372 bi,
4373 DataType2Text(singleDecisionBlocks[bi]->fDataType).c_str(),
4374 singleDecisionBlocks[bi]->fPtr,
4375 singleDecisionBlocks[bi]->fSize,
4376 bj,
4377 DataType2Text(singleDecisionBlocks[bj]->fDataType).c_str(),
4378 singleDecisionBlocks[bj]->fPtr,
4379 singleDecisionBlocks[bj]->fSize,
4380 bi, i,
4381 bj, j
4382 );
4383 MarkBlock(blocks, blockOk, blockCount, singleDecisionBlocks[bi]);
4384 MarkBlock(blocks, blockOk, blockCount, singleDecisionBlocks[bj]);
4385 }
4386 }
4387 }
4388 }
4389
4390 for (AliHLTUInt32_t bi = 0; bi < pairDecisionBlocksCount; bi++)
4391 {
4392 AliHLTMUONPairsDecisionBlockReader inblocki(pairDecisionBlocks[bi]->fPtr, pairDecisionBlocks[bi]->fSize);
4393 if (not inblocki.BufferSizeOk()) continue;
4394
4395 AliHLTUInt32_t maxPairs = totalTrackCount * (totalTrackCount-1) / 2;
4396 const AliHLTMUONPairsDecisionBlockStruct& hdr = inblocki.BlockHeader();
4397 const AliHLTComponentBlockData* block = pairDecisionBlocks[bi];
a8982f78 4398 if (IsScalarTooLargePairs(block, bi, "track pair", "fNunlikeAnyPt", hdr.fNunlikeAnyPt, maxPairs) or
4399 IsScalarTooLargePairs(block, bi, "track pair", "fNunlikeLowPt", hdr.fNunlikeLowPt, maxPairs) or
4400 IsScalarTooLargePairs(block, bi, "track pair", "fNunlikeHighPt", hdr.fNunlikeHighPt, maxPairs) or
4401 IsScalarTooLargePairs(block, bi, "track pair", "fNlikeAnyPt", hdr.fNlikeAnyPt, maxPairs) or
4402 IsScalarTooLargePairs(block, bi, "track pair", "fNlikeLowPt", hdr.fNlikeLowPt, maxPairs) or
4403 IsScalarTooLargePairs(block, bi, "track pair", "fNlikeHighPt", hdr.fNlikeHighPt, maxPairs) or
4404 IsScalarTooLargePairs(block, bi, "track pair", "fNmassAny", hdr.fNmassAny, maxPairs) or
4405 IsScalarTooLargePairs(block, bi, "track pair", "fNmassLow", hdr.fNmassLow, maxPairs) or
4406 IsScalarTooLargePairs(block, bi, "track pair", "fNmassHigh", hdr.fNmassHigh, maxPairs) or
210736fa 4407 IsScalarALargerThanB(block, bi, "track pair", "fNunlikeHighPt", hdr.fNunlikeHighPt, "fNunlikeLowPt", hdr.fNunlikeLowPt) or
4408 IsScalarALargerThanB(block, bi, "track pair", "fNunlikeLowPt", hdr.fNunlikeLowPt, "fNunlikeAnyPt", hdr.fNunlikeAnyPt) or
4409 IsScalarALargerThanB(block, bi, "track pair", "fNlikeHighPt", hdr.fNlikeHighPt, "fNlikeLowPt", hdr.fNlikeLowPt) or
4410 IsScalarALargerThanB(block, bi, "track pair", "fNlikeLowPt", hdr.fNlikeLowPt, "fNlikeAnyPt", hdr.fNlikeAnyPt) or
4411 IsScalarALargerThanB(block, bi, "track pair", "fNmassHigh", hdr.fNmassHigh, "fNmassLow", hdr.fNmassLow) or
4412 IsScalarALargerThanB(block, bi, "track pair", "fNmassLow", hdr.fNmassLow, "fNmassAny", hdr.fNmassAny)
dba14d7d 4413 )
4414 {
4415 MarkBlock(blocks, blockOk, blockCount, block);
4416 }
4417
4418 // Check if all the Manso track IDs in the trigger decision structures exist.
4419 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
4420 {
4421 bool found = false;
4422
4423 for (AliHLTUInt32_t bj = 0; bj < mansoTrackBlocksCount and not found; bj++)
4424 {
4425 AliHLTMUONMansoTracksBlockReader inblockj(mansoTrackBlocks[bj]->fPtr, mansoTrackBlocks[bj]->fSize);
4426 if (not inblockj.BufferSizeOk()) continue;
4427
4428 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4429 {
4430 if (inblocki[i].fTrackAId == inblockj[j].fId)
4431 {
4432 found = true;
4433 break;
4434 }
4435 }
4436 }
4437
4438 if (not found)
4439 {
4440 HLTError("Problem found with track pair trigger decision"
4441 " data block %d, fDataType = '%s', fPtr = %p and"
4442 " fSize = %u bytes."
4443 " Problem with decision %d in block: The track"
4444 " identifier %d does not exist in any Manso tracks"
4445 " data block.",
4446 bi,
4447 DataType2Text(pairDecisionBlocks[bi]->fDataType).c_str(),
4448 pairDecisionBlocks[bi]->fPtr,
4449 pairDecisionBlocks[bi]->fSize,
4450 i, inblocki[i].fTrackAId
4451 );
4452 MarkBlock(blocks, blockOk, blockCount, pairDecisionBlocks[bi]);
4453 }
4454
4455 found = false;
4456
4457 for (AliHLTUInt32_t bj = 0; bj < mansoTrackBlocksCount and not found; bj++)
4458 {
4459 AliHLTMUONMansoTracksBlockReader inblockj(mansoTrackBlocks[bj]->fPtr, mansoTrackBlocks[bj]->fSize);
4460 if (not inblockj.BufferSizeOk()) continue;
4461
4462 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4463 {
4464 if (inblocki[i].fTrackBId == inblockj[j].fId)
4465 {
4466 found = true;
4467 break;
4468 }
4469 }
4470 }
4471
4472 if (not found)
4473 {
4474 HLTError("Problem found with track pair trigger decision"
4475 " data block %d, fDataType = '%s', fPtr = %p and"
4476 " fSize = %u bytes."
4477 " Problem with decision %d in block: The track"
4478 " identifier %d does not exist in any Manso tracks"
4479 " data block.",
4480 bi,
4481 DataType2Text(pairDecisionBlocks[bi]->fDataType).c_str(),
4482 pairDecisionBlocks[bi]->fPtr,
4483 pairDecisionBlocks[bi]->fSize,
4484 i, inblocki[i].fTrackBId
4485 );
4486 MarkBlock(blocks, blockOk, blockCount, pairDecisionBlocks[bi]);
4487 }
4488 }
4489
4490 // Check if all the trigger decision structures are unique up to the ID and
4491 // have unique Manso track identifier pairs.
4492 for (AliHLTUInt32_t bj = bi+1; bj < pairDecisionBlocksCount; bj++)
4493 {
4494 AliHLTMUONPairsDecisionBlockReader inblockj(pairDecisionBlocks[bj]->fPtr, pairDecisionBlocks[bj]->fSize);
4495 if (not inblockj.BufferSizeOk()) continue;
4496
4497 for (AliHLTUInt32_t i = 0; i < inblocki.Nentries(); i++)
4498 for (AliHLTUInt32_t j = 0; j < inblockj.Nentries(); j++)
4499 {
4500 if (inblocki[i].fTrackAId == inblockj[j].fTrackAId and
4501 inblocki[i].fTrackBId == inblockj[j].fTrackBId
4502 )
4503 {
4504 HLTError("Problem found with track pair trigger decision"
4505 " data block %d, fDataType = '%s', fPtr = %p and"
4506 " fSize = %u bytes, and track pair trigger decision"
4507 " data block %d,"
4508 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
4509 " Problem: The trigger decision %d in block %d and entry"
4510 " %d in block %d have the same Manso track identifier pair,"
4511 " but the pair should be unique.",
4512 bi,
4513 DataType2Text(pairDecisionBlocks[bi]->fDataType).c_str(),
4514 pairDecisionBlocks[bi]->fPtr,
4515 pairDecisionBlocks[bi]->fSize,
4516 bj,
4517 DataType2Text(pairDecisionBlocks[bj]->fDataType).c_str(),
4518 pairDecisionBlocks[bj]->fPtr,
4519 pairDecisionBlocks[bj]->fSize,
4520 bi, i,
4521 bj, j
4522 );
4523 MarkBlock(blocks, blockOk, blockCount, pairDecisionBlocks[bi]);
4524 MarkBlock(blocks, blockOk, blockCount, pairDecisionBlocks[bj]);
4525 }
4526
4527 AliHLTMUONPairDecisionStruct a = inblocki[i];
4528 AliHLTMUONPairDecisionStruct b = inblockj[j];
4529 a.fTrackAId = a.fTrackBId = b.fTrackAId = b.fTrackBId = -1;
4530 if (a == b)
4531 {
4532 HLTError("Problem found with track pair trigger decision"
4533 " data block %d, fDataType = '%s', fPtr = %p and"
4534 " fSize = %u bytes, and track pair trigger decision"
4535 " data block %d,"
4536 " fDataType = '%s', fPtr = %p and fSize = %u bytes."
4537 " Problem: The trigger decision %d in block %d and entry"
4538 " %d in block %d have the same data."
4539 " The data may have been duplicated.",
4540 bi,
4541 DataType2Text(pairDecisionBlocks[bi]->fDataType).c_str(),
4542 pairDecisionBlocks[bi]->fPtr,
4543 pairDecisionBlocks[bi]->fSize,
4544 bj,
4545 DataType2Text(pairDecisionBlocks[bj]->fDataType).c_str(),
4546 pairDecisionBlocks[bj]->fPtr,
4547 pairDecisionBlocks[bj]->fSize,
4548 bi, i,
4549 bj, j
4550 );
4551 MarkBlock(blocks, blockOk, blockCount, pairDecisionBlocks[bi]);
4552 MarkBlock(blocks, blockOk, blockCount, pairDecisionBlocks[bj]);
4553 }
4554 }
4555 }
4556 }
4557}
4558