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

#ifndef ALIHLTMUONDATATYPES_H
#define ALIHLTMUONDATATYPES_H
/**************************************************************************
 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

/**
 * @file   AliHLTMUONDataTypes.h
 * @author Artur Szostak <artursz@iafrica.com>
 * @date   
 * @brief  Declaration of basic data types used in HLT/MUON module.
 *
 * The types and structs are defined with C linkage since C generally gives us
 * more binary compatibility between compilers.
 */

#include "AliHLTDataTypes.h"
#include <ostream>

extern "C"
{

typedef signed char AliHLTInt8_t;
typedef signed int AliHLTInt32_t;
typedef float AliHLTFloat32_t;
typedef double AliHLTFloat64_t;

/**
 * The common internal dimuon HLT data block header.
 * These headers help to identify the data block when it is written to disk and
 * helps to check the integrity of the data blocks in the system.
 */
struct AliHLTMUONDataBlockHeader
{
	AliHLTUInt16_t fType; // The type of the data block. Must contain a value
	                      // defined by AliHLTMUONDataBlockType.
	AliHLTUInt16_t fRecordWidth; // The number of bytes each record uses. 
	AliHLTUInt32_t fNrecords; // Number of records in this data block.
};

} // extern "C"


/**
 * The sign of a particle.
 */
enum AliHLTMUONParticleSign
{
	kSignMinus   = -1,
	kSignUnknown = 0,
	kSignPlus    = 1
};

/**
 * The chamber names of the dimuon spectrometer.
 */
enum AliHLTMUONChamberName
{
	kChamber1 = 0,
	kChamber2 = 1,
	kChamber3 = 2,
	kChamber4 = 3,
	kChamber5 = 4,
	kChamber6 = 5,
	kChamber7 = 6,
	kChamber8 = 7,
	kChamber9 = 8,
	kChamber10 = 9,
	kChamber11 = 10,
	kChamber12 = 11,
	kChamber13 = 12,
	kChamber14 = 13
};

/**
 * The internal data block type codes.
 */
enum AliHLTMUONDataBlockType
{
	kUnknownDataBlock = 0,
	kTriggerRecordsDataBlock = 1000,
	kTrigRecsDebugDataBlock = 1001,
	kTriggerChannelDataBlock = 1002,
	kRecHitsDataBlock = 2000,
	kClustersDataBlock = 2001,
	kChannelsDataBlock = 2002,
	kMansoTracksDataBlock = 3000,
	kMansoRoIDataBlock = 3001,
	kMansoTrialsDataBlock = 3002,
	kDecisionDataBlock = 4000,
	kDecisionDebugDataBlock = 4001
};


/**
 * Stream operator to be able to print AliHLTMUONParticleSign with human
 * readable names to some stream object like cout (standard output).
 */
inline std::ostream& operator << (std::ostream& stream, AliHLTMUONParticleSign sign)
{
	switch (sign)
	{
	case kSignMinus:   stream << "kSignMinus";   break;
	case kSignUnknown: stream << "kSignUnknown"; break;
	case kSignPlus:    stream << "kSignPlus";    break;
	default:           stream << "INVALID";
	}
	return stream;
}

/**
 * Stream operator to be able to print AliHLTMUONChamberName with human
 * readable names to some stream object like cout (standard output).
 */
inline std::ostream& operator << (std::ostream& stream, AliHLTMUONChamberName chamber)
{
	switch (chamber)
	{
	case kChamber1:  stream << "kChamber1";  break;
	case kChamber2:  stream << "kChamber2";  break;
	case kChamber3:  stream << "kChamber3";  break;
	case kChamber4:  stream << "kChamber4";  break;
	case kChamber5:  stream << "kChamber5";  break;
	case kChamber6:  stream << "kChamber6";  break;
	case kChamber7:  stream << "kChamber7";  break;
	case kChamber8:  stream << "kChamber8";  break;
	case kChamber9:  stream << "kChamber9";  break;
	case kChamber10: stream << "kChamber10"; break;
	case kChamber11: stream << "kChamber11"; break;
	case kChamber12: stream << "kChamber12"; break;
	case kChamber13: stream << "kChamber13"; break;
	case kChamber14: stream << "kChamber14"; break;
	default:         stream << "INVALID";
	}
	return stream;
}

/**
 * Stream operator to be able to print AliHLTMUONDataBlockType with human
 * readable names to some stream object like cout (standard output).
 */
