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

#ifndef ALIHLTMUONTRACKSBLOCKSTRUCT_H
#define ALIHLTMUONTRACKSBLOCKSTRUCT_H
/* This file is property of and copyright by the ALICE HLT Project        *
 * ALICE Experiment at CERN, All rights reserved.                         *
 * See cxx source for full Copyright notice                               */

// $Id: AliHLTMUONTracksBlockStruct.h 36627 2009-11-10 19:21:49Z aszostak $

///
/// @file   AliHLTMUONTracksBlockStruct.h
/// @author Artur Szostak <artursz@iafrica.com>
/// @date   10 Feb 2010
/// @brief  Definition the internal dimuon HLT data block for full tracks.
///
/// The tracks data block is an internal dimuon HLT data block structure generated
/// by the tracker component to store found tracks.
/// The structures are defined with C linkage since C generally gives us more
/// binary compatibility between compilers.
///

#include "AliHLTMUONRecHitsBlockStruct.h"

extern "C"
{

/**
 * Track structure containing information about a track found by the tracker.
 */
struct AliHLTMUONTrackStruct
{
	AliHLTInt32_t fId; /// Each track should have an ID number unique for a given event. -1 == invalid.

	AliHLTInt32_t fTrigRec; /// The associated trigger record ID that was matched to the track.

	// The flags word constains the following bit fields (bit 31 is most
	// significant):
	// bits:  [31][30][29 -- 16][  15   ][  14   ]...[  1   ][  0   ]
	// field:  -   +   reserved  hst[15]  hst[14]     hst[1]  hst[0]
	// Where fields hst[i] indicates if fHit[i] has been filled/set.
	// Reserved bits should be set to zero.
	// Particle sign: if '-' is set then particle has minus sign.
	//                if '+' is set then particle has negative sign.
	// Either '+' or '-' should be set and if neither then the particle
	// sign is unknown.
	AliHLTUInt32_t fFlags;  /// Bit fields for the track structure.

	AliHLTFloat32_t fPx; /// Particle's momentum X component in GeV/c.
	AliHLTFloat32_t fPy; /// Particle's momentum Y component in GeV/c.
	AliHLTFloat32_t fPz; /// Particle's momentum Z component in GeV/c.
	
	AliHLTFloat32_t fInverseBendingMomentum; /// One over the momentum of the fitted track [GeV/c].
	AliHLTFloat32_t fThetaX; /// The slope of the fitted track in the non-bending plane.
	AliHLTFloat32_t fThetaY; /// The slope of the fitted track in the bending plane.
	AliHLTFloat32_t fX; /// Non-bending plane coordinate for the distance of closest approach (DCA) [cm].
	AliHLTFloat32_t fY; /// Bending plane coordinate for the DCA [cm].
	AliHLTFloat32_t fZ; /// Z coordinate for the DCA [cm].
	
	// Chi squared of the track fit.
	// If set to -1 then no fit was done and the momentum vector and DCA coordinate is invalid.
	AliHLTFloat32_t fChi2; /// The chi squared of the fit of fHit points to the track model.

	AliHLTMUONRecHitStruct fHit[16];  /// Particle hit coordinates found by the hit reconstruction stage.
};

/**
 * AliHLTMUONTracksBlockStruct defines the format of the internal tracks data block.
 */
struct AliHLTMUONTracksBlockStruct
{
	AliHLTMUONDataBlockHeader fHeader; // Common data block header.

	// Array of tracks.
	//AliHLTMUONTrackStruct fTrack[/*fHeader.fNrecords*/];
};

} // extern "C"


/**
 * Stream operator for usage with std::ostream classes which prints the track
 * information in the following format:
 *  {fId = xx, fTrigRec = yy, fFlags = 0xZZ, fPx = uu, fPy = vv, fPz = ww,
 *   fInverseBendingMomentum = pp, fThetaX = nn, fThetaY = mm, fX = kk, fY = ll, fZ = hh,
 *   fChi2 = ss, fHit[0] = {...}, fHit[1] = {...}, ... fHit[14] = {...}, fHit[15] = {...}}
 */
std::ostream& operator << (
		std::ostream& stream, const AliHLTMUONTrackStruct& trigrec
	);

/**
 * Stream operator for usage with std::ostream classes which prints the
 * AliHLTMUONTracksBlockStruct in the following format:
 *   {fHeader = xx, fTrack[] = [{..}, {..}, ...]}
 */
std::ostream& operator << (
		std::ostream& stream, const AliHLTMUONTracksBlockStruct& block
	);


bool operator == (
		const AliHLTMUONTrackStruct& a,
		const AliHLTMUONTrackStruct& b
	);

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


bool operator == (
		const AliHLTMUONTracksBlockStruct& a,
		const AliHLTMUONTracksBlockStruct& b
	);

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

