Adding new internal dimuon HLT data structures for the Manso tracker and dHLT trigger...
authorszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 21 May 2007 01:17:32 +0000 (01:17 +0000)
committerszostak <szostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 21 May 2007 01:17:32 +0000 (01:17 +0000)
AliHLTMUONMansoTracksBlockStruct contains tracks partially reconstructed by the Manso tracker.
AliHLTMUONMansoCandidatesBlockStruct is used for debugging and contains track candidates considered by the tracker.
AliHLTMUONSinglesDecisionBlockStruct contains trigger decisions about single tracks.
AliHLTMUONPairsDecisionBlockStruct contains trigger decisions about pairs of tracks.

15 files changed:
HLT/MUON/AliHLTMUONConstants.cxx
HLT/MUON/AliHLTMUONConstants.h
HLT/MUON/AliHLTMUONDataBlockReader.h
HLT/MUON/AliHLTMUONDataBlockWriter.h
HLT/MUON/AliHLTMUONDataTypes.h
HLT/MUON/AliHLTMUONMansoCandidatesBlockStruct.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONMansoCandidatesBlockStruct.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONMansoTracksBlockStruct.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONMansoTracksBlockStruct.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONPairsDecisionBlockStruct.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONPairsDecisionBlockStruct.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.cxx [new file with mode: 0644]
HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.h [new file with mode: 0644]
HLT/MUON/AliHLTMUONUtils.cxx
HLT/MUON/AliHLTMUONUtils.h

index d2a79a0..227f6c6 100644 (file)
 const AliHLTMUONTriggerRecordStruct
 AliHLTMUONConstants::fgkNilTriggerRecordStruct = {
        0, 0, 0, 0, 0,
-       {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}
+       {
+        AliHLTMUONConstants::fgkNilRecHitStruct,
+        AliHLTMUONConstants::fgkNilRecHitStruct,
+        AliHLTMUONConstants::fgkNilRecHitStruct,
+        AliHLTMUONConstants::fgkNilRecHitStruct
+       }
 };
 
 const AliHLTMUONTrigRecInfoStruct
@@ -42,11 +47,44 @@ const AliHLTMUONRecHitStruct
 AliHLTMUONConstants::fgkNilRecHitStruct = {0, 0, 0};
 
 const AliHLTMUONClusterStruct
-AliHLTMUONConstants::fgkNilClusterStruct = {0, {0, 0, 0}, 0, 0};
+AliHLTMUONConstants::fgkNilClusterStruct = {
+       0, AliHLTMUONConstants::fgkNilRecHitStruct, 0, 0
+};
 
 const AliHLTMUONChannelStruct
 AliHLTMUONConstants::fgkNilChannelStruct = {0, 0, 0, 0, 0};
 
