c613e2cb021f7f107b28dd394a0bb59535a0b58a
[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONRecHit.h
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