Adding header files common to dimuon HLT.
authorszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 May 2007 03:22:44 +0000 (03:22 +0000)
committerszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 May 2007 03:22:44 +0000 (03:22 +0000)
AliHLTMUONRecHitsBlockStruct.h contains the reconstructed hit structure generated by the hit reconstruction component. It is now a 3D point which is
required if we are to have any kind of p_T resolution.
AliHLTMUONRecHitsDebugBlockStruct.* contain the structure definitions of the data block for debugging information from the hit rec component.
AliHLTMUONConstants.* contain some useful constants like data type definitions.
AliHLTMUONUtils.* at the moment just contains a routine to check integrity of AliHLTMUONRecHitsDebugBlockStruct data blocks.

HLT/MUON/AliHLTMUONConstants.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONConstants.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONRecHitsBlockStruct.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONRecHitsDebugBlockStruct.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONRecHitsDebugBlockStruct.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONUtils.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONUtils.h [new file with mode: 0644]

diff --git a/HLT/MUON/AliHLTMUONConstants.cxx b/HLT/MUON/AliHLTMUONConstants.cxx
new file mode 100644 (file)
index 0000000..3e52404
--- /dev/null
@@ -0,0 +1,102 @@
+/**************************************************************************
+ * 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   AliHLTMUONConstants.cxx
+ * @author Indranil Das <indra.das@saha.ac.in>,
+ *         Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definitions of the various dimuon HLT constants.
+ */
+
+#include "AliHLTMUONConstants.h"
+
+const AliHLTMUONRecHitStruct
+AliHLTMUONConstants::fgkNilRecHitStruct = {0, 0, 0};
+
+const AliHLTMUONChannelInfoStruct
+AliHLTMUONConstants::fgkNilChannelInfoStruct = {0, 0, 0, 0};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkTriggerDDLStreamDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'D','D','L','T','R','I','G','R'},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkTrackingDDLStreamDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'D','D','L','T','R','A','C','K'},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkRecHitsBlockDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'R','E','C','H','I','T','S',' '},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkRecHitsDebugBlockDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'R','H','I','T','S','d','b','g'},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkTriggerRecordsBlockDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'T','R','I','G','R','E','C','S'},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkTriggerRecordsDebugBlockDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'T','R','I','G','R','d','b','g'},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkMansoTracksBlockDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'M','A','N','T','R','A','C','K'},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkMansoTracksDebugBlockDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'M','N','T','R','K','d','b','g'},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkDecisionBlockDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'D','E','C','I','S','I','O','N'},
+       {'D','I','M','U'}
+};
+
+const AliHLTComponentDataType
+AliHLTMUONConstants::fgkDecisionDebugBlockDataType = {
+       sizeof(AliHLTComponentDataType),
+       {'D','E','C','I','S','d','b','g'},
+       {'D','I','M','U'}
+};
diff --git a/HLT/MUON/AliHLTMUONConstants.h b/HLT/MUON/AliHLTMUONConstants.h
new file mode 100644 (file)
index 0000000..5c8f016
--- /dev/null
@@ -0,0 +1,139 @@
+#ifndef ALIHLTMUONCONSTANTS_H
+#define ALIHLTMUONCONSTANTS_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONConstants.h
+ * @author Indranil Das <indra.das@saha.ac.in>,
+ *         Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Class containing various dimuon HLT constants used in the system.
+ */
+
+#include "AliHLTDataTypes.h"
+#include "AliHLTMUONRecHitsBlockStruct.h"
+#include "AliHLTMUONRecHitsDebugBlockStruct.h"
+
+/**
+ * AliHLTMUONConstants contains a list of global dimuon HLT specific constants
+ * and constant structures used in the system.
+ * Static methods are provided to access these values.
+ */
+class AliHLTMUONConstants
+{
+public:
+
+       static const AliHLTMUONRecHitStruct& NilRecHitStruct()
+       {
+               return fgkNilRecHitStruct;
+       }
+
+       static const AliHLTMUONChannelInfoStruct& NilChannelInfoStruct()
+       {
+               return fgkNilChannelInfoStruct;
+       }
+
+       static const AliHLTMUONClusterInfoStruct& NilClusterInfoStruct()
+       {
+               return fgkNilClusterInfoStruct;
+       }
+
+       static const AliHLTComponentDataType& TriggerDDLStreamDataType()
+       {
+               return fgkTriggerDDLStreamDataType;
+       }
+
+       static const AliHLTComponentDataType& TrackingDDLStreamDataType()
+       {
+               return fgkTrackingDDLStreamDataType;
+       }
+
+       static const AliHLTComponentDataType& RecHitsBlockDataType()
+       {
+               return fgkRecHitsBlockDataType;
+       }
+
+       static const AliHLTComponentDataType& RecHitsDebugBlockDataType()
+       {
+               return fgkRecHitsDebugBlockDataType;
+       }
+
+       static const AliHLTComponentDataType& TriggerRecordsBlockDataType()
+       {
+               return fgkTriggerRecordsBlockDataType;
+       }
+
+       static const AliHLTComponentDataType& TriggerRecordsDebugBlockDataType()
+       {
+               return fgkTriggerRecordsDebugBlockDataType;
+       }
+
+       static const AliHLTComponentDataType& MansoTracksBlockDataType()
+       {
+               return fgkMansoTracksBlockDataType;
+       }
+
+       static const AliHLTComponentDataType& MansoTracksDebugBlockDataType()
+       {
+               return fgkMansoTracksDebugBlockDataType;
+       }
+
+       static const AliHLTComponentDataType& DecisionBlockDataType()
+       {
+               return fgkDecisionBlockDataType;
+       }
+
+       static const AliHLTComponentDataType& DecisionDebugBlockDataType()
+       {
+               return fgkDecisionDebugBlockDataType;
+       }
+
+private:
+       // Should never have to create or destroy this object.
+       AliHLTMUONConstants();
+       ~AliHLTMUONConstants();
+
+       // Sentinel structure for a reconstructed hit.
+       static const AliHLTMUONRecHitStruct fgkNilRecHitStruct;
+
+       // Sentinel structure for channel information.
+       static const AliHLTMUONChannelInfoStruct fgkNilChannelInfoStruct;
+
+       // Sentinel structure for cluster information.
+       static const AliHLTMUONClusterInfoStruct fgkNilClusterInfoStruct;
+
+       // DDL packed data block type from dimuon trigger stations.
+       static const AliHLTComponentDataType fgkTriggerDDLStreamDataType;
+
+       // DDL packed data block type from dimuon tracking stations.
+       static const AliHLTComponentDataType fgkTrackingDDLStreamDataType;
+
+       // Reconstructed hits block type generated by hit reconstruction components.
+       static const AliHLTComponentDataType fgkRecHitsBlockDataType;
+
+       // Debugging information block type generated by hit reconstruction components.
+       static const AliHLTComponentDataType fgkRecHitsDebugBlockDataType;
+
+       // Trigger records block type generated by trigger DDL translation components.
+       static const AliHLTComponentDataType fgkTriggerRecordsBlockDataType;
+
+       // Debugging information block type generated by trigger DDL translation components.
+       static const AliHLTComponentDataType fgkTriggerRecordsDebugBlockDataType;
+
+       // Manso tracks block type generated by Manso tracker components.
+       static const AliHLTComponentDataType fgkMansoTracksBlockDataType;
+
+       // Debugging information block type generated by Manso tracker components.
+       static const AliHLTComponentDataType fgkMansoTracksDebugBlockDataType;
+
+       // Trigger decision block type generated by dimuon HLT trigger components.
+       static const AliHLTComponentDataType fgkDecisionBlockDataType;
+
+       // Debugging information block type generated by dimuon HLT trigger components.
+       static const AliHLTComponentDataType fgkDecisionDebugBlockDataType;
+};
+
+#endif // ALIHLTMUONCONSTANTS_H
diff --git a/HLT/MUON/AliHLTMUONRecHitsBlockStruct.h b/HLT/MUON/AliHLTMUONRecHitsBlockStruct.h
new file mode 100644 (file)
index 0000000..5b60a1f
--- /dev/null
@@ -0,0 +1,128 @@
+#ifndef ALIHLTMUONRECHITSBLOCKSTRUCT_H
+#define ALIHLTMUONRECHITSBLOCKSTRUCT_H
+/**************************************************************************
+ * 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   AliHLTMUONRecHitsBlockStruct.h
+ * @author Indranil Das <indra.das@saha.ac.in>,
+ *         Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definition of internal dimuon HLT reconstructed hit block structure.
+ * 
+ * The structures are defined with C linkage since C generally gives us more
+ * binary compatibility between compilers.
+ */
+
+#include "AliHLTMUONDataTypes.h"
+
+extern "C"
+{
+
+/**
+ * A 3D reconstructed hit point structure.
+ * These are used to store the hits reconstructed on the tracking or trigger
+ * chambers.
+ * Reconstructed hit values of (0, 0, 0) indicate an invalid or nil hit.
+ */
+struct AliHLTMUONRecHitStruct
+{
+       AliHLTFloat32_t fX; // X coordinate.
+       AliHLTFloat32_t fY; // Y coordinate.
+       AliHLTFloat32_t fZ; // Z coordinate.
+};
+
+/**
+ * AliHLTMUONRecHitsBlockStruct defines the format of the internal
+ * reconstructed hit data block.
+ */
+struct AliHLTMUONRecHitsBlockStruct
+{
+       AliHLTUInt32_t fNhits;                   // Number of hits in this block.
+       AliHLTMUONRecHitStruct fHit[/*fNhits*/]; // Array of reconstructed hits.
+};
+
+} // extern "C"
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * reconstructed hit in the following format: {fX = xx, fY = yy, fZ = zz}
+ */
+inline std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONRecHitStruct& hit
+       )
+{
+       stream  << "{fX = " << hit.fX << ", fY = " << hit.fY << ", fZ = "
+               << hit.fZ << "}";
+       return stream;
+}
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONRecHitsBlockStruct in the following format:
+ *   {fNhits = xx, fHit[] = [{..}, {..}, ...]}
+ */
+inline std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONRecHitsBlockStruct& block
+       )
+{
+       stream << "{fNhits = " << block.fNhits << ", fHit[] = [";
+       if (block.fNhits > 0) stream << block.fHit[0];
+       for (AliHLTUInt32_t i = 1; i < block.fNhits; i++)
+               stream << ", " << block.fHit[i];
+       stream << "]}";
+       return stream;
+}
+
+
+inline bool operator == (
+               const AliHLTMUONRecHitStruct& a, const AliHLTMUONRecHitStruct& b
+       )
+{
+       return a.fX == b.fX and a.fY == b.fY and a.fZ == b.fZ;
+}
+
+inline bool operator != (
+               const AliHLTMUONRecHitStruct& a, const AliHLTMUONRecHitStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+inline bool operator == (
+               const AliHLTMUONRecHitsBlockStruct& a, const AliHLTMUONRecHitsBlockStruct& b
+       )
+{
+       // First check if the blocks have the same number of hits. If they do then
+       // check if every hit is the same. In either case if we find a difference
+       // return false.
+       if (a.fNhits != b.fNhits) return false;
+       for (AliHLTUInt32_t i = 0; i < a.fNhits; i++)
+               if (a.fHit[i] != b.fHit[i]) return false;
+       return true;
+}
+
+inline bool operator != (
+               const AliHLTMUONRecHitsBlockStruct& a, const AliHLTMUONRecHitsBlockStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+#endif // ALIHLTMUONRECHITSBLOCKSTRUCT_H
diff --git a/HLT/MUON/AliHLTMUONRecHitsDebugBlockStruct.cxx b/HLT/MUON/AliHLTMUONRecHitsDebugBlockStruct.cxx
new file mode 100644 (file)
index 0000000..dbde3b5
--- /dev/null
@@ -0,0 +1,128 @@
+/**************************************************************************
+ * 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   AliHLTMUONRecHitsDebugBlockStruct.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of the stream and comparison operators.
+ */
+
+#include "AliHLTMUONRecHitsDebugBlockStruct.h"
+#include "AliHLTMUONUtils.h"
+#include <assert.h>
+
+
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONClusterInfoStruct& cluster
+       )
+{
+       stream  << "{fClusterId = " << cluster.fClusterId
+               << ", fHit = " << cluster.fHit
+               << ", fDetElemId = " << cluster.fDetElemId
+               << ", fNchannels = " << cluster.fNchannels << "}";
+       return stream;
+}
+
+
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONChannelInfoStruct& channel
+       )
+{
+       stream  << "{fClusterId = " << channel.fClusterId
+               << ", fManu = " << channel.fManu
+               << ", fChannel = " << channel.fChannel
+               << ", fSignal = " << channel.fSignal
+               << ", fRawDataWord = " << std::showbase << std::hex
+               << channel.fRawDataWord << std::dec << "}";
+       return stream;
+}
+
+
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONRecHitsDebugBlockStruct& block
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(block) );
+
+       const AliHLTMUONChannelInfoStruct* channel =
+               reinterpret_cast<const AliHLTMUONChannelInfoStruct*>(
+                       & block.fCluster[block.fNclusters]
+               );
+
+       // Now write the block header information.
+       stream  << "{fNclusters = " << block.fNclusters
+               << ", fClustersStartOffset = " << block.fClustersStartOffset
+               << ", fClustersEndOffset = " << block.fClustersEndOffset
+               << ", fNchannels = " << block.fNchannels
+               << ", fChannelsStartOffset = " << block.fChannelsStartOffset
+               << ", fChannelsEndOffset = " << block.fChannelsEndOffset
+               << ", fCluster[] = ";
+
+       // And finally write the arrays.
+       if (block.fNclusters > 0) stream << block.fCluster[0];
+       for (AliHLTUInt32_t i = 1; i < block.fNclusters; i++)
+               stream << ", " << block.fCluster[i];
+
+       stream << "], fChannels[] = ";
+       if (block.fNchannels > 0) stream << channel[0];
+       for (AliHLTUInt32_t i = 1; i < block.fNchannels; i++)
+               stream << ", " << channel[i];
+       stream << "]}";
+
+       return stream;
+}
+
+
+bool operator == (
+               const AliHLTMUONRecHitsDebugBlockStruct& a,
+               const AliHLTMUONRecHitsDebugBlockStruct& b
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(a) );
+       assert( AliHLTMUONUtils::IntegrityOk(b) );
+
+       const AliHLTMUONChannelInfoStruct* channelA =
+               reinterpret_cast<const AliHLTMUONChannelInfoStruct*>(
+                       & a.fCluster[a.fNclusters]
+               );
+       const AliHLTMUONChannelInfoStruct* channelB =
+               reinterpret_cast<const AliHLTMUONChannelInfoStruct*>(
+                       & b.fCluster[b.fNclusters]
+               );
+
+       // First check if the blocks have the same header fields. If they do then
+       // check the cluster and channel arrays are the same. In either case if we
+       // find a difference return false.
+       if (
+               a.fNclusters != b.fNclusters
+               or a.fClustersStartOffset != b.fClustersStartOffset
+               or a.fClustersEndOffset != b.fClustersEndOffset
+               or a.fNchannels != b.fNchannels
+               or a.fChannelsStartOffset != b.fChannelsStartOffset
+               or a.fChannelsEndOffset != b.fChannelsEndOffset
+          )
+               return false;
+
+       for (AliHLTUInt32_t i = 0; i < a.fNclusters; i++)
+               if (a.fCluster[i] != b.fCluster[i]) return false;
+       for (AliHLTUInt32_t i = 0; i < a.fNchannels; i++)
+               if (channelA[i] != channelB[i]) return false;
+
+       return true;
+}
diff --git a/HLT/MUON/AliHLTMUONRecHitsDebugBlockStruct.h b/HLT/MUON/AliHLTMUONRecHitsDebugBlockStruct.h
new file mode 100644 (file)
index 0000000..14ce11c
--- /dev/null
@@ -0,0 +1,169 @@
+#ifndef ALIHLTMUONRECHITSDEBUGBLOCKSTRUCT_H
+#define ALIHLTMUONRECHITSDEBUGBLOCKSTRUCT_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONRecHitsDebugBlockStruct.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definition of internal dimuon HLT block structure containing
+ *         debugging information about reconstructed hits.
+ * 
+ * The structures are defined with C linkage since C generally gives us more
+ * binary compatibility between compilers.
+ */
+
+#include "AliHLTMUONDataTypes.h"
+#include "AliHLTMUONRecHitsBlockStruct.h"
+#include <ostream>
+
+extern "C"
+{
+
+/**
+ * Debugging information about a cluster and its reconstructed hit.
+ */
+struct AliHLTMUONClusterInfoStruct
+{
+       AliHLTUInt32_t fClusterId; // Unique ID for the cluster. It must be at
+                                  // least unique for any given data block.
+
+       AliHLTMUONRecHitStruct fHit; // Corresponding reconstructed hit.
+
+       AliHLTInt32_t fDetElemId;  // Detector ID number from AliRoot geometry
+                                  // on which the cluster was found.
+
+       AliHLTUInt32_t fNchannels; // Number of channels/pads in the cluster.
+};
+
+/**
+ * Gives the fired channel/pad information which was considered during
+ * hit reconstruction and correlated into a common cluster.
+ */
+struct AliHLTMUONChannelInfoStruct
+{
+       AliHLTUInt32_t fClusterId;   // ID corresponding to the cluster this
+                                    // channels is part of.
+
+       AliHLTUInt16_t fManu;        // The MANU address on electronics.
+       AliHLTUInt16_t fChannel;     // The channel address on electronics.
+       AliHLTUInt16_t fSignal;      // ADC value of signal.
+       AliHLTUInt32_t fRawDataWord; // The raw data word as found in the DDL stream.
+};
+
+/**
+ * AliHLTMUONRecHitsDebugBlockStruct defines the format of the internal data
+ * block which contains debugging information about reconstructed hits.
+ */
+struct AliHLTMUONRecHitsDebugBlockStruct
+{
+       AliHLTUInt32_t fNclusters; // Number of cluster records in this block.
+       
+       // Offset in bytes to the start and end of the cluster data from the
+       // beginning of this AliHLTMUONRecHitsDebugBlockStruct structure.
+       AliHLTUInt32_t fClustersStartOffset;
+       AliHLTUInt32_t fClustersEndOffset;
+
+       AliHLTUInt32_t fNchannels; // Number of channel records in this block.
+       
+       // Offset in bytes to the start and end of the channel data from the
+       // beginning of this AliHLTMUONRecHitsDebugBlockStruct structure.
+       AliHLTUInt32_t fChannelsStartOffset;
+       AliHLTUInt32_t fChannelsEndOffset;
+
+       // Array of debugging information for reconstructed hits.
+       AliHLTMUONClusterInfoStruct fCluster[/*fNclusters*/];
+
+       // The array of channel information would follow here.
+       //AliHLTMUONChannelInfoStruct fChannel[fNchannels];
+};
+
+} // extern "C"
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONClusterInfoStruct in the following format:
+ *   {fClusterId = xx, fHit = yy, fDetElemId = zz, fNchannels = ww}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONClusterInfoStruct& cluster
+       );
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONChannelInfoStruct in the following format:
+ *   {fClusterId = xx, fManu = yy, fChannel = zz, fSignal = ww, fRawDataWord = 0xXXXXXXXX}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONChannelInfoStruct& channel
+       );
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONRecHitsDebugBlockStruct in the following format:
+ *   {fNclusters = xx, fClustersStartOffset = yy, fClustersEndOffset = zz,
+ *    fNchannels = uu, fChannelsStartOffset = vv, fChannelsEndOffset = ww,
+ *    fCluster[] = [{..}, {..}, ...], fChannel[] = [{..}, {..}, ...]}
+ */
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONRecHitsDebugBlockStruct& block
+       );
+
+
+inline bool operator == (
+               const AliHLTMUONClusterInfoStruct& a,
+               const AliHLTMUONClusterInfoStruct& b
+       )
+{
+       return  a.fClusterId == b.fClusterId and a.fHit == b.fHit and
+               a.fDetElemId == b.fDetElemId and a.fNchannels == b.fNchannels;
+}
+
+inline bool operator != (
+               const AliHLTMUONClusterInfoStruct& a,
+               const AliHLTMUONClusterInfoStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+inline bool operator == (
+               const AliHLTMUONChannelInfoStruct& a,
+               const AliHLTMUONChannelInfoStruct& b
+       )
+{
+       return  a.fClusterId == b.fClusterId and a.fManu == b.fManu and
+               a.fChannel == b.fChannel and a.fSignal == b.fSignal and
+               a.fRawDataWord == b.fRawDataWord;
+}
+
+inline bool operator != (
+               const AliHLTMUONChannelInfoStruct& a,
+               const AliHLTMUONChannelInfoStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+bool operator == (
+               const AliHLTMUONRecHitsDebugBlockStruct& a,
+               const AliHLTMUONRecHitsDebugBlockStruct& b
+       );
+
+inline bool operator != (
+               const AliHLTMUONRecHitsDebugBlockStruct& a,
+               const AliHLTMUONRecHitsDebugBlockStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+#endif // ALIHLTMUONRECHITSDEBUGBLOCKSTRUCT_H
diff --git a/HLT/MUON/AliHLTMUONUtils.cxx b/HLT/MUON/AliHLTMUONUtils.cxx
new file mode 100644 (file)
index 0000000..e435e0b
--- /dev/null
@@ -0,0 +1,55 @@
+/**************************************************************************
+ * 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   AliHLTMUONUtils.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of AliHLTMUONUtils utility routines.
+ */
+
+#include "AliHLTMUONUtils.h"
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONRecHitsDebugBlockStruct& block)
+{
+       // Perform some sanity checks:
+       // We expect the start and end offsets to correspond to the number
+       // of elements in the array. The offsets should not overlap and
+       // the arrays should be consecutive.
+       if (block.fClustersEndOffset < block.fClustersStartOffset) return false;
+       if (block.fChannelsEndOffset < block.fChannelsStartOffset) return false;
+
+       if ((block.fClustersEndOffset - block.fClustersStartOffset)
+               / sizeof(AliHLTMUONClusterInfoStruct) != block.fNclusters
+          )
+               return false;
+
+       if ((block.fChannelsEndOffset - block.fChannelsStartOffset)
+               / sizeof(AliHLTMUONChannelInfoStruct) != block.fNchannels
+          )
+               return false;
+
+       if (block.fClustersEndOffset != block.fChannelsStartOffset) return false;
+
+       if (block.fClustersStartOffset != sizeof(AliHLTMUONRecHitsDebugBlockStruct))
+               return false;
+
+       // TODO: check the channel ID's etc...
+
+       return true;
+}
diff --git a/HLT/MUON/AliHLTMUONUtils.h b/HLT/MUON/AliHLTMUONUtils.h
new file mode 100644 (file)
index 0000000..537d065
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef ALIHLTMUONUTILS_H
+#define ALIHLTMUONUTILS_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONUtils.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Class containing various dimuon HLT utility routines.
+ */
+
+#include "AliHLTMUONRecHitsDebugBlockStruct.h"
+
+/**
+ * AliHLTMUONUtils contains arbitrary utility methods to be used in various
+ * parts of the dimuon HLT system.
+ * These include methods to perform basic sanity checks on the integrity of
+ * data blocks.
+ */
+class AliHLTMUONUtils
+{
+public:
+
+       /**
+        * Checks if the integrity of the block is Ok and returns true in that case.
+        */
+       static bool IntegrityOk(const AliHLTMUONRecHitsDebugBlockStruct& block);
+
+private:
+       // Should never have to create or destroy this object.
+       AliHLTMUONUtils();
+       ~AliHLTMUONUtils();
+};
+
+#endif // ALIHLTMUONUTILS_H