+const AliHLTMUONMansoTrackStruct
+AliHLTMUONConstants::fgkNilMansoTrackStruct = {
+       0, 0, 0, 0, 0, 0, 0,
+       {
+        AliHLTMUONConstants::fgkNilRecHitStruct,
+        AliHLTMUONConstants::fgkNilRecHitStruct,
+        AliHLTMUONConstants::fgkNilRecHitStruct,
+        AliHLTMUONConstants::fgkNilRecHitStruct
+       }
+};
+       
+const AliHLTMUONMansoRoIStruct
+AliHLTMUONConstants::fgkNilMansoRoIStruct = {0, 0, 0, 0};
+
+const AliHLTMUONMansoCandidateStruct
+AliHLTMUONConstants::fgkNilMansoCandidateStruct = {
+       AliHLTMUONConstants::fgkNilMansoTrackStruct,
+       {
+        AliHLTMUONConstants::fgkNilMansoRoIStruct,
+        AliHLTMUONConstants::fgkNilMansoRoIStruct,
+        AliHLTMUONConstants::fgkNilMansoRoIStruct,
+        AliHLTMUONConstants::fgkNilMansoRoIStruct
+       }
+};
+
+const AliHLTMUONTrackDecisionStruct
+AliHLTMUONConstants::fgkNilTrackDecisionStruct = {0, 0};
+
+const AliHLTMUONPairDecisionStruct
+AliHLTMUONConstants::fgkNilPairDecisionStruct = {0, 0, 0, 0};
+
 
 const AliHLTComponentDataType
 AliHLTMUONConstants::fgkTriggerDDLStreamDataType = {
@@ -112,29 +150,22 @@ AliHLTMUONConstants::fgkMansoTracksBlockDataType = {
 };
 
 const AliHLTComponentDataType
-AliHLTMUONConstants::fgkMansoRoIBlockDataType = {
-       sizeof(AliHLTComponentDataType),
-       {'M','A','N','S','O','R','O','I'},
-       {'D','I','M','U'}
-};
-
-const AliHLTComponentDataType
-AliHLTMUONConstants::fgkMansoTrialsBlockDataType = {
+AliHLTMUONConstants::fgkMansoCandidatesBlockDataType = {
        sizeof(AliHLTComponentDataType),
-       {'M','A','N','T','R','I','A','L'},
+       {'M','N','C','A','N','D','I','D'},
        {'D','I','M','U'}
 };
 
 const AliHLTComponentDataType
-AliHLTMUONConstants::fgkDecisionBlockDataType = {
+AliHLTMUONConstants::fgkSinglesDecisionBlockDataType = {
        sizeof(AliHLTComponentDataType),
-       {'D','E','C','I','S','I','O','N'},
+       {'D','E','C','I','D','S','G','L'},
        {'D','I','M','U'}
 };
 
 const AliHLTComponentDataType
-AliHLTMUONConstants::fgkDecisionDebugBlockDataType = {
+AliHLTMUONConstants::fgkPairsDecisionBlockDataType = {
        sizeof(AliHLTComponentDataType),
-       {'D','E','C','I','S','D','B','G'},
+       {'D','E','C','I','D','P','A','R'},
        {'D','I','M','U'}
 };
index e924166..ca09e26 100644 (file)
 #include "AliHLTMUONRecHitsBlockStruct.h"
 #include "AliHLTMUONClustersBlockStruct.h"
 #include "AliHLTMUONChannelsBlockStruct.h"
+#include "AliHLTMUONMansoTracksBlockStruct.h"
+#include "AliHLTMUONMansoCandidatesBlockStruct.h"
+#include "AliHLTMUONSinglesDecisionBlockStruct.h"
+#include "AliHLTMUONPairsDecisionBlockStruct.h"
 
 /**
  * AliHLTMUONConstants contains a list of global dimuon HLT specific constants
@@ -59,6 +63,31 @@ public:
                return fgkNilClusterStruct;
        }
 
+       static const AliHLTMUONMansoTrackStruct& NilMansoTrackStruct()
+       {
+               return fgkNilMansoTrackStruct;
+       }
+
+       static const AliHLTMUONMansoRoIStruct& NilMansoRoIStruct()
+       {
+               return fgkNilMansoRoIStruct;
+       }
+
+       static const AliHLTMUONMansoCandidateStruct& NilMansoCandidateStruct()
+       {
+               return fgkNilMansoCandidateStruct;
+       }
+
+       static const AliHLTMUONTrackDecisionStruct& NilTrackDecisionStruct()
+       {
+               return fgkNilTrackDecisionStruct;
+       }
+
+       static const AliHLTMUONPairDecisionStruct& NilPairDecisionStruct()
+       {
+               return fgkNilPairDecisionStruct;
+       }
+
        static const AliHLTComponentDataType& TriggerDDLStreamDataType()
        {
                return fgkTriggerDDLStreamDataType;
@@ -104,27 +133,23 @@ public:
                return fgkMansoTracksBlockDataType;
        }
 
-       static const AliHLTComponentDataType& MansoRoIBlockDataType()
+       static const AliHLTComponentDataType& MansoCandidatesBlockDataType()
        {
-               return fgkMansoRoIBlockDataType;
+               return fgkMansoCandidatesBlockDataType;
        }
 
-       static const AliHLTComponentDataType& MansoTrialsBlockDataType()
+       static const AliHLTComponentDataType& SinglesDecisionBlockDataType()
        {
-               return fgkMansoTrialsBlockDataType;
+               return fgkSinglesDecisionBlockDataType;
        }
 
-       static const AliHLTComponentDataType& DecisionBlockDataType()
+       static const AliHLTComponentDataType& PairsDecisionBlockDataType()
        {
-               return fgkDecisionBlockDataType;
-       }
-
-       static const AliHLTComponentDataType& DecisionDebugBlockDataType()
-       {
-               return fgkDecisionDebugBlockDataType;
+               return fgkPairsDecisionBlockDataType;
        }
 
 private:
+
        // Should never have to create or destroy this object.
        AliHLTMUONConstants();
        ~AliHLTMUONConstants();
@@ -136,6 +161,11 @@ private:
        static const AliHLTMUONRecHitStruct fgkNilRecHitStruct;
        static const AliHLTMUONChannelStruct fgkNilChannelStruct;
        static const AliHLTMUONClusterStruct fgkNilClusterStruct;
+       static const AliHLTMUONMansoTrackStruct fgkNilMansoTrackStruct;
+       static const AliHLTMUONMansoRoIStruct fgkNilMansoRoIStruct;
+       static const AliHLTMUONMansoCandidateStruct fgkNilMansoCandidateStruct;
+       static const AliHLTMUONTrackDecisionStruct fgkNilTrackDecisionStruct;
+       static const AliHLTMUONPairDecisionStruct fgkNilPairDecisionStruct;
 
        // DDL packed data block type from dimuon trigger stations.
        static const AliHLTComponentDataType fgkTriggerDDLStreamDataType;
@@ -164,19 +194,14 @@ private:
        // Manso tracks block type generated by Manso tracker components.
        static const AliHLTComponentDataType fgkMansoTracksBlockDataType;
 
-       // Debugging information block type containing region of interests
-       // considered by the Manso tracker components.
-       static const AliHLTComponentDataType fgkMansoRoIBlockDataType;
-
-       // Debugging information block type containing the trial tracks considered
-       // by the Manso tracker components.
-       static const AliHLTComponentDataType fgkMansoTrialsBlockDataType;
+       // Debugging information about a track candidate generated by the Manso algorithm.
+       static const AliHLTComponentDataType fgkMansoCandidatesBlockDataType;
 
-       // Trigger decision block type generated by dimuon HLT trigger components.
-       static const AliHLTComponentDataType fgkDecisionBlockDataType;
+       // Trigger decision block type for single track decisions.
+       static const AliHLTComponentDataType fgkSinglesDecisionBlockDataType;
 
-       // Debugging information block type generated by dimuon HLT trigger components.
-       static const AliHLTComponentDataType fgkDecisionDebugBlockDataType;
+       // Trigger decision block type for pairs of particles.
+       static const AliHLTComponentDataType fgkPairsDecisionBlockDataType;
 };
 
 #endif // ALIHLTMUONCONSTANTS_H
index 5d09f84..44a0c8e 100644 (file)
 #include "AliHLTMUONRecHitsBlockStruct.h"
 #include "AliHLTMUONClustersBlockStruct.h"
 #include "AliHLTMUONChannelsBlockStruct.h"
+#include "AliHLTMUONMansoTracksBlockStruct.h"
+#include "AliHLTMUONMansoCandidatesBlockStruct.h"
+#include "AliHLTMUONSinglesDecisionBlockStruct.h"
+#include "AliHLTMUONPairsDecisionBlockStruct.h"
 
 /**
  * A light weight class for reading the contents of an internal dimuon HLT
@@ -105,10 +109,18 @@ public:
        /**
         * Returns the common data block header.
         */
-       const AliHLTMUONDataBlockHeader& BlockHeader() const
+       const AliHLTMUONDataBlockHeader& CommonBlockHeader() const
        {
                return fBlock->fHeader;
        }
+       
+       /**
+        * Returns the whole data block header.
+        */
+       const DataBlockType& BlockHeader() const
+       {
+               return fBlock;
+       }
 
        /**
         * Returns the total number of entries in the data block.
@@ -187,4 +199,24 @@ typedef AliHLTMUONDataBlockReader<
                AliHLTMUONChannelStruct
        > AliHLTMUONChannelsBlockReader;
 
+typedef AliHLTMUONDataBlockReader<
+               AliHLTMUONMansoTracksBlockStruct,
+               AliHLTMUONMansoTrackStruct
+       > AliHLTMUONMansoTracksBlockReader;
+
+typedef AliHLTMUONDataBlockReader<
+               AliHLTMUONMansoCandidatesBlockStruct,
+               AliHLTMUONMansoCandidateStruct
+       > AliHLTMUONMansoCandidatesBlockReader;
+
+typedef AliHLTMUONDataBlockReader<
+               AliHLTMUONSinglesDecisionBlockStruct,
+               AliHLTMUONTrackDecisionStruct
+       > AliHLTMUONSinglesDecisionBlockReader;
+
+typedef AliHLTMUONDataBlockReader<
+               AliHLTMUONPairsDecisionBlockStruct,
+               AliHLTMUONPairDecisionStruct
+       > AliHLTMUONPairsDecisionBlockReader;
+
 #endif // ALIHLTMUONDATABLOCKREADER_H
index b6d3b3e..16679cd 100644 (file)
 #include "AliHLTMUONRecHitsBlockStruct.h"
 #include "AliHLTMUONClustersBlockStruct.h"
 #include "AliHLTMUONChannelsBlockStruct.h"
+#include "AliHLTMUONMansoTracksBlockStruct.h"
+#include "AliHLTMUONMansoCandidatesBlockStruct.h"
+#include "AliHLTMUONSinglesDecisionBlockStruct.h"
+#include "AliHLTMUONPairsDecisionBlockStruct.h"
 
 /**
  * A light weight class for writing an internal dimuon HLT data block.
@@ -113,11 +117,11 @@ public:
        }
 
        /**
-        * Initialises the data block header by setting the type and record width
-        * fields. If the buffer size was to small to create the header then this
-        * method returns false, otherwise true on success.
+        * Initialises the common data block header by setting the type and record
+        * width fields. If the buffer size was to small to create the header then
+        * this method returns false, otherwise true on success.
         */
-       bool InitHeader() const
+       bool InitCommonHeader() const
        {
                // The block size must be at least sizeof(DataBlockType) bytes.
                if (fSize < sizeof(DataBlockType)) return false;
@@ -130,13 +134,26 @@ public:
        }
        
        /**
-        * Returns the data block header.
+        * Returns the common data block header.
         */
-       const AliHLTMUONDataBlockHeader& BlockHeader() const
+       const AliHLTMUONDataBlockHeader& CommonBlockHeader() const
        {
                return fBlock->fHeader;
        }
        
+       /**
+        * Returns the whole data block header.
+        */
+       DataBlockType& BlockHeader()
+       {
+               return fBlock;
+       }
+       
+       const DataBlockType& BlockHeader() const
+       {
+               return fBlock;
+       }
+       
        /**
         * Returns a pointer to the next location where a data entry can be
         * written and increments the number of entries.
@@ -282,4 +299,28 @@ typedef AliHLTMUONDataBlockWriter<
                kChannelsDataBlock
        > AliHLTMUONChannelsBlockWriter;
 
+typedef AliHLTMUONDataBlockWriter<
+               AliHLTMUONMansoTracksBlockStruct,
+               AliHLTMUONMansoTrackStruct,
+               kMansoTracksDataBlock
+       > AliHLTMUONMansoTracksBlockWriter;
+
+typedef AliHLTMUONDataBlockWriter<
+               AliHLTMUONMansoCandidatesBlockStruct,
+               AliHLTMUONMansoCandidateStruct,
+               kMansoCandidatesDataBlock
+       > AliHLTMUONMansoCandidatesBlockWriter;
+       
+typedef AliHLTMUONDataBlockWriter<
+               AliHLTMUONSinglesDecisionBlockStruct,
+               AliHLTMUONTrackDecisionStruct,
+               kSinglesDecisionDataBlock
+       > AliHLTMUONSinglesDecisionBlockWriter;
+       
+typedef AliHLTMUONDataBlockWriter<
+               AliHLTMUONPairsDecisionBlockStruct,
+               AliHLTMUONPairDecisionBlockStruct,
+               kPairsDecisionDataBlock
+       > AliHLTMUONPairsDecisionBlockWriter;
+
 #endif // ALIHLTMUONDATABLOCKWRITER_H
index 2ecb06d..396b93d 100644 (file)
@@ -98,10 +98,9 @@ enum AliHLTMUONDataBlockType
        kClustersDataBlock = 2001,
        kChannelsDataBlock = 2002,
        kMansoTracksDataBlock = 3000,
-       kMansoRoIDataBlock = 3001,
-       kMansoTrialsDataBlock = 3002,
-       kDecisionDataBlock = 4000,
-       kDecisionDebugDataBlock = 4001
+       kMansoCandidatesDataBlock = 3001,
+       kSinglesDecisionDataBlock = 4000,
+       kPairsDecisionDataBlock = 4001
 };
 
 
@@ -164,10 +163,9 @@ inline std::ostream& operator << (std::ostream& stream, AliHLTMUONDataBlockType
        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;
+       case kMansoCandidatesDataBlock: stream << "kMansoCandidatesDataBlock"; break;
+       case kSinglesDecisionDataBlock: stream << "kSinglesDecisionDataBlock"; break;
+       case kPairsDecisionDataBlock:   stream << "kPairsDecisionDataBlock";   break;
        default:                        stream << "INVALID";
        }
        return stream;
diff --git a/HLT/MUON/AliHLTMUONMansoCandidatesBlockStruct.cxx b/HLT/MUON/AliHLTMUONMansoCandidatesBlockStruct.cxx
new file mode 100644 (file)
index 0000000..8d9bddd
--- /dev/null
@@ -0,0 +1,88 @@
+/**************************************************************************
+ * 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   AliHLTMUONMansoCandidatesBlockStruct.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of useful stream and comparison operators.
+ */
+
+#include "AliHLTMUONMansoCandidatesBlockStruct.h"
+#include "AliHLTMUONUtils.h"
+#include <cassert>
+
+
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONMansoRoIStruct& roi
+       )
+{
+       stream  << "{fX = " << roi.fX
+               << ", fY = " << roi.fY
+               << ", fZ = " << roi.fZ
+               << ", fRadius = " << roi.fRadius
+               << "}";
+       return stream;
+}
+
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONMansoCandidateStruct& candidate
+       )
+{
+       stream  << "{fTrack = " << candidate.fTrack
+               << ", fRoI[0] = " << candidate.fRoI[0]
+               << ", fRoI[1] = " << candidate.fRoI[1]
+               << ", fRoI[2] = " << candidate.fRoI[2]
+               << ", fRoI[3] = " << candidate.fRoI[3]
+               << "}";
+       return stream;
+}
+
+
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONMansoCandidatesBlockStruct& block
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(block) );
+
+       stream  << "{fHeader = " << block.fHeader << ", fCandidate[] = [";
+       if (block.fHeader.fNrecords > 0) stream << block.fCandidate[0];
+       for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
+               stream << ", " << block.fCandidate[i];
+       stream << "]}";
+       return stream;
+}
+
+
+bool operator == (
+               const AliHLTMUONMansoCandidatesBlockStruct& a,
+               const AliHLTMUONMansoCandidatesBlockStruct& 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 track candidate 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.fCandidate[i] != b.fCandidate[i]) return false;
+       return true;
+}
diff --git a/HLT/MUON/AliHLTMUONMansoCandidatesBlockStruct.h b/HLT/MUON/AliHLTMUONMansoCandidatesBlockStruct.h
new file mode 100644 (file)
index 0000000..c843c18
--- /dev/null
@@ -0,0 +1,136 @@
+#ifndef ALIHLTMUONMANSOCANDIDATESBLOCKSTRUCT_H
+#define ALIHLTMUONMANSOCANDIDATESBLOCKSTRUCT_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONMansoCandidatesBlockStruct.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definition of internal dimuon HLT track candidates data block
+ *         structure generated by the Manso algorithm.
+ * 
+ * The structures are defined with C linkage since C generally gives us more
+ * binary compatibility between compilers.
+ */
+
+#include "AliHLTMUONMansoTracksBlockStruct.h"
+
+extern "C"
+{
+
+/**
+ * Structure containing information about a region of interest (RoI) used in
+ * the Manso algorithm to find track candidates.
+ */
+struct AliHLTMUONMansoRoIStruct
+{
+       AliHLTFloat32_t fX; // The X coordinate for the RoI disc centre.
+       AliHLTFloat32_t fY; // The Y coordinate for the RoI disc centre.
+       AliHLTFloat32_t fZ; // The detection plane Z coordinate in which the RoI is in.
+       AliHLTFloat32_t fRadius; // The radius of the RoI disc.
+};
+
+/**
+ * This structure contains information about a track candidate that was attempted
+ * during track reconstruction in the Manso algorithm. The regions of interests
+ * used are indicated including the partially reconstructed track.
+ */
+struct AliHLTMUONMansoCandidateStruct
+{
+       // The partially of fully reconstructed track.
+       AliHLTMUONMansoTrackStruct fTrack;
+       
+       // The regions of interest searched on the various chambers.
+       // fRoI[0] is region of interest on chamber 7, fRoI[1] is on 8 etc...
+       AliHLTMUONMansoRoIStruct fRoI[4];
+};
+
+/**
+ * AliHLTMUONMansoCandidatesBlockStruct defines the format of the internal
+ * Manso track candidates data block.
+ */
+struct AliHLTMUONMansoCandidatesBlockStruct
+{
+       AliHLTMUONDataBlockHeader fHeader; // Common data block header.
+
+       // Array of Manso track candidates.
+       AliHLTMUONMansoCandidateStruct fCandidate[/*fHeader.fNrecords*/];
+};
+
+} // extern "C"
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the RoI
+ * information in the following format:
+ *  {fX = xx, fY = yy, fZ = zz, fRadius = rr}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONMansoRoIStruct& roi
+       );
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the track
+ * candidate information in the following format:
+ *  {fTrack = xx, fRoI[0] = {...}, fRoI[1] = {...}, fRoI[2] = {...}, fRoI[3] = {...}}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONMansoCandidateStruct& candidate
+       );
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONMansoCandidatesBlockStruct in the following format:
+ *   {fHeader = xx, fCandidate[] = [{..}, {..}, ...]}
+ */
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONMansoCandidatesBlockStruct& block
+       );
+
+
+inline bool operator == (
+               const AliHLTMUONMansoRoIStruct& a,
+               const AliHLTMUONMansoRoIStruct& b
+       )
+{
+       return a.fX == b.fX and a.fY == b.fY and a.fZ == b.fZ
+               and a.fRadius == b.fRadius;
+}
+
+inline bool operator == (
+               const AliHLTMUONMansoCandidateStruct& a,
+               const AliHLTMUONMansoCandidateStruct& b
+       )
+{
+       return a.fTrack == b.fTrack
+               and a.fRoI[0] == b.fRoI[0] and a.fRoI[1] == b.fRoI[1]
+               and a.fRoI[2] == b.fRoI[2] and a.fRoI[3] == b.fRoI[3];
+}
+
+inline bool operator != (
+               const AliHLTMUONMansoCandidateStruct& a,
+               const AliHLTMUONMansoCandidateStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+bool operator == (
+               const AliHLTMUONMansoCandidatesBlockStruct& a,
+               const AliHLTMUONMansoCandidatesBlockStruct& b
+       );
+
+inline bool operator != (
+               const AliHLTMUONMansoCandidatesBlockStruct& a,
+               const AliHLTMUONMansoCandidatesBlockStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+#endif // ALIHLTMUONMANSOCANDIDATESBLOCKSTRUCT_H
diff --git a/HLT/MUON/AliHLTMUONMansoTracksBlockStruct.cxx b/HLT/MUON/AliHLTMUONMansoTracksBlockStruct.cxx
new file mode 100644 (file)
index 0000000..5fb0e77
--- /dev/null
@@ -0,0 +1,82 @@
+/**************************************************************************
+ * 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   AliHLTMUONMansoTracksBlockStruct.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of useful stream and comparison operators.
+ */
+
+#include "AliHLTMUONMansoTracksBlockStruct.h"
+#include "AliHLTMUONUtils.h"
+#include <cassert>
+
+
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONMansoTrackStruct& track
+       )
+{
+       stream  << "{fId = " << track.fFlags
+               << ", fTrigRec = " << track.fTrigRec
+               << ", fFlags = " << std::showbase << std::hex
+               << track.fFlags << std::dec
+               << ", fPx = " << track.fPx
+               << ", fPy = " << track.fPy
+               << ", fPz = " << track.fPz
+               << ", fChi2 = " << track.fChi2
+               << ", fHit[0] = " << track.fHit[0]
+               << ", fHit[1] = " << track.fHit[1]
+               << ", fHit[2] = " << track.fHit[2]
+               << ", fHit[3] = " << track.fHit[3]
+               << "}";
+       return stream;
+}
+
+
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONMansoTracksBlockStruct& block
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(block) );
+
+       stream  << "{fHeader = " << block.fHeader << ", fTrack[] = [";
+       if (block.fHeader.fNrecords > 0) stream << block.fTrack[0];
+       for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
+               stream << ", " << block.fTrack[i];
+       stream << "]}";
+       return stream;
+}
+
+
+bool operator == (
+               const AliHLTMUONMansoTracksBlockStruct& a,
+               const AliHLTMUONMansoTracksBlockStruct& 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 track 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.fTrack[i] != b.fTrack[i]) return false;
+       return true;
+}
diff --git a/HLT/MUON/AliHLTMUONMansoTracksBlockStruct.h b/HLT/MUON/AliHLTMUONMansoTracksBlockStruct.h
new file mode 100644 (file)
index 0000000..6739541
--- /dev/null
@@ -0,0 +1,129 @@
+#ifndef ALIHLTMUONMANSOTRACKSBLOCKSTRUCT_H
+#define ALIHLTMUONMANSOTRACKSBLOCKSTRUCT_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONMansoTracksBlockStruct.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definition of internal dimuon HLT tracks data block structure
+ *         generated by the Manso algorithm.
+ * 
+ * The structures are defined with C linkage since C generally gives us more
+ * binary compatibility between compilers.
+ */
+
+#include "AliHLTMUONRecHitsBlockStruct.h"
+
+extern "C"
+{
+
+/**
+ * Track structure containing information about a partial track generated by
+ * the Manso algorithm.
+ */
+struct AliHLTMUONMansoTrackStruct
+{
+       AliHLTInt32_t fId; // Each Manso track should have an ID number unique
+                          // for a given event. -1 == invalid.
+
+       AliHLTInt32_t fTrigRec; // The associated trigger record ID used as the
+                               // seed for the Manso algorithm.
+
+       // The flags word constains the following bit fields (bit 31 is most
+       // significant):
+       // bits:  [31][30][29 --- 4][  3   ][  2   ][  1   ][  0   ]
+       // field:  -   +   reserved  hst[3]  hst[2]  hst[1]  hst[0]
+       // Where fields hst[i] indicates if fHit[i] has been filled/set.
+       // Reserved bits should be set to zero.
+       // Particle sign: if '-' is set then particle has minus sign.
+       //                if '+' is set then particle has negative sign.
+       // Either '+' or '-' should be set and if neither then the particle
+       // sign is unknown.
+       AliHLTUInt32_t fFlags;
+
+       AliHLTFloat32_t fPx; // Particle's momentum X component in GeV/c.
+       AliHLTFloat32_t fPy; // Particle's momentum Y component in GeV/c.
+       AliHLTFloat32_t fPz; // Particle's momentum Z component in GeV/c.
+       AliHLTFloat32_t fChi2; // The chi squared of the fit of fHit points to
+                              // the track model.
+
+       // Particle hit coordinates on tracking chambers 7 to 10.
+       // fHit[0] is for chamber 7 fHit[1] for chamber 8 etc...
+       AliHLTMUONRecHitStruct fHit[4];
+};
+
+/**
+ * AliHLTMUONMansoTracksBlockStruct defines the format of the internal
+ * Manso tracks data block.
+ */
+struct AliHLTMUONMansoTracksBlockStruct
+{
+       AliHLTMUONDataBlockHeader fHeader; // Common data block header.
+
+       // Array of Manso tracks.
+       AliHLTMUONMansoTrackStruct fTrack[/*fHeader.fNrecords*/];
+};
+
+} // extern "C"
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the track
+ * information in the following format:
+ *  {fId = xx, fTrigRec = yy, fFlags = 0xZZ, fPx = uu, fPy = vv, fPz = ww,
+ *   fChi2 = ss, fHit[0] = {...}, fHit[1] = {...}, fHit[2] = {...},
+ *   fHit[3] = {...}}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONMansoTrackStruct& trigrec
+       );
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONMansoTracksBlockStruct in the following format:
+ *   {fHeader = xx, fTrack[] = [{..}, {..}, ...]}
+ */
+std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONMansoTracksBlockStruct& block
+       );
+
+
+inline bool operator == (
+               const AliHLTMUONMansoTrackStruct& a,
+               const AliHLTMUONMansoTrackStruct& b
+       )
+{
+       return a.fId == b.fId and a.fTrigRec == b.fTrigRec
+               and a.fFlags == b.fFlags and a.fPx == b.fPx and a.fPy == b.fPy
+               and a.fPz == b.fPz and a.fChi2 == b.fChi2
+               and a.fHit[0] == b.fHit[0] and a.fHit[1] == b.fHit[1]
+               and a.fHit[2] == b.fHit[2] and a.fHit[3] == b.fHit[3];
+}
+
+inline bool operator != (
+               const AliHLTMUONMansoTrackStruct& a,
+               const AliHLTMUONMansoTrackStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+bool operator == (
+               const AliHLTMUONMansoTracksBlockStruct& a,
+               const AliHLTMUONMansoTracksBlockStruct& b
+       );
+
+inline bool operator != (
+               const AliHLTMUONMansoTracksBlockStruct& a,
+               const AliHLTMUONMansoTracksBlockStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+#endif // ALIHLTMUONMANSOTRACKSBLOCKSTRUCT_H
diff --git a/HLT/MUON/AliHLTMUONPairsDecisionBlockStruct.cxx b/HLT/MUON/AliHLTMUONPairsDecisionBlockStruct.cxx
new file mode 100644 (file)
index 0000000..45c3aa0
--- /dev/null
@@ -0,0 +1,76 @@
+/**************************************************************************
+ * 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   AliHLTMUONPairsDecisionBlockStruct.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of useful stream and comparison operators.
+ */
+
+#include "AliHLTMUONPairsDecisionBlockStruct.h"
+#include "AliHLTMUONUtils.h"
+#include <cassert>
+
+
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONPairsDecisionBlockStruct& block
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(block) );
+
+       stream  << "{fHeader = " << block.fHeader
+               << ", fNunlikeLowPt = " << block.fNunlikeLowPt
+               << ", fNunlikeHighPt = " << block.fNunlikeHighPt
+               << ", fNlikeLowPt = " << block.fNlikeLowPt
+               << ", fNlikeHighPt = " << block.fNlikeHighPt
+               << ", fNmassAny = " << block.fNmassAny
+               << ", fNmassLow = " << block.fNmassLow
+               << ", fNmassHigh = " << block.fNmassHigh
+               << ", fDecision[] = [";
+       if (block.fHeader.fNrecords > 0) stream << block.fDecision[0];
+       for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
+               stream << ", " << block.fDecision[i];
+       stream << "]}";
+       return stream;
+}
+
+
+bool operator == (
+               const AliHLTMUONPairsDecisionBlockStruct& a,
+               const AliHLTMUONPairsDecisionBlockStruct& 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 track pair's decision is the same. In either case if
+       // we find a difference return false.
+       if (a.fHeader != b.fHeader) return false;
+       if (a.fNunlikeLowPt != b.fNunlikeLowPt) return false;
+       if (a.fNunlikeHighPt != b.fNunlikeHighPt) return false;
+       if (a.fNlikeLowPt != b.fNlikeLowPt) return false;
+       if (a.fNlikeHighPt != b.fNlikeHighPt) return false;
+       if (a.fNmassAny != b.fNmassAny) return false;
+       if (a.fNmassLow != b.fNmassLow) return false;
+       if (a.fNmassHigh != b.fNmassHigh) return false;
+       for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
+               if (a.fDecision[i] != b.fDecision[i]) return false;
+       return true;
+}
diff --git a/HLT/MUON/AliHLTMUONPairsDecisionBlockStruct.h b/HLT/MUON/AliHLTMUONPairsDecisionBlockStruct.h
new file mode 100644 (file)
index 0000000..b3c3d1b
--- /dev/null
@@ -0,0 +1,154 @@
+#ifndef ALIHLTMUONPAIRSDECISIONBLOCKSTRUCT_H
+#define ALIHLTMUONPAIRSDECISIONBLOCKSTRUCT_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONPairsDecisionBlockStruct.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definition of internal dimuon HLT trigger decision data structure
+ *         containing decision information for pairs of tracks.
+ * 
+ * The structures are defined with C linkage since C generally gives us more
+ * binary compatibility between compilers.
+ */
+
+#include "AliHLTMUONDataTypes.h"
+
+extern "C"
+{
+
+/**
+ * Structure contains information about the trigger decision for a pair of tracks.
+ */
+struct AliHLTMUONPairDecisionStruct
+{
+       // The ID numbers of the tracks we are referring to.
+       // These could also be trigger record ID numbers.
+       AliHLTInt32_t fTrackAId;
+       AliHLTInt32_t fTrackBId;
+       
+       // The trigger bits have the following meaning:
+       // bit:  [31 --- 7][ 6 ][ 5 ][   4  ][3--2][1--0]
+       // field: reserved  hiM  loM  unlike  hipt  lopt
+       // Reserved bits should be set to zero.
+       // hiM == Pair passed the high invariant mass cut.
+       // loM == Pair passed the low invariant mass cut.
+       // unlike == is the pair an unlike sign pair.
+       // hipt: 0 if neither track has pt > high pt cut, 1 if either has
+       // and 2 if both have. A value of 3 is invalid.
+       // lopt: 0 if neither track has pt > lo pt cut, 1 if either has
+       // and 2 if both have. A value of 3 is invalid.
+       AliHLTUInt32_t fTriggerBits;
+       
+       AliHLTFloat32_t fInvMass; // Invariant mass of the track pair assuming
+                                 // they are both muons in (GeV/c^2)
+};
+
+/**
+ * AliHLTMUONPairsDecisionBlockStruct defines the format of the internal
+ * dimuon HLT decision data block for pairs of tracks.
+ */
+struct AliHLTMUONPairsDecisionBlockStruct
+{
+       AliHLTMUONDataBlockHeader fHeader; // Common data block header.
+       
+       // Number of unlike sign low pt triggers where both tracks have
+       // pt > low cut.
+       AliHLTUInt32_t fNunlikeLowPt;
+       
+       // Number of unlike sign high pt triggers where both tracks have
+       // pt > high cut.
+       AliHLTUInt32_t fNunlikeHighPt;
+       
+       // Number of like sign low pt triggers where both tracks have
+       // pt > low cut.
+       AliHLTUInt32_t fNlikeLowPt;
+       
+       // Number of like sign high pt triggers where both tracks have
+       // pt > high cut.
+       AliHLTUInt32_t fNlikeHighPt;
+       
+       // Number of pairs that have invariant mass > low mass cut, any pt
+       // and unlike sign.
+       AliHLTUInt32_t fNmassAny;
+       
+       // Number of pairs that have invariant mass > low mass cut,
+       // pt > low pt cut and unlike sign.
+       AliHLTUInt32_t fNmassLow;
+       
+       // Number of pairs that have invariant mass > low mass cut,
+       // pt > high pt cut and unlike sign.
+       AliHLTUInt32_t fNmassHigh;
+
+       // Array of decisions for track pairs.
+       AliHLTMUONPairDecisionStruct fDecision[/*fHeader.fNrecords*/];
+};
+
+} // extern "C"
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * trigger decision information for pairs of tracks in the following format:
+ *  {fTrackAId = xx, fTrackBId = yy, fTriggerBits = 0xZZ}
+ */
+inline std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONPairDecisionStruct& trig
+       )
+{
+       stream  << "{fTrackAId = " << trig.fTrackAId
+               << ", fTrackBId = " << trig.fTrackBId << ", fTriggerBits = "
+               << std::showbase << std::hex << trig.fTriggerBits << std::dec
+               << "}";
+       return stream;
+}
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONPairsDecisionBlockStruct in the following format:
+ *   {fHeader = aa, fNunlikeLowPt = bb, fNunlikeHighPt = cc, fNlikeLowPt = dd,
+ *    fNlikeHighPt = ee, fNmassAny = ff, fNmassLow = gg, fNmassHigh = hh
+ *    fDecision[] = [{..}, {..}, ...]}
+ */
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONPairsDecisionBlockStruct& block
+       );
+
+
+inline bool operator == (
+               const AliHLTMUONPairDecisionStruct& a,
+               const AliHLTMUONPairDecisionStruct& b
+       )
+{
+       return a.fTrackAId == b.fTrackAId and a.fTrackBId == b.fTrackBId
+               and a.fTriggerBits == b.fTriggerBits;
+}
+
+inline bool operator != (
+               const AliHLTMUONPairDecisionStruct& a,
+               const AliHLTMUONPairDecisionStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+bool operator == (
+               const AliHLTMUONPairsDecisionBlockStruct& a,
+               const AliHLTMUONPairsDecisionBlockStruct& b
+       );
+
+inline bool operator != (
+               const AliHLTMUONPairsDecisionBlockStruct& a,
+               const AliHLTMUONPairsDecisionBlockStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+#endif // ALIHLTMUONPAIRSDECISIONBLOCKSTRUCT_H
diff --git a/HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.cxx b/HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.cxx
new file mode 100644 (file)
index 0000000..c6b2c60
--- /dev/null
@@ -0,0 +1,66 @@
+/**************************************************************************
+ * 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   AliHLTMUONSinglesDecisionBlockStruct.cxx
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Implementation of useful stream and comparison operators.
+ */
+
+#include "AliHLTMUONSinglesDecisionBlockStruct.h"
+#include "AliHLTMUONUtils.h"
+#include <cassert>
+
+
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONSinglesDecisionBlockStruct& block
+       )
+{
+       assert( AliHLTMUONUtils::IntegrityOk(block) );
+
+       stream  << "{fHeader = " << block.fHeader
+               << ", fNlowPt = " << block.fNlowPt
+               << ", fNhighPt = " << block.fNhighPt
+               << ", fDecision[] = [";
+       if (block.fHeader.fNrecords > 0) stream << block.fDecision[0];
+       for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
+               stream << ", " << block.fDecision[i];
+       stream << "]}";
+       return stream;
+}
+
+
+bool operator == (
+               const AliHLTMUONSinglesDecisionBlockStruct& a,
+               const AliHLTMUONSinglesDecisionBlockStruct& 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 track decision is the same. In either case if we find
+       // a difference return false.
+       if (a.fHeader != b.fHeader) return false;
+       if (a.fNlowPt != b.fNlowPt) return false;
+       if (a.fNhighPt != b.fNhighPt) return false;
+       for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
+               if (a.fDecision[i] != b.fDecision[i]) return false;
+       return true;
+}
diff --git a/HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.h b/HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.h
new file mode 100644 (file)
index 0000000..79bede9
--- /dev/null
@@ -0,0 +1,113 @@
+#ifndef ALIHLTMUONSINGLESDECISIONBLOCKSTRUCT_H
+#define ALIHLTMUONSINGLESDECISIONBLOCKSTRUCT_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+/**
+ * @file   AliHLTMUONSinglesDecisionBlockStruct.h
+ * @author Artur Szostak <artursz@iafrica.com>
+ * @date   
+ * @brief  Definition of internal dimuon HLT trigger decision data structure
+ *         containing decision information for single tracks.
+ * 
+ * The structures are defined with C linkage since C generally gives us more
+ * binary compatibility between compilers.
+ */
+
+#include "AliHLTMUONDataTypes.h"
+
+extern "C"
+{
+
+/**
+ * Structure contains information about the trigger decision for a single track.
+ */
+struct AliHLTMUONTrackDecisionStruct
+{
+       AliHLTInt32_t fTrackId; // The ID number of the track we are referring to.
+                               // This could also be a trigger record ID.
+       
+       // The trigger bits have the following meaning:
+       // bit:  [31 --- 2][  1 ][  0 ]
+       // field: reserved  hipt  lopt
+       // Reserved bits should be set to zero.
+       // hipt == passed high pt cut. lopt == passed low pt cut.
+       AliHLTUInt32_t fTriggerBits;
+};
+
+/**
+ * AliHLTMUONSinglesDecisionBlockStruct defines the format of the internal
+ * dimuon HLT decision data block for individual tracks.
+ */
+struct AliHLTMUONSinglesDecisionBlockStruct
+{
+       AliHLTMUONDataBlockHeader fHeader; // Common data block header.
+       AliHLTUInt32_t fNlowPt;  // Number of low pt triggers.
+       AliHLTUInt32_t fNhighPt; // Number of high pt triggers.
+
+       // Array of decisions for individual tracks.
+       AliHLTMUONTrackDecisionStruct fDecision[/*fHeader.fNrecords*/];
+};
+
+} // extern "C"
+
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * trigger decision information for individual tracks in the following format:
+ *  {fTrackId = xx, fTriggerBits = 0xYY}
+ */
+inline std::ostream& operator << (
+               std::ostream& stream, const AliHLTMUONTrackDecisionStruct& trig
+       )
+{
+       stream  << "{fTrackId = " << trig.fTrackId << ", fTriggerBits = "
+               << std::showbase << std::hex << trig.fTriggerBits << std::dec
+               << "}";
+       return stream;
+}
+
+/**
+ * Stream operator for usage with std::ostream classes which prints the
+ * AliHLTMUONSinglesDecisionBlockStruct in the following format:
+ *   {fHeader = xx, fNlowPt = yy, fNhighPt = zz, fDecision[] = [{..}, {..}, ...]}
+ */
+std::ostream& operator << (
+               std::ostream& stream,
+               const AliHLTMUONSinglesDecisionBlockStruct& block
+       );
+
+
+inline bool operator == (
+               const AliHLTMUONTrackDecisionStruct& a,
+               const AliHLTMUONTrackDecisionStruct& b
+       )
+{
+       return a.fTrackId == b.fTrackId and a.fTriggerBits == b.fTriggerBits;
+}
+
+inline bool operator != (
+               const AliHLTMUONTrackDecisionStruct& a,
+               const AliHLTMUONTrackDecisionStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+
+bool operator == (
+               const AliHLTMUONSinglesDecisionBlockStruct& a,
+               const AliHLTMUONSinglesDecisionBlockStruct& b
+       );
+
+inline bool operator != (
+               const AliHLTMUONSinglesDecisionBlockStruct& a,
+               const AliHLTMUONSinglesDecisionBlockStruct& b
+       )
+{
+       return not operator == (a, b);
+}
+
+#endif // ALIHLTMUONSINGLESDECISIONBLOCKSTRUCT_H
index 8105681..cd762ca 100644 (file)
 #include "AliHLTMUONRecHitsBlockStruct.h"
 #include "AliHLTMUONClustersBlockStruct.h"
 #include "AliHLTMUONChannelsBlockStruct.h"
+#include "AliHLTMUONMansoTracksBlockStruct.h"
+#include "AliHLTMUONMansoCandidatesBlockStruct.h"
+#include "AliHLTMUONSinglesDecisionBlockStruct.h"
+#include <cassert>
 
 
 AliHLTUInt32_t AliHLTMUONUtils::PackTriggerRecordFlags(
@@ -50,9 +54,7 @@ AliHLTUInt32_t AliHLTMUONUtils::PackTriggerRecordFlags(
 
 
 void AliHLTMUONUtils::UnpackTriggerRecordFlags(
-               AliHLTUInt32_t flags, // [in]
-               AliHLTMUONParticleSign& sign, // [out]
-               bool hitset[4] // [out]
+               AliHLTUInt32_t flags, AliHLTMUONParticleSign& sign, bool hitset[4]
        )
 {
        AliHLTUInt32_t signbits = flags & 0xC0000000;
@@ -69,67 +71,180 @@ void AliHLTMUONUtils::UnpackTriggerRecordFlags(
 }
 
 
+AliHLTUInt32_t AliHLTMUONUtils::PackTrackDecisionBits(bool highPt, bool lowPt)
+{
+       return (highPt ? 0x2 : 0) | (lowPt ? 0x1 : 0);
+}
+
+
+void AliHLTMUONUtils::UnpackTrackDecisionBits(
+               AliHLTUInt32_t bits, bool& highPt, bool& lowPt
+       )
+{
+       lowPt  = (bits & 0x1) == 1;
+       highPt = (bits & 0x2) == 1;
+}
+
+
+AliHLTUInt32_t AliHLTMUONUtils::PackPairDecisionBits(
+               bool highMass, bool lowMass, bool unlike,
+               AliHLTUInt8_t highPtCount, AliHLTUInt8_t lowPtCount
+       )
+{
+       assert( highPtCount + lowPtCount <= 2 );
+       // highMass and lowMass must be false if unlike is false:
+       assert( not unlike ? (highMass == false and lowMass == false) : true );
+       
+       return (highMass ? 0x40 : 0) | (lowMass ? 0x20 : 0) | (unlike ? 0x10 : 0)
+               | ((highPtCount & 0x3) << 2) | (lowPtCount & 0x3);
+}
+
+
+void AliHLTMUONUtils::UnpackPairDecisionBits(
+               AliHLTUInt32_t bits, bool& highMass, bool& lowMass, bool& unlike,
+               AliHLTUInt8_t& highPtCount, AliHLTUInt8_t& lowPtCount
+       )
+{
+       highMass = (bits & 0x40) == 1;
+       lowMass  = (bits & 0x20) == 1;
+       unlike   = (bits & 0x10) == 1;
+       highPtCount = (bits & 0xC) >> 2;
+       lowPtCount = bits & 0x3;
+}
+
+
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block)
 {
        // The block must have the correct type.
        if (block.fHeader.fType != kTriggerRecordsDataBlock) return false;
-       // The block's record widths must be the correct size.
+       // The block's record width must be the correct size.
        if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTriggerRecordStruct))
                return false;
        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.
+       // The block's record width 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.
+       // The block's record width 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.
        if (block.fHeader.fType != kRecHitsDataBlock) return false;
-       // The block's record widths must be the correct size.
+       // The block's record width must be the correct size.
        if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONRecHitStruct))
                return false;
        return true;
 }
 
