Adding internal HLT data blocks for debugging information from the trigger chambers.
authorszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 19 May 2007 18:49:00 +0000 (18:49 +0000)
committerszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 19 May 2007 18:49:00 +0000 (18:49 +0000)
HLT/MUON/AliHLTMUONConstants.cxx
HLT/MUON/AliHLTMUONConstants.h
HLT/MUON/AliHLTMUONDataTypes.h
HLT/MUON/AliHLTMUONTrigRecsDebugBlockStruct.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONTrigRecsDebugBlockStruct.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONTriggerChannelsBlockStruct.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONTriggerChannelsBlockStruct.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONUtils.cxx
HLT/MUON/AliHLTMUONUtils.h

index ea69279..d2a79a0 100644 (file)
 #include "AliHLTMUONConstants.h"
 
 
+const AliHLTMUONTriggerRecordStruct
+AliHLTMUONConstants::fgkNilTriggerRecordStruct = {
+       0, 0, 0, 0, 0,
+       {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}
+};
+
+const AliHLTMUONTrigRecInfoStruct
+AliHLTMUONConstants::fgkNilTrigRecInfoStruct = {0, 0, 0, 0};
+
+const AliHLTMUONTriggerChannelStruct
+AliHLTMUONConstants::fgkNilTriggerChannelStruct = {0, 0, 0, 0};
+       
 const AliHLTMUONRecHitStruct
 AliHLTMUONConstants::fgkNilRecHitStruct = {0, 0, 0};
 
index 1a9abf3..e924166 100644 (file)
@@ -14,6 +14,8 @@
  */
 
 #include "AliHLTMUONTriggerRecordsBlockStruct.h"
+#include "AliHLTMUONTrigRecsDebugBlockStruct.h"
+#include "AliHLTMUONTriggerChannelsBlockStruct.h"
 #include "AliHLTMUONRecHitsBlockStruct.h"
 #include "AliHLTMUONClustersBlockStruct.h"
 #include "AliHLTMUONChannelsBlockStruct.h"