inline std::ostream& operator << (std::ostream& stream, AliHLTMUONDataBlockType type)
{
	switch (type)
	{
	case kUnknownDataBlock:        stream << "kUnknownDataBlock";        break;
	case kTriggerRecordsDataBlock: stream << "kTriggerRecordsDataBlock"; break;
	case kTrigRecsDebugDataBlock:  stream << "kTrigRecsDebugDataBlock";  break;
	case kTriggerChannelDataBlock: stream << "kTriggerChannelDataBlock"; break;
	case kRecHitsDataBlock:        stream << "kRecHitsDataBlock";        break;
	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;
	default:                       stream << "INVALID";
	}
	return stream;
}

/**
 * Stream operator for usage with std::ostream classes which prints the common
 * data block header in the following format:
 *  {fType = xx, fRecordWidth = yy, fNrecords = zz}
 */
inline std::ostream& operator << (
		std::ostream& stream, const AliHLTMUONDataBlockHeader& header
	)
{
	stream	<< "{fType = " << AliHLTMUONDataBlockType(header.fType)
		<< ", fRecordWidth = " << header.fRecordWidth
		<< ", fNrecords = " << header.fNrecords << "}";
	return stream;
}


inline bool operator == (
		const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
	)
{
	return a.fType == b.fType and a.fRecordWidth == b.fRecordWidth
		and a.fNrecords == b.fNrecords;
}

inline bool operator != (
		const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
	)
{
	return not operator == (a, b);
}