+
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONClustersBlockStruct& block)
 {
        // The block must have the correct type.
        if (block.fHeader.fType != kClustersDataBlock) return false;
-       // The block's record widths must be the correct size.
+       // The block's record width must be the correct size.
        if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONClusterStruct))
                return false;
        return true;
 }
 
+
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONChannelsBlockStruct& block)
 {
        // The block must have the correct type.
        if (block.fHeader.fType != kChannelsDataBlock) return false;
-       // The block's record widths must be the correct size.
+       // The block's record width must be the correct size.
        if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONChannelStruct))
                return false;
        return true;
 }
 
 
+bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block)
+{
+       // The block must have the correct type.
+       if (block.fHeader.fType != kMansoTracksDataBlock) return false;
+       // The block's record width must be the correct size.
+       if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONMansoTrackStruct))
+               return false;
+       return true;
+}
+
+
+bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block)
+{
+       // The block must have the correct type.
+       if (block.fHeader.fType != kMansoCandidatesDataBlock) return false;
+       // The block's record width must be the correct size.
+       if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONMansoCandidateStruct))
+               return false;
+       return true;
+}
+
+
+bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block)
+{
+       // The block must have the correct type.
+       if (block.fHeader.fType != kSinglesDecisionDataBlock) return false;
+       // The block's record width must be the correct size.
+       if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONTrackDecisionStruct))
+               return false;
+       return true;
+}
+
+
+bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block)
+{
+       // The block must have the correct type.
+       if (block.fHeader.fType != kPairsDecisionDataBlock) return false;
+       // The block's record width must be the correct size.
+       if (block.fHeader.fRecordWidth != sizeof(AliHLTMUONPairDecisionStruct))
+               return false;
+       return true;
+}
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordStruct& tr)
+{
+       // Make sure that the reserved bits in the fFlags field are set
+       // to zero.
+       if ((tr.fFlags & 0x3FFFFFF0) != 0) return false;
+
+       // Make sure the sign is not invalid.
+       if ((tr.fFlags & 0xC0000000) == 3) return false;
+
+       // Check that fHit[i] is nil if the corresponding bit in the
+       // flags word is zero.
+       const AliHLTMUONRecHitStruct& nilhit
+               = AliHLTMUONConstants::NilRecHitStruct();
+       if ((tr.fFlags & 0x1) == 0 and tr.fHit[0] != nilhit) return false;
+       if ((tr.fFlags & 0x2) == 0 and tr.fHit[1] != nilhit) return false;
+       if ((tr.fFlags & 0x4) == 0 and tr.fHit[2] != nilhit) return false;
+       if ((tr.fFlags & 0x8) == 0 and tr.fHit[3] != nilhit) return false;
+
+       return true;
+}
+
+
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& block)
 {
        if (not HeaderOk(block)) return false;
@@ -145,42 +260,30 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& blo
                }
        }
 
