]>
Commit | Line | Data |
---|---|---|
b92524d0 | 1 | /************************************************************************** |
2 | * This file is property of and copyright by the ALICE HLT Project * | |
3 | * All rights reserved. * | |
4 | * * | |
5 | * Primary Authors: * | |
6 | * Artur Szostak <artursz@iafrica.com> * | |
7 | * Indranil Das <indra.das@saha.ac.in> * | |
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 | ||
1d8ae082 | 18 | // $Id$ |
b92524d0 | 19 | |
6253e09b | 20 | /// |
21 | /// @file AliHLTMUONMansoTrackerFSMComponent.cxx | |
22 | /// @author Artur Szostak <artursz@iafrica.com>, | |
23 | /// Indranil Das <indra.das@saha.ac.in> | |
4e22efc4 | 24 | /// @date 18 Sep 2007 |
6253e09b | 25 | /// @brief Implementation of AliHLTMUONMansoTrackerFSMComponent class. |
26 | /// | |
b92524d0 | 27 | |
28 | #include "AliHLTMUONMansoTrackerFSMComponent.h" | |
29 | #include "AliHLTMUONConstants.h" | |
2b7af22a | 30 | #include "AliHLTMUONCalculations.h" |
b92524d0 | 31 | #include "AliHLTMUONUtils.h" |
32 | #include "AliHLTMUONMansoTrackerFSM.h" | |
33 | #include "AliHLTMUONDataBlockReader.h" | |
34 | #include "AliHLTMUONDataBlockWriter.h" | |
35 | #include <cstdlib> | |
d42549e3 | 36 | #include <cstring> |
b92524d0 | 37 | #include <cerrno> |
5bf92d6f | 38 | #include <new> |
b92524d0 | 39 | |
b92524d0 | 40 | ClassImp(AliHLTMUONMansoTrackerFSMComponent); |
41 | ||
42 | ||
43 | AliHLTMUONMansoTrackerFSMComponent::AliHLTMUONMansoTrackerFSMComponent() : | |
154cba94 | 44 | AliHLTMUONProcessor(), |
b92524d0 | 45 | AliHLTMUONMansoTrackerFSMCallback(), |
46 | fTracker(NULL), | |
47 | fTrackCount(0), | |
d42549e3 | 48 | fBlock(NULL), |
5bf92d6f | 49 | fRecHitBlockArraySize(0), |
2b7af22a | 50 | fWarnForUnexpecedBlock(false), |
2b7af22a | 51 | fCanLoadZmiddle(true), |
52 | fCanLoadBL(true) | |
b92524d0 | 53 | { |
6253e09b | 54 | /// |
55 | /// Default constructor. | |
56 | /// | |
5bf92d6f | 57 | |
2b7af22a | 58 | for (int i = 0; i < 4; i++) |
5bf92d6f | 59 | { |
60 | fRecHitBlockCount[i] = 0; | |
61 | fRecHitBlock[i] = NULL; | |
62 | } | |
2b7af22a | 63 | |
64 | ResetCanLoadFlags(); | |
b92524d0 | 65 | } |
66 | ||
67 | ||
68 | AliHLTMUONMansoTrackerFSMComponent::~AliHLTMUONMansoTrackerFSMComponent() | |
69 | { | |
6253e09b | 70 | /// |
71 | /// Default destructor. | |
72 | /// | |
73 | ||
a6b16447 | 74 | // Should never have the following 2 pointers non-NULL since DoDeinit |
75 | // should have been called before, but handle this case anyway. | |
76 | if (fTracker != NULL) delete fTracker; | |
77 | ||
78 | // Remember that only fRecHitBlock[0] stores the pointer to the allocated | |
79 | // memory. The other pointers are just reletive to this. | |
80 | if (fRecHitBlock[0] != NULL) delete [] fRecHitBlock[0]; | |
b92524d0 | 81 | } |
82 | ||
83 | ||
84 | const char* AliHLTMUONMansoTrackerFSMComponent::GetComponentID() | |
85 | { | |
6253e09b | 86 | /// |
87 | /// Inherited from AliHLTComponent. Returns the component ID. | |
88 | /// | |
89 | ||
b92524d0 | 90 | return AliHLTMUONConstants::MansoTrackerFSMId(); |
91 | } | |
92 | ||
93 | ||
94 | void AliHLTMUONMansoTrackerFSMComponent::GetInputDataTypes( | |
ffb64d3e | 95 | AliHLTComponentDataTypeList& list |
b92524d0 | 96 | ) |
97 | { | |
6253e09b | 98 | /// |
99 | /// Inherited from AliHLTProcessor. Returns the list of expected input data types. | |
100 | /// | |
101 | ||
b92524d0 | 102 | assert( list.empty() ); |
103 | list.push_back( AliHLTMUONConstants::TriggerRecordsBlockDataType() ); | |
104 | list.push_back( AliHLTMUONConstants::RecHitsBlockDataType() ); | |
105 | } | |
106 | ||
107 | ||
108 | AliHLTComponentDataType AliHLTMUONMansoTrackerFSMComponent::GetOutputDataType() | |
109 | { | |
6253e09b | 110 | /// |
111 | /// Inherited from AliHLTComponent. Returns the output data type. | |
112 | /// | |
113 | ||
4d76a068 | 114 | return kAliHLTMultipleDataType; |
115 | } | |
116 | ||
117 | ||
118 | int AliHLTMUONMansoTrackerFSMComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& list) | |
119 | { | |
120 | /// Inherited from AliHLTComponent. Returns the output data types. | |
121 | ||
122 | assert( list.empty() ); | |
123 | list.push_back( AliHLTMUONConstants::MansoTracksBlockDataType() ); | |
124 | list.push_back( AliHLTMUONConstants::MansoCandidatesBlockDataType() ); | |
125 | return list.size(); | |
b92524d0 | 126 | } |
127 | ||
128 | ||
129 | void AliHLTMUONMansoTrackerFSMComponent::GetOutputDataSize( | |
130 | unsigned long& constBase, double& inputMultiplier | |
131 | ) | |
132 | { | |
6253e09b | 133 | /// |
134 | /// Inherited from AliHLTComponent. Returns an estimate of the expected output data size. | |
135 | /// | |
136 | ||
979076f8 | 137 | constBase = sizeof(AliHLTMUONMansoTracksBlockStruct) + 1024*1024; |
b92524d0 | 138 | inputMultiplier = 1; |
139 | } | |
140 | ||
141 | ||
142 | AliHLTComponent* AliHLTMUONMansoTrackerFSMComponent::Spawn() | |
143 | { | |
6253e09b | 144 | /// |
145 | /// Inherited from AliHLTComponent. Creates a new object instance. | |
146 | /// | |
147 | ||
b92524d0 | 148 | return new AliHLTMUONMansoTrackerFSMComponent; |
149 | } | |
150 | ||
151 | ||
152 | int AliHLTMUONMansoTrackerFSMComponent::DoInit(int argc, const char** argv) | |
153 | { | |
6253e09b | 154 | /// |
155 | /// Inherited from AliHLTComponent. | |
156 | /// Parses the command line parameters and initialises the component. | |
157 | /// | |
158 | ||
6ec6a7c1 | 159 | HLTInfo("Initialising dHLT manso tracker FSM component."); |
160 | ||
ffb64d3e | 161 | // Inherit the parents functionality. |
162 | int result = AliHLTMUONProcessor::DoInit(argc, argv); | |
163 | if (result != 0) return result; | |
164 | ||
a6b16447 | 165 | // Just in case for whatever reason we still have some of the internal |
166 | // object allocated previously still hanging around delete them now. | |
167 | FreeMemory(); | |
168 | ||
d42549e3 | 169 | fWarnForUnexpecedBlock = false; |
2b7af22a | 170 | ResetCanLoadFlags(); |
2b7af22a | 171 | double zmiddle = 0; |
172 | double bfieldintegral = 0; | |
173 | double roiA[4] = {0, 0, 0, 0}; | |
174 | double roiB[4] = {0, 0, 0, 0}; | |
175 | double chamberZ[6] = {0, 0, 0, 0, 0, 0}; | |
d42549e3 | 176 | |
177 | for (int i = 0; i < argc; i++) | |
178 | { | |
ffb64d3e | 179 | if (ArgumentAlreadyHandled(i, argv[i])) continue; |
180 | ||
2b7af22a | 181 | if (strcmp( argv[i], "-zmiddle" ) == 0) |
182 | { | |
183 | if (not fCanLoadZmiddle) | |
184 | { | |
185 | HLTWarning("The Z coordinate for the middle of the dipole was already specified." | |
186 | " Will replace previous value given by -zmiddle." | |
187 | ); | |
188 | } | |
189 | ||
190 | if ( argc <= i+1 ) | |
191 | { | |
192 | HLTError("The Z coordinate for the middle of the dipole was not specified." ); | |
2b7af22a | 193 | return -EINVAL; |
194 | } | |
195 | ||
196 | char* cpErr = NULL; | |
197 | zmiddle = strtod(argv[i+1], &cpErr); | |
198 | if (cpErr == NULL or *cpErr != '\0') | |
199 | { | |
200 | HLTError("Cannot convert '%s' to a valid floating point number.", | |
201 | argv[i+1] | |
202 | ); | |
2b7af22a | 203 | return -EINVAL; |
204 | } | |
205 | ||
206 | fCanLoadZmiddle = false; // Prevent loading from CDB. | |
207 | i++; | |
208 | continue; | |
209 | } | |
210 | ||
211 | if (strcmp( argv[i], "-bfieldintegral" ) == 0) | |
212 | { | |
213 | if (not fCanLoadBL) | |
214 | { | |
215 | HLTWarning("The magnetic field integral was already specified." | |
216 | " Will replace previous value given by -bfieldintegral." | |
217 | ); | |
218 | } | |
219 | ||
220 | if ( argc <= i+1 ) | |
221 | { | |
222 | HLTError("The magnetic field integral was not specified." ); | |
2b7af22a | 223 | return -EINVAL; |
224 | } | |
225 | ||
226 | char* cpErr = NULL; | |
227 | bfieldintegral = strtod(argv[i+1], &cpErr); | |
228 | if (cpErr == NULL or *cpErr != '\0') | |
229 | { | |
230 | HLTError("Cannot convert '%s' to a valid floating point number.", | |
231 | argv[i+1] | |
232 | ); | |
2b7af22a | 233 | return -EINVAL; |
234 | } | |
235 | ||
236 | fCanLoadBL = false; // Prevent loading from CDB. | |
237 | i++; | |
238 | continue; | |
239 | } | |
240 | ||
241 | if (strcmp(argv[i], "-a7") == 0 or strcmp(argv[i], "-a8") == 0 or | |
242 | strcmp(argv[i], "-a9") == 0 or strcmp(argv[i], "-a10") == 0 | |
243 | ) | |
244 | { | |
245 | int chamber = 7; int chamberIndex = 0; | |
246 | switch (argv[i][2]) | |
247 | { | |
248 | case '7': chamber = 7; chamberIndex = 0; break; | |
249 | case '8': chamber = 8; chamberIndex = 1; break; | |
250 | case '9': chamber = 9; chamberIndex = 2; break; | |
251 | case '1': chamber = 10; chamberIndex = 3; break; | |
252 | } | |
253 | ||
254 | if (not fCanLoadA[chamberIndex]) | |
255 | { | |
256 | HLTWarning("The region of interest parameter 'A' for chamber %d was" | |
257 | " already specified. Will replace previous value given by -a%d.", | |
258 | chamber, chamber | |
259 | ); | |
260 | } | |
261 | ||
262 | if ( argc <= i+1 ) | |
263 | { | |
264 | HLTError("The region of interest parameter was not specified." ); | |
2b7af22a | 265 | return -EINVAL; |
266 | } | |
267 | ||
268 | char* cpErr = NULL; | |
269 | roiA[chamberIndex] = strtod(argv[i+1], &cpErr); | |
270 | if (cpErr == NULL or *cpErr != '\0') | |
271 | { | |
272 | HLTError("Cannot convert '%s' to a valid floating point number.", | |
273 | argv[i+1] | |
274 | ); | |
2b7af22a | 275 | return -EINVAL; |
276 | } | |
277 | ||
278 | fCanLoadA[chamberIndex] = false; // Prevent loading from CDB. | |
279 | i++; | |
280 | continue; | |
281 | } | |
282 | ||
283 | if (strcmp(argv[i], "-b7") == 0 or strcmp(argv[i], "-b8") == 0 or | |
284 | strcmp(argv[i], "-b9") == 0 or strcmp(argv[i], "-b10") == 0 | |
285 | ) | |
286 | { | |
287 | int chamber = 7; int chamberIndex = 0; | |
288 | switch (argv[i][2]) | |
289 | { | |
290 | case '7': chamber = 7; chamberIndex = 0; break; | |
291 | case '8': chamber = 8; chamberIndex = 1; break; | |
292 | case '9': chamber = 9; chamberIndex = 2; break; | |
293 | case '1': chamber = 10; chamberIndex = 3; break; | |
294 | } | |
295 | ||
296 | if (not fCanLoadB[chamberIndex]) | |
297 | { | |
298 | HLTWarning("The region of interest parameter 'B' for chamber %d was" | |
299 | " already specified. Will replace previous value given by -b%d.", | |
300 | chamber, chamber | |
301 | ); | |
302 | } | |
303 | ||
304 | if ( argc <= i+1 ) | |
305 | { | |
306 | HLTError("The region of interest parameter was not specified." ); | |
2b7af22a | 307 | return -EINVAL; |
308 | } | |
309 | ||
310 | char* cpErr = NULL; | |
311 | roiB[chamberIndex] = strtod(argv[i+1], &cpErr); | |
312 | if (cpErr == NULL or *cpErr != '\0') | |
313 | { | |
314 | HLTError("Cannot convert '%s' to a valid floating point number.", | |
315 | argv[i+1] | |
316 | ); | |
2b7af22a | 317 | return -EINVAL; |
318 | } | |
319 | ||
320 | fCanLoadB[chamberIndex] = false; // Prevent loading from CDB. | |
321 | i++; | |
322 | continue; | |
323 | } | |
324 | ||
325 | if (strcmp(argv[i], "-z7") == 0 or strcmp(argv[i], "-z8") == 0 or | |
326 | strcmp(argv[i], "-z9") == 0 or strcmp(argv[i], "-z10") == 0 or | |
327 | strcmp(argv[i], "-z11") == 0 or strcmp(argv[i], "-z13") == 0 | |
328 | ) | |
329 | { | |
330 | int chamber = 7; int chamberIndex = 0; | |
331 | switch (argv[i][2]) | |
332 | { | |
333 | case '7': chamber = 7; chamberIndex = 0; break; | |
334 | case '8': chamber = 8; chamberIndex = 1; break; | |
335 | case '9': chamber = 9; chamberIndex = 2; break; | |
336 | case '1': | |
337 | switch (argv[i][3]) | |
338 | { | |
339 | case '0': chamber = 10; chamberIndex = 3; break; | |
340 | case '1': chamber = 11; chamberIndex = 4; break; | |
341 | case '3': chamber = 13; chamberIndex = 5; break; | |
342 | } | |
343 | break; | |
344 | } | |
345 | ||
346 | if (not fCanLoadZ[chamberIndex]) | |
347 | { | |
348 | HLTWarning("The nominal Z coordinate of chamber %d was already" | |
349 | " specified. Will replace previous value given by -z%d.", | |
350 | chamber, chamber | |
351 | ); | |
352 | } | |
353 | ||
354 | if ( argc <= i+1 ) | |
355 | { | |
356 | HLTError("The region of interest parameter was not specified." ); | |
2b7af22a | 357 | return -EINVAL; |
358 | } | |
359 | ||
360 | char* cpErr = NULL; | |
361 | chamberZ[chamberIndex] = strtod(argv[i+1], &cpErr); | |
362 | if (cpErr == NULL or *cpErr != '\0') | |
363 | { | |
364 | HLTError("Cannot convert '%s' to a valid floating point number.", | |
365 | argv[i+1] | |
366 | ); | |
2b7af22a | 367 | return -EINVAL; |
368 | } | |
369 | ||
370 | fCanLoadZ[chamberIndex] = false; // Prevent loading from CDB. | |
371 | i++; | |
372 | continue; | |
373 | } | |
374 | ||
d42549e3 | 375 | if (strcmp(argv[i], "-warn_on_unexpected_block") == 0) |
47415aa9 | 376 | { |
d42549e3 | 377 | fWarnForUnexpecedBlock = true; |
47415aa9 | 378 | continue; |
379 | } | |
380 | ||
381 | HLTError("Unknown option '%s'.", argv[i]); | |
a6b16447 | 382 | return -EINVAL; |
d42549e3 | 383 | } |
384 | ||
ffb64d3e | 385 | try |
2b7af22a | 386 | { |
ffb64d3e | 387 | fTracker = new AliHLTMUONMansoTrackerFSM(); |
388 | } | |
389 | catch (const std::bad_alloc&) | |
390 | { | |
391 | HLTError("Could not allocate more memory for the tracker component."); | |
392 | return -ENOMEM; | |
2b7af22a | 393 | } |
ffb64d3e | 394 | fTracker->SetCallback(this); |
2b7af22a | 395 | |
396 | // Set all the parameters that were found on the command line. | |
397 | if (not fCanLoadZmiddle) AliHLTMUONCalculations::Zf(zmiddle); | |
398 | if (not fCanLoadBL) AliHLTMUONCalculations::QBL(bfieldintegral); | |
399 | if (not fCanLoadA[0]) fTracker->SetA7(roiA[0]); | |
400 | if (not fCanLoadA[1]) fTracker->SetA8(roiA[1]); | |
401 | if (not fCanLoadA[2]) fTracker->SetA9(roiA[2]); | |
402 | if (not fCanLoadA[3]) fTracker->SetA10(roiA[3]); | |
403 | if (not fCanLoadB[0]) fTracker->SetB7(roiB[0]); | |
404 | if (not fCanLoadB[1]) fTracker->SetB8(roiB[1]); | |
405 | if (not fCanLoadB[2]) fTracker->SetB9(roiB[2]); | |
406 | if (not fCanLoadB[3]) fTracker->SetB10(roiB[3]); | |
407 | if (not fCanLoadZ[0]) fTracker->SetZ7(chamberZ[0]); | |
408 | if (not fCanLoadZ[1]) fTracker->SetZ8(chamberZ[1]); | |
409 | if (not fCanLoadZ[2]) fTracker->SetZ9(chamberZ[2]); | |
410 | if (not fCanLoadZ[3]) fTracker->SetZ10(chamberZ[3]); | |
411 | if (not fCanLoadZ[4]) fTracker->SetZ11(chamberZ[4]); | |
412 | if (not fCanLoadZ[5]) fTracker->SetZ13(chamberZ[5]); | |
413 | ||
ffb64d3e | 414 | if (not DelaySetup()) |
2b7af22a | 415 | { |
416 | if (AtLeastOneCanLoadFlagsIsSet()) | |
417 | { | |
418 | HLTInfo("Loading configuration parameters from CDB."); | |
419 | ||
4e22efc4 | 420 | result = ReadConfigFromCDB(); |
2b7af22a | 421 | if (result != 0) |
422 | { | |
423 | // Error messages already generated in ReadConfigFromCDB. | |
424 | FreeMemory(); // Make sure we cleanup to avoid partial initialisation. | |
425 | return result; | |
426 | } | |
427 | } | |
428 | else | |
429 | { | |
430 | // Print the debug messages here since ReadConfigFromCDB does not get called, | |
431 | // in-which the debug messages would have been printed. | |
432 | HLTDebug("Using the following configuration parameters:"); | |
433 | HLTDebug(" Middle of dipole Z coordinate = %f cm", AliHLTMUONCalculations::Zf()); | |
434 | HLTDebug(" Magnetic field integral = %f T.m", AliHLTMUONCalculations::QBL()); | |
435 | HLTDebug(" Region of interest parameter 'A' for chamber 7 = %f", fTracker->GetA7()); | |
436 | HLTDebug(" Region of interest parameter 'B' for chamber 7 = %f cm", fTracker->GetB7()); | |
437 | HLTDebug(" Region of interest parameter 'A' for chamber 8 = %f", fTracker->GetA8()); | |
438 | HLTDebug(" Region of interest parameter 'B' for chamber 8 = %f cm", fTracker->GetB8()); | |
439 | HLTDebug(" Region of interest parameter 'A' for chamber 9 = %f", fTracker->GetA9()); | |
440 | HLTDebug(" Region of interest parameter 'B' for chamber 9 = %f cm", fTracker->GetB9()); | |
441 | HLTDebug(" Region of interest parameter 'A' for chamber 10 = %f", fTracker->GetA10()); | |
442 | HLTDebug(" Region of interest parameter 'B' for chamber 10 = %f cm", fTracker->GetB10()); | |
443 | HLTDebug(" Nominal Z coordinate for chamber 7 = %f cm", fTracker->GetZ7()); | |
444 | HLTDebug(" Nominal Z coordinate for chamber 8 = %f cm", fTracker->GetZ8()); | |
445 | HLTDebug(" Nominal Z coordinate for chamber 9 = %f cm", fTracker->GetZ9()); | |
446 | HLTDebug(" Nominal Z coordinate for chamber 10 = %f cm", fTracker->GetZ10()); | |
447 | HLTDebug(" Nominal Z coordinate for chamber 11 = %f cm", fTracker->GetZ11()); | |
448 | HLTDebug(" Nominal Z coordinate for chamber 13 = %f cm", fTracker->GetZ13()); | |
449 | } | |
450 | ||
451 | ResetCanLoadFlags(); // From this point read all parameters from CDB. | |
452 | } | |
453 | ||
5bf92d6f | 454 | const int initArraySize = 10; |
a6b16447 | 455 | // Allocate some initial memory for the reconstructed hit arrays. |
5bf92d6f | 456 | try |
457 | { | |
458 | fRecHitBlock[0] = new AliRecHitBlockInfo[initArraySize*4]; | |
459 | } | |
460 | catch (const std::bad_alloc&) | |
461 | { | |
462 | HLTError("Could not allocate more memory for the reconstructed hit arrays."); | |
a6b16447 | 463 | FreeMemory(); // Make sure we cleanup to avoid partial initialisation. |
5bf92d6f | 464 | return -ENOMEM; |
465 | } | |
466 | // Only set the arrays' size once we have successfully allocated the memory for the arrays. | |
467 | fRecHitBlockArraySize = initArraySize; | |
468 | // Now we need to set the pointers fRecHitBlock[i] {i>0} relative to fRecHitBlock[0]. | |
469 | for (Int_t i = 1; i < 4; i++) | |
470 | { | |
471 | fRecHitBlock[i] = fRecHitBlock[i-1] + fRecHitBlockArraySize; | |
472 | } | |
473 | // And reset the number of records actually stored in the arrays. | |
474 | for (Int_t i = 0; i < 4; i++) | |
475 | { | |
476 | fRecHitBlockCount[i] = 0; | |
477 | } | |
478 | ||
b92524d0 | 479 | return 0; |
480 | } | |
481 | ||
482 | ||
2b7af22a | 483 | int AliHLTMUONMansoTrackerFSMComponent::Reconfigure( |
484 | const char* cdbEntry, const char* componentId | |
485 | ) | |
486 | { | |
487 | /// Inherited from AliHLTComponent. This method will reload CDB configuration | |
488 | /// entries for this component from the CDB. | |
489 | /// \param cdbEntry If this is NULL or equals "HLT/ConfigMUON/MansoTrackerFSM" | |
490 | /// then new configuration parameters are loaded, otherwise nothing is done. | |
491 | /// \param componentId The name of the component in the current chain. | |
492 | ||
493 | bool givenConfigPath = strcmp(cdbEntry, AliHLTMUONConstants::MansoTrackerFSMCDBPath()) == 0; | |
494 | ||
495 | if (cdbEntry == NULL or givenConfigPath) | |
496 | { | |
497 | HLTInfo("Reading new configuration entries from CDB for component '%s'.", componentId); | |
498 | ResetCanLoadFlags(); // Make sure to allow reading all values from CDB. | |
499 | int result = ReadConfigFromCDB(); | |
500 | if (result != 0) return result; | |
501 | } | |
502 | ||
503 | return 0; | |
504 | } | |
505 | ||
506 | ||
507 | int AliHLTMUONMansoTrackerFSMComponent::ReadPreprocessorValues(const char* modules) | |
508 | { | |
509 | /// Inherited from AliHLTComponent. | |
510 | /// Updates the configuration of this component if HLT or ALL has been | |
511 | /// specified in the 'modules' list. | |
512 | ||
513 | TString mods = modules; | |
514 | if (mods.Contains("ALL")) | |
515 | { | |
516 | return Reconfigure(NULL, GetComponentID()); | |
517 | } | |
518 | if (mods.Contains("HLT")) | |
519 | { | |
520 | return Reconfigure(AliHLTMUONConstants::MansoTrackerFSMCDBPath(), GetComponentID()); | |
521 | } | |
522 | return 0; | |
523 | } | |
524 | ||
525 | ||
526 | int AliHLTMUONMansoTrackerFSMComponent::ReadConfigFromCDB() | |
527 | { | |
528 | /// Reads this component's configuration parameters from the CDB. | |
529 | /// These include the middle of the dipole Z coordinate (zmiddle), the | |
530 | /// integrated magnetic field of the dipole, Z coordinates of the chambers | |
531 | /// and the region of interest parameters used during the tracking. | |
532 | /// \param setZmiddle Indicates if the zmiddle parameter should be set | |
533 | /// (default true). | |
534 | /// \param setBL Indicates if the integrated magnetic field parameter should | |
535 | /// be set (default true). | |
536 | /// \return 0 if no errors occured and negative error code compatible with | |
537 | /// the HLT framework on errors. | |
538 | ||
539 | const char* pathToEntry = AliHLTMUONConstants::MansoTrackerFSMCDBPath(); | |
540 | ||
541 | TMap* map = NULL; | |
542 | int result = FetchTMapFromCDB(pathToEntry, map); | |
543 | if (result != 0) return result; | |
544 | ||
545 | Double_t value = 0; | |
546 | if (fCanLoadZmiddle) | |
547 | { | |
548 | result = GetFloatFromTMap(map, "zmiddle", value, pathToEntry, "dipole middle Z coordinate"); | |
549 | if (result != 0) return result; | |
550 | AliHLTMUONCalculations::Zf(value); | |
551 | } | |
552 | ||
553 | if (fCanLoadBL) | |
554 | { | |
555 | result = GetFloatFromTMap(map, "bfieldintegral", value, pathToEntry, "integrated magnetic field"); | |
556 | if (result != 0) return result; | |
557 | AliHLTMUONCalculations::QBL(value); | |
558 | } | |
559 | ||
560 | if (fCanLoadA[0]) | |
561 | { | |
562 | result = GetFloatFromTMap(map, "roi_paramA_chamber7", value, pathToEntry, "chamber 7 region of interest 'A'"); | |
563 | if (result != 0) return result; | |
564 | fTracker->SetA7(value); | |
565 | } | |
566 | if (fCanLoadA[1]) | |
567 | { | |
568 | result = GetFloatFromTMap(map, "roi_paramA_chamber8", value, pathToEntry, "chamber 8 region of interest 'A'"); | |
569 | if (result != 0) return result; | |
570 | fTracker->SetA8(value); | |
571 | } | |
572 | if (fCanLoadA[2]) | |
573 | { | |
574 | result = GetFloatFromTMap(map, "roi_paramA_chamber9", value, pathToEntry, "chamber 9 region of interest 'A'"); | |
575 | if (result != 0) return result; | |
576 | fTracker->SetA9(value); | |
577 | } | |
578 | if (fCanLoadA[3]) | |
579 | { | |
580 | result = GetFloatFromTMap(map, "roi_paramA_chamber10", value, pathToEntry, "chamber 10 region of interest 'A'"); | |
581 | if (result != 0) return result; | |
582 | fTracker->SetA10(value); | |
583 | } | |
584 | ||
585 | if (fCanLoadB[0]) | |
586 | { | |
587 | result = GetFloatFromTMap(map, "roi_paramB_chamber7", value, pathToEntry, "chamber 7 region of interest 'B'"); | |
588 | if (result != 0) return result; | |
589 | fTracker->SetB7(value); | |
590 | } | |
591 | if (fCanLoadB[1]) | |
592 | { | |
593 | result = GetFloatFromTMap(map, "roi_paramB_chamber8", value, pathToEntry, "chamber 8 region of interest 'B'"); | |
594 | if (result != 0) return result; | |
595 | fTracker->SetB8(value); | |
596 | } | |
597 | if (fCanLoadB[2]) | |
598 | { | |
599 | result = GetFloatFromTMap(map, "roi_paramB_chamber9", value, pathToEntry, "chamber 9 region of interest 'B'"); | |
600 | if (result != 0) return result; | |
601 | fTracker->SetB9(value); | |
602 | } | |
603 | if (fCanLoadB[3]) | |
604 | { | |
605 | result = GetFloatFromTMap(map, "roi_paramB_chamber10", value, pathToEntry, "chamber 10 region of interest 'B'"); | |
606 | if (result != 0) return result; | |
607 | fTracker->SetB10(value); | |
608 | } | |
609 | ||
610 | if (fCanLoadZ[0]) | |
611 | { | |
612 | result = GetFloatFromTMap(map, "chamber7postion", value, pathToEntry, "nominal chamber 7 Z coordinate"); | |
613 | if (result != 0) return result; | |
614 | fTracker->SetZ7(value); | |
615 | } | |
616 | if (fCanLoadZ[1]) | |
617 | { | |
618 | result = GetFloatFromTMap(map, "chamber8postion", value, pathToEntry, "nominal chamber 8 Z coordinate"); | |
619 | if (result != 0) return result; | |
620 | fTracker->SetZ8(value); | |
621 | } | |
622 | if (fCanLoadZ[2]) | |
623 | { | |
624 | result = GetFloatFromTMap(map, "chamber9postion", value, pathToEntry, "nominal chamber 9 Z coordinate"); | |
625 | if (result != 0) return result; | |
626 | fTracker->SetZ9(value); | |
627 | } | |
628 | if (fCanLoadZ[3]) | |
629 | { | |
630 | result = GetFloatFromTMap(map, "chamber10postion", value, pathToEntry, "nominal chamber 10 Z coordinate"); | |
631 | if (result != 0) return result; | |
632 | fTracker->SetZ10(value); | |
633 | } | |
634 | if (fCanLoadZ[4]) | |
635 | { | |
636 | result = GetFloatFromTMap(map, "chamber11postion", value, pathToEntry, "nominal chamber 11 Z coordinate"); | |
637 | if (result != 0) return result; | |
638 | fTracker->SetZ11(value); | |
639 | } | |
640 | if (fCanLoadZ[5]) | |
641 | { | |
642 | result = GetFloatFromTMap(map, "chamber13postion", value, pathToEntry, "nominal chamber 13 Z coordinate"); | |
643 | if (result != 0) return result; | |
644 | fTracker->SetZ13(value); | |
645 | } | |
646 | ||
647 | HLTDebug("Using the following configuration parameters:"); | |
648 | HLTDebug(" Middle of dipole Z coordinate = %f cm", AliHLTMUONCalculations::Zf()); | |
649 | HLTDebug(" Magnetic field integral = %f T.m", AliHLTMUONCalculations::QBL()); | |
650 | HLTDebug(" Region of interest parameter 'A' for chamber 7 = %f", fTracker->GetA7()); | |
651 | HLTDebug(" Region of interest parameter 'B' for chamber 7 = %f cm", fTracker->GetB7()); | |
652 | HLTDebug(" Region of interest parameter 'A' for chamber 8 = %f", fTracker->GetA8()); | |
653 | HLTDebug(" Region of interest parameter 'B' for chamber 8 = %f cm", fTracker->GetB8()); | |
654 | HLTDebug(" Region of interest parameter 'A' for chamber 9 = %f", fTracker->GetA9()); | |
655 | HLTDebug(" Region of interest parameter 'B' for chamber 9 = %f cm", fTracker->GetB9()); | |
656 | HLTDebug(" Region of interest parameter 'A' for chamber 10 = %f", fTracker->GetA10()); | |
657 | HLTDebug(" Region of interest parameter 'B' for chamber 10 = %f cm", fTracker->GetB10()); | |
658 | HLTDebug(" Nominal Z coordinate for chamber 7 = %f cm", fTracker->GetZ7()); | |
659 | HLTDebug(" Nominal Z coordinate for chamber 8 = %f cm", fTracker->GetZ8()); | |
660 | HLTDebug(" Nominal Z coordinate for chamber 9 = %f cm", fTracker->GetZ9()); | |
661 | HLTDebug(" Nominal Z coordinate for chamber 10 = %f cm", fTracker->GetZ10()); | |
662 | HLTDebug(" Nominal Z coordinate for chamber 11 = %f cm", fTracker->GetZ11()); | |
663 | HLTDebug(" Nominal Z coordinate for chamber 13 = %f cm", fTracker->GetZ13()); | |
664 | ||
665 | return 0; | |
666 | } | |
667 | ||
668 | ||
b92524d0 | 669 | int AliHLTMUONMansoTrackerFSMComponent::DoDeinit() |
670 | { | |
6253e09b | 671 | /// |
672 | /// Inherited from AliHLTComponent. Performs a cleanup of the component. | |
673 | /// | |
674 | ||
6ec6a7c1 | 675 | HLTInfo("Deinitialising dHLT manso tracker FSM component."); |
a6b16447 | 676 | FreeMemory(); |
b92524d0 | 677 | return 0; |
678 | } | |
679 | ||
680 | ||
681 | int AliHLTMUONMansoTrackerFSMComponent::DoEvent( | |
682 | const AliHLTComponentEventData& evtData, | |
5def1693 | 683 | const AliHLTComponentBlockData* blocks, |
ffb64d3e | 684 | AliHLTComponentTriggerData& trigData, |
5def1693 | 685 | AliHLTUInt8_t* outputPtr, |
b92524d0 | 686 | AliHLTUInt32_t& size, |
ffb64d3e | 687 | AliHLTComponentBlockDataList& outputBlocks |
b92524d0 | 688 | ) |
689 | { | |
6253e09b | 690 | /// |
691 | /// Inherited from AliHLTProcessor. Processes the new event data. | |
692 | /// | |
693 | ||
2b7af22a | 694 | // Initialise the configuration parameters from CDB if we were |
695 | // requested to initialise only when the first event was received. | |
ffb64d3e | 696 | if (DelaySetup()) |
2b7af22a | 697 | { |
698 | // Load the configuration paramters from CDB if they have not | |
699 | // been given on the command line. | |
700 | if (AtLeastOneCanLoadFlagsIsSet()) | |
701 | { | |
702 | HLTInfo("Loading configuration parameters from CDB."); | |
703 | int result = ReadConfigFromCDB(); | |
704 | if (result != 0) return result; | |
705 | } | |
706 | ||
ffb64d3e | 707 | DoneDelayedSetup(); |
2b7af22a | 708 | ResetCanLoadFlags(); // From this point read all parameters from CDB. |
709 | } | |
710 | ||
b92524d0 | 711 | Reset(); |
712 | AliHLTUInt32_t specification = 0; // Contains the output data block spec bits. | |
713 | ||
a6b16447 | 714 | // Resize the rec hit arrays if we possibly will need more space. |
715 | // To guarantee that they will not overflow we need to make sure each | |
716 | // array is at least as big as the number of input data blocks. | |
5bf92d6f | 717 | if (fRecHitBlockArraySize < evtData.fBlockCnt) |
718 | { | |
719 | // Release the old memory block and allocate more memory. | |
a6b16447 | 720 | if (fRecHitBlock[0] != NULL) |
721 | { | |
722 | delete [] fRecHitBlock[0]; | |
723 | } | |
724 | ||
5bf92d6f | 725 | // Reset the number of records actually stored in the arrays. |
726 | for (Int_t i = 0; i < 4; i++) | |
727 | { | |
728 | fRecHitBlockCount[i] = 0; | |
729 | } | |
730 | ||
731 | try | |
732 | { | |
733 | fRecHitBlock[0] = new AliRecHitBlockInfo[evtData.fBlockCnt*4]; | |
734 | } | |
735 | catch (const std::bad_alloc&) | |
736 | { | |
737 | HLTError("Could not allocate more memory for the reconstructed hit arrays."); | |
738 | // Ok so now we need to clear all the pointers because we actually | |
739 | // deleted the memory. | |
740 | fRecHitBlockArraySize = 0; | |
741 | for (Int_t i = 0; i < 4; i++) | |
742 | { | |
743 | fRecHitBlock[i] = NULL; | |
744 | } | |
ffb64d3e | 745 | if (DumpDataOnError()) DumpEvent(evtData, blocks, trigData, outputPtr, size, outputBlocks); |
5bf92d6f | 746 | return -ENOMEM; |
747 | } | |
748 | // Only set the arrays' size once we have successfully allocated the memory for the arrays. | |
749 | fRecHitBlockArraySize = evtData.fBlockCnt; | |
750 | // Now we need to set the pointers fRecHitBlock[i] {i>0} relative to fRecHitBlock[0]. | |
751 | for (Int_t i = 1; i < 4; i++) | |
752 | { | |
753 | fRecHitBlock[i] = fRecHitBlock[i-1] + fRecHitBlockArraySize; | |
754 | } | |
755 | } | |
756 | ||
b92524d0 | 757 | AliHLTMUONMansoTracksBlockWriter block(outputPtr, size); |
758 | fBlock = █ | |
759 | ||
760 | if (not block.InitCommonHeader()) | |
761 | { | |
762 | Logging(kHLTLogError, | |
763 | "AliHLTMUONMansoTrackerFSMComponent::DoEvent", | |
764 | "Buffer overflow", | |
765 | "The buffer is only %d bytes in size. We need a minimum of %d bytes.", | |
766 | size, sizeof(AliHLTMUONMansoTracksBlockWriter::HeaderType) | |
767 | ); | |
ffb64d3e | 768 | if (DumpDataOnError()) DumpEvent(evtData, blocks, trigData, outputPtr, size, outputBlocks); |
b92524d0 | 769 | size = 0; // Important to tell framework that nothing was generated. |
5bf92d6f | 770 | return -ENOBUFS; |
b92524d0 | 771 | } |
772 | ||
773 | // Loop over all input blocks in the event and add the ones that contain | |
774 | // reconstructed hits into the hit buffers. The blocks containing trigger | |
775 | // records are ignored for now and will be processed later. | |
776 | for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++) | |
777 | { | |
450e0b36 | 778 | HLTDebug("Handling block: %u, with fDataType = '%s', fPtr = %p and fSize = %u bytes.", |
779 | n, DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fPtr, blocks[n].fSize | |
780 | ); | |
781 | ||
b92524d0 | 782 | if (blocks[n].fDataType == AliHLTMUONConstants::RecHitsBlockDataType()) |
783 | { | |
784 | specification |= blocks[n].fSpecification; | |
785 | ||
3240b3ce | 786 | AliHLTMUONRecHitsBlockReader inblock(blocks[n].fPtr, blocks[n].fSize); |
ffb64d3e | 787 | if (not BlockStructureOk(inblock)) |
788 | { | |
789 | if (DumpDataOnError()) DumpEvent(evtData, blocks, trigData, outputPtr, size, outputBlocks); | |
790 | continue; | |
791 | } | |
b92524d0 | 792 | |
4a9f11d4 | 793 | if (inblock.Nentries() != 0) |
794 | AddRecHits(blocks[n].fSpecification, inblock.GetArray(), inblock.Nentries()); | |
795 | else | |
796 | { | |
d42549e3 | 797 | Logging(kHLTLogDebug, |
4a9f11d4 | 798 | "AliHLTMUONMansoTrackerFSMComponent::DoEvent", |
799 | "Block empty", | |
800 | "Received a reconstructed hits data block which contains no entries." | |
801 | ); | |
802 | } | |
b92524d0 | 803 | } |
804 | else if (blocks[n].fDataType != AliHLTMUONConstants::TriggerRecordsBlockDataType()) | |
805 | { | |
806 | // Log a message indicating that we got a data block that we | |
807 | // do not know how to handle. | |
d42549e3 | 808 | if (fWarnForUnexpecedBlock) |
450e0b36 | 809 | HLTWarning("Received a data block of a type we cannot handle: '%s', spec: 0x%X", |
810 | DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fSpecification | |
d42549e3 | 811 | ); |
4e22efc4 | 812 | #ifdef __DEBUG |
d42549e3 | 813 | else |
450e0b36 | 814 | HLTDebug("Received a data block of a type we cannot handle: '%s', spec: 0x%X", |
815 | DataType2Text(blocks[n].fDataType).c_str(), blocks[n].fSpecification | |
d42549e3 | 816 | ); |
4e22efc4 | 817 | #endif |
b92524d0 | 818 | } |
819 | } | |
820 | ||
821 | // Again loop over all input blocks in the event, but this time look for | |
822 | // the trigger record blocks and process these. | |
823 | for (AliHLTUInt32_t n = 0; n < evtData.fBlockCnt; n++) | |
824 | { | |
825 | if (blocks[n].fDataType != AliHLTMUONConstants::TriggerRecordsBlockDataType()) | |
826 | continue; | |
827 | ||
3240b3ce | 828 | AliHLTMUONTriggerRecordsBlockReader inblock(blocks[n].fPtr, blocks[n].fSize); |
ffb64d3e | 829 | if (not BlockStructureOk(inblock)) |
830 | { | |
831 | if (DumpDataOnError()) DumpEvent(evtData, blocks, trigData, outputPtr, size, outputBlocks); | |
832 | continue; | |
833 | } | |
154cba94 | 834 | |
b92524d0 | 835 | DebugTrace("Processing a trigger block with " |
836 | << inblock.Nentries() << " entries." | |
837 | ); | |
838 | ||
839 | specification |= blocks[n].fSpecification; | |
840 | ||
841 | for (AliHLTUInt32_t i = 0; i < inblock.Nentries(); i++) | |
842 | { | |
843 | fTracker->FindTrack(inblock[i]); | |
844 | ||
845 | // Reset the tracker so that we do not double count tracks. | |
846 | fTracker->Reset(); | |
847 | } | |
848 | } | |
849 | ||
850 | AliHLTComponentBlockData bd; | |
851 | FillBlockData(bd); | |
852 | bd.fPtr = outputPtr; | |
853 | bd.fOffset = 0; | |
854 | bd.fSize = block.BytesUsed(); | |
855 | bd.fDataType = AliHLTMUONConstants::MansoTracksBlockDataType(); | |
856 | bd.fSpecification = specification; | |
857 | outputBlocks.push_back(bd); | |
858 | size = block.BytesUsed(); | |
859 | ||
860 | return 0; | |
861 | } | |
862 | ||
863 | ||
864 | void AliHLTMUONMansoTrackerFSMComponent::Reset() | |
865 | { | |
6253e09b | 866 | /// |
867 | /// Reset the track count and reconstructed hit data block arrays. | |
868 | /// | |
869 | ||
b92524d0 | 870 | DebugTrace("Resetting AliHLTMUONMansoTrackerFSMComponent."); |
871 | ||
872 | //fTracker->Reset(); // Not necessary here because it is done after every FindTrack call. | |
873 | fTrackCount = 0; | |
874 | fBlock = NULL; // Do not delete. Already done implicitly at the end of DoEvent. | |
875 | for (int i = 0; i < 4; i++) | |
876 | { | |
5bf92d6f | 877 | fRecHitBlockCount[i] = 0; |
b92524d0 | 878 | } |
879 | } | |
880 | ||
881 | ||
a6b16447 | 882 | void AliHLTMUONMansoTrackerFSMComponent::FreeMemory() |
883 | { | |
884 | /// Deletes any objects and arrays allocated by this component and releases | |
885 | /// the memory used. This is called as a helper routine by the init and deinit | |
886 | /// methods. If some or all of the object pointers are already NULL then | |
887 | /// nothing is done for those. This method guarantees that all the relevant | |
888 | /// pointers will be NULL after returning from this method. | |
889 | ||
890 | if (fTracker != NULL) | |
891 | { | |
892 | delete fTracker; | |
893 | fTracker = NULL; | |
894 | } | |
895 | ||
896 | // Remember that only fRecHitBlock[0] stores the pointer to the allocated memory. | |
897 | // The other pointers are just reletive to this. | |
898 | if (fRecHitBlock[0] != NULL) | |
899 | delete [] fRecHitBlock[0]; | |
900 | ||
901 | fRecHitBlockArraySize = 0; | |
902 | for (Int_t i = 0; i < 4; i++) | |
903 | { | |
904 | fRecHitBlockCount[i] = 0; | |
905 | fRecHitBlock[i] = NULL; | |
906 | } | |
907 | } | |
908 | ||
909 | ||
b92524d0 | 910 | void AliHLTMUONMansoTrackerFSMComponent::AddRecHits( |
6253e09b | 911 | AliHLTUInt32_t specification, |
b92524d0 | 912 | const AliHLTMUONRecHitStruct* recHits, |
913 | AliHLTUInt32_t count | |
914 | ) | |
915 | { | |
6253e09b | 916 | /// |
917 | /// Adds a new reconstructed hit data block to the internal list of blocks | |
918 | /// for the tracker to process. | |
919 | /// These lists will later be used when the tracker requests them through | |
920 | /// the callback method 'RequestClusters'. | |
921 | /// | |
922 | ||
b92524d0 | 923 | DebugTrace("AliHLTMUONMansoTrackerFSMComponent::AddRecHits called with specification = 0x" |
924 | << std::hex << specification << std::dec << " and count = " | |
925 | << count << " rec hits." | |
926 | ); | |
927 | ||
928 | AliHLTUInt8_t chamberMap[20] = { | |
929 | 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10 | |
930 | }; | |
931 | ||
932 | // Identify the chamber the rec hits came from using the specifications field. | |
933 | bool gotDataFromDDL[22]; | |
934 | AliHLTMUONUtils::UnpackSpecBits(specification, gotDataFromDDL); | |
935 | ||
936 | AliHLTInt8_t chamber = -1; | |
937 | for (int i = 0; i < 20; i++) | |
938 | { | |
939 | if (not gotDataFromDDL[i]) continue; | |
940 | if (7 <= chamberMap[i] and chamberMap[i] <= 10) | |
941 | { | |
942 | if (chamber != -1 and chamber != chamberMap[i]) | |
943 | { | |
944 | Logging(kHLTLogError, | |
945 | "AliHLTMUONMansoTrackerFSMComponent::AddRecHits", | |
946 | "Invalid block", | |
947 | "Received a data block with data from multiple chambers." | |
948 | " This component cannot handle such a case." | |
949 | ); | |
950 | return; | |
951 | } | |
952 | else | |
953 | chamber = chamberMap[i]; | |
954 | } | |
955 | else | |
956 | { | |
957 | Logging(kHLTLogError, | |
958 | "AliHLTMUONMansoTrackerFSMComponent::AddRecHits", | |
959 | "Invalid chamber", | |
960 | "Received a data block with data from chamber %d" | |
961 | " which is outside the expected range: [7..10].", | |
962 | chamberMap[i] | |
963 | ); | |
964 | return; | |
965 | } | |
966 | } | |
967 | ||
968 | // Make sure we got one chamber number. | |
969 | if (chamber < 7 or 10 < chamber) | |
970 | { | |
971 | Logging(kHLTLogError, | |
972 | "AliHLTMUONMansoTrackerFSMComponent::AddRecHits", | |
973 | "Invalid block", | |
974 | "Received a reconstructed hit data block with a null specification." | |
975 | " Cannot know which chamber the data comes from." | |
976 | ); | |
977 | return; | |
978 | } | |
979 | ||
980 | DebugTrace("Added " << count << " reconstructed hits from chamber " | |
d42549e3 | 981 | << (int)chamber << " to the internal arrays." |
982 | ); | |
b92524d0 | 983 | |
5bf92d6f | 984 | assert( fRecHitBlockCount[chamber-7] < fRecHitBlockArraySize ); |
985 | AliRecHitBlockInfo info(count, recHits); | |
986 | fRecHitBlock[chamber-7][fRecHitBlockCount[chamber-7]] = info; | |
987 | fRecHitBlockCount[chamber-7]++; | |
b92524d0 | 988 | } |
989 | ||
990 | ||
2b7af22a | 991 | void AliHLTMUONMansoTrackerFSMComponent::ResetCanLoadFlags() |
992 | { | |
993 | /// Resets all the fCanLoad* flags to true. This enables loading of all | |
994 | /// those CDB entries in the method ReadConfigFromCDB. | |
995 | ||
996 | fCanLoadZmiddle = true; | |
997 | fCanLoadBL = true; | |
998 | for (int i = 0; i < 4; i++) | |
999 | { | |
1000 | fCanLoadA[i] = true; | |
1001 | fCanLoadB[i] = true; | |
1002 | } | |
1003 | for (int i = 0; i < 6; i++) | |
1004 | { | |
1005 | fCanLoadZ[i] = true; | |
1006 | } | |
1007 | } | |
1008 | ||
1009 | ||
1010 | bool AliHLTMUONMansoTrackerFSMComponent::AtLeastOneCanLoadFlagsIsSet() const | |
1011 | { | |
1012 | /// Returns true if at least one fCanLoad* flag was true and false otherwise. | |
1013 | ||
1014 | if (fCanLoadZmiddle or fCanLoadBL) return true; | |
1015 | for (int i = 0; i < 4; i++) | |
1016 | { | |
1017 | if (fCanLoadA[i]) return true; | |
1018 | if (fCanLoadB[i]) return true; | |
1019 | } | |
1020 | for (int i = 0; i < 6; i++) | |
1021 | { | |
1022 | if (fCanLoadZ[i]) return true; | |
1023 | } | |
1024 | return false; | |
1025 | } | |
1026 | ||
1027 | ||
b92524d0 | 1028 | void AliHLTMUONMansoTrackerFSMComponent::RequestClusters( |
1029 | AliHLTMUONMansoTrackerFSM* tracker, | |
f1169efa | 1030 | AliHLTFloat32_t left, AliHLTFloat32_t right, |
1031 | AliHLTFloat32_t bottom, AliHLTFloat32_t top, | |
b92524d0 | 1032 | AliHLTMUONChamberName chamber, const void* tag |
1033 | ) | |
1034 | { | |
6253e09b | 1035 | /// |
1036 | /// Inherited from AliHLTMUONMansoTrackerFSMCallback. | |
1037 | /// This is the call back method used by the tracker algorithm to request | |
1038 | /// clusters on a certain chamber. | |
1039 | /// | |
1040 | ||
b92524d0 | 1041 | DebugTrace("AliHLTMUONMansoTracker::RequestClusters(chamber = " << chamber << ")"); |
1042 | void* ctag = const_cast<void*>(tag); | |
1043 | int chNo = -1; | |
5bf92d6f | 1044 | AliHLTUInt32_t recHitsCount = 0; |
1045 | AliRecHitBlockInfo* recHitsBlock = NULL; | |
b92524d0 | 1046 | switch (chamber) |
1047 | { | |
1048 | case kChamber7: | |
5bf92d6f | 1049 | recHitsCount = fRecHitBlockCount[0]; |
1050 | recHitsBlock = fRecHitBlock[0]; | |
b92524d0 | 1051 | chNo = 7; |
1052 | break; | |
1053 | ||
1054 | case kChamber8: | |
5bf92d6f | 1055 | recHitsCount = fRecHitBlockCount[1]; |
1056 | recHitsBlock = fRecHitBlock[1]; | |
b92524d0 | 1057 | chNo = 8; |
1058 | break; | |
1059 | ||
1060 | case kChamber9: | |
5bf92d6f | 1061 | recHitsCount = fRecHitBlockCount[2]; |
1062 | recHitsBlock = fRecHitBlock[2]; | |
b92524d0 | 1063 | chNo = 9; |
1064 | break; | |
1065 | ||
1066 | case kChamber10: | |
5bf92d6f | 1067 | recHitsCount = fRecHitBlockCount[3]; |
1068 | recHitsBlock = fRecHitBlock[3]; | |
b92524d0 | 1069 | chNo = 10; |
1070 | break; | |
1071 | ||
1072 | default: return; | |
1073 | } | |
1074 | ||
1075 | DebugTrace("Returning requested hits for chamber " << chNo << ":"); | |
5bf92d6f | 1076 | for (AliHLTUInt32_t i = 0; i < recHitsCount; i++) |
1077 | for (AliHLTUInt32_t j = 0; j < recHitsBlock[i].Count(); j++) | |
b92524d0 | 1078 | { |
5bf92d6f | 1079 | const AliHLTMUONRecHitStruct* hit = &(recHitsBlock[i].Data()[j]); |
f1169efa | 1080 | if (left < hit->fX and hit->fX < right and bottom < hit->fY and hit->fY < top) |
1081 | tracker->ReturnClusters(ctag, hit, 1); | |
b92524d0 | 1082 | } |
1083 | DebugTrace("Done returning hits from chamber " << chNo << "."); | |
1084 | tracker->EndOfClusters(ctag); | |
1085 | } | |
1086 | ||
1087 | ||
1088 | void AliHLTMUONMansoTrackerFSMComponent::EndOfClusterRequests( | |
5def1693 | 1089 | AliHLTMUONMansoTrackerFSM* /*tracker*/ |
b92524d0 | 1090 | ) |
1091 | { | |
6253e09b | 1092 | /// |
1093 | /// Inherited from AliHLTMUONMansoTrackerFSMCallback. | |
1094 | /// Nothing special to do here. | |
1095 | /// | |
1096 | ||
b92524d0 | 1097 | DebugTrace("End of cluster requests."); |
1098 | } | |
1099 | ||
1100 | ||
1101 | void AliHLTMUONMansoTrackerFSMComponent::FoundTrack(AliHLTMUONMansoTrackerFSM* tracker) | |
1102 | { | |
6253e09b | 1103 | /// |
1104 | /// Inherited from AliHLTMUONMansoTrackerFSMCallback. | |
1105 | /// This is the call back method used by the tracker algorithm to declare | |
1106 | /// that a new track has been found. | |
1107 | /// | |
1108 | ||
b92524d0 | 1109 | DebugTrace("AliHLTMUONMansoTrackerFSMComponent::FoundTrack()"); |
1110 | ||
1111 | AliHLTMUONMansoTracksBlockWriter* block = | |
1112 | reinterpret_cast<AliHLTMUONMansoTracksBlockWriter*>(fBlock); | |
1113 | ||
1f18ea3f | 1114 | AliHLTMUONMansoTrackStruct newTrack; |
1115 | tracker->FillTrackData(newTrack); | |
1116 | ||
f05f6212 | 1117 | // The indicies of the duplicate tracks. If set to block->Nentries() then |
1118 | // this indicates the index is not used. | |
1119 | AliHLTUInt32_t dup1 = block->Nentries(); | |
1120 | AliHLTUInt32_t dup2 = block->Nentries(); | |
1121 | ||
1122 | // Check if there are any tracks that use the same hits as the one found. | |
1123 | // If there are, then use the one that has the highest pT. | |
1124 | // There will be at most 2 duplicate tracks. | |
1f18ea3f | 1125 | for (AliHLTUInt32_t i = 0; i < block->Nentries(); i++) |
1126 | { | |
1127 | AliHLTMUONMansoTrackStruct& track = (*block)[i]; | |
1128 | bool hasNoDuplicates = true; | |
1129 | for (AliHLTUInt32_t j = 0; j < 4; j++) | |
1130 | { | |
1131 | if (track.fHit[j] == AliHLTMUONConstants::NilRecHitStruct()) continue; | |
1132 | if (newTrack.fHit[j] == AliHLTMUONConstants::NilRecHitStruct()) continue; | |
1133 | if (track.fHit[j] == newTrack.fHit[j]) | |
1134 | { | |
1135 | hasNoDuplicates = false; | |
1136 | break; | |
1137 | } | |
1138 | } | |
1139 | if (hasNoDuplicates) continue; | |
1140 | ||
f05f6212 | 1141 | if (dup1 == block->Nentries()) |
1f18ea3f | 1142 | { |
f05f6212 | 1143 | dup1 = i; |
1144 | } | |
1145 | else if (dup2 == block->Nentries()) | |
1146 | { | |
1147 | dup2 = i; | |
1148 | } | |
1149 | else | |
1150 | { | |
1151 | HLTError("Found more than 2 tracks with duplicate hits. This is completely unexpected. Something is seriously wrong!"); | |
1f18ea3f | 1152 | } |
1f18ea3f | 1153 | } |
1154 | ||
f05f6212 | 1155 | if (dup1 != block->Nentries() and dup2 != block->Nentries()) |
b92524d0 | 1156 | { |
f05f6212 | 1157 | // In this case we found 2 duplicate entries. |
1158 | // Figure out which one has the highest pT and keep only that one. | |
1159 | AliHLTMUONMansoTrackStruct& track1 = (*block)[dup1]; | |
1160 | AliHLTMUONMansoTrackStruct& track2 = (*block)[dup2]; | |
1161 | double newPt = sqrt(newTrack.fPx * newTrack.fPx + newTrack.fPy * newTrack.fPy); | |
1162 | double dupPt1 = sqrt(track1.fPx * track1.fPx + track1.fPy * track1.fPy); | |
1163 | double dupPt2 = sqrt(track2.fPx * track2.fPx + track2.fPy * track2.fPy); | |
1164 | ||
1165 | if (newPt >= dupPt1 and newPt >= dupPt2) | |
1166 | { | |
1167 | // The new track must replace both existing tracks. | |
1168 | track1 = newTrack; | |
1169 | track2 = (*block)[block->Nentries()-1]; | |
1170 | } | |
1171 | else if (dupPt1 >= newPt and dupPt1 >= dupPt2) | |
1172 | { | |
1173 | // track1 has the highest pT so ignore the new track and delete track2. | |
1174 | track2 = (*block)[block->Nentries()-1]; | |
1175 | } | |
1176 | else | |
1177 | { | |
1178 | // In this case track2 must have the highest pT so ignore the new | |
1179 | // track and delete track1. | |
1180 | track1 = (*block)[block->Nentries()-1]; | |
1181 | } | |
1182 | ||
1183 | // Decrement the number of entries because we deleted a track. | |
1184 | assert(fTrackCount > 0); | |
1185 | assert(block->Nentries() > 0); | |
1186 | block->SetNumberOfEntries(block->Nentries()-1); | |
1187 | fTrackCount--; | |
1188 | } | |
1189 | else if (dup1 != block->Nentries()) | |
1190 | { | |
1191 | // Only one track with duplicate hits found. | |
1192 | // See if the new track has higher pT. If it does then replace the | |
1193 | // exisiting track, otherwise ignore the new track. | |
1194 | AliHLTMUONMansoTrackStruct& track1 = (*block)[dup1]; | |
1195 | double newPt = sqrt(newTrack.fPx * newTrack.fPx + newTrack.fPy * newTrack.fPy); | |
1196 | double dupPt1 = sqrt(track1.fPx * track1.fPx + track1.fPy * track1.fPy); | |
1197 | if (newPt >= dupPt1) | |
1198 | { | |
1199 | track1 = newTrack; | |
1200 | } | |
1201 | } | |
1202 | else | |
1203 | { | |
1204 | // No track found with duplicate hits so we can add the new track as it is. | |
1205 | AliHLTMUONMansoTrackStruct* track = block->AddEntry(); | |
1206 | if (track == NULL) | |
1207 | { | |
1208 | Logging(kHLTLogError, | |
1209 | "AliHLTMUONMansoTrackerFSMComponent::FoundTrack", | |
1210 | "Buffer overflow", | |
1211 | "We have overflowed the output buffer for Manso track data." | |
1212 | " The output buffer size is only %d bytes.", | |
1213 | block->BufferSize() | |
1214 | ); | |
1215 | return; | |
1216 | } | |
1217 | ||
1218 | fTrackCount++; | |
1219 | *track = newTrack; | |
1220 | DebugTrace("\tAdded new track: " << *track); | |
b92524d0 | 1221 | } |
b92524d0 | 1222 | } |
1223 | ||
1224 | ||
5def1693 | 1225 | void AliHLTMUONMansoTrackerFSMComponent::NoTrackFound(AliHLTMUONMansoTrackerFSM* /*tracker*/) |
b92524d0 | 1226 | { |
6253e09b | 1227 | /// |
1228 | /// Inherited from AliHLTMUONMansoTrackerFSMCallback. | |
1229 | /// Nothing special to do here. | |
1230 | /// | |
1231 | ||
b92524d0 | 1232 | DebugTrace("No track found."); |
1233 | } | |
6253e09b | 1234 |