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

#ifndef ALIHLTMUONRECHIT_H
#define ALIHLTMUONRECHIT_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$ */

/**
 * @file   AliHLTMUONRecHit.h
 * @author Artur Szostak <artursz@iafrica.com>
 * @date   
 * @brief  Declaration of a reconstructed hit ROOT object to store 3D hit
 *         coordinates translated from dHLT raw data.
 */

#include "TObject.h"
#include "TClonesArray.h"
#include "TVector3.h"
#include <ostream>

/**
 * A 3D hit object used to store hits reconstructed on the tracking chambers by
 * the dHLT. These objects store information translated into ROOT format from
 * dHLT raw data. Reconstructed hit values of (0, 0, 0) indicate an invalid or
 * nil hit.
 */
class AliHLTMUONRecHit : public TObject
{
	/**
	 * Stream operator for usage with std::ostream classes.
	 * Allows usage such as:
	 *   AliHLTMUONRecHit h; std::cout << h;
	 */
	friend std::ostream& operator << (std::ostream& stream, const AliHLTMUONRecHit& hit);

public:

	/**
	 * The Channel class stores extra debugging information about the channels
	 * and raw data words that were considered during reconstruction of a hit
	 * by the dHLT hit reconstructor component.
	 */
	class Channel : public TObject
	{
		/**
		 * Stream operator for usage with std::ostream classes.
		 */
		friend std::ostream& operator << (std::ostream& stream, const Channel& c);
	
	public:
		
		Channel(
				Short_t manu = -1,
				Short_t channel = -1,
				Short_t signal = -1,
				UInt_t rawDataWord = 0
			) :
			TObject(),
			fManu(manu), fAddress(channel), fSignal(signal),
			fRawDataWord(rawDataWord)
		{}
		
		virtual ~Channel() {}
		
		/**
		 * Returns the MANU address.
		 */
		Short_t Manu() const { return fManu; }
		
		/**
		 * Returns the channel address of the MANU.
		 */
		Short_t Address() const { return fAddress; }
		
		/**
		 * Returns the ADC signal measured on the channel.
		 */
		Short_t Signal() const { return fSignal; }
		
		/**
		 * Returns the raw data word as found in the tracking DDL payload.
		 */
		UInt_t RawDataWord() const { return fRawDataWord; }
		
		virtual void Print(Option_t* option = NULL) const;
	
		// Methods inherited from TObject
		virtual Bool_t IsSortable() const { return kTRUE; }
		Int_t Compare(const TObject* obj) const;

		// Implement comparison operators.
		bool operator == (const Channel& c) const
		{
			return fManu == c.fManu and fAddress == c.fAddress 
				and fSignal == c.fSignal
				and fRawDataWord == c.fRawDataWord;
		}

		bool operator != (const Channel& hit) const
		{
			return not this->operator == (hit);
		}
	
	private:
	
		Short_t fManu;       // The MANU address on the electronics.
		Short_t fAddress;    // The channel address on the electronics.
		Short_t fSignal;     // ADC value of signal.
		UInt_t fRawDataWord; // The raw data word as found in the DDL stream.
		
		ClassDef(AliHLTMUONRecHit::Channel, 1); // A MANU channel forming part of a cluster that was considered during hit reconstruction in dHLT.
	};

	/**
	 * Construct a new AliHLTMUONRecHit object with coordinate (x, y, z).
	 * @param x           X coordinate of hit
	 * @param y           Y coordinate of hit
	 * @param z           Z coordinate of hit
	 * @param sourceDDL   The DDL from which this hit originates.
	 * @param detectorId  The ID number for the AliRoot detector element on
	 *                    which this hit resides.
	 * @param clusterId   The cluster ID number assigned to the hit's cluster.
	 * @param nChExp      The expected number of channels that form the cluster.
	 */
	AliHLTMUONRecHit(
			Float_t x = 0,
			Float_t y = 0,
			Float_t z = 0,
			Int_t sourceDDL = -1,
			Int_t detElemId = -1,
			Int_t clusterId = -1,
			Int_t nChExp = 0
		) :
		fCoordinate(x, y, z), fSourceDDL(sourceDDL),
		fDetElemId(detElemId), fClusterId(clusterId), fNchExp(nChExp),
		fChannels("AliHLTMUONRecHit::Channel", 6)
	{}
	
	virtual ~AliHLTMUONRecHit() {}

	/**
	 * Returns the 3D hit coordinate.
	 */
	const TVector3& Coordinate() const { return fCoordinate; }

	/**
	 * Returns the X coordinate of the reconstructed hit in centimetres.
	 */
	Double_t X() const { return fCoordinate.X(); }

	/**
	 * Returns the Y coordinate of the reconstructed hit in centimetres.
	 */
	Double_t Y() const { return fCoordinate.Y(); }