+       // Check integrity of individual trigger records.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               const AliHLTMUONTriggerRecordStruct& tr = block.fTriggerRecord[i];
-
-               // Make sure that the reserved bits in the fFlags field are set
-               // to zero.
-               if ((tr.fFlags & 0x3FFFFFF0) != 0) return false;
-
-               // Make sure the sign is not invalid.
-               if ((tr.fFlags & 0xC0000000) == 3) return false;
-
-               // Check that fHit[i] is nil if the corresponding bit in the
-               // flags word is zero.
-               const AliHLTMUONRecHitStruct& nilhit
-                       = AliHLTMUONConstants::NilRecHitStruct();
-               if ((tr.fFlags & 0x1) == 0 and tr.fHit[0] != nilhit) return false;
-               if ((tr.fFlags & 0x2) == 0 and tr.fHit[1] != nilhit) return false;
-               if ((tr.fFlags & 0x4) == 0 and tr.fHit[2] != nilhit) return false;
-               if ((tr.fFlags & 0x8) == 0 and tr.fHit[3] != nilhit) return false;
+               if (not IntegrityOk(block.fTriggerRecord[i])) return false;
        }
 
        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)
 {
        if (not HeaderOk(block)) return false;
@@ -206,8 +309,129 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONClustersBlockStruct& block)
        return true;
 }
 