#endif // ALIHLTMUONDATATYPES_H
Commit	Line	Data
dc4f7fda	1	#ifndef ALIHLTMUONDATATYPES_H
	2	#define ALIHLTMUONDATATYPES_H
	3	/**************************************************************************
	4	* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	5	* *
	6	* Author: The ALICE Off-line Project. *
	7	* Contributors are mentioned in the code where appropriate. *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	/* $Id$ */
	19
	20	/**
	21	* @file AliHLTMUONDataTypes.h
	22	* @author Artur Szostak <artursz@iafrica.com>
	23	* @date
	24	* @brief Declaration of basic data types used in HLT/MUON module.
	25	*
	26	* The types and structs are defined with C linkage since C generally gives us
	27	* more binary compatibility between compilers.
	28	*/
	29
	30	#include "AliHLTDataTypes.h"
	31	#include <ostream>
	32
	33	extern "C"
	34	{
	35
	36	typedef signed char AliHLTInt8_t;
	37	typedef signed int AliHLTInt32_t;
	38	typedef float AliHLTFloat32_t;
	39	typedef double AliHLTFloat64_t;
	40
	41	/**
	42	* The common internal dimuon HLT data block header.
	43	* These headers help to identify the data block when it is written to disk and
	44	* helps to check the integrity of the data blocks in the system.
	45	*/
	46	struct AliHLTMUONDataBlockHeader
	47	{
	48	AliHLTUInt16_t fType; // The type of the data block. Must contain a value
	49	// defined by AliHLTMUONDataBlockType.
	50	AliHLTUInt16_t fRecordWidth; // The number of bytes each record uses.
	51	AliHLTUInt32_t fNrecords; // Number of records in this data block.
	52	};
	53
	54	} // extern "C"
	55
	56
	57	/**
	58	* The sign of a particle.
	59	*/
	60	enum AliHLTMUONParticleSign
	61	{
	62	kSignMinus = -1,
	63	kSignUnknown = 0,
	64	kSignPlus = 1
65	};
66
67	/**
68	* The chamber names of the dimuon spectrometer.
69	*/
70	enum AliHLTMUONChamberName
71	{
72	kChamber1 = 0,
73	kChamber2 = 1,
74	kChamber3 = 2,
75	kChamber4 = 3,
76	kChamber5 = 4,
77	kChamber6 = 5,
78	kChamber7 = 6,
79	kChamber8 = 7,
80	kChamber9 = 8,
81	kChamber10 = 9,
82	kChamber11 = 10,
83	kChamber12 = 11,
84	kChamber13 = 12,
85	kChamber14 = 13
86	};
87
88	/**
89	* The internal data block type codes.
90	*/
91	enum AliHLTMUONDataBlockType
92	{
93	kUnknownDataBlock = 0,
94	kTriggerRecordsDataBlock = 1000,
95	kTrigRecsDebugDataBlock = 1001,
96	kTriggerChannelDataBlock = 1002,
97	kRecHitsDataBlock = 2000,
98	kClustersDataBlock = 2001,
99	kChannelsDataBlock = 2002,
100	kMansoTracksDataBlock = 3000,
101	kMansoRoIDataBlock = 3001,
102	kMansoTrialsDataBlock = 3002,
103	kDecisionDataBlock = 4000,
104	kDecisionDebugDataBlock = 4001
105	};
106
107
108	/**
109	* Stream operator to be able to print AliHLTMUONParticleSign with human
110	* readable names to some stream object like cout (standard output).
111	*/
112	inline std::ostream& operator << (std::ostream& stream, AliHLTMUONParticleSign sign)
113	{
114	switch (sign)
115	{
116	case kSignMinus: stream << "kSignMinus"; break;
117	case kSignUnknown: stream << "kSignUnknown"; break;
118	case kSignPlus: stream << "kSignPlus"; break;
119	default: stream << "INVALID";
120	}
121	return stream;
122	}
123
124	/**
125	* Stream operator to be able to print AliHLTMUONChamberName with human
126	* readable names to some stream object like cout (standard output).
127	*/
128	inline std::ostream& operator << (std::ostream& stream, AliHLTMUONChamberName chamber)
129	{
130	switch (chamber)
131	{
132	case kChamber1: stream << "kChamber1"; break;
133	case kChamber2: stream << "kChamber2"; break;
134	case kChamber3: stream << "kChamber3"; break;
135	case kChamber4: stream << "kChamber4"; break;
136	case kChamber5: stream << "kChamber5"; break;
137	case kChamber6: stream << "kChamber6"; break;
138	case kChamber7: stream << "kChamber7"; break;
139	case kChamber8: stream << "kChamber8"; break;
140	case kChamber9: stream << "kChamber9"; break;
141	case kChamber10: stream << "kChamber10"; break;
142	case kChamber11: stream << "kChamber11"; break;
143	case kChamber12: stream << "kChamber12"; break;
144	case kChamber13: stream << "kChamber13"; break;
145	case kChamber14: stream << "kChamber14"; break;
146	default: stream << "INVALID";
147	}
148	return stream;
149	}
150
151	/**
152	* Stream operator to be able to print AliHLTMUONDataBlockType with human
153	* readable names to some stream object like cout (standard output).
154	*/
155	inline std::ostream& operator << (std::ostream& stream, AliHLTMUONDataBlockType type)
156	{
157	switch (type)
158	{
159	case kUnknownDataBlock: stream << "kUnknownDataBlock"; break;
160	case kTriggerRecordsDataBlock: stream << "kTriggerRecordsDataBlock"; break;
161	case kTrigRecsDebugDataBlock: stream << "kTrigRecsDebugDataBlock"; break;
162	case kTriggerChannelDataBlock: stream << "kTriggerChannelDataBlock"; break;
163	case kRecHitsDataBlock: stream << "kRecHitsDataBlock"; break;
164	case kClustersDataBlock: stream << "kClustersDataBlock"; break;
165	case kChannelsDataBlock: stream << "kChannelsDataBlock"; break;
166	case kMansoTracksDataBlock: stream << "kMansoTracksDataBlock"; break;
167	case kMansoRoIDataBlock: stream << "kMansoRoIDataBlock"; break;
168	case kMansoTrialsDataBlock: stream << "kMansoTrialsDataBlock"; break;
169	case kDecisionDataBlock: stream << "kDecisionDataBlock"; break;
170	case kDecisionDebugDataBlock: stream << "kDecisionDebugDataBlock"; break;
171	default: stream << "INVALID";
172	}
173	return stream;
174	}
175
176	/**
177	* Stream operator for usage with std::ostream classes which prints the common
178	* data block header in the following format:
179	* {fType = xx, fRecordWidth = yy, fNrecords = zz}
180	*/
181	inline std::ostream& operator << (
182	std::ostream& stream, const AliHLTMUONDataBlockHeader& header
183	)
184	{
185	stream << "{fType = " << AliHLTMUONDataBlockType(header.fType)
186	<< ", fRecordWidth = " << header.fRecordWidth
187	<< ", fNrecords = " << header.fNrecords << "}";
188	return stream;
189	}
190
191
192	inline bool operator == (
193	const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
194	)
195	{
196	return a.fType == b.fType and a.fRecordWidth == b.fRecordWidth
197	and a.fNrecords == b.fNrecords;
198	}
199
200	inline bool operator != (
201	const AliHLTMUONDataBlockHeader& a, const AliHLTMUONDataBlockHeader& b
202	)
203	{
204	return not operator == (a, b);
205	}
206
207	#endif // ALIHLTMUONDATATYPES_H