[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONUtils.h

#ifndef ALIHLTMUONUTILS_H
#define ALIHLTMUONUTILS_H
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

/**
 * @file   AliHLTMUONUtils.h
 * @author Artur Szostak <artursz@iafrica.com>
 * @date   
 * @brief  Class containing various dimuon HLT utility routines and macros.
 */

#include "AliHLTMUONDataTypes.h"

// 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"

/**
 * AliHLTMUONUtils contains arbitrary utility methods to be used in various
 * parts of the dimuon HLT system.
 * These include methods to perform basic sanity checks on the integrity of
 * data blocks.
 */
class AliHLTMUONUtils
{
public:
	/**
	 * 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.
	 */
	static AliHLTUInt32_t PackTriggerRecordFlags(
			AliHLTMUONParticleSign sign, const 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.
	 */
	static void UnpackTriggerRecordFlags(
			AliHLTUInt32_t flags, // [in]
			AliHLTMUONParticleSign& sign, // [out]
			bool hitset[4] // [out]
		);

	/**
	 * This packs the given parameters into the bits of a word appropriate
	 * for AliHLTMUONMansoTrackStruct::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 PackMansoTrackFlags(
			AliHLTMUONParticleSign sign, const bool hitset[4]
		)
	{
		return PackTriggerRecordFlags(sign, hitset);
	}

	/**
	 * 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
	 *                fHits[i] element was set/filled.
	 */
	static void UnpackMansoTrackFlags(
			AliHLTUInt32_t flags, // [in]
			AliHLTMUONParticleSign& sign, // [out]
			bool hitset[4] // [out]
		)
	{
		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]
		);
	
	/**
	 * 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.
	 */
	static AliHLTUInt32_t PackSpecBits(
			const 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.
	 */
	static void UnpackSpecBits(
			AliHLTUInt32_t bits, // [in]
			bool ddl[22] // [out]
		);

	/**
	 * These codes indicate the reason why a data block failed its
	 * validity check.
	 */
	enum WhyNotValid
	{
		kNoReason,
		kHeaderContainsWrongType,
		kHeaderContainsWrongRecordWidth,
	};

	/**
	 * 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);

	/**
	 * 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.
	AliHLTMUONUtils();
	~AliHLTMUONUtils();
};

//_____________________________________________________________________________

// 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 { }
// If the compiler supports __finally use it otherwise make our own.
#if defined(__BORLANDC__)
#	define finally(str) __finally{str}
#else
#	define finally(code) \
		catch(...) \
		{ \
			code \
			throw; \
		}; \
		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
// defined. Here is a usage example:
//
//  // statements...
//  DebugTrace("some debug information.");
//  // statements...
//
// One can also use C++ ostream operators and manipulators like so:
//
//  // statements...
//  int x, y;
//  DebugTrace("x = " << x << " and y = 0x" << std::hex << y );
//  // statements...
//
#ifdef DEBUG
#	include <ostream>
#	define DebugTrace(message) {std::cout << message << std::endl;}
#else // DEBUG
#	define DebugTrace(message)
#endif // DEBUG


#endif // ALIHLTMUONUTILS_H
Commit	Line	Data
26a4668d	1	#ifndef ALIHLTMUONUTILS_H
	2	#define ALIHLTMUONUTILS_H
	3	/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	/**
	9	* @file AliHLTMUONUtils.h
	10	* @author Artur Szostak <artursz@iafrica.com>
	11	* @date
b727f838	12	* @brief Class containing various dimuon HLT utility routines and macros.
26a4668d	13	*/
26a4668d	14
c8ec7c7e	15	#include "AliHLTMUONDataTypes.h"
	16
	17	// Forward declare structures.
	18	extern "C" {
90a74d7a	19	struct AliHLTMUONTriggerRecordStruct;
c8ec7c7e	20	struct AliHLTMUONTriggerRecordsBlockStruct;
	21	struct AliHLTMUONTrigRecsDebugBlockStruct;
	22	struct AliHLTMUONTriggerChannelsBlockStruct;
	23	struct AliHLTMUONRecHitsBlockStruct;
	24	struct AliHLTMUONClustersBlockStruct;
	25	struct AliHLTMUONChannelsBlockStruct;
90a74d7a	26	struct AliHLTMUONMansoTrackStruct;
	27	struct AliHLTMUONMansoTracksBlockStruct;
	28	struct AliHLTMUONMansoCandidatesBlockStruct;
	29	struct AliHLTMUONTrackDecisionStruct;
	30	struct AliHLTMUONSinglesDecisionBlockStruct;
	31	struct AliHLTMUONPairDecisionStruct;
	32	struct AliHLTMUONPairsDecisionBlockStruct;
c8ec7c7e	33	} // extern "C"
26a4668d	34
	35	/**
	36	* AliHLTMUONUtils contains arbitrary utility methods to be used in various
	37	* parts of the dimuon HLT system.
	38	* These include methods to perform basic sanity checks on the integrity of
	39	* data blocks.
	40	*/
	41	class AliHLTMUONUtils
	42	{
	43	public:
b727f838	44	/**
	45	* This packs the given parameters into the bits of a word appropriate
	46	* for AliHLTMUONTriggerRecordStruct::fFlags.
	47	* @param sign The particle sign.
	48	* @param hitset Flags to indicate if the corresponding fHits[i] elements
	49	* was set/filled.
	50	* @return Returns the 32 bit packed word.
	51	*/
	52	static AliHLTUInt32_t PackTriggerRecordFlags(
e6357f88	53	AliHLTMUONParticleSign sign, const bool hitset[4]
b727f838	54	);
	55
	56	/**
	57	* This unpacks the AliHLTMUONTriggerRecordStruct::fFlags bits into
	58	* its component fields.
	59	* @param flags The flags from an AliHLTMUONTriggerRecordStruct structure.
	60	* @param sign Sets this to the particle sign.
	61	* @param hitset Sets the array elements to indicate if the corresponding
	62	* fHits[i] element was set/filled.
	63	*/
	64	static void UnpackTriggerRecordFlags(
	65	AliHLTUInt32_t flags, // [in]
	66	AliHLTMUONParticleSign& sign, // [out]
	67	bool hitset[4] // [out]
	68	);
	69
	70	/**
	71	* This packs the given parameters into the bits of a word appropriate
	72	* for AliHLTMUONMansoTrackStruct::fFlags.
	73	* @param sign The particle sign.
	74	* @param hitset Flags to indicate if the corresponding fHits[i] elements
	75	* was set/filled.
	76	* @return Returns the 32 bit packed word.
	77	*/
	78	static AliHLTUInt32_t PackMansoTrackFlags(
e6357f88	79	AliHLTMUONParticleSign sign, const bool hitset[4]
b727f838	80	)
	81	{
	82	return PackTriggerRecordFlags(sign, hitset);
	83	}
	84
	85	/**
	86	* This unpacks the AliHLTMUONMansoTrackStruct::fFlags bits into
	87	* its component fields.
	88	* @param flags The flags from an AliHLTMUONMansoTrackStruct structure.
	89	* @param sign Sets this to the particle sign.
	90	* @param hitset Sets the array elements to indicate if the corresponding
	91	* fHits[i] element was set/filled.
	92	*/
	93	static void UnpackMansoTrackFlags(
	94	AliHLTUInt32_t flags, // [in]
	95	AliHLTMUONParticleSign& sign, // [out]
	96	bool hitset[4] // [out]
	97	)
	98	{
	99	UnpackTriggerRecordFlags(flags, sign, hitset);
	100	}
90a74d7a	101
	102	/**
	103	* This packs the given parameters into the bits of a word appropriate
	104	* for AliHLTMUONTrackDecisionStruct::fTriggerBits.
	105	* @param highPt Has the track passed the high pt cut.
	106	* @param lowPt Has the track passed the low pt cut.
	107	* @return Returns the 32 bit packed word.
	108	*/
	109	static AliHLTUInt32_t PackTrackDecisionBits(bool highPt, bool lowPt);
	110
	111	/**
	112	* This unpacks the AliHLTMUONTrackDecisionStruct::fTriggerBits bits into
	113	* its component fields.
	114	* @param bits The trigger bits from an AliHLTMUONTrackDecisionStruct
	115	* structure.
	116	* @param highPt Sets this to the value of the high pt cut bit.
	117	* @param lowPt Sets this to the value of the low pt cut bit.
	118	*/
	119	static void UnpackTrackDecisionBits(
	120	AliHLTUInt32_t bits, // [in]
	121	bool& highPt, // [out]
	122	bool& lowPt // [out]
	123	);
	124
	125	/**
	126	* This packs the given parameters into the bits of a word appropriate
	127	* for AliHLTMUONPairDecisionStruct::fTriggerBits.
	128	*
	129	* @param highMass Has the track pair passed the high invariant mass cut.
	130	* @param lowMass Has the track pair passed the low invariant mass cut.
	131	* @param unlike Does the track pair have unlike signs.
	132	* @param highPtCount The number of tracks that passed the high pt cut
	133	* in the pair.
	134	* @param lowPtCount The number of tracks that passed the low pt cut
	135	* in the pair.
	136	* @return Returns the 32 bit packed word.
	137	*
	138	* Note: Must have highPtCount + lowPtCount <= 2 and unlike == true if
	139	* highMass or lowMass is true.
	140	*/
	141	static AliHLTUInt32_t PackPairDecisionBits(
	142	bool highMass, bool lowMass, bool unlike,
	143	AliHLTUInt8_t highPtCount, AliHLTUInt8_t lowPtCount
	144	);
	145
	146	/**
	147	* This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into
	148	* its component fields.
	149	* @param bits The trigger bits from an AliHLTMUONPairDecisionStruct
	150	* structure.
	151	* @param highMass Sets this to the value of the high invariant mass cut bit.
	152	* @param lowMass Sets this to the value of the low invariant mass cut bit.
	153	* @param unlike Sets this if the pair is unlike sign.
	154	* @param highPtCount Sets this to the high pt count bits.
	155	* @param lowPtCount Sets this to the low pt count bits.
	156	*/
	157	static void UnpackPairDecisionBits(
	158	AliHLTUInt32_t bits, // [in]
	159	bool& highMass, // [out]
	160	bool& lowMass, // [out]
	161	bool& unlike, // [out]
	162	AliHLTUInt8_t& highPtCount, // [out]
	163	AliHLTUInt8_t& lowPtCount // [out]
	164	);
e6357f88	165
	166	/**
	167	* This packs the given parameters into the 32bit Pub/Sub specification
	168	* word in the data block descriptor.
	169	*
	170	* @param ddl The list of DDLs forming part of the readout. ddl[0]
	171	* indicates DDL number 2560, ddl[1] is for DDL 2561 and so
	172	* on up to ddl[19]. ddl[20] and ddl[21] will be for the
	173	* trigger DDLs 2816 and 2817 respectively.
	174	* @return Returns the 32 bit packed specification word.
	175	*/
	176	static AliHLTUInt32_t PackSpecBits(
	177	const bool ddl[22]
	178	);
	179
	180	/**
	181	* This unpacks the AliHLTMUONPairDecisionStruct::fTriggerBits bits into
	182	* its component fields.
	183	* @param bits The Pub/Sub specification word from a data block descriptor.
	184	* @param ddl The output list of DDLs forming part of the readout. ddl[0]
	185	* indicates DDL number 2560, ddl[1] is for DDL 2561 and so
	186	* on up to ddl[19]. ddl[20] and ddl[21] will be for the
	187	* trigger DDLs 2816 and 2817 respectively.
	188	*/
	189	static void UnpackSpecBits(
	190	AliHLTUInt32_t bits, // [in]
	191	bool ddl[22] // [out]
	192	);
26a4668d	193
698c9498	194	/**
	195	* These codes indicate the reason why a data block failed its
	196	* validity check.
	197	*/
	198	enum WhyNotValid
	199	{
	200	kNoReason,
	201	kHeaderContainsWrongType,
	202	kHeaderContainsWrongRecordWidth,
	203	};
	204
26a4668d	205	/**
b727f838	206	* Methods used to check if the header information corresponds to the
b727f838	207	* supposed type of the data block.
698c9498	208	* If the 'reason' parameter is not NULL then these methods will fill the
	209	* memory pointed to by reason with a code describing of why the header
	210	* is not valid, if and only if a problem is found with the data.
26a4668d	211	*/
698c9498	212	static bool HeaderOk(const AliHLTMUONTriggerRecordsBlockStruct& block, WhyNotValid* reason = NULL);
c8ec7c7e	213	static bool HeaderOk(const AliHLTMUONTrigRecsDebugBlockStruct& block);
c8ec7c7e	214	static bool HeaderOk(const AliHLTMUONTriggerChannelsBlockStruct& block);
b727f838	215	static bool HeaderOk(const AliHLTMUONRecHitsBlockStruct& block);
	216	static bool HeaderOk(const AliHLTMUONClustersBlockStruct& block);
	217	static bool HeaderOk(const AliHLTMUONChannelsBlockStruct& block);
90a74d7a	218	static bool HeaderOk(const AliHLTMUONMansoTracksBlockStruct& block);
	219	static bool HeaderOk(const AliHLTMUONMansoCandidatesBlockStruct& block);
	220	static bool HeaderOk(const AliHLTMUONSinglesDecisionBlockStruct& block);
	221	static bool HeaderOk(const AliHLTMUONPairsDecisionBlockStruct& block);
b727f838	222
b727f838	223	/**
90a74d7a	224	* Methods used to check more extensively if the integrity of various
90a74d7a	225	* types of data blocks are Ok and returns true in that case.
b727f838	226	* These can be slow and should generally only be used for debugging.
b727f838	227	*/
90a74d7a	228	static bool IntegrityOk(const AliHLTMUONTriggerRecordStruct& tr);
b727f838	229	static bool IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& block);
c8ec7c7e	230	static bool IntegrityOk(const AliHLTMUONTrigRecsDebugBlockStruct& block);
c8ec7c7e	231	static bool IntegrityOk(const AliHLTMUONTriggerChannelsBlockStruct& block);
b727f838	232	static bool IntegrityOk(const AliHLTMUONRecHitsBlockStruct& block);
	233	static bool IntegrityOk(const AliHLTMUONClustersBlockStruct& block);
	234	static bool IntegrityOk(const AliHLTMUONChannelsBlockStruct& block);
90a74d7a	235	static bool IntegrityOk(const AliHLTMUONMansoTrackStruct& track);
	236	static bool IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block);
	237	static bool IntegrityOk(const AliHLTMUONMansoCandidatesBlockStruct& block);
	238	static bool IntegrityOk(const AliHLTMUONTrackDecisionStruct& decision);
	239	static bool IntegrityOk(const AliHLTMUONSinglesDecisionBlockStruct& block);
	240	static bool IntegrityOk(const AliHLTMUONPairDecisionStruct& decision);
	241	static bool IntegrityOk(const AliHLTMUONPairsDecisionBlockStruct& block);
26a4668d	242
	243	private:
	244	// Should never have to create or destroy this object.
	245	AliHLTMUONUtils();
	246	~AliHLTMUONUtils();
	247	};
	248
b727f838	249	//_____________________________________________________________________________
	250
	251	// Since c++ is missing a finally "keyword" we define one. Its usage is identical
	252	// to a try..finally statement in Java etc.. however, since it is officialy a macro
	253	// one must use the ( ) brackets instead of { }
	254	// If the compiler supports __finally use it otherwise make our own.
	255	#if defined(__BORLANDC__)
	256	# define finally(str) __finally{str}
	257	#else
	258	# define finally(code) \
	259	catch(...) \
	260	{ \
	261	code \
	262	throw; \
	263	}; \
	264	code
	265	#endif // __BORLANDC__
	266
	267	// If we do not already have them, then define logical operators that are easier
	268	// to read. 'and' = &&, 'or' = \|\|, 'not' = !
	269	#if ! defined(__GNUC__) && ! defined(__CINT__)
b12fe461	270	// TODO: Should use iso646.h
b727f838	271	# define and &&
	272	# define or \|\|
	273	# define not !
	274	#endif // __GNUC__ \| __CINT__
	275
	276
	277	// Here we define the DebugTrace(message) macro for easy embedding of debug
	278	// information into the dimuon HLT code. Its usage is meant to be for generating
	279	// traces of the program which are only useful during full scale debugging.
	280	// Log messages should use the standard HLT logging mechanisms.
	281	// The output is only generated in programs compiled with the DEBUG directive
	282	// defined. Here is a usage example:
	283	//
	284	// // statements...
	285	// DebugTrace("some debug information.");
	286	// // statements...
	287	//
	288	// One can also use C++ ostream operators and manipulators like so:
	289	//
	290	// // statements...
	291	// int x, y;
b12fe461	292	// DebugTrace("x = " << x << " and y = 0x" << std::hex << y );
b727f838	293	// // statements...
	294	//
	295	#ifdef DEBUG
	296	# include <ostream>
	297	# define DebugTrace(message) {std::cout << message << std::endl;}
	298	#else // DEBUG
	299	# define DebugTrace(message)
	300	#endif // DEBUG
	301
	302
26a4668d	303	#endif // ALIHLTMUONUTILS_H