	/**
	 * Returns the Z coordinate of the reconstructed hit in centimetres.
	 */
	Double_t Z() const { return fCoordinate.Z(); }
	
	/**
	 * Returns the source DDL from which this hit originates.
	 * -1 is returned if this was not set.
	 */
	Int_t SourceDDL() const { return fSourceDDL; }
	
	/**
	 * Returns the detector element ID on which this reconstructed hit resides.
	 * -1 is returned if this was not set.
	 */
	Int_t DetElemId() const { return fDetElemId; }
	
	/**
	 * Returns the chamber number of this hit in the range [1..14].
	 * If -1 is returned then the chamber number is not known because the
	 * extra debugging information such as detector element ID was not set.
	 * @param warn  Indicates if any warning should be printed in case of problems.
	 */
	Int_t Chamber(bool warn = true) const;
	
	/**
	 * Returns the ID number given to the hit's cluster.
	 */
	Int_t ClusterId() const { return fClusterId; }
	
	/**
	 * Returns the expected number of channels that are to be added to this hit.
	 * If the number of calls to AddChannel does not correspond to this value
	 * then we lost some debugging information along the way.
	 */
	UInt_t ExpectedNchannels() const { return fNchExp; }
	
	/**
	 * Sets the debugging information for this hit.
	 * @param detElemId  The detector element ID.
	 * @param clusterId  Cluster ID of the hit's cluster.
	 * @param nChExp     Number of expected channels forming the cluster.
	 * @param sourceDDL  The source DDL of this hit.
	 */
	void SetDebugInfo(
			Int_t detElemId, Int_t clusterId, UInt_t nChExp,
			Int_t sourceDDL = -1
		);
	
	/**
	 * Sets the hit coordinate.
	 */
	void SetHit(Float_t x, Float_t y, Float_t z)
	{
		fCoordinate.SetXYZ(x, y, z);
	}
	
	/**
	 * Returns the number of channels associated with this hit.
	 */
	Int_t Nchannels() const { return fChannels.GetEntriesFast(); }
	
	/**
	 * Returns the i'th channel associated with this hit.
	 * @param i  Should be a number in the range [0..n), where n = Nchannels().
	 */
	const Channel* GetChannel(Int_t i) const
	{
		return static_cast<const Channel*>(fChannels[i]);
	}
	
	/**
	 * Adds a new channel to this hit if it is on a tracking chamber.
	 * @param manu    The MANU number
	 * @param channel The MANU channel address.
	 * @param signal  The ADC signal value measured on the channel.
	 * @param rawDataWord This is the raw data word as read from the DDL.
	 */
	void AddChannel(
			Short_t manu, Short_t channel, Short_t signal,
			UInt_t rawDataWord
		);

	/**
	 * Prints the details of the reconstructed hit.
	 * @param option  A case sensitive string that can contain one of the
	 *     following strings:
	 *       "compact" - Prints just the coordinates of the hit in a terse format.
	 *       "detail" - Prints the coordinates and detector element ID.
	 *       "all" - Prints all known information about this hit including
	 *               channel information forming the cluster that was reconstructed.
	 *     If the string contains an empty option or NULL then the default is
	 *     to print compactly.
	 */
	virtual void Print(Option_t* option = NULL) const;
	
	// Methods inherited from TObject
	virtual Bool_t IsSortable() const { return kTRUE; }
	Int_t Compare(const TObject* obj) const;

	// Implement comparison operators.
	bool operator == (const AliHLTMUONRecHit& hit) const
	{
		return X() == hit.X() and Y() == hit.Y() and Z() == hit.Z();
	}

	bool operator != (const AliHLTMUONRecHit& hit) const
	{
		return not this->operator == (hit);
	}

private:

	TVector3 fCoordinate; // The 3D coordinate of the hit in AliRoot global coordinates (cm).
	
	// The following is debugging information and may not be filled if the
	// dHLT components were not set to produce this information.
	Int_t fSourceDDL;  // The DDL from which this hit originates.
	Int_t fDetElemId;  // Detector element ID number.
	Int_t fClusterId;  // The cluster ID number used to relate all the channels to each other.
	UInt_t fNchExp;    // The number of channels that were supposed to be found.
	TClonesArray fChannels; // The channels forming part of the cluster from which this hit was reconstructed.

	ClassDef(AliHLTMUONRecHit, 1); // A reconstructed hit translated from dHLT raw data into ROOT format.
};