@@ -27,6 +29,21 @@ class AliHLTMUONConstants
 {
 public:
 
+       static const AliHLTMUONTriggerRecordStruct& NilTriggerRecordStruct()
+       {
+               return fgkNilTriggerRecordStruct;
+       }
+
+       static const AliHLTMUONTrigRecInfoStruct& NilTrigRecInfoStruct()
+       {
+               return fgkNilTrigRecInfoStruct;
+       }
+
+       static const AliHLTMUONTriggerChannelStruct& NilTriggerChannelStruct()
+       {
+               return fgkNilTriggerChannelStruct;
+       }
+
        static const AliHLTMUONRecHitStruct& NilRecHitStruct()
        {
                return fgkNilRecHitStruct;
@@ -111,14 +128,13 @@ private:
        // Should never have to create or destroy this object.
        AliHLTMUONConstants();
        ~AliHLTMUONConstants();
-
-       // Sentinel structure for a reconstructed hit.
+       
+       // The following are null/nil structures that can also be used as sentinels.
+       static const AliHLTMUONTriggerRecordStruct fgkNilTriggerRecordStruct;
+       static const AliHLTMUONTrigRecInfoStruct fgkNilTrigRecInfoStruct;
+       static const AliHLTMUONTriggerChannelStruct fgkNilTriggerChannelStruct;
        static const AliHLTMUONRecHitStruct fgkNilRecHitStruct;
-
-       // Sentinel structure for channel information.
        static const AliHLTMUONChannelStruct fgkNilChannelStruct;
-
-       // Sentinel structure for cluster information.
        static const AliHLTMUONClusterStruct fgkNilClusterStruct;
 
        // DDL packed data block type from dimuon trigger stations.
index ef6346f..2ecb06d 100644 (file)
@@ -93,7 +93,7 @@ enum AliHLTMUONDataBlockType
        kUnknownDataBlock = 0,
        kTriggerRecordsDataBlock = 1000,
        kTrigRecsDebugDataBlock = 1001,
-       kTriggerChannelDataBlock = 1002,
+       kTriggerChannelsDataBlock = 1002,
        kRecHitsDataBlock = 2000,
        kClustersDataBlock = 2001,
        kChannelsDataBlock = 2002,
@@ -156,19 +156,19 @@ inline std::ostream& operator << (std::ostream& stream, AliHLTMUONDataBlockType
 {
        switch (type)
        {
-       case kUnknownDataBlock:        stream << "kUnknownDataBlock";        break;
-       case kTriggerRecordsDataBlock: stream << "kTriggerRecordsDataBlock"; break;
-       case kTrigRecsDebugDataBlock:  stream << "kTrigRecsDebugDataBlock";  break;
-       case kTriggerChannelDataBlock: stream << "kTriggerChannelDataBlock"; break;
-       case kRecHitsDataBlock:        stream << "kRecHitsDataBlock";        break;
-       case kClustersDataBlock:       stream << "kClustersDataBlock";       break;
-       case kChannelsDataBlock:       stream << "kChannelsDataBlock";       break;
-       case kMansoTracksDataBlock:    stream << "kMansoTracksDataBlock";    break;
-       case kMansoRoIDataBlock:       stream << "kMansoRoIDataBlock";       break;
-       case kMansoTrialsDataBlock:    stream << "kMansoTrialsDataBlock";    break;
-       case kDecisionDataBlock:       stream << "kDecisionDataBlock";       break;
-       case kDecisionDebugDataBlock:  stream << "kDecisionDebugDataBlock";  break;
-       default:                       stream << "INVALID";
+       case kUnknownDataBlock:         stream << "kUnknownDataBlock";         break;
+       case kTriggerRecordsDataBlock:  stream << "kTriggerRecordsDataBlock";  break;
+       case kTrigRecsDebugDataBlock:   stream << "kTrigRecsDebugDataBlock";   break;
+       case kTriggerChannelsDataBlock: stream << "kTriggerChannelsDataBlock"; break;
+       case kRecHitsDataBlock:         stream << "kRecHitsDataBlock";         break;
+       case kClustersDataBlock:        stream << "kClustersDataBlock";        break;
+       case kChannelsDataBlock:        stream << "kChannelsDataBlock";        break;
+       case kMansoTracksDataBlock:     stream << "kMansoTracksDataBlock";     break;
+       case kMansoRoIDataBlock:        stream << "kMansoRoIDataBlock";        break;
+       case kMansoTrialsDataBlock:     stream << "kMansoTrialsDataBlock";     break;
+       case kDecisionDataBlock:        stream << "kDecisionDataBlock";        break;
+       case kDecisionDebugDataBlock:   stream << "kDecisionDebugDataBlock";   break;
+       default:                        stream << "INVALID";
        }
        return stream;
 }
diff --git a/HLT/MUON/AliHLTMUONTrigRecsDebugBlockStruct.cxx b/HLT/MUON/AliHLTMUONTrigRecsDebugBlockStruct.cxx
new file mode 100644 (file)
index 0000000..cc62fbd
--- /dev/null
@@ -0,0 +1,74 @@
+/**************************************************************************
+ * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONTrigRecsDebugBlockStruct.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of useful stream and comparison operators.
+ */
+
+#include "AliHLTMUONTrigRecsDebugBlockStruct.h"
+#include "AliHLTMUONUtils.h"
+#include <cassert>
+
+
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONTrigRecInfoStruct& info
+       )
+{
+       stream  << "{fTrigRecId = " << info.fTrigRecId
+               << ", fDetElemId = " << info.fDetElemId
+               << ", fZmiddle = " << info.fZmiddle
+               << ", fBl = " << info.fBl
+               << "}";
+       return stream;
+}
+
+
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONTrigRecsDebugBlockStruct& block
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(block) );
+
+       stream  << "{fHeader = " << block.fHeader << ", fTrigRecInfo[] = [";
+       if (block.fHeader.fNrecords > 0) stream << block.fTrigRecInfo[0];
+       for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
+               stream << ", " << block.fTrigRecInfo[i];
+       stream << "]}";
+       return stream;
+}
+
+
+bool operator == (
+               const AliHLTMUONTrigRecsDebugBlockStruct& a,
+               const AliHLTMUONTrigRecsDebugBlockStruct& b
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(a) );
+       assert( AliHLTMUONUtils::IntegrityOk(b) );
+
+       // First check if the blocks have the same header. If they do then check
+       // if all debug information is the same. In either case if we find a
+       // difference return false.
+       if (a.fHeader != b.fHeader) return false;
+       for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
+               if (a.fTrigRecInfo[i] != b.fTrigRecInfo[i]) return false;
+       return true;
+}
diff --git a/HLT/MUON/AliHLTMUONTrigRecsDebugBlockStruct.h b/HLT/MUON/AliHLTMUONTrigRecsDebugBlockStruct.h
new file mode 100644 (file)
index 0000000..f9d1f6d
--- /dev/null
@@ -0,0 +1,106 @@
+#ifndef ALIHLTMUONTRIGRECSDEBUGBLOCKSTRUCT_H
+#define ALIHLTMUONTRIGRECSDEBUGBLOCKSTRUCT_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONTrigRecsDebugBlockStruct.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definition of internal dimuon HLT data structures for storing debugging
+ *         information about trigger records.
+ * 
+ * The structures are defined with C linkage since C generally gives us more
+ * binary compatibility between compilers.
+ */
+
+#include "AliHLTMUONDataTypes.h"
+
+extern "C"
+{
+
+/**
+ * Debug trigger record structures contain debug information about the trigger
+ * records that were decoded from the dimuon hardware trigger electronics.
+ */
+struct AliHLTMUONTrigRecInfoStruct
+{
+       AliHLTInt32_t fTrigRecId; // The corresponding trigger record ID this
+                                 // debug information corresponds to. -1 == invalid.
+
+       AliHLTInt32_t fDetElemId;  // Detector ID number from AliRoot geometry
+                                  // on which the hit clusters were found.
+
+       // The parameters used for momentum estimation:
+       AliHLTFloat32_t fZmiddle; // Particle momentum X component in GeV/c.
+       AliHLTFloat32_t fBl; // The integrated magnetic field in (T.m) tesla metres.
+};
+
+/**
+ * AliHLTMUONTrigRecsDebugBlockStruct defines the format of the internal
+ * data block for storing debugging information for trigger records.
+ */
+struct AliHLTMUONTrigRecsDebugBlockStruct
+{
+       AliHLTMUONDataBlockHeader fHeader; // Common data block header
+
+       // Array of trigger records.
+       AliHLTMUONTrigRecInfoStruct fTrigRecInfo[/*fHeader.fNrecords*/];
+};
+
+} // extern "C"
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the trigger
+ * record debug information in the following format:
+ *  {fTrigRecId = xx, fDetElemId = yy, fZmiddle = zz, fBl = ww}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONTrigRecInfoStruct& info
+       );
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONTrigRecsDebugBlockStruct in the following format:
+ *   {fHeader = xx, fTrigRecInfo[] = [{..}, {..}, ...]}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONTrigRecsDebugBlockStruct& block
+       );
+
+
+inline bool operator == (
+               const AliHLTMUONTrigRecInfoStruct& a,
+               const AliHLTMUONTrigRecInfoStruct& b
+       )
+{
+       return a.fTrigRecId == b.fTrigRecId and a.fDetElemId == b.fDetElemId
+               and a.fZmiddle == b.fZmiddle and a.fBl == b.fBl;
+}
+
+inline bool operator != (
+               const AliHLTMUONTrigRecInfoStruct& a,
+               const AliHLTMUONTrigRecInfoStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+bool operator == (
+               const AliHLTMUONTrigRecsDebugBlockStruct& a,
+               const AliHLTMUONTrigRecsDebugBlockStruct& b
+       );
+
+inline bool operator != (
+               const AliHLTMUONTrigRecsDebugBlockStruct& a,
+               const AliHLTMUONTrigRecsDebugBlockStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+#endif // ALIHLTMUONTRIGRECSDEBUGBLOCKSTRUCT_H
diff --git a/HLT/MUON/AliHLTMUONTriggerChannelsBlockStruct.cxx b/HLT/MUON/AliHLTMUONTriggerChannelsBlockStruct.cxx
new file mode 100644 (file)
index 0000000..c2cb208
--- /dev/null
@@ -0,0 +1,73 @@
+/**************************************************************************
+ * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONTriggerChannelsBlockStruct.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of the stream and comparison operators.
+ */
+
+#include "AliHLTMUONTriggerChannelsBlockStruct.h"
+#include "AliHLTMUONUtils.h"
+#include <cassert>
+
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONTriggerChannelStruct& channel
+       )
+{
+       stream  << "{fTrigRecId = " << channel.fTrigRecId
+               << ", fChamber = " << channel.fChamber
+               << ", fSignal = " << channel.fSignal
+               << ", fRawDataWord = " << std::showbase << std::hex
+               << channel.fRawDataWord << std::dec << "}";
+       return stream;
+}
+
+
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONTriggerChannelsBlockStruct& block
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(block) );
+
+       stream  << "{fHeader = " << block.fHeader << ", fChannel[] = [";
+       if (block.fHeader.fNrecords > 0) stream << block.fChannel[0];
+       for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
+               stream << ", " << block.fChannel[i];
+       stream << "]}";
+       return stream;
+}
+
+
+bool operator == (
+               const AliHLTMUONTriggerChannelsBlockStruct& a,
+               const AliHLTMUONTriggerChannelsBlockStruct& b
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(a) );
+       assert( AliHLTMUONUtils::IntegrityOk(b) );
+
+       // First check if the blocks have the same header. If they do then check
+       // if every channel is the same. In either case if we find a difference
+       // return false.
+       if (a.fHeader != b.fHeader) return false;
+       for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
+               if (a.fChannel[i] != b.fChannel[i]) return false;
+       return true;
+}
diff --git a/HLT/MUON/AliHLTMUONTriggerChannelsBlockStruct.h b/HLT/MUON/AliHLTMUONTriggerChannelsBlockStruct.h
new file mode 100644 (file)
index 0000000..be28fcb
--- /dev/null
@@ -0,0 +1,107 @@
+#ifndef ALIHLTMUONTRIGGERCHANNELSBLOCKSTRUCT_H
+#define ALIHLTMUONTRIGGERCHANNELSBLOCKSTRUCT_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONTriggerChannelsBlockStruct.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definition of internal dimuon HLT block structure containing
+ *         debugging information about channels that belong to trigger records.
+ * 
+ * The structures are defined with C linkage since C generally gives us more
+ * binary compatibility between compilers.
+ */
+
+#include "AliHLTMUONDataTypes.h"
+#include <ostream>
+
+extern "C"
+{
+
+/**
+ * Gives the fired channel/strip information which was considered during
+ * hit reconstruction on trigger chambers and correlated into a common cluster.
+ */
+struct AliHLTMUONTriggerChannelStruct
+{
+       AliHLTInt32_t fTrigRecId; // ID corresponding to the trigger records this
+                                 // channel is part of. -1 == invalid.
+                                 
+       AliHLTUInt16_t fChamber; // The chamber this hit corresponds to.
+                                // In the range [11..14].
+                                
+       AliHLTUInt16_t fSignal;      // ADC value of signal.
+       AliHLTUInt32_t fRawDataWord; // The raw data word as found in the DDL stream.
+};
+
+/**
+ * AliHLTMUONTriggerChannelsBlockStruct defines the format of the internal
+ * channel data block corresponding to clusters on the trigger chambers.
+ */
+struct AliHLTMUONTriggerChannelsBlockStruct
+{
+       AliHLTMUONDataBlockHeader fHeader; // Common data block header
+
+       // Array of trigger channels/strips.
+       AliHLTMUONTriggerChannelStruct fChannel[/*fHeader.fNrecords*/];
+};
+
+} // extern "C"
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONTriggerChannelStruct in the following format:
+ *   {fTrigRecId = xx, fChamber = yy, fSignal = zz, fRawDataWord = 0xXXXXXXXX}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONTriggerChannelStruct& channel
+       );
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONTriggerChannelsBlockStruct in the following format:
+ *   {fHeader = xx, fChannel[] = [{..}, {..}, ...]}
+ */
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONTriggerChannelsBlockStruct& block
+       );
+
+
+inline bool operator == (
+               const AliHLTMUONTriggerChannelStruct& a,
+               const AliHLTMUONTriggerChannelStruct& b
+       )
+{
+       return a.fTrigRecId == b.fTrigRecId and a.fChamber == b.fChamber and
+               a.fSignal == b.fSignal and a.fRawDataWord == b.fRawDataWord;
+}
+
+inline bool operator != (
+               const AliHLTMUONTriggerChannelStruct& a,
+               const AliHLTMUONTriggerChannelStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+bool operator == (
+               const AliHLTMUONTriggerChannelsBlockStruct& a,
+               const AliHLTMUONTriggerChannelsBlockStruct& b
+       );
+
+inline bool operator != (
+               const AliHLTMUONTriggerChannelsBlockStruct& a,
+               const AliHLTMUONTriggerChannelsBlockStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+#endif // ALIHLTMUONTRIGGERCHANNELSBLOCKSTRUCT_H
index 336b37d..8105681 100644 (file)
 
 #include "AliHLTMUONUtils.h"
 #include "AliHLTMUONConstants.h"
+#include "AliHLTMUONTriggerRecordsBlockStruct.h"
+#include "AliHLTMUONTrigRecsDebugBlockStruct.h"
+#include "AliHLTMUONTriggerChannelsBlockStruct.h"
+#include "AliHLTMUONRecHitsBlockStruct.h"
+#include "AliHLTMUONClustersBlockStruct.h"
+#include "AliHLTMUONChannelsBlockStruct.h"
 
 
 AliHLTUInt32_t AliHLTMUONUtils::PackTriggerRecordFlags(
@@ -73,6 +79,26 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block)
        return true;
 }
 
+bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
+{
+       // The block must have the correct type.
+       if (block.fHeader.fType != kTrigRecsDebugDataBlock) return false;
+       // The block's record widths must be the correct size.
+       if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTrigRecInfoStruct))
+               return false;
+       return true;
+}
+
+bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block)
+{
+       // The block must have the correct type.
+       if (block.fHeader.fType != kTriggerChannelsDataBlock) return false;
+       // The block's record widths must be the correct size.
+       if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTriggerChannelStruct))
+               return false;
+       return true;
+}
+
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONRecHitsBlockStruct& block)
 {
        // The block must have the correct type.
@@ -143,6 +169,17 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& blo
        return true;
 }
 
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
+{
+       if (not HeaderOk(block)) return false;
+       return true;
+}
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerChannelsBlockStruct& block)
+{
+       if (not HeaderOk(block)) return false;
+       return true;
+}
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block)
 {
@@ -154,25 +191,23 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block)
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONClustersBlockStruct& block)
 {
        if (not HeaderOk(block)) return false;
-       // The block must have the correct type.
-       if (block.fHeader.fType != kClustersDataBlock) return false;
-       
-       // The block's record widths must be the correct size.
-       if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONClusterStruct))
-               return false;
 
