Line data Source code
1 : #ifndef ALIHLTMUONMANSOTRACKERFSM_H
2 : #define ALIHLTMUONMANSOTRACKERFSM_H
3 : /**************************************************************************
4 : * This file is property of and copyright by the ALICE HLT Project *
5 : * All rights reserved. *
6 : * *
7 : * Primary Authors: *
8 : * Artur Szostak <artursz@iafrica.com> *
9 : * *
10 : * Permission to use, copy, modify and distribute this software and its *
11 : * documentation strictly for non-commercial purposes is hereby granted *
12 : * without fee, provided that the above copyright notice appears in all *
13 : * copies and that both the copyright notice and this permission notice *
14 : * appear in the supporting documentation. The authors make no claims *
15 : * about the suitability of this software for any purpose. It is *
16 : * provided "as is" without express or implied warranty. *
17 : **************************************************************************/
18 :
19 : // $Id$
20 :
21 : ///
22 : /// @file AliHLTMUONMansoTrackerFSM.h
23 : /// @author Artur Szostak <artursz@iafrica.com>
24 : /// @date 29 May 2007
25 : /// @brief Declaration of the AliHLTMUONMansoTrackerFSM class which implements the Manso tracking algorithm.
26 : ///
27 :
28 : #include "AliHLTLogging.h"
29 : #include "AliHLTMUONDataTypes.h"
30 : #include "AliHLTMUONList.h"
31 : #include "AliHLTMUONCountedList.h"
32 : #include "AliHLTMUONRecHitsBlockStruct.h"
33 : #include "AliHLTMUONMansoTrackerFSMCallback.h"
34 : #include <cassert>
35 :
36 : extern "C" struct AliHLTMUONTriggerRecordStruct;
37 : extern "C" struct AliHLTMUONMansoTrackStruct;
38 : extern "C" struct AliHLTMUONMansoCandidateStruct;
39 :
40 : /**
41 : * The AliHLTMUONMansoTrackerFSM implements the Manso tracking
42 : * algorithm as a finite state machine, which partially reconstructs
43 : * tracks in the muon spectrometer.
44 : */
45 : class AliHLTMUONMansoTrackerFSM : public AliHLTLogging
46 : {
47 : public:
48 :
49 : AliHLTMUONMansoTrackerFSM();
50 : virtual ~AliHLTMUONMansoTrackerFSM();
51 :
52 :
53 : /* This is the starting point for the tracking algorithm. The tracker is
54 : called at this point with the specified trigger record. It needs to figure
55 : out which cluster blocks it needs and request them with calls to
56 : RequestClusters.
57 : Any memory allocated at this point should be released in the Reset method.
58 :
59 : Note: Reset should be called for before calling FindTrack, for the
60 : second or subsequent method calls to FindTrack.
61 : */
62 : virtual void FindTrack(const AliHLTMUONTriggerRecordStruct& trigger);
63 :
64 : /* When requested clusters have been found by the framework they are returned
65 : to the tracker using this method.
66 : This method should implement any processing of the cluster blocks. If more
67 : more regions of interest are identified then appropriate request should me
68 : made using RequestClusters. The tag parameter will be the same one as was
69 : passed to RequestClusters.
70 : */
71 : virtual void ReturnClusters(
72 : void* tag, const AliHLTMUONRecHitStruct* clusters,
73 : AliHLTUInt32_t count
74 : );
75 :
76 : /* When no more clusters are to be expected for the request with the corresponding
77 : tag value, then this method is called.
78 : Any final processing can be placed in here and when the track is found then
79 : the algorithm can call FoundTrack otherwise NoTrackFound to indicate end of
80 : processing.
81 : */
82 : virtual void EndOfClusters(void* tag);
83 :
84 : /* Called to receive track information after receiving a FoundTrack call.
85 : The tracker should fill the track data block with all relevant information.
86 : The method will return false if the momentum could not be calculated from
87 : the hits found. The hits in the track structure will however still be filled.
88 : */
89 : virtual bool FillTrackData(AliHLTMUONMansoTrackStruct& track);
90 :
91 : /* Called when the tracker should be reset to a initial state.
92 : All extra internal allocated data structured should be released.
93 : */
94 : virtual void Reset();
95 :
96 : /* To set the TrackerCallback callback object.
97 : */
98 : void SetCallback(AliHLTMUONMansoTrackerFSMCallback* callback)
99 : {
100 0 : fCallback = callback;
101 0 : };
102 :
103 : /// Returns the flag indicating if track candidates are stored.
104 0 : bool MakeCandidates() const { return fMakeCandidates; }
105 :
106 : /// Sets the flag to indicate if track candidates are stored or not.
107 0 : void MakeCandidates(bool value) { fMakeCandidates = value; }
108 :
109 : /// Returns the number of track candidates found in the list returned by TrackCandidates().
110 0 : AliHLTUInt32_t TrackCandidatesCount() const { return fCandidatesCount; }
111 :
112 : /// Returns the array of track candidates.
113 0 : const AliHLTMUONMansoCandidateStruct* TrackCandidates() const { return fCandidates; }
114 :
115 : /// Removes all the elements in the track candidates array.
116 0 : void ZeroTrackCandidatesList() { fCandidatesCount = 0; }
117 :
118 : /* Get and set methods for the a and b parameters used to build the region
119 : of interests. Refer to AliRegionOfInterest for details about a and b parameters.
120 : */
121 : static AliHLTFloat32_t GetA7() { return fgA7; };
122 0 : static void SetA7(AliHLTFloat32_t value) { fgA7 = value; };
123 : static AliHLTFloat32_t GetA8() { return fgA8; };
124 0 : static void SetA8(AliHLTFloat32_t value) { fgA8 = value; };
125 : static AliHLTFloat32_t GetA9() { return fgA9; };
126 0 : static void SetA9(AliHLTFloat32_t value) { fgA9 = value; };
127 : static AliHLTFloat32_t GetA10() { return fgA10; };
128 0 : static void SetA10(AliHLTFloat32_t value) { fgA10 = value; };
129 :
130 : static AliHLTFloat32_t GetB7() { return fgB7; };
131 0 : static void SetB7(AliHLTFloat32_t value) { fgB7 = value; };
132 : static AliHLTFloat32_t GetB8() { return fgB8; };
133 0 : static void SetB8(AliHLTFloat32_t value) { fgB8 = value; };
134 : static AliHLTFloat32_t GetB9() { return fgB9; };
135 0 : static void SetB9(AliHLTFloat32_t value) { fgB9 = value; };
136 : static AliHLTFloat32_t GetB10() { return fgB10; };
137 0 : static void SetB10(AliHLTFloat32_t value) { fgB10 = value; };
138 :
139 : static AliHLTFloat32_t GetZ7() { return fgZ7; };
140 0 : static void SetZ7(AliHLTFloat32_t value) { fgZ7 = value; };
141 : static AliHLTFloat32_t GetZ8() { return fgZ8; };
142 0 : static void SetZ8(AliHLTFloat32_t value) { fgZ8 = value; };
143 : static AliHLTFloat32_t GetZ9() { return fgZ9; };
144 0 : static void SetZ9(AliHLTFloat32_t value) { fgZ9 = value; };
145 : static AliHLTFloat32_t GetZ10() { return fgZ10; };
146 0 : static void SetZ10(AliHLTFloat32_t value) { fgZ10 = value; };
147 : static AliHLTFloat32_t GetZ11() { return fgZ11; };
148 0 : static void SetZ11(AliHLTFloat32_t value) { fgZ11 = value; };
149 : static AliHLTFloat32_t GetZ13() { return fgZ13; };
150 0 : static void SetZ13(AliHLTFloat32_t value) { fgZ13 = value; };
151 :
152 :
153 : protected:
154 :
155 : class AliRegionOfInterest
156 : {
157 : public:
158 :
159 0 : AliRegionOfInterest() : fCentre(), fRs(0.0) {};
160 :
161 : AliRegionOfInterest(AliHLTMUONRecHitStruct p, AliHLTFloat32_t a, AliHLTFloat32_t b)
162 : : fCentre(), fRs(0)
163 : {
164 : Create(p, a, b);
165 : };
166 :
167 : /* Creates a region of interest. In this implementation it is a
168 : circular disk.
169 :
170 : The point p is the intersecting point of the track with the chamber.
171 : For more details and for details about the parameters a and b refer to:
172 : "A first algorithm for dimuon High Level Trigger"
173 : Ref ID: ALICE-INT-2002-04 version 1.0
174 : equation:
175 : Rs = a * Rp + b
176 : given on page 3 section 4.
177 : */
178 : void Create(AliHLTMUONRecHitStruct p, AliHLTFloat32_t a, AliHLTFloat32_t b);
179 :
180 : /* Returns true if the point p is within the region of interest.
181 : */
182 : bool Contains(AliHLTMUONRecHitStruct p) const;
183 :
184 : void GetBoundaryBox(AliHLTFloat32_t& left, AliHLTFloat32_t& right, AliHLTFloat32_t& bottom, AliHLTFloat32_t& top) const;
185 :
186 : /// Returns the centre point of the region of interest.
187 0 : const AliHLTMUONRecHitStruct& Centre() const { return fCentre; }
188 :
189 : /// Returns the radius of the region of interest disk.
190 0 : AliHLTFloat32_t Radius() const { return fRs; }
191 :
192 : private:
193 :
194 : AliHLTMUONRecHitStruct fCentre; // The centre point of the region of interest.
195 : AliHLTFloat32_t fRs; // The redius of the region of interest around fcentre.
196 : };
197 :
198 :
199 : class AliVertex
200 : {
201 : public:
202 :
203 : AliVertex(AliHLTFloat32_t x = 0.0, AliHLTFloat32_t y = 0.0, AliHLTFloat32_t z = 0.0);
204 : AliVertex(AliHLTMUONRecHitStruct xy, AliHLTFloat32_t z);
205 :
206 : AliHLTMUONRecHitStruct AsXYPoint() const
207 : {
208 : AliHLTMUONRecHitStruct p;
209 : p.fX = fX; p.fY = fY; p.fZ = 0;
210 : return p;
211 : };
212 :
213 : // Get/set methods:
214 : AliHLTFloat32_t X() const { return fX; };
215 : AliHLTFloat32_t Y() const { return fY; };
216 : AliHLTFloat32_t Z() const { return fZ; };
217 0 : AliHLTFloat32_t& X() { return fX; };
218 0 : AliHLTFloat32_t& Y() { return fY; };
219 0 : AliHLTFloat32_t& Z() { return fZ; };
220 : void X(AliHLTFloat32_t value) { fX = value; };
221 : void Y(AliHLTFloat32_t value) { fY = value; };
222 : void Z(AliHLTFloat32_t value) { fZ = value; };
223 :
224 : private:
225 :
226 : AliHLTFloat32_t fX, fY, fZ; // 3D coordinates.
227 : };
228 :
229 :
230 : class AliLine
231 : {
232 : public:
233 :
234 : /* Creates a vector line between points A and B.
235 : ax, ay, az are x, y and z coordinates for space point A respectively.
236 : simmilarly for B.
237 : */
238 : AliLine(
239 : AliHLTFloat32_t ax = 0.0, AliHLTFloat32_t ay = 0.0, AliHLTFloat32_t az = 0.0,
240 : AliHLTFloat32_t bx = 0.0, AliHLTFloat32_t by = 0.0, AliHLTFloat32_t bz = 0.0
241 : );
242 :
243 : /* Creates a vector line between vertices A and B.
244 : */
245 : AliLine(AliVertex a, AliVertex b);
246 :
247 : /* Finds the intersection point with the xy plain specified by the z coordinate.
248 : The z coordiante would be the distance of the n'th chamber to the interaction
249 : vertex.
250 : */
251 : AliHLTMUONRecHitStruct FindIntersectWithXYPlain(AliHLTFloat32_t z) const;
252 :
253 : private:
254 :
255 : // Parameters for the vector line: L = M*t + C
256 : AliHLTFloat32_t fMx, fMy, fMz, fCx, fCy, fCz; // line parameters.
257 : };
258 :
259 :
260 : class AliTagData
261 : {
262 : public:
263 0 : AliTagData() : fChamber(kChamber1), fRoi(), fLine(), fCandidate(NULL) {};
264 :
265 : AliHLTMUONChamberName fChamber; // The chamber on which the region of interest lies.
266 : AliRegionOfInterest fRoi; // Region of interest on the next station.
267 : AliLine fLine; // line between a cluster point and the previous station.
268 : AliHLTMUONMansoCandidateStruct* fCandidate; // Track candidate related to the RoI.
269 : };
270 :
271 : class AliStation5Data
272 : {
273 : public:
274 0 : AliStation5Data() : fClusterPoint(), fTag() {};
275 :
276 : AliHLTMUONRecHitStruct fClusterPoint; // Cluster point found on station 5.
277 : AliTagData fTag; // Chamber, ROI and line data for station 5.
278 : };
279 :
280 : typedef AliHLTMUONCountedList<AliStation5Data> Station5List;
281 :
282 : class AliStation4Data
283 : {
284 : public:
285 0 : AliStation4Data() : fClusterPoint(), fSt5tag() {};
286 :
287 : AliStation4Data(const AliStation4Data& data) :
288 : fClusterPoint(data.fClusterPoint), fSt5tag(data.fSt5tag)
289 : {};
290 :
291 : AliStation4Data& operator = (const AliStation4Data& data)
292 : {
293 : fClusterPoint = data.fClusterPoint;
294 : fSt5tag = data.fSt5tag;
295 : return *this;
296 : };
297 :
298 : AliHLTMUONRecHitStruct fClusterPoint; // Cluster point found on station 4.
299 : const AliTagData* fSt5tag; // Corresponding station 5 tag.
300 : };
301 :
302 : typedef AliHLTMUONList<AliStation4Data> Station4List;
303 :
304 :
305 : void ReceiveClustersChamber7(const AliHLTMUONRecHitStruct* clusters, AliHLTUInt32_t count, const AliTagData* data);
306 : void ReceiveClustersChamber8(const AliHLTMUONRecHitStruct* clusters, AliHLTUInt32_t count, const AliTagData* data);
307 : void ReceiveClustersChamber9(const AliHLTMUONRecHitStruct* clusters, AliHLTUInt32_t count);
308 : void ReceiveClustersChamber10(const AliHLTMUONRecHitStruct* clusters, AliHLTUInt32_t count);
309 : void EndOfClustersChamber7();
310 : void EndOfClustersChamber8();
311 : void EndOfClustersChamber9();
312 : void EndOfClustersChamber10();
313 :
314 : void ProjectToStation4(AliStation5Data* data, AliHLTFloat32_t station5z, AliHLTUInt32_t chamberSt5);
315 : void ProcessClusters();
316 :
317 : #ifdef DEBUG
318 : public:
319 : #endif
320 : // States for state machine 4 (SM4).
321 : enum StatesSM4
322 : {
323 : kSM4Idle,
324 : kWaitChamber8,
325 : kWaitMoreChamber8,
326 : kWaitChamber7,
327 : kWaitMoreChamber7
328 : };
329 :
330 : // States for state machine 5 (SM5).
331 : enum StatesSM5
332 : {
333 : kSM5Idle,
334 : kWaitChamber10,
335 : kWaitMoreChamber10,
336 : kWaitChamber9,
337 : kWaitMoreChamber9,
338 : kSM5Done
339 : };
340 :
341 : protected:
342 :
343 : AliHLTMUONMansoTrackerFSMCallback* fCallback; // Pointer to the callback interface from which we fetch reco hits and to which we publish results.
344 :
345 : StatesSM4 fSm4state; // State of SM4 used for fetching clusters on chambers 7 and 8.
346 : StatesSM5 fSm5state; // State of SM5 used for fetching clusters on chambers 9 and 10.
347 : AliHLTUInt32_t fRequestsCompleted; // Number of requests for station 4 that have completed.
348 : AliHLTMUONChamberName fSt4chamber; // The chamber on station 4 that data was retreived from.
349 :
350 : AliVertex fV1; // The impact (hit) vertex for trigger station 1.
351 : AliTagData fMc1; // Trigger station 1 data.
352 :
353 : Station5List fSt5data; // List of found cluster points for station 5 and their tag data.
354 : Station4List fSt4points; // The found cluster points for station 4.
355 :
356 : // Iterators used in the FoundTrack, FillTrackData methods.
357 : Station5List::Iterator fSt5rec; // current station 5 record
358 : Station4List::Iterator fFoundPoint; // current found point
359 : AliHLTInt32_t fTriggerId; // The current ID number of the trigger record being processed.
360 : AliHLTInt32_t fTrackId; // Track ID counter for the current track.
361 :
362 : bool fMakeCandidates; // Indicates if the track candidates should be recorded.
363 : AliHLTUInt32_t fCandidatesCount; // The number of track candidates in the fCandidates list.
364 : AliHLTUInt32_t fCandidatesSize; // Number of elements that the fCandidates list can store.
365 : AliHLTMUONMansoCandidateStruct* fCandidates; // The track candidates buffer.
366 :
367 : /* To request clusters from the boundary box specified by the 'left', 'right',
368 : 'top' and 'bottom' boundaries and on the given chamber use this method call.
369 : Supply a tag parameter if you want the request uniquely identified.
370 : This is usefull to supply a pointer to some internal state data structure
371 : to figure out where processing should continue in the ReturnClusters or
372 : EndOfClusters methods.
373 : */
374 : void RequestClusters(
375 : AliHLTFloat32_t left, AliHLTFloat32_t right, AliHLTFloat32_t bottom, AliHLTFloat32_t top,
376 : AliHLTMUONChamberName chamber, const void* tag = NULL
377 : )
378 : {
379 0 : assert( fCallback != NULL );
380 0 : fCallback->RequestClusters(this, left, right, bottom, top, chamber, tag);
381 0 : };
382 :
383 : /* When no more cluster requests will be generated by this tracker then this
384 : method should be called.
385 : DO NOT request more clusters after calling this method.
386 : */
387 : void EndOfClusterRequests()
388 : {
389 0 : assert( fCallback != NULL );
390 0 : fCallback->EndOfClusterRequests(this);
391 0 : };
392 :
393 : /* When the tracker has found a track it should call this method to inform
394 : the rest of the system. At this point all cluster blocks received with
395 : ReturnClusters are to be considered released and MUST NOT be accessed.
396 : */
397 : void FoundTrack()
398 : {
399 0 : assert( fCallback != NULL );
400 0 : fCallback->FoundTrack(this);
401 0 : };
402 :
403 : /* If the tracker is finished processing the trigger record but has not found
404 : a track it should call this method to inform the rest of the system.
405 : At this point all cluster blocks received with ReturnClusters are to be
406 : considered released and MUST NOT be accessed.
407 : */
408 : void NoTrackFound()
409 : {
410 0 : assert( fCallback != NULL );
411 0 : fCallback->NoTrackFound(this);
412 0 : };
413 :
414 : /**
415 : * Adds a new track candidate to the fCandidates list and returns the pointer
416 : * to the new structure to be filled.
417 : * \returns a pointer to the new structure and NULL if we ran out of space.
418 : */
419 : AliHLTMUONMansoCandidateStruct* AddTrackCandidate();
420 :
421 : private:
422 :
423 : // Not allowed to copy this object.
424 : AliHLTMUONMansoTrackerFSM(const AliHLTMUONMansoTrackerFSM& tracker);
425 : AliHLTMUONMansoTrackerFSM& operator = (const AliHLTMUONMansoTrackerFSM& tracker);
426 :
427 : static AliHLTFloat32_t fgA7, fgB7; // Parameters used to create a region of interest for the 7'th chamber.
428 : static AliHLTFloat32_t fgA8, fgB8; // Parameters used to create a region of interest for the 8'th chamber.
429 : static AliHLTFloat32_t fgA9, fgB9; // Parameters used to create a region of interest for the 9'th chamber.
430 : static AliHLTFloat32_t fgA10, fgB10; // Parameters used to create a region of interest for the 10'th chamber.
431 : static AliHLTFloat32_t fgZ7, fgZ8, fgZ9, fgZ10, fgZ11, fgZ13; // Z coordinates of chambers 7 to 10.
432 :
433 : };
434 :
435 :
436 : #endif // ALIHLTMUONMANSOTRACKERFSM_H
|