#endif // ALIHLTMUONRECHIT_H
Commit	Line	Data
753896cd	1	#ifndef ALIHLTMUONRECHIT_H
	2	#define ALIHLTMUONRECHIT_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$ */
	8
	9	/**
	10	* @file AliHLTMUONRecHit.h
	11	* @author Artur Szostak <artursz@iafrica.com>
	12	* @date
	13	* @brief Declaration of a reconstructed hit ROOT object to store 3D hit
	14	* coordinates translated from dHLT raw data.
	15	*/
	16
	17	#include "TObject.h"
	18	#include "TClonesArray.h"
	19	#include "TVector3.h"
	20	#include <ostream>
	21
	22	/**
	23	* A 3D hit object used to store hits reconstructed on the tracking chambers by
	24	* the dHLT. These objects store information translated into ROOT format from
	25	* dHLT raw data. Reconstructed hit values of (0, 0, 0) indicate an invalid or
	26	* nil hit.
	27	*/
	28	class AliHLTMUONRecHit : public TObject
	29	{
	30	/**
	31	* Stream operator for usage with std::ostream classes.
	32	* Allows usage such as:
	33	* AliHLTMUONRecHit h; std::cout << h;
	34	*/
	35	friend std::ostream& operator << (std::ostream& stream, const AliHLTMUONRecHit& hit);
	36
	37	public:
	38
	39	/**
	40	* The Channel class stores extra debugging information about the channels
	41	* and raw data words that were considered during reconstruction of a hit
	42	* by the dHLT hit reconstructor component.
	43	*/
	44	class Channel : public TObject
	45	{
	46	/**
	47	* Stream operator for usage with std::ostream classes.
	48	*/
	49	friend std::ostream& operator << (std::ostream& stream, const Channel& c);
	50
	51	public:
	52
	53	Channel(
	54	Short_t manu = -1,
	55	Short_t channel = -1,
	56	Short_t signal = -1,
	57	UInt_t rawDataWord = 0
	58	) :
	59	TObject(),
	60	fManu(manu), fAddress(channel), fSignal(signal),
	61	fRawDataWord(rawDataWord)
	62	{}
	63
	64	virtual ~Channel() {}
65
66	/**
67	* Returns the MANU address.
68	*/
69	Short_t Manu() const { return fManu; }
70
71	/**
72	* Returns the channel address of the MANU.
73	*/
74	Short_t Address() const { return fAddress; }
75
76	/**
77	* Returns the ADC signal measured on the channel.
78	*/
79	Short_t Signal() const { return fSignal; }
80
81	/**
82	* Returns the raw data word as found in the tracking DDL payload.
83	*/
84	UInt_t RawDataWord() const { return fRawDataWord; }
85
86	virtual void Print(Option_t* option = NULL) const;
87
88	// Methods inherited from TObject
89	virtual Bool_t IsSortable() const { return kTRUE; }
90	Int_t Compare(const TObject* obj) const;
91
92	// Implement comparison operators.
93	bool operator == (const Channel& c) const
94	{
95	return fManu == c.fManu and fAddress == c.fAddress
96	and fSignal == c.fSignal
97	and fRawDataWord == c.fRawDataWord;
98	}
99
100	bool operator != (const Channel& hit) const
101	{
102	return not this->operator == (hit);
103	}
104
105	private:
106
107	Short_t fManu; // The MANU address on the electronics.
108	Short_t fAddress; // The channel address on the electronics.
109	Short_t fSignal; // ADC value of signal.
110	UInt_t fRawDataWord; // The raw data word as found in the DDL stream.
111
112	ClassDef(AliHLTMUONRecHit::Channel, 1); // A MANU channel forming part of a cluster that was considered during hit reconstruction in dHLT.
113	};
114
115	/**
116	* Construct a new AliHLTMUONRecHit object with coordinate (x, y, z).
117	* @param x X coordinate of hit
118	* @param y Y coordinate of hit
119	* @param z Z coordinate of hit
120	* @param sourceDDL The DDL from which this hit originates.
121	* @param detectorId The ID number for the AliRoot detector element on
122	* which this hit resides.
123	* @param clusterId The cluster ID number assigned to the hit's cluster.
124	* @param nChExp The expected number of channels that form the cluster.
125	*/
126	AliHLTMUONRecHit(
127	Float_t x = 0,
128	Float_t y = 0,
129	Float_t z = 0,
130	Int_t sourceDDL = -1,
131	Int_t detElemId = -1,
132	Int_t clusterId = -1,
133	Int_t nChExp = 0
134	) :
135	fCoordinate(x, y, z), fSourceDDL(sourceDDL),
136	fDetElemId(detElemId), fClusterId(clusterId), fNchExp(nChExp),
137	fChannels("AliHLTMUONRecHit::Channel", 6)
138	{}
139
140	virtual ~AliHLTMUONRecHit() {}
141
142	/**
143	* Returns the 3D hit coordinate.
144	*/
145	const TVector3& Coordinate() const { return fCoordinate; }
146
147	/**
148	* Returns the X coordinate of the reconstructed hit in centimetres.
149	*/
150	Double_t X() const { return fCoordinate.X(); }
151
152	/**
153	* Returns the Y coordinate of the reconstructed hit in centimetres.
154	*/
155	Double_t Y() const { return fCoordinate.Y(); }
156
157	/**
158	* Returns the Z coordinate of the reconstructed hit in centimetres.
159	*/
160	Double_t Z() const { return fCoordinate.Z(); }
161
162	/**
163	* Returns the source DDL from which this hit originates.
164	* -1 is returned if this was not set.
165	*/
166	Int_t SourceDDL() const { return fSourceDDL; }
167
168	/**
169	* Returns the detector element ID on which this reconstructed hit resides.
170	* -1 is returned if this was not set.
171	*/
172	Int_t DetElemId() const { return fDetElemId; }
173
174	/**
175	* Returns the chamber number of this hit in the range [1..14].
176	* If -1 is returned then the chamber number is not known because the
177	* extra debugging information such as detector element ID was not set.
178	* @param warn Indicates if any warning should be printed in case of problems.
179	*/
180	Int_t Chamber(bool warn = true) const;
181
182	/**
183	* Returns the ID number given to the hit's cluster.
184	*/
185	Int_t ClusterId() const { return fClusterId; }
186
187	/**
188	* Returns the expected number of channels that are to be added to this hit.
189	* If the number of calls to AddChannel does not correspond to this value
190	* then we lost some debugging information along the way.
191	*/
192	UInt_t ExpectedNchannels() const { return fNchExp; }
193
194	/**
195	* Sets the debugging information for this hit.
196	* @param detElemId The detector element ID.
197	* @param clusterId Cluster ID of the hit's cluster.
198	* @param nChExp Number of expected channels forming the cluster.
199	* @param sourceDDL The source DDL of this hit.
200	*/
201	void SetDebugInfo(
202	Int_t detElemId, Int_t clusterId, UInt_t nChExp,
203	Int_t sourceDDL = -1
204	);
205
206	/**
207	* Sets the hit coordinate.
208	*/
209	void SetHit(Float_t x, Float_t y, Float_t z)
210	{
211	fCoordinate.SetXYZ(x, y, z);
212	}
213
214	/**
215	* Returns the number of channels associated with this hit.
216	*/
217	Int_t Nchannels() const { return fChannels.GetEntriesFast(); }
218
219	/**
220	* Returns the i'th channel associated with this hit.
221	* @param i Should be a number in the range [0..n), where n = Nchannels().
222	*/
223	const Channel* GetChannel(Int_t i) const
224	{
225	return static_cast<const Channel*>(fChannels[i]);
226	}
227
228	/**
229	* Adds a new channel to this hit if it is on a tracking chamber.
230	* @param manu The MANU number
231	* @param channel The MANU channel address.
232	* @param signal The ADC signal value measured on the channel.
233	* @param rawDataWord This is the raw data word as read from the DDL.
234	*/
235	void AddChannel(
236	Short_t manu, Short_t channel, Short_t signal,
237	UInt_t rawDataWord
238	);
239
240	/**
241	* Prints the details of the reconstructed hit.
242	* @param option A case sensitive string that can contain one of the
243	* following strings:
244	* "compact" - Prints just the coordinates of the hit in a terse format.
245	* "detail" - Prints the coordinates and detector element ID.
246	* "all" - Prints all known information about this hit including
247	* channel information forming the cluster that was reconstructed.
248	* If the string contains an empty option or NULL then the default is
249	* to print compactly.
250	*/
251	virtual void Print(Option_t* option = NULL) const;
252
253	// Methods inherited from TObject
254	virtual Bool_t IsSortable() const { return kTRUE; }
255	Int_t Compare(const TObject* obj) const;
256
257	// Implement comparison operators.
258	bool operator == (const AliHLTMUONRecHit& hit) const
259	{
260	return X() == hit.X() and Y() == hit.Y() and Z() == hit.Z();
261	}
262
263	bool operator != (const AliHLTMUONRecHit& hit) const
264	{
265	return not this->operator == (hit);
266	}
267
268	private:
269
270	TVector3 fCoordinate; // The 3D coordinate of the hit in AliRoot global coordinates (cm).
271
272	// The following is debugging information and may not be filled if the
273	// dHLT components were not set to produce this information.
274	Int_t fSourceDDL; // The DDL from which this hit originates.
275	Int_t fDetElemId; // Detector element ID number.
276	Int_t fClusterId; // The cluster ID number used to relate all the channels to each other.
277	UInt_t fNchExp; // The number of channels that were supposed to be found.
278	TClonesArray fChannels; // The channels forming part of the cluster from which this hit was reconstructed.
279
280	ClassDef(AliHLTMUONRecHit, 1); // A reconstructed hit translated from dHLT raw data into ROOT format.
281	};
282
283	#endif // ALIHLTMUONRECHIT_H