X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FMUON%2FAliHLTMUONUtils.h;h=205d9709321a86f93ad9c90d8eb9a7127fa02a40;hb=58acb8abb48ea8315a0326846b241bbec1944b3f;hp=ff70c267ff74766cbb26c7f0c339747ae4645d42;hpb=f68b4e0e909e83843ace22be2b5e611e22290ab2;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/MUON/AliHLTMUONUtils.h b/HLT/MUON/AliHLTMUONUtils.h index ff70c267ff7..205d9709321 100644 --- a/HLT/MUON/AliHLTMUONUtils.h +++ b/HLT/MUON/AliHLTMUONUtils.h @@ -3,29 +3,37 @@ /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. * * See cxx source for full Copyright notice */ -/* $Id$ */ +// $Id$ /// /// @file AliHLTMUONUtils.h /// @author Artur Szostak -/// @date +/// @date 17 May 2007 /// @brief Class containing various dimuon HLT utility routines and macros. /// +#include "TObject.h" #include "AliHLTMUONDataTypes.h" +#include // Forward declare structures. extern "C" { struct AliHLTMUONTriggerRecordStruct; struct AliHLTMUONTriggerRecordsBlockStruct; +struct AliHLTMUONTrigRecInfoStruct; struct AliHLTMUONTrigRecsDebugBlockStruct; -struct AliHLTMUONTriggerChannelsBlockStruct; +struct AliHLTMUONRecHitStruct; struct AliHLTMUONRecHitsBlockStruct; +struct AliHLTMUONClusterStruct; struct AliHLTMUONClustersBlockStruct; +struct AliHLTMUONChannelStruct; struct AliHLTMUONChannelsBlockStruct; struct AliHLTMUONMansoTrackStruct; struct AliHLTMUONMansoTracksBlockStruct; +struct AliHLTMUONMansoCandidateStruct; struct AliHLTMUONMansoCandidatesBlockStruct; +struct AliHLTMUONTrackStruct; +struct AliHLTMUONTracksBlockStruct; struct AliHLTMUONTrackDecisionStruct; struct AliHLTMUONSinglesDecisionBlockStruct; struct AliHLTMUONPairDecisionStruct; @@ -56,9 +64,9 @@ public: /** * 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 + * @param [in] flags The flags from an AliHLTMUONTriggerRecordStruct structure. + * @param [out] sign Sets this to the particle sign. + * @param [out] hitset Sets the array elements to indicate if the corresponding * fHits[i] element was set/filled. */ static void UnpackTriggerRecordFlags( @@ -66,6 +74,39 @@ public: AliHLTMUONParticleSign& sign, // [out] bool hitset[4] // [out] ); + + /** + * This packs the given parameters into the bits of a word appropriate + * for AliHLTMUONRecHitStruct::fFlags. + * @param chamber The chamber number in the range [0..13]. + * @param detElemId Detector element ID number. + * @return Returns the 32 bit packed word. + */ + static AliHLTUInt32_t PackRecHitFlags( + AliHLTUInt8_t chamber, AliHLTUInt16_t detElemId + ); + + /** + * This unpacks the AliHLTMUONRecHitStruct::fFlags bits into + * its component fields. + * @param [in] flags The flags from an AliHLTMUONRecHitStruct structure. + * @param [out] chamber Sets the chamber number in the range [0..13]. + * @param [out] detElemId Sets the detector element ID number. + */ + static void UnpackRecHitFlags( + AliHLTUInt32_t flags, // [in] + AliHLTUInt8_t& chamber, // [out] + AliHLTUInt16_t& detElemId // [out] + ); + + /** + * Returns the detector element ID from the flags bits. + * @param [in] flags The flags from an AliHLTMUONRecHitStruct structure. + */ + static AliHLTUInt16_t GetDetElemIdFromFlags(AliHLTUInt32_t flags) + { + return flags & 0xFFF; + } /** * This packs the given parameters into the bits of a word appropriate @@ -85,9 +126,9 @@ public: /** * This unpacks the AliHLTMUONMansoTrackStruct::fFlags bits into * its component fields. - * @param flags The flags from an AliHLTMUONMansoTrackStruct structure. - * @param sign Sets this to the particle sign. - * @param hitset Sets the array elements to indicate if the corresponding + * @param [in] flags The flags from an AliHLTMUONMansoTrackStruct structure. + * @param [out] sign Sets this to the particle sign. + * @param [out] hitset Sets the array elements to indicate if the corresponding * fHits[i] element was set/filled. */ static void UnpackMansoTrackFlags( @@ -98,6 +139,32 @@ public: { UnpackTriggerRecordFlags(flags, sign, hitset); } + + /** + * This packs the given parameters into the bits of a word appropriate + * for AliHLTMUONTrackStruct::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. + */ + static AliHLTUInt32_t PackTrackFlags( + AliHLTMUONParticleSign sign, const bool hitset[16] + ); + + /** + * This unpacks the AliHLTMUONTrackStruct::fFlags bits into + * its component fields. + * @param [in] flags The flags from an AliHLTMUONTrackStruct structure. + * @param [out] sign Sets this to the particle sign. + * @param [out] hitset Sets the array elements to indicate if the corresponding + * fHits[i] element was set/filled. + */ + static void UnpackTrackFlags( + AliHLTUInt32_t flags, // [in] + AliHLTMUONParticleSign& sign, // [out] + bool hitset[16] // [out] + ); /** * This packs the given parameters into the bits of a word appropriate @@ -111,10 +178,10 @@ public: /** * This unpacks the AliHLTMUONTrackDecisionStruct::fTriggerBits bits into * its component fields. - * @param bits The trigger bits from an AliHLTMUONTrackDecisionStruct + * @param [in] 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. + * @param [out] highPt Sets this to the value of the high pt cut bit. + * @param [out] lowPt Sets this to the value of the low pt cut bit. */ static void UnpackTrackDecisionBits( AliHLTUInt32_t bits, // [in] @@ -146,13 +213,13 @@ public: /** * This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into * its component fields. - * @param bits The trigger bits from an AliHLTMUONPairDecisionStruct + * @param [in] 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. + * @param [out] highMass Sets this to the value of the high invariant mass cut bit. + * @param [out] lowMass Sets this to the value of the low invariant mass cut bit. + * @param [out] unlike Sets this if the pair is unlike sign. + * @param [out] highPtCount Sets this to the high pt count bits. + * @param [out] lowPtCount Sets this to the low pt count bits. */ static void UnpackPairDecisionBits( AliHLTUInt32_t bits, // [in] @@ -180,8 +247,8 @@ public: /** * 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] + * @param [in] bits The Pub/Sub specification word from a data block descriptor. + * @param [out] 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. @@ -267,73 +334,895 @@ public: AliHLTInt32_t ddl = SpecToDDLNumber(spec); return (0 <= ddl and ddl <= 19); } + + /** + * Returns true if the given specification is in principle valid. + * It checks if the bits that should be zero are indeed zero. + */ + static bool IsSpecValid(AliHLTUInt32_t spec) + { + AliHLTUInt32_t mask = ~AliHLTUInt32_t((1 << 22) - 1); // First 22 bits indicate DDL number. + return (spec & mask) == 0x0; + } + + /** + * Returns true if the data specification indicates the data block contains + * information generated from a trigger DDL or data fragments thereof. + */ + static bool ContainsDataFromTrigger(AliHLTUInt32_t spec) + { + AliHLTUInt32_t mask = AliHLTUInt32_t((1 << 22) - 1) & ~AliHLTUInt32_t((1 << 20) - 1); + return (spec & mask) != 0x0; + } + + /** + * Returns true if the data specification indicates the data block contains + * information generated from a tracker DDL or data fragments thereof. + */ + static bool ContainsDataFromTracker(AliHLTUInt32_t spec) + { + AliHLTUInt32_t mask = AliHLTUInt32_t((1 << 20) - 1); + return (spec & mask) != 0x0; + } /** - * Parses the string containing the type name of a dHLT data block and - * returns the corresponding AliHLTMUONDataBlockType value. - * \param type The string containing the type name. - * \returns The data block type or kUnknownDataBlock if the type name - * is invalid. - */ + * Parses the string containing the type name of a dHLT data block and + * returns the corresponding AliHLTMUONDataBlockType value. + * \param type The string containing the type name. + * \returns The data block type or kUnknownDataBlock if the type name + * is invalid. + */ static AliHLTMUONDataBlockType ParseCommandLineTypeString(const char* type); - + + /** + * Converts a type ID to a type string to be used for the dHLT FilePublisher + * component configuration parameters for example. + */ + static const char* DataBlockTypeToString(AliHLTMUONDataBlockType type); + /** * These codes indicate the reason why a data block failed its * validity check. */ enum WhyNotValid { - kNoReason, - kHeaderContainsWrongType, - kHeaderContainsWrongRecordWidth + kNoReason, ///< There was no reason for failure. + kHeaderContainsWrongType, ///< The common header contains an incorrect type ID. + kHeaderContainsWrongRecordWidth, ///< The common header contains an incorrect data record width. + kInvalidIdValue, ///< The structure identifier does not have a valid value. + kInvalidTriggerIdValue, ///< The trigger structure identifier does not have a valid value. + kInvalidTrackIdValue, ///< The track structure identifier does not have a valid value. + kReservedBitsNotZero, ///< Reserved bits have not been set to zero. + kParticleSignBitsNotValid, ///< The particle sign bits are not a valid value. + kHitNotMarkedAsNil, ///< A hit was marked as not found, but the corresponding hit structure was not set to nil. + kInvalidDetElementNumber, ///< An invalid detector element ID was found. + kInvalidChamberNumber, ///< An invalid chamber number was found. + kHitIsNil, ///< The hit cannot be set to a nil value. + kInvalidChannelCountB, ///< The number of channels in the bending plane indicated is zero or outside the valid range. + kInvalidChannelCountNB, ///< The number of channels in the non-bending plane indicated is zero or outside the valid range. + kInvalidChargeB, ///< The charge for the bending plane does not have a valid value. + kInvalidChargeNB, ///< The charge for the non-bending plane does not have a valid value. + kInvalidBusPatchId, ///< The bus patch ID is outside the valid range. + kInvalidManuId, ///< The MANU ID is outside the valid range. + kInvalidChannelAddress, ///< The MANU channel address is outside the valid range. + kInvalidSignal, ///< The ADC signal value is outside the valid range. + kDataWordDifferent, ///< The raw data word is different from the unpacked values. + kChiSquareInvalid, ///< The chi squared value must be a positive value or -1 indicating a fitting error. + kMomentumVectorNotZero, ///< The chi sqaured value is set to -1, but momentum vector not zero. + kMomentumParamsNotZero, ///< The chi sqaured value is set to -1, but fitted momentum parameters are not zero. + kDCAVertexNotZero, ///< The chi sqaured value is set to -1, but DCA vertex is not zero. + kRoiRadiusInvalid, ///< The region of interest radius is invalid. + kHitNotWithinRoi, ///< A tracks hit is not within the corresponding region of interest. + kPtValueNotValid, ///< The pT value is not positive nor -1 indicating an invalid value. + kPairTrackIdsAreIdentical, ///< The track IDs of the track pair are identical. + kMassValueNotValid, ///< The invariant mass value is not positive nor -1 indicating an invalid value. + kLowPtCountInvalid, ///< The low pT trigger count is greater than 2, which is invalid. + kHighPtCountInvalid, ///< The high pT trigger count is greater than 2, which is invalid. + kFoundDuplicateIDs, ///< Found duplicate identifiers, but they should all be unique. + kFoundDuplicateHits, ///< Found duplicate hits. + kFoundDuplicateTriggers ///< Found duplicate trigger decisions. }; + + /** + * This method converts the WhyNotValid enumeration to a string representation. + */ + static const char* FailureReasonToString(WhyNotValid reason); + + /** + * This method returns a string containing a user readable message explaining + * the reason for failure described by the WhyNotValid enumeration. + */ + static const char* FailureReasonToMessage(WhyNotValid reason); + + /** + * Method used to check if the header information corresponds to the + * supposed type of the trigger records data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the trigger debug information data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the reconstructed hits data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONRecHitsBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the clusters data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONClustersBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the channels data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONChannelsBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the Manso tracks data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the Manso candidates data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the tracks data block given. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONTracksBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the single tracks dHLT trigger decision data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } + + /** + * Method used to check if the header information corresponds to the + * supposed type of the track pairs dHLT trigger decision data block. + * This method will return either kHeaderContainsWrongType or + * kHeaderContainsWrongRecordWidth as the reason code. + * \param [in] block The data block to check. + * \param [out] reason If this is not NULL, then the variable pointed to + * by this pointer will be filled with the reason code describing why + * the header is not valid, if and only if a problem is found with + * the data. + * \returns true if there is no problem with the header and false otherwise. + */ + static bool HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block, WhyNotValid* reason = NULL) + { + AliHLTUInt32_t count = 1; + return HeaderOk(block, reason, count); + } /** * 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. - */ - static bool HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block, WhyNotValid* reason = NULL); - static bool HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block); - static bool HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block); - static bool HeaderOk(const AliHLTMUONRecHitsBlockStruct& block); - static bool HeaderOk(const AliHLTMUONClustersBlockStruct& block); - static bool HeaderOk(const AliHLTMUONChannelsBlockStruct& block); - static bool HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block); - static bool HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block); - static bool HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block); - static bool HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block); + * If the 'reason' parameter should point to an array which will store + * the reason codes indicating the problems with the data block. + * The 'reasonCount' parameter should initialy contain the number of + * elements that can be stored in reason. When the method exits it will + * store the number of elements in the 'reason' array actually filled. + */ + static bool HeaderOk( + const AliHLTMUONTriggerRecordsBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONTrigRecsDebugBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONRecHitsBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONClustersBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONChannelsBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONMansoTracksBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONMansoCandidatesBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONTracksBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONSinglesDecisionBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool HeaderOk( + const AliHLTMUONPairsDecisionBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + /** + * This method is used to check more extensively if the integrity of the + * trigger record structure is OK and returns true in that case. + * \param [in] tr The trigger record structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the structure and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONTriggerRecordStruct& tr, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(tr, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The trigger record data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the trigger record that had a problem. This value will + * only contain a valid value if the method RecordNumberWasSet(*reason) + * returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONTriggerRecordsBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * trigger record debug information structure is OK and returns true in that case. + * \param [in] trigInfo The trigger record debug information structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the structure and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONTrigRecInfoStruct& trigInfo, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(trigInfo, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The trigger record debugging information data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the trigger record debug information structure that had + * a problem. This value will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONTrigRecsDebugBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * reconstructed hit structure is OK and returns true in that case. + * \param [in] hit The reconstructed hit structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONRecHitStruct& hit, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(hit, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The reconstructed hits data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the cluster structure that had a problem. This value + * will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONRecHitsBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * cluster data structure is OK and returns true in that case. + * \param [in] cluster The cluster structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONClusterStruct& cluster, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(cluster, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The clusters data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the cluster structure that had a problem. This value + * will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONClustersBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * channel data structure is OK and returns true in that case. + * \param [in] cluster The channel structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONChannelStruct& channel, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(channel, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The ADC channels data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the channel structure that had a problem. This value + * will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONChannelsBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * Manso track structure is OK and returns true in that case. + * \param [in] track The Manso track structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the structure and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONMansoTrackStruct& track, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(track, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The Manso track data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the Manso track structure that had a problem. + * This value will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONMansoTracksBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * Manso track candidate structure is OK and returns true in that case. + * \param [in] candidate The Manso track candidate structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the structure and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONMansoCandidateStruct& candidate, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(candidate, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The Manso track candidate data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the Manso track candidate structure that had a problem. + * This value will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONMansoCandidatesBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * full track structure is OK and returns true in that case. + * \param [in] track The track structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the structure and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONTrackStruct& track, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(track, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The track data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the Manso track structure that had a problem. + * This value will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONTracksBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * single track trigger decision structure is OK and returns true in that case. + * \param [in] decision The trigger decision structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the structure and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONTrackDecisionStruct& decision, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(decision, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The single track trigger decision data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the single track trigger decision structure that had + * a problem. This value will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONSinglesDecisionBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * track pair trigger decision structure is OK and returns true in that case. + * \param [in] decision The trigger decision structure to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the structure is not valid, if and + * only if a problem is found with the data. + * \returns true if there is no problem with the structure and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONPairDecisionStruct& decision, + WhyNotValid* reason = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(decision, reason, count); + } + + /** + * This method is used to check more extensively if the integrity of the + * dHLT raw internal data block is OK and returns true in that case. + * \param [in] block The track pair trigger decision data block to check. + * \param [out] reason If this is not NULL, then it will be filled with + * the reason code describing why the data block is not valid, if and + * only if a problem is found with the data. + * \param [out] recordNum If this is not NULL, then it will be filled with + * the number of the track pairs trigger decision structure that had + * a problem. This value will only contain a valid value if the method + * RecordNumberWasSet(*reason) returns true. Thus, 'reason' must be set. + * \returns true if there is no problem with the data and false otherwise. + */ + static bool IntegrityOk( + const AliHLTMUONPairsDecisionBlockStruct& block, + WhyNotValid* reason = NULL, AliHLTUInt32_t* recordNum = NULL + ) + { + AliHLTUInt32_t count = 1; + return IntegrityOk(block, reason, recordNum, count); + } /** * 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. + * The methods are able to return multiple reasons for the problems related + * to the data block under test. */ - 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); + static bool IntegrityOk( + const AliHLTMUONTriggerRecordStruct& tr, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONTriggerRecordsBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONTrigRecInfoStruct& trigInfo, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONTrigRecsDebugBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONRecHitStruct& hit, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONRecHitsBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONClusterStruct& cluster, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONClustersBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONChannelStruct& channel, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONChannelsBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONMansoTrackStruct& track, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONMansoTracksBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONMansoCandidateStruct& candidate, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONMansoCandidatesBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONTrackStruct& track, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONTracksBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONTrackDecisionStruct& decision, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONSinglesDecisionBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONPairDecisionStruct& decision, + WhyNotValid* reason, AliHLTUInt32_t& reasonCount + ); + + static bool IntegrityOk( + const AliHLTMUONPairsDecisionBlockStruct& block, + WhyNotValid* reason, AliHLTUInt32_t* recordNum, + AliHLTUInt32_t& reasonCount + ); + + /** + * Returns true if the \em recordNum in the corresponding IntegrityOk method + * would have been set, if it returned false and a reason was set. + * This helper method makes it easy to test if the \em recordNum parameter + * is filled with a valid value or not. + */ + static bool RecordNumberWasSet(WhyNotValid reason); private: - // Should never have to create or destroy this object. - AliHLTMUONUtils(); - ~AliHLTMUONUtils(); + + // Should never have to create, copy or destroy this object. + AliHLTMUONUtils() {} + AliHLTMUONUtils(const AliHLTMUONUtils& obj); + virtual ~AliHLTMUONUtils() {} + AliHLTMUONUtils& operator = (const AliHLTMUONUtils& obj); + + ClassDef(AliHLTMUONUtils, 0); // Interface for helpful dHLT utility methods. }; //_____________________________________________________________________________ +inline std::ostream& operator << (std::ostream& stream, AliHLTMUONUtils::WhyNotValid reason) +{ + /// Stream operator for the WhyNotValid enumeration for usage with + /// std::ostream classes. Allows usages such as: + /// AliHLTMUONUtils::WhyNotValid r; std::cout << r; + + stream << AliHLTMUONUtils::FailureReasonToString(reason); + return stream; +} + +//_____________________________________________________________________________ + // Since c++ is missing a finally "keyword" we define one. Its usage is identical // to a try..finally statement in Java etc.. however, since it is officialy a macro // one must use the ( ) brackets instead of { } @@ -350,21 +1239,11 @@ private: code #endif // __BORLANDC__ -// If we do not already have them, then define logical operators that are easier -// to read. 'and' = &&, 'or' = ||, 'not' = ! -#if ! defined(__GNUC__) && ! defined(__CINT__) -// TODO: Should use iso646.h -# define and && -# define or || -# define not ! -#endif // __GNUC__ | __CINT__ - - // Here we define the DebugTrace(message) macro for easy embedding of debug // information into the dimuon HLT code. Its usage is meant to be for generating // traces of the program which are only useful during full scale debugging. // Log messages should use the standard HLT logging mechanisms. -// The output is only generated in programs compiled with the DEBUG directive +// The output is only generated in programs compiled with the DEBUGTRACE directive // defined. Here is a usage example: // // // statements... @@ -378,7 +1257,7 @@ private: // DebugTrace("x = " << x << " and y = 0x" << std::hex << y ); // // statements... // -#ifdef DEBUG +#ifdef DEBUGTRACE # include # define DebugTrace(message) {std::cout << message << std::endl;} #else // DEBUG