+
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONChannelsBlockStruct& block)
 {
        if (not HeaderOk(block)) return false;
        return true;
 }
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTrackStruct& track)
+{
+       // Make sure that the reserved bits in the fFlags field are set
+       // to zero.
+       if ((track.fFlags & 0x3FFFFFF0) != 0) return false;
+
+       // Make sure the sign is not invalid.
+       if ((track.fFlags & 0xC0000000) == 0xC0000000) return false;
+
+       // Check that fHit[i] is nil if the corresponding bit in the
+       // flags word is zero.
+       const AliHLTMUONRecHitStruct& nilhit
+               = AliHLTMUONConstants::NilRecHitStruct();
+       if ((track.fFlags & 0x1) == 0 and track.fHit[0] != nilhit) return false;
+       if ((track.fFlags & 0x2) == 0 and track.fHit[1] != nilhit) return false;
+       if ((track.fFlags & 0x4) == 0 and track.fHit[2] != nilhit) return false;
+       if ((track.fFlags & 0x8) == 0 and track.fHit[3] != nilhit) return false;
+       
+       return true;
+}
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block)
+{
+       if (not HeaderOk(block)) return false;
+
+       // Check if any ID is duplicated.
+       for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
+       {
+               AliHLTUInt32_t id = block.fTrack[i].fId;
+               for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
+               {
+                       if (id == block.fTrack[j].fId)
+                               return false;
+               }
+       }
+
+       // Check that the tracks have integrity.
+       for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
+       {
+               if (not IntegrityOk(block.fTrack[i])) return false;
+       }
+
+       return true;
+}
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoCandidatesBlockStruct& block)
+{
+       if (not HeaderOk(block)) return false;
+
+       // Check that the tracks have integrity.
+       for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
+       {
+               if (not IntegrityOk(block.fCandidate[i].fTrack)) return false;
+       }
+       
+       return true;
+}
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrackDecisionStruct& decision)
+{
+       // Make sure that the reserved bits in the fTriggerBits field are set
+       // to zero.
+       if ((decision.fTriggerBits & 0xFFFFFFFC) != 0) return false;
+       return true;
+}
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONSinglesDecisionBlockStruct& block)
+{
+       if (not HeaderOk(block)) return false;
+
+       // Check that the trigger bits for each track have integrity.
+       for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
+       {
+               if (not IntegrityOk(block.fDecision[i])) return false;
+       }
+       
+       return true;
+}
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONPairDecisionStruct& decision)
+{
+       // Make sure that the reserved bits in the fTriggerBits field are set
+       // to zero.
+       if ((decision.fTriggerBits & 0xFFFFFF80) != 0) return false;
+       
+       // The high mass or low mass bits can only be set if unlike bit is set.
+       if ((decision.fTriggerBits & 0x00000010) == 0
+           and (decision.fTriggerBits & 0x00000060) != 0
+          )
+               return false;
+       
+       // Neither the high pt (hipt) or low pt (lopt) count bits can be > 2.
+       // And the sum must not be > 2.
+       AliHLTUInt8_t lowPtCount = (decision.fTriggerBits & 0x00000003);
+       AliHLTUInt8_t highPtCount = (decision.fTriggerBits & 0x0000000C) >> 2;
+       if (lowPtCount + highPtCount > 2) return false;
+       
+       return true;
+}
+
+
+bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONPairsDecisionBlockStruct& block)
+{
+       if (not HeaderOk(block)) return false;
+
+       // Check that the trigger bits for each track pair have integrity.
+       for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
+       {
+               if (not IntegrityOk(block.fDecision[i])) return false;
+       }
+       
+       return true;
+}
index b112f4d..d642ecf 100644 (file)
 
 // Forward declare structures.
 extern "C" {
+struct AliHLTMUONTriggerRecordStruct;
 struct AliHLTMUONTriggerRecordsBlockStruct;
 struct AliHLTMUONTrigRecsDebugBlockStruct;
 struct AliHLTMUONTriggerChannelsBlockStruct;
 struct AliHLTMUONRecHitsBlockStruct;
 struct AliHLTMUONClustersBlockStruct;
 struct AliHLTMUONChannelsBlockStruct;
+struct AliHLTMUONMansoTrackStruct;
+struct AliHLTMUONMansoTracksBlockStruct;
+struct AliHLTMUONMansoCandidatesBlockStruct;
+struct AliHLTMUONTrackDecisionStruct;
+struct AliHLTMUONSinglesDecisionBlockStruct;
+struct AliHLTMUONPairDecisionStruct;
+struct AliHLTMUONPairsDecisionBlockStruct;
 } // extern "C"
 
 /**
@@ -90,6 +98,70 @@ public:
        {
                UnpackTriggerRecordFlags(flags, sign, hitset);
        }
+       
+       /**
+        * This packs the given parameters into the bits of a word appropriate
+        * for AliHLTMUONTrackDecisionStruct::fTriggerBits.
+        * @param highPt  Has the track passed the high pt cut.
+        * @param lowPt   Has the track passed the low pt cut.
+        * @return  Returns the 32 bit packed word.
+        */
+       static AliHLTUInt32_t PackTrackDecisionBits(bool highPt, bool lowPt);
+       
+       /**
+        * This unpacks the AliHLTMUONTrackDecisionStruct::fTriggerBits bits into
+        * its component fields.
+        * @param bits  The trigger bits from an AliHLTMUONTrackDecisionStruct
+        *              structure.
+        * @param highPt Sets this to the value of the high pt cut bit.
+        * @param lowPt  Sets this to the value of the low pt cut bit.
+        */
+       static void UnpackTrackDecisionBits(
+                       AliHLTUInt32_t bits, // [in]
+                       bool& highPt, // [out]
+                       bool& lowPt // [out]
+               );
+       
+       /**
+        * This packs the given parameters into the bits of a word appropriate
+        * for AliHLTMUONPairDecisionStruct::fTriggerBits.
+        *
+        * @param highMass Has the track pair passed the high invariant mass cut.
+        * @param lowMass  Has the track pair passed the low invariant mass cut.
+        * @param unlike   Does the track pair have unlike signs.
+        * @param highPtCount The number of tracks that passed the high pt cut
+        *                    in the pair.
+        * @param lowPtCount  The number of tracks that passed the low pt cut
+        *                    in the pair.
+        * @return  Returns the 32 bit packed word.
+        *
+        * Note: Must have highPtCount + lowPtCount <= 2 and unlike == true if
+        * highMass or lowMass is true.
+        */
+       static AliHLTUInt32_t PackPairDecisionBits(
+                       bool highMass, bool lowMass, bool unlike,
+                       AliHLTUInt8_t highPtCount, AliHLTUInt8_t lowPtCount
+               );
+       
+       /**
+        * This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into
+        * its component fields.
+        * @param bits  The trigger bits from an AliHLTMUONPairDecisionStruct
+        *              structure.
+        * @param highMass Sets this to the value of the high invariant mass cut bit.
+        * @param lowMass  Sets this to the value of the low invariant mass cut bit.
+        * @param unlike   Sets this if the pair is unlike sign.
+        * @param highPtCount Sets this to the high pt count bits.
+        * @param lowPtCount  Sets this to the low pt count bits.
+        */
+       static void UnpackPairDecisionBits(
+                       AliHLTUInt32_t bits, // [in]
+                       bool& highMass, // [out]
+                       bool& lowMass, // [out]
+                       bool& unlike, // [out]
+                       AliHLTUInt8_t& highPtCount, // [out]
+                       AliHLTUInt8_t& lowPtCount // [out]
+               );
 
        /**
         * Methods used to check if the header information corresponds to the
@@ -101,18 +173,30 @@ public:
        static bool HeaderOk(const AliHLTMUONRecHitsBlockStruct& block);
        static bool HeaderOk(const AliHLTMUONClustersBlockStruct& block);
        static bool HeaderOk(const AliHLTMUONChannelsBlockStruct& block);
+       static bool HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block);
+       static bool HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block);
+       static bool HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block);
+       static bool HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block);
 
        /**
-        * Methods used to check extensively if the integrity of various types
-        * of data blocks are Ok and returns true in that case.
+        * Methods used to check more extensively if the integrity of various
+        * types of data blocks are Ok and returns true in that case.
         * These can be slow and should generally only be used for debugging.
         */
+       static bool IntegrityOk(const AliHLTMUONTriggerRecordStruct& tr);
        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);
+       static bool IntegrityOk(const AliHLTMUONMansoTrackStruct& track);
+       static bool IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block);
+       static bool IntegrityOk(const AliHLTMUONMansoCandidatesBlockStruct& block);
+       static bool IntegrityOk(const AliHLTMUONTrackDecisionStruct& decision);
+       static bool IntegrityOk(const AliHLTMUONSinglesDecisionBlockStruct& block);
+       static bool IntegrityOk(const AliHLTMUONPairDecisionStruct& decision);
+       static bool IntegrityOk(const AliHLTMUONPairsDecisionBlockStruct& block);
 
 private:
        // Should never have to create or destroy this object.