+       // Check if any ID is duplicated.
+       for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
+       {
+               AliHLTUInt32_t id = block.fCluster[i].fId;
+               for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
+               {
+                       if (id == block.fCluster[j].fId)
+                               return false;
+               }
+       }
+       
        return true;
 }
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONChannelsBlockStruct& block)
 {
        if (not HeaderOk(block)) return false;
-       // The block must have the correct type.
-       if (block.fHeader.fType != kChannelsDataBlock) return false;
-       
-       // The block's record widths must be the correct size.
-       if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONChannelStruct))
-               return false;
-
        return true;
 }
index d5eeb7d..b112f4d 100644 (file)
  * @brief  Class containing various dimuon HLT utility routines and macros.
  */
 
-#include "AliHLTMUONTriggerRecordsBlockStruct.h"
-#include "AliHLTMUONRecHitsBlockStruct.h"
-#include "AliHLTMUONClustersBlockStruct.h"
-#include "AliHLTMUONChannelsBlockStruct.h"
+#include "AliHLTMUONDataTypes.h"
+
+// Forward declare structures.
+extern "C" {
+struct AliHLTMUONTriggerRecordsBlockStruct;
+struct AliHLTMUONTrigRecsDebugBlockStruct;
+struct AliHLTMUONTriggerChannelsBlockStruct;
+struct AliHLTMUONRecHitsBlockStruct;
+struct AliHLTMUONClustersBlockStruct;
+struct AliHLTMUONChannelsBlockStruct;
+} // extern "C"
 
 /**
  * AliHLTMUONUtils contains arbitrary utility methods to be used in various
@@ -89,6 +96,8 @@ public:
         * supposed type of the data block.
         */
        static bool HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block);
+       static bool HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block);
+       static bool HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block);
        static bool HeaderOk(const AliHLTMUONRecHitsBlockStruct& block);
        static bool HeaderOk(const AliHLTMUONClustersBlockStruct& block);
        static bool HeaderOk(const AliHLTMUONChannelsBlockStruct& block);
@@ -99,6 +108,8 @@ public:
         * These can be slow and should generally only be used for debugging.
         */
        static bool IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& block);
+       static bool IntegrityOk(const AliHLTMUONTrigRecsDebugBlockStruct& block);
+       static bool IntegrityOk(const AliHLTMUONTriggerChannelsBlockStruct& block);
        static bool IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block);
        static bool IntegrityOk(const AliHLTMUONClustersBlockStruct& block);
        static bool IntegrityOk(const AliHLTMUONChannelsBlockStruct& block);