Fixing coding violations and getting rid of warnings.
[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONUtils.cxx
index c0dc4af..db4eacf 100644 (file)
 
 /* $Id$ */
 
-/**
- * @file   AliHLTMUONUtils.cxx
- * @author Artur Szostak <artursz@iafrica.com>
- * @date   
- * @brief  Implementation of AliHLTMUONUtils utility routines.
- */
+///
+/// @file   AliHLTMUONUtils.cxx
+/// @author Artur Szostak <artursz@iafrica.com>
+/// @date   
+/// @brief  Implementation of AliHLTMUONUtils utility routines.
+///
 
 #include "AliHLTMUONUtils.h"
 #include "AliHLTMUONConstants.h"
@@ -41,6 +41,15 @@ AliHLTUInt32_t AliHLTMUONUtils::PackTriggerRecordFlags(
                AliHLTMUONParticleSign sign, const bool hitset[4]
        )
 {
+       ///
+       /// This packs the given parameters into the bits of a word appropriate
+       /// for AliHLTMUONTriggerRecordStruct::fFlags.
+       /// @param sign    The particle sign.
+       /// @param hitset  Flags to indicate if the corresponding fHits[i] elements
+       ///                was set/filled.
+       /// @return  Returns the 32 bit packed word.
+       ///
+       
        AliHLTUInt32_t flags;
        switch (sign)
        {
@@ -58,6 +67,15 @@ void AliHLTMUONUtils::UnpackTriggerRecordFlags(
                AliHLTUInt32_t flags, AliHLTMUONParticleSign& sign, bool hitset[4]
        )
 {
+       ///
+       /// This unpacks the AliHLTMUONTriggerRecordStruct::fFlags bits into
+       /// its component fields.
+       /// @param flags  The flags from an AliHLTMUONTriggerRecordStruct structure.
+       /// @param sign    Sets this to the particle sign.
+       /// @param hitset  Sets the array elements to indicate if the corresponding
+       ///                fHits[i] element was set/filled.
+       ///
+       
        AliHLTUInt32_t signbits = flags & 0xC0000000;
        switch (signbits)
        {
@@ -74,6 +92,14 @@ void AliHLTMUONUtils::UnpackTriggerRecordFlags(
 
 AliHLTUInt32_t AliHLTMUONUtils::PackTrackDecisionBits(bool highPt, bool lowPt)
 {
+       ///
+       /// 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.
+       ///
+       
        return (highPt ? 0x2 : 0) | (lowPt ? 0x1 : 0);
 }
 
@@ -82,6 +108,15 @@ void AliHLTMUONUtils::UnpackTrackDecisionBits(
                AliHLTUInt32_t bits, 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.
+       ///
+       
        lowPt  = (bits & 0x1) == 1;
        highPt = (bits & 0x2) == 1;
 }
@@ -92,6 +127,23 @@ AliHLTUInt32_t AliHLTMUONUtils::PackPairDecisionBits(
                AliHLTUInt8_t highPtCount, AliHLTUInt8_t lowPtCount
        )
 {
+       ///
+       /// 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.
+       ///
+       
        assert( highPtCount + lowPtCount <= 2 );
        // highMass and lowMass must be false if unlike is false:
        assert( not unlike ? (highMass == false and lowMass == false) : true );
@@ -106,6 +158,18 @@ void AliHLTMUONUtils::UnpackPairDecisionBits(
                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.
+       ///
+       
        highMass = (bits & 0x40) == 1;
        lowMass  = (bits & 0x20) == 1;
        unlike   = (bits & 0x10) == 1;
@@ -118,6 +182,17 @@ AliHLTUInt32_t AliHLTMUONUtils::PackSpecBits(
                const bool ddl[22]
        )
 {
+       ///
+       /// This packs the given parameters into the 32bit Pub/Sub specification
+       /// word in the data block descriptor.
+       ///
+       /// @param ddl  The list of DDLs forming part of the readout. ddl[0]
+       ///             indicates DDL number 2560, ddl[1] is for DDL 2561 and so
+       ///             on up to ddl[19]. ddl[20] and ddl[21] will be for the
+       ///             trigger DDLs 2816 and 2817 respectively.
+       /// @return  Returns the 32 bit packed specification word.
+       ///
+       
        // Pack the bits into the following format:
        //   bit:   [        31 - 22        ][     21     ][     20     ][  19 - 0 ]
        //   field: [ reserved, set to zero ][ TRGDDL2817 ][ TRGDDL2816 ][ TRKDDLS ]
@@ -137,6 +212,16 @@ void AliHLTMUONUtils::UnpackSpecBits(
                AliHLTUInt32_t bits, bool ddl[22]
        )
 {
+       ///
+       /// This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into
+       /// its component fields.
+       /// @param bits  The Pub/Sub specification word from a data block descriptor.
+       /// @param ddl  The output list of DDLs forming part of the readout. ddl[0]
+       ///             indicates DDL number 2560, ddl[1] is for DDL 2561 and so
+       ///             on up to ddl[19]. ddl[20] and ddl[21] will be for the
+       ///             trigger DDLs 2816 and 2817 respectively.
+       ///
+       
        // Perform the inverse operation of PackSpecBits.
        for (int i = 0; i < 22; i++)
                ddl[i] = ((bits >> i) & 0x1) == 1;
@@ -148,6 +233,14 @@ bool AliHLTMUONUtils::HeaderOk(
                WhyNotValid* reason
        )
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data block.
+       /// If the 'reason' parameter is not NULL then these methods will fill the
+       /// memory pointed to by reason with a code describing of why the header
+       /// is not valid, if and only if a problem is found with the data.
+       ///
+        
        // The block must have the correct type.
        if (block.fHeader.fType != kTriggerRecordsDataBlock)
        {
@@ -168,6 +261,11 @@ bool AliHLTMUONUtils::HeaderOk(
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data block.
+       ///
+       
        // The block must have the correct type.
        if (block.fHeader.fType != kTrigRecsDebugDataBlock) return false;
        // The block's record width must be the correct size.
@@ -179,6 +277,11 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data block.
+       ///
+       
        // The block must have the correct type.
        if (block.fHeader.fType != kTriggerChannelsDataBlock) return false;
        // The block's record width must be the correct size.
@@ -190,6 +293,11 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONRecHitsBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data block.
+       ///
+       
        // The block must have the correct type.
        if (block.fHeader.fType != kRecHitsDataBlock) return false;
        // The block's record width must be the correct size.
@@ -201,6 +309,11 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONRecHitsBlockStruct& block)
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONClustersBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data block.
+       ///
+       
        // The block must have the correct type.
        if (block.fHeader.fType != kClustersDataBlock) return false;
        // The block's record width must be the correct size.
@@ -212,6 +325,11 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONClustersBlockStruct& block)
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONChannelsBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data block.
+       ///
+       
        // The block must have the correct type.
        if (block.fHeader.fType != kChannelsDataBlock) return false;
        // The block's record width must be the correct size.
@@ -223,6 +341,11 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONChannelsBlockStruct& block)
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data 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.
@@ -234,6 +357,11 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block)
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data 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.
@@ -245,6 +373,11 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data 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.
@@ -256,6 +389,11 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block
 
 bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block)
 {
+       ///
+       /// Methods used to check if the header information corresponds to the
+       /// supposed type of the data 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.
@@ -267,6 +405,12 @@ bool AliHLTMUONUtils::HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordStruct& tr)
 {
+       ///
+       /// 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.
+       ///
+       
        // Make sure that the reserved bits in the fFlags field are set
        // to zero.
        if ((tr.fFlags & 0x3FFFFFF0) != 0) return false;
@@ -289,6 +433,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordStruct& tr)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
 
        // Check if any ID is duplicated.
@@ -314,6 +464,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& blo
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrigRecsDebugBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
        return true;
 }
@@ -321,6 +477,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrigRecsDebugBlockStruct& bloc
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerChannelsBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
        return true;
 }
@@ -328,6 +490,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerChannelsBlockStruct& bl
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
        return true;
 }
@@ -335,6 +503,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONClustersBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
 
        // Check if any ID is duplicated.
@@ -354,6 +528,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONClustersBlockStruct& block)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONChannelsBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
        return true;
 }
@@ -361,6 +541,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONChannelsBlockStruct& block)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTrackStruct& track)
 {
+       ///
+       /// 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.
+       ///
+       
        // Make sure that the reserved bits in the fFlags field are set
        // to zero.
        if ((track.fFlags & 0x3FFFFFF0) != 0) return false;
@@ -383,6 +569,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTrackStruct& track)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
 
        // Check if any ID is duplicated.
@@ -408,6 +600,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoCandidatesBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
 
        // Check that the tracks have integrity.
@@ -422,6 +620,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoCandidatesBlockStruct& bl
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrackDecisionStruct& decision)
 {
+       ///
+       /// 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.
+       ///
+       
        // Make sure that the reserved bits in the fTriggerBits field are set
        // to zero.
        if ((decision.fTriggerBits & 0xFFFFFFFC) != 0) return false;
@@ -431,6 +635,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTrackDecisionStruct& decision)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONSinglesDecisionBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
 
        // Check that the trigger bits for each track have integrity.
@@ -445,6 +655,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONSinglesDecisionBlockStruct& bl
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONPairDecisionStruct& decision)
 {
+       ///
+       /// 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.
+       ///
+       
        // Make sure that the reserved bits in the fTriggerBits field are set
        // to zero.
        if ((decision.fTriggerBits & 0xFFFFFF80) != 0) return false;
@@ -467,6 +683,12 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONPairDecisionStruct& decision)
 
 bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONPairsDecisionBlockStruct& block)
 {
+       ///
+       /// 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.
+       ///
+       
        if (not HeaderOk(block)) return false;
 
        // Check that the trigger bits for each track pair have integrity.