#endif // ALIHLTMUONTRACKSBLOCKSTRUCT_H
Commit	Line	Data
a8982f78	1	#ifndef ALIHLTMUONTRACKSBLOCKSTRUCT_H
	2	#define ALIHLTMUONTRACKSBLOCKSTRUCT_H
	3	/* This file is property of and copyright by the ALICE HLT Project *
	4	* ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	// $Id: AliHLTMUONTracksBlockStruct.h 36627 2009-11-10 19:21:49Z aszostak $
	8
	9	///
	10	/// @file AliHLTMUONTracksBlockStruct.h
	11	/// @author Artur Szostak <artursz@iafrica.com>
	12	/// @date 10 Feb 2010
	13	/// @brief Definition the internal dimuon HLT data block for full tracks.
	14	///
	15	/// The tracks data block is an internal dimuon HLT data block structure generated
	16	/// by the tracker component to store found tracks.
	17	/// The structures are defined with C linkage since C generally gives us more
	18	/// binary compatibility between compilers.
	19	///
	20
	21	#include "AliHLTMUONRecHitsBlockStruct.h"
	22
	23	extern "C"
	24	{
	25
	26	/**
	27	* Track structure containing information about a track found by the tracker.
	28	*/
	29	struct AliHLTMUONTrackStruct
	30	{
	31	AliHLTInt32_t fId; /// Each track should have an ID number unique for a given event. -1 == invalid.
	32
	33	AliHLTInt32_t fTrigRec; /// The associated trigger record ID that was matched to the track.
	34
	35	// The flags word constains the following bit fields (bit 31 is most
	36	// significant):
	37	// bits: [31][30][29 -- 16][ 15 ][ 14 ]...[ 1 ][ 0 ]
	38	// field: - + reserved hst[15] hst[14] hst[1] hst[0]
	39	// Where fields hst[i] indicates if fHit[i] has been filled/set.
	40	// Reserved bits should be set to zero.
	41	// Particle sign: if '-' is set then particle has minus sign.
	42	// if '+' is set then particle has negative sign.
	43	// Either '+' or '-' should be set and if neither then the particle
	44	// sign is unknown.
	45	AliHLTUInt32_t fFlags; /// Bit fields for the track structure.
	46
	47	AliHLTFloat32_t fPx; /// Particle's momentum X component in GeV/c.
	48	AliHLTFloat32_t fPy; /// Particle's momentum Y component in GeV/c.
	49	AliHLTFloat32_t fPz; /// Particle's momentum Z component in GeV/c.
	50
	51	AliHLTFloat32_t fInverseBendingMomentum; /// One over the momentum of the fitted track [GeV/c].
	52	AliHLTFloat32_t fThetaX; /// The slope of the fitted track in the non-bending plane.
	53	AliHLTFloat32_t fThetaY; /// The slope of the fitted track in the bending plane.
	54	AliHLTFloat32_t fX; /// Non-bending plane coordinate for the distance of closest approach (DCA) [cm].
	55	AliHLTFloat32_t fY; /// Bending plane coordinate for the DCA [cm].
	56	AliHLTFloat32_t fZ; /// Z coordinate for the DCA [cm].
	57
	58	// Chi squared of the track fit.
	59	// If set to -1 then no fit was done and the momentum vector and DCA coordinate is invalid.
	60	AliHLTFloat32_t fChi2; /// The chi squared of the fit of fHit points to the track model.
	61
	62	AliHLTMUONRecHitStruct fHit[16]; /// Particle hit coordinates found by the hit reconstruction stage.
	63	};
	64
65	/**
66	* AliHLTMUONTracksBlockStruct defines the format of the internal tracks data block.
67	*/
68	struct AliHLTMUONTracksBlockStruct
69	{
70	AliHLTMUONDataBlockHeader fHeader; // Common data block header.
71
72	// Array of tracks.
73	//AliHLTMUONTrackStruct fTrack[/fHeader.fNrecords/];
74	};
75
76	} // extern "C"
77
78
79	/**
80	* Stream operator for usage with std::ostream classes which prints the track
81	* information in the following format:
82	* {fId = xx, fTrigRec = yy, fFlags = 0xZZ, fPx = uu, fPy = vv, fPz = ww,
83	* fInverseBendingMomentum = pp, fThetaX = nn, fThetaY = mm, fX = kk, fY = ll, fZ = hh,
84	* fChi2 = ss, fHit[0] = {...}, fHit[1] = {...}, ... fHit[14] = {...}, fHit[15] = {...}}
85	*/
86	std::ostream& operator << (
87	std::ostream& stream, const AliHLTMUONTrackStruct& trigrec
88	);
89
90	/**
91	* Stream operator for usage with std::ostream classes which prints the
92	* AliHLTMUONTracksBlockStruct in the following format:
93	* {fHeader = xx, fTrack[] = [{..}, {..}, ...]}
94	*/
95	std::ostream& operator << (
96	std::ostream& stream, const AliHLTMUONTracksBlockStruct& block
97	);
98
99
100	bool operator == (
101	const AliHLTMUONTrackStruct& a,
102	const AliHLTMUONTrackStruct& b
103	);
104
105	inline bool operator != (
106	const AliHLTMUONTrackStruct& a,
107	const AliHLTMUONTrackStruct& b
108	)
109	{
110	return not operator == (a, b);
111	}
112
113
114	bool operator == (
115	const AliHLTMUONTracksBlockStruct& a,
116	const AliHLTMUONTracksBlockStruct& b
117	);
118
119	inline bool operator != (
120	const AliHLTMUONTracksBlockStruct& a,
121	const AliHLTMUONTracksBlockStruct& b
122	)
123	{
124	return not operator == (a, b);
125	}
126
127	#endif // ALIHLTMUONTRACKSBLOCKSTRUCT_H