]>
Commit | Line | Data |
---|---|---|
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 | * * | |
8 | * Permission to use, copy, modify and distribute this software and its * | |
9 | * documentation strictly for non-commercial purposes is hereby granted * | |
10 | * without fee, provided that the above copyright notice appears in all * | |
11 | * copies and that both the copyright notice and this permission notice * | |
12 | * appear in the supporting documentation. The authors make no claims * | |
13 | * about the suitability of this software for any purpose. It is * | |
14 | * provided "as is" without express or implied warranty. * | |
15 | **************************************************************************/ | |
16 | ||
17 | /* $Id$ */ | |
18 | ||
19 | /** | |
20 | * @file AliHLTMUONTriggerRecordsSource.cxx | |
21 | * @author Artur Szostak <artursz@iafrica.com> | |
22 | * @date | |
23 | * @brief Implementation of the AliHLTMUONTriggerRecordsSource component. | |
24 | */ | |
25 | ||
26 | #include "AliHLTMUONTriggerRecordsSource.h" | |
27 | #include "AliHLTMUONConstants.h" | |
28 | #include "AliHLTMUONUtils.h" | |
29 | #include "AliHLTMUONDataBlockWriter.h" | |
30 | #include "AliHLTMUONCalculations.h" | |
31 | #include "AliMUONMCDataInterface.h" | |
32 | #include "AliMUONDataInterface.h" | |
33 | #include "AliMUONHit.h" | |
34 | #include "AliMUONRawCluster.h" | |
35 | #include "AliMUONConstants.h" | |
36 | #include "AliMUONVClusterStore.h" | |
37 | #include "AliMUONVHitStore.h" | |
38 | #include "mapping/AliMpCDB.h" | |
39 | #include "mapping/AliMpDDLStore.h" | |
40 | #include "mapping/AliMpLocalBoard.h" | |
41 | #include "mapping/AliMpTriggerCrate.h" | |
42 | #include "mapping/AliMpDEManager.h" | |
43 | #include "mapping/AliMpDetElement.h" | |
44 | #include "AliLog.h" | |
45 | #include "TClonesArray.h" | |
46 | #include <cstdlib> | |
47 | #include <cstdio> | |
48 | #include <cerrno> | |
49 | #include <cassert> | |
50 | #include <new> | |
51 | ||
52 | namespace | |
53 | { | |
54 | // The global object used for automatic component registration. | |
55 | // Note DO NOT use this component for calculation! | |
56 | AliHLTMUONTriggerRecordsSource gAliHLTMUONTriggerRecordsSource; | |
57 | ||
58 | //TODO: The following method should be in MUON/mapping | |
59 | Int_t FindDDLOfDetElement(Int_t detElemId) | |
60 | { | |
61 | // Find what the DDL ID number is for a detector element from | |
62 | // trigger chambers 11 to 14. We first have to find the local | |
63 | // board associated with the detector element and then we can | |
64 | // associate that local board to the trigger crate which has | |
65 | // the DDL number specified. | |
66 | AliMpDDLStore* ddlStore = AliMpDDLStore::Instance(); | |
67 | if (ddlStore == NULL) return -1; | |
68 | Int_t ddl = -1, boardIndex = 1; | |
69 | do | |
70 | { | |
71 | AliMpLocalBoard* board = ddlStore->GetLocalBoard(boardIndex++); | |
72 | if (board == NULL) break; | |
73 | if (board->HasDEId(detElemId)) | |
74 | { | |
75 | AliMpTriggerCrate* crate = ddlStore->GetTriggerCrate(board->GetCrate()); | |
76 | if (crate == NULL) continue; | |
77 | ddl = crate->GetDdlId(); | |
78 | break; | |
79 | } | |
80 | } | |
81 | while (ddl == -1); | |
82 | return ddl; | |
83 | } | |
84 | ||
85 | } | |
86 | ||
87 | ||
88 | ClassImp(AliHLTMUONTriggerRecordsSource); | |
89 | ||
90 | ||
91 | AliHLTMUONTriggerRecordsSource::AliHLTMUONTriggerRecordsSource() : | |
92 | AliHLTOfflineDataSource(), | |
93 | fMCDataInterface(NULL), | |
94 | fDataInterface(NULL), | |
95 | fBuildFromHits(false), | |
96 | fSelection(kWholePlane), | |
97 | fCurrentEvent(0) | |
98 | { | |
99 | } | |
100 | ||
101 | ||
102 | AliHLTMUONTriggerRecordsSource::~AliHLTMUONTriggerRecordsSource() | |
103 | { | |
104 | assert( fMCDataInterface == NULL ); | |
105 | assert( fDataInterface == NULL ); | |
106 | } | |
107 | ||
108 | ||
109 | int AliHLTMUONTriggerRecordsSource::DoInit(int argc, const char** argv) | |
110 | { | |
111 | assert( fMCDataInterface == NULL ); | |
112 | assert( fDataInterface == NULL ); | |
113 | ||
114 | // Parse the command line arguments: | |
115 | bool hitdata = false; | |
116 | bool simdata = false; | |
117 | bool recdata = false; | |
118 | fCurrentEvent = 0; | |
119 | bool firstEventSet = false; | |
120 | bool eventNumLitSet = false; | |
121 | ||
122 | for (int i = 0; i < argc; i++) | |
123 | { | |
124 | if (strcmp(argv[i], "-hitdata") == 0) | |
125 | { | |
126 | hitdata = true; | |
127 | } | |
128 | else if (strcmp(argv[i], "-simdata") == 0) | |
129 | { | |
130 | simdata = true; | |
131 | } | |
132 | else if (strcmp(argv[i], "-recdata") == 0) | |
133 | { | |
134 | recdata = true; | |
135 | } | |
136 | else if (strcmp(argv[i], "-plane") == 0) | |
137 | { | |
138 | i++; | |
139 | if (i >= argc) | |
140 | { | |
141 | Logging(kHLTLogError, | |
142 | "AliHLTMUONTriggerRecordsSource::DoInit", | |
143 | "Missing parameter", | |
144 | "Expected one of 'left', 'right' or 'all' after '-plane'." | |
145 | ); | |
146 | return EINVAL; | |
147 | } | |
148 | if (strcmp(argv[i], "left") == 0) | |
149 | fSelection = kLeftPlane; | |
150 | else if (strcmp(argv[i], "right") == 0) | |
151 | fSelection = kRightPlane; | |
152 | else if (strcmp(argv[i], "all") == 0) | |
153 | fSelection = kWholePlane; | |
154 | else | |
155 | { | |
156 | Logging(kHLTLogError, | |
157 | "AliHLTMUONTriggerRecordsSource::DoInit", | |
158 | "Invalid parameter", | |
159 | "The parameter '%s' is invalid and must be one of 'left'," | |
160 | " 'right' or 'all'.", | |
161 | argv[i] | |
162 | ); | |
163 | return EINVAL; | |
164 | } | |
165 | } | |
166 | else if (strcmp(argv[i], "-firstevent") == 0) | |
167 | { | |
168 | if (eventNumLitSet) | |
169 | { | |
170 | HLTWarning("The -firstevent flag is overridden by a" | |
171 | " previous use of -event_number_literal." | |
172 | ); | |
173 | } | |
174 | i++; | |
175 | if (i >= argc) | |
176 | { | |
177 | HLTError("Expected a positive number after -firstevent."); | |
178 | return EINVAL; | |
179 | } | |
180 | char* end = ""; | |
181 | long num = strtol(argv[i], &end, 0); | |
182 | if (*end != '\0' or num < 0) // Check if the conversion is OK. | |
183 | { | |
184 | HLTError(Form( | |
185 | "Expected a positive number after -firstevent" | |
186 | " but got: %s", argv[i] | |
187 | )); | |
188 | return EINVAL; | |
189 | } | |
190 | fCurrentEvent = Int_t(num); | |
191 | firstEventSet = true; | |
192 | } | |
193 | else if (strcmp(argv[i], "-event_number_literal") == 0) | |
194 | { | |
195 | if (firstEventSet) | |
196 | { | |
197 | HLTWarning("The -event_number_literal option will" | |
198 | " override -firstevent." | |
199 | ); | |
200 | } | |
201 | fCurrentEvent = -1; | |
202 | eventNumLitSet = true; | |
203 | } | |
204 | else | |
205 | { | |
206 | Logging(kHLTLogError, | |
207 | "AliHLTMUONTriggerRecordsSource::DoInit", | |
208 | "Unknown argument", | |
209 | "The argument '%s' is invalid.", | |
210 | argv[i] | |
211 | ); | |
212 | return EINVAL; | |
213 | } | |
214 | } | |
215 | ||
216 | // Check that one and only one of the the -hitdata, -simdata or | |
217 | // -recdata parameters was specified on the command line. | |
218 | if ((not hitdata and not simdata and not recdata) or | |
219 | (not hitdata and simdata and recdata) or | |
220 | (hitdata and not simdata and recdata) or | |
221 | (hitdata and simdata and not recdata) or | |
222 | (hitdata and simdata and recdata) | |
223 | ) | |
224 | { | |
225 | Logging(kHLTLogError, | |
226 | "AliHLTMUONTriggerRecordsSource::DoInit", | |
227 | "Missing arguments", | |
228 | "Must have one and only one of -hitdata, -simdata or -recdata specified." | |
229 | ); | |
230 | return EINVAL; | |
231 | } | |
232 | ||
233 | // Must load the mapping data for AliMpTriggerCrate::GetDdlId() //TODO AliMpTriggerCrate => AliMpDetElement | |
234 | // to return useful information later on. | |
235 | AliMpCDB::LoadDDLStore(); | |
236 | ||
237 | // Now we can initialise the data interface objects and loaders. | |
238 | fBuildFromHits = hitdata; | |
239 | if (hitdata or simdata) | |
240 | { | |
241 | const char* message = fBuildFromHits ? | |
242 | "Loading simulated GEANT hits with AliMUONMCDataInterface." | |
243 | : "Loading simulated local trigger objects with AliMUONMCDataInterface."; | |
244 | ||
245 | Logging(kHLTLogDebug, "AliHLTMUONTriggerRecordsSource::DoInit", | |
246 | "Data interface", message | |
247 | ); | |
248 | ||
249 | try | |
250 | { | |
251 | fMCDataInterface = new AliMUONMCDataInterface("galice.root"); | |
252 | } | |
253 | catch (const std::bad_alloc&) | |
254 | { | |
255 | Logging(kHLTLogError, | |
256 | "AliHLTMUONTriggerRecordsSource::DoInit", | |
257 | "Out of memory", | |
258 | "Not enough memory to allocate AliMUONMCDataInterface." | |
259 | ); | |
260 | return ENOMEM; | |
261 | } | |
262 | } | |
263 | else if (recdata) | |
264 | { | |
265 | Logging(kHLTLogDebug, | |
266 | "AliHLTMUONTriggerRecordsSource::DoInit", | |
267 | "Data interface", | |
268 | "Loading reconstructed local trigger objects with AliMUONDataInterface." | |
269 | ); | |
270 | ||
271 | try | |
272 | { | |
273 | fDataInterface = new AliMUONDataInterface("galice.root"); | |
274 | } | |
275 | catch (const std::bad_alloc&) | |
276 | { | |
277 | Logging(kHLTLogError, | |
278 | "AliHLTMUONTriggerRecordsSource::DoInit", | |
279 | "Out of memory", | |
280 | "Not enough memory to allocate AliMUONDataInterface." | |
281 | ); | |
282 | return ENOMEM; | |
283 | } | |
284 | } | |
285 | ||
286 | // Check that the fCurrentEvent number falls within the correct range. | |
287 | UInt_t maxevent = 0; | |
288 | if (fMCDataInterface != NULL) | |
289 | maxevent = UInt_t(fMCDataInterface->NumberOfEvents()); | |
290 | else if (fDataInterface != NULL) | |
291 | maxevent = UInt_t(fDataInterface->NumberOfEvents()); | |
292 | if (fCurrentEvent != -1 and UInt_t(fCurrentEvent) >= maxevent and maxevent != 0) | |
293 | { | |
294 | fCurrentEvent = 0; | |
295 | HLTWarning(Form("The selected first event number (%d) was larger than" | |
296 | " the available number of events (%d). Resetting the event" | |
297 | " counter to zero.", fCurrentEvent, maxevent | |
298 | )); | |
299 | } | |
300 | ||
301 | return 0; | |
302 | } | |
303 | ||
304 | ||
305 | int AliHLTMUONTriggerRecordsSource::DoDeinit() | |
306 | { | |
307 | if (fMCDataInterface != NULL) | |
308 | { | |
309 | delete fMCDataInterface; | |
310 | fMCDataInterface = NULL; | |
311 | } | |
312 | if (fDataInterface != NULL) | |
313 | { | |
314 | delete fDataInterface; | |
315 | fDataInterface = NULL; | |
316 | } | |
317 | return 0; | |
318 | } | |
319 | ||
320 | ||
321 | const char* AliHLTMUONTriggerRecordsSource::GetComponentID() | |
322 | { | |
323 | return AliHLTMUONConstants::TriggerRecordsSourceId(); | |
324 | } | |
325 | ||
326 | ||
327 | AliHLTComponentDataType AliHLTMUONTriggerRecordsSource::GetOutputDataType() | |
328 | { | |
329 | return AliHLTMUONConstants::TriggerRecordsBlockDataType(); | |
330 | } | |
331 | ||
332 | ||
333 | void AliHLTMUONTriggerRecordsSource::GetOutputDataSize( | |
334 | unsigned long& constBase, double& inputMultiplier | |
335 | ) | |
336 | { | |
337 | constBase = sizeof(AliHLTMUONTriggerRecordsBlockStruct) + | |
338 | sizeof(AliHLTMUONTriggerRecordStruct) * AliMUONConstants::NTriggerCircuit(); | |
339 | inputMultiplier = 0; | |
340 | } | |
341 | ||
342 | ||
343 | AliHLTComponent* AliHLTMUONTriggerRecordsSource::Spawn() | |
344 | { | |
345 | return new AliHLTMUONTriggerRecordsSource(); | |
346 | } | |
347 | ||
348 | ||
349 | int AliHLTMUONTriggerRecordsSource::GetEvent( | |
350 | const AliHLTComponentEventData& evtData, | |
351 | AliHLTComponentTriggerData& /*trigData*/, | |
352 | AliHLTUInt8_t* outputPtr, | |
353 | AliHLTUInt32_t& size, | |
354 | vector<AliHLTComponentBlockData>& outputBlocks | |
355 | ) | |
356 | { | |
357 | assert( fMCDataInterface != NULL or fDataInterface != NULL ); | |
358 | ||
359 | AliHLTInt32_t trigRecId = 0; | |
360 | ||
361 | // Check the size of the event descriptor structure. | |
362 | if (evtData.fStructSize < sizeof(AliHLTComponentEventData)) | |
363 | { | |
364 | Logging(kHLTLogError, | |
365 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
366 | "Invalid event descriptor", | |
367 | "The event descriptor (AliHLTComponentEventData) size is" | |
368 | " smaller than expected. It claims to be %d bytes, but" | |
369 | " we expect it to be %d bytes.", | |
370 | evtData.fStructSize, | |
371 | sizeof(AliHLTComponentEventData) | |
372 | ); | |
373 | size = 0; // Important to tell framework that nothing was generated. | |
374 | return EINVAL; | |
375 | } | |
376 | ||
377 | // Use the fEventID as the event number to load if fCurrentEvent == -1, | |
378 | // check it and load that event with the runloader. | |
379 | // If fCurrentEvent is a positive number then us it instead and | |
380 | // increment it. | |
381 | UInt_t eventnumber = UInt_t(evtData.fEventID); | |
382 | UInt_t maxevent = fMCDataInterface != NULL ? | |
383 | UInt_t(fMCDataInterface->NumberOfEvents()) | |
384 | : UInt_t(fDataInterface->NumberOfEvents()); | |
385 | if (fCurrentEvent != -1) | |
386 | { | |
387 | eventnumber = UInt_t(fCurrentEvent); | |
388 | fCurrentEvent++; | |
389 | if (UInt_t(fCurrentEvent) >= maxevent) | |
390 | fCurrentEvent = 0; | |
391 | } | |
392 | if ( eventnumber >= maxevent ) | |
393 | { | |
394 | Logging(kHLTLogError, | |
395 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
396 | "Bad event ID", | |
397 | "The event number (%d) is larger than the available number" | |
398 | " of events on file (%d).", | |
399 | eventnumber, | |
400 | maxevent | |
401 | ); | |
402 | size = 0; // Important to tell framework that nothing was generated. | |
403 | return EINVAL; | |
404 | } | |
405 | ||
406 | // Create and initialise a new data block. | |
407 | AliHLTMUONTriggerRecordsBlockWriter block(outputPtr, size); | |
408 | if (not block.InitCommonHeader()) | |
409 | { | |
410 | Logging(kHLTLogError, | |
411 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
412 | "Buffer too small", | |
413 | "There is not enough buffer space to create a new data block." | |
414 | " We require at least %d bytes but the buffer is only %d bytes.", | |
415 | sizeof(AliHLTMUONTriggerRecordsBlockWriter::HeaderType), | |
416 | block.BufferSize() | |
417 | ); | |
418 | size = 0; // Important to tell framework that nothing was generated. | |
419 | return ENOBUFS; | |
420 | } | |
421 | ||
422 | // Initialise the DDL list containing the DDLs which contributed to the | |
423 | // data block. These are required to create the specification word later. | |
424 | bool ddlList[22]; | |
425 | for (Int_t i = 0; i < 22; i++) | |
426 | ddlList[i] = false; | |
427 | ||
428 | if (fMCDataInterface != NULL and fBuildFromHits) | |
429 | { | |
430 | Logging(kHLTLogDebug, | |
431 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
432 | "Filling triggers", | |
433 | "Filling data block with trigger records from GEANT hits for event %d.", | |
434 | eventnumber | |
435 | ); | |
436 | ||
437 | // Loop over all tracks, extract the hits from chambers 11 to 14 and | |
438 | // create trigger records from them to write to the data block. | |
439 | Int_t ntracks = fMCDataInterface->NumberOfTracks(eventnumber); | |
440 | for (Int_t i = 0; i < ntracks; ++i) | |
441 | { | |
442 | AliMUONHit* hit11 = NULL; | |
443 | AliMUONHit* hit12 = NULL; | |
444 | AliMUONHit* hit13 = NULL; | |
445 | AliMUONHit* hit14 = NULL; | |
446 | Int_t ddl11 = -1; | |
447 | Int_t ddl12 = -1; | |
448 | Int_t ddl13 = -1; | |
449 | Int_t ddl14 = -1; | |
450 | ||
451 | AliMUONVHitStore* hitStore = fMCDataInterface->HitStore(eventnumber,i); | |
452 | AliMUONHit* hit; | |
453 | TIter next(hitStore->CreateIterator()); | |
454 | while ( ( hit = static_cast<AliMUONHit*>(next()) ) ) | |
455 | { | |
456 | // Select only hits on trigger chambers. | |
457 | if (hit->Chamber() <= AliMUONConstants::NTrackingCh()) continue; | |
458 | ||
459 | // Only select hits from the given part of the plane | |
460 | if (fSelection == kLeftPlane and not (hit->Xref() < 0)) continue; | |
461 | if (fSelection == kRightPlane and not (hit->Xref() >= 0)) continue; | |
462 | ||
463 | // Workout which DDL this hit should be readout of. | |
464 | Int_t ddl = FindDDLOfDetElement(hit->DetElemId()); | |
465 | if (not (0 <= ddl and ddl < 22)) | |
466 | { | |
467 | ddl = -1; | |
468 | Logging(kHLTLogError, | |
469 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
470 | "No DDL ID", | |
471 | "Could not find the DDL ID from which readout would take place." | |
472 | ); | |
473 | } | |
474 | ||
475 | switch (hit->Chamber()) | |
476 | { | |
477 | case 11: hit11 = hit; ddl11 = ddl; break; | |
478 | case 12: hit12 = hit; ddl12 = ddl; break; | |
479 | case 13: hit13 = hit; ddl13 = ddl; break; | |
480 | case 14: hit14 = hit; ddl14 = ddl; break; | |
481 | default: break; | |
482 | } | |
483 | } | |
484 | ||
485 | // Check that there are at least 3 of 4 hits on the trigger chambers. | |
486 | Int_t hitCount = 0; | |
487 | if (hit11 != NULL) hitCount++; | |
488 | if (hit12 != NULL) hitCount++; | |
489 | if (hit13 != NULL) hitCount++; | |
490 | if (hit14 != NULL) hitCount++; | |
491 | if (hitCount < 3) continue; | |
492 | ||
493 | AliHLTMUONTriggerRecordStruct* trigRec = block.AddEntry(); | |
494 | if (trigRec == NULL) | |
495 | { | |
496 | Logging(kHLTLogError, | |
497 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
498 | "Buffer overflow", | |
499 | "There is not enough buffer space to add more trigger records." | |
500 | " We overflowed the buffer which is only %d bytes.", | |
501 | block.BufferSize() | |
502 | ); | |
503 | size = 0; // Important to tell framework that nothing was generated. | |
504 | return ENOBUFS; | |
505 | } | |
506 | ||
507 | // Fill the new trigger record with the hit information. | |
508 | bool hitset[4] = {false, false, false, false}; | |
509 | AliHLTFloat32_t x1 = 0, y1 = 0, y2 = 0, z1 = 0, z2 = 0; | |
510 | if (hit11 != NULL) | |
511 | { | |
512 | trigRec->fHit[0].fX = hit11->Xref(); | |
513 | trigRec->fHit[0].fY = hit11->Yref(); | |
514 | trigRec->fHit[0].fZ = hit11->Zref(); | |
515 | hitset[0] = true; | |
516 | x1 = hit11->Xref(); | |
517 | y1 = hit11->Yref(); | |
518 | z1 = hit11->Zref(); | |
519 | } | |
520 | if (hit12 != NULL) | |
521 | { | |
522 | trigRec->fHit[1].fX = hit12->Xref(); | |
523 | trigRec->fHit[1].fY = hit12->Yref(); | |
524 | trigRec->fHit[1].fZ = hit12->Zref(); | |
525 | hitset[1] = true; | |
526 | x1 = hit12->Xref(); | |
527 | y1 = hit12->Yref(); | |
528 | z1 = hit12->Zref(); | |
529 | } | |
530 | if (hit13 != NULL) | |
531 | { | |
532 | trigRec->fHit[2].fX = hit13->Xref(); | |
533 | trigRec->fHit[2].fY = hit13->Yref(); | |
534 | trigRec->fHit[2].fZ = hit13->Zref(); | |
535 | hitset[2] = true; | |
536 | y2 = hit13->Yref(); | |
537 | z2 = hit13->Zref(); | |
538 | } | |
539 | if (hit14 != NULL) | |
540 | { | |
541 | trigRec->fHit[3].fX = hit14->Xref(); | |
542 | trigRec->fHit[3].fY = hit14->Yref(); | |
543 | trigRec->fHit[3].fZ = hit14->Zref(); | |
544 | hitset[3] = true; | |
545 | y2 = hit14->Yref(); | |
546 | z2 = hit14->Zref(); | |
547 | } | |
548 | ||
549 | bool calculated = AliHLTMUONCalculations::ComputeMomentum(x1, y1, y2, z1, z2); | |
550 | if (not calculated) | |
551 | Logging(kHLTLogDebug, | |
552 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
553 | "Calculation failure", | |
554 | "Something went wrong when calculating the momentum from" | |
555 | " x1 = %f, y1 = %f, y2 = %f, z1 = %f, z2 = %f.", | |
556 | x1, y1, y2, z1, z2 | |
557 | ); | |
558 | ||
559 | trigRec->fId = trigRecId++; | |
560 | trigRec->fFlags = AliHLTMUONUtils::PackTriggerRecordFlags( | |
561 | AliHLTMUONCalculations::Sign(), hitset | |
562 | ); | |
563 | trigRec->fPx = AliHLTMUONCalculations::Px(); | |
564 | trigRec->fPy = AliHLTMUONCalculations::Py(); | |
565 | trigRec->fPz = AliHLTMUONCalculations::Pz(); | |
566 | ||
567 | // Mark the DDLs over which this trigger record would be readout. | |
568 | if (ddl11 != -1) ddlList[ddl11] = true; | |
569 | if (ddl12 != -1) ddlList[ddl12] = true; | |
570 | if (ddl13 != -1) ddlList[ddl13] = true; | |
571 | if (ddl14 != -1) ddlList[ddl14] = true; | |
572 | } | |
573 | } | |
574 | else if (fMCDataInterface != NULL and not fBuildFromHits) | |
575 | { | |
576 | Logging(kHLTLogDebug, | |
577 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
578 | "Filling triggers", | |
579 | "Filling data block with simulated local triggers for event %d.", | |
580 | eventnumber | |
581 | ); | |
582 | ||
583 | AliFatal("Sorry, -simdata option not yet implemented!"); | |
584 | // TODO | |
585 | } | |
586 | else if (fDataInterface != NULL) | |
587 | { | |
588 | Logging(kHLTLogDebug, | |
589 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
590 | "Filling triggers", | |
591 | "Filling data block with reconstructed local triggers for event %d.", | |
592 | eventnumber | |
593 | ); | |
594 | // TODO | |
595 | AliFatal("Sorry, -recdata option not yet implemented!"); | |
596 | } | |
597 | else | |
598 | { | |
599 | Logging(kHLTLogError, | |
600 | "AliHLTMUONTriggerRecordsSource::GetEvent", | |
601 | "Missing data interface", | |
602 | "Neither AliMUONDataInterface nor AliMUONMCDataInterface were created." | |
603 | ); | |
604 | size = 0; // Important to tell framework that nothing was generated. | |
605 | return EFAULT; | |
606 | } | |
607 | ||
608 | AliHLTComponentBlockData bd; | |
609 | FillBlockData(bd); | |
610 | bd.fPtr = outputPtr; | |
611 | bd.fOffset = 0; | |
612 | bd.fSize = block.BytesUsed(); | |
613 | bd.fDataType = AliHLTMUONConstants::TriggerRecordsBlockDataType(); | |
614 | bd.fSpecification = AliHLTMUONUtils::PackSpecBits(ddlList); | |
615 | outputBlocks.push_back(bd); | |
616 | size = block.BytesUsed(); | |
617 | ||
618 | return 0; | |
619 | } |