]>
Commit | Line | Data |
---|---|---|
7e914051 | 1 | // $Id$ |
9c7b5023 | 2 | |
3 | /************************************************************************** | |
4 | * This file is property of and copyright by the ALICE HLT Project * | |
5 | * ALICE Experiment at CERN, All rights reserved. * | |
6 | * * | |
7 | * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> * | |
8 | * for The ALICE HLT Project. * | |
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 | /** @file AliRawReaderHLT.cxx | |
20 | @author Matthias Richter | |
21 | @date | |
22 | @brief AliRawReader implementation which replaces original input of | |
23 | detectors with the appropriate HLT output. */ | |
24 | ||
25 | // see header file for class documentation | |
26 | // or | |
27 | // refer to README to build package | |
28 | // or | |
29 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
30 | ||
31 | #include "AliRawReaderHLT.h" | |
13b78f4c | 32 | #include "AliHLTOUTRawReader.h" |
33 | #include "AliHLTModuleAgent.h" | |
626bfcc1 | 34 | #include "AliHLTOUTHandler.h" |
35 | #include "AliHLTOUTHandlerEquId.h" | |
a3ef3c1d | 36 | #include "AliHLTSystem.h" |
e3917543 | 37 | #include "AliLog.h" |
13b78f4c | 38 | #include "AliDAQ.h" // RAW, for detector names and equipment ids |
39 | #include "TObjString.h" | |
40 | #include <cassert> | |
9c7b5023 | 41 | |
42 | /** ROOT macro for the implementation of ROOT specific class methods */ | |
43 | ClassImp(AliRawReaderHLT) | |
44 | ||
45 | AliRawReaderHLT::AliRawReaderHLT(AliRawReader* pRawreader, const char* options) | |
46 | : | |
47 | AliRawReader(), | |
a3ef3c1d | 48 | AliHLTReconstructorBase(), |
9c7b5023 | 49 | fpParentReader(pRawreader), |
13b78f4c | 50 | fOptions(), |
a3ef3c1d | 51 | fSystemOptions(), |
13b78f4c | 52 | fpData(NULL), |
53 | fDataSize(0), | |
54 | fOffset(0), | |
d3833f99 | 55 | fPosition(0), |
13b78f4c | 56 | fEquipmentId(-1), |
57 | fbHaveHLTData(false), | |
58 | fDetectors(), | |
626bfcc1 | 59 | fpHLTOUT(NULL), |
44dc7683 | 60 | fbReadFirst(true), |
626bfcc1 | 61 | fpDataHandler(NULL) |
9c7b5023 | 62 | { |
63 | // see header file for class documentation | |
64 | // or | |
65 | // refer to README to build package | |
66 | // or | |
67 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
68 | fOptions=options; | |
13b78f4c | 69 | ScanOptions(options); |
9c7b5023 | 70 | } |
71 | ||
72 | AliRawReaderHLT::~AliRawReaderHLT() | |
73 | { | |
74 | // see header file for class documentation | |
d3833f99 | 75 | ReleaseHLTData(); |
9c7b5023 | 76 | } |
77 | ||
78 | UInt_t AliRawReaderHLT::GetType() const | |
79 | { | |
80 | // see header file for class documentation | |
81 | return fpParentReader->GetType(); | |
82 | } | |
83 | ||
84 | UInt_t AliRawReaderHLT::GetRunNumber() const | |
85 | { | |
86 | // see header file for class documentation | |
87 | return fpParentReader->GetRunNumber(); | |
88 | } | |
89 | ||
90 | const UInt_t* AliRawReaderHLT::GetEventId() const | |
91 | { | |
92 | // see header file for class documentation | |
93 | return fpParentReader->GetEventId(); | |
94 | } | |
95 | ||
96 | const UInt_t* AliRawReaderHLT::GetTriggerPattern() const | |
97 | { | |
98 | // see header file for class documentation | |
99 | return fpParentReader->GetTriggerPattern(); | |
100 | } | |
101 | ||
102 | const UInt_t* AliRawReaderHLT::GetDetectorPattern() const | |
103 | { | |
104 | // see header file for class documentation | |
105 | return fpParentReader->GetDetectorPattern(); | |
106 | } | |
107 | ||
108 | const UInt_t* AliRawReaderHLT::GetAttributes() const | |
109 | { | |
110 | // see header file for class documentation | |
111 | return fpParentReader->GetAttributes(); | |
112 | } | |
113 | ||
114 | const UInt_t* AliRawReaderHLT::GetSubEventAttributes() const | |
115 | { | |
116 | // see header file for class documentation | |
117 | return fpParentReader->GetSubEventAttributes(); | |
118 | } | |
119 | ||
120 | UInt_t AliRawReaderHLT::GetLDCId() const | |
121 | { | |
122 | // see header file for class documentation | |
123 | return fpParentReader->GetLDCId(); | |
124 | } | |
125 | ||
126 | UInt_t AliRawReaderHLT::GetGDCId() const | |
127 | { | |
128 | // see header file for class documentation | |
129 | return fpParentReader->GetGDCId(); | |
130 | } | |
131 | ||
132 | UInt_t AliRawReaderHLT::GetTimestamp() const | |
133 | { | |
134 | // see header file for class documentation | |
135 | return fpParentReader->GetTimestamp(); | |
136 | } | |
137 | ||
138 | const UInt_t* AliRawReaderHLT::GetEquipmentAttributes() const | |
139 | { | |
140 | // see header file for class documentation | |
141 | return fpParentReader->GetEquipmentAttributes(); | |
142 | } | |
143 | ||
144 | Int_t AliRawReaderHLT::GetEquipmentElementSize() const | |
145 | { | |
146 | // see header file for class documentation | |
13b78f4c | 147 | // don't know what it really means, bu the AliRawReaderFile |
148 | // just sets it to 0 | |
149 | // do the same if we have a valid equipment data set from | |
150 | // the HLT stream | |
151 | if (fEquipmentId>=0) return 0; | |
9c7b5023 | 152 | return fpParentReader->GetEquipmentElementSize(); |
153 | } | |
154 | ||
155 | Int_t AliRawReaderHLT::GetEquipmentHeaderSize() const | |
156 | { | |
157 | // see header file for class documentation | |
13b78f4c | 158 | |
159 | // equipment header means the additional data header? | |
160 | // if we have a valid equipment data set from the HLT stream | |
161 | // there is no additional header | |
162 | if (fEquipmentId>=0) return 0; | |
9c7b5023 | 163 | return fpParentReader->GetEquipmentHeaderSize(); |
164 | } | |
165 | ||
166 | Int_t AliRawReaderHLT::GetEquipmentSize() const | |
167 | { | |
168 | // see header file for class documentation | |
13b78f4c | 169 | if (fEquipmentId>=0) return fDataSize+sizeof(AliRawDataHeader); |
9c7b5023 | 170 | return fpParentReader->GetEquipmentSize(); |
171 | } | |
172 | ||
173 | Int_t AliRawReaderHLT::GetEquipmentType() const | |
174 | { | |
175 | // see header file for class documentation | |
176 | return fpParentReader->GetEquipmentType(); | |
177 | } | |
178 | ||
179 | Int_t AliRawReaderHLT::GetEquipmentId() const | |
180 | { | |
181 | // see header file for class documentation | |
13b78f4c | 182 | Int_t id=-1; |
183 | if (fEquipmentId>=0) id=fEquipmentId; | |
184 | else id=fpParentReader->GetEquipmentId(); | |
e3917543 | 185 | return id; |
9c7b5023 | 186 | } |
187 | ||
188 | Bool_t AliRawReaderHLT::ReadHeader() | |
189 | { | |
190 | // see header file for class documentation | |
e94eb049 | 191 | Bool_t result=kFALSE; |
d3833f99 | 192 | Bool_t firstParentCycle=fbHaveHLTData; |
193 | while (fbHaveHLTData=(fbHaveHLTData && ReadNextHLTData())) { | |
e94eb049 | 194 | // all internal data variables set |
195 | assert(fpData!=NULL); | |
196 | fHeader=reinterpret_cast<AliRawDataHeader*>(const_cast<AliHLTUInt8_t*>(fpData)); | |
d3833f99 | 197 | fOffset=sizeof(AliRawDataHeader); |
198 | fPosition=fOffset; | |
e94eb049 | 199 | if (result=IsSelected()) break; |
200 | } | |
d3833f99 | 201 | firstParentCycle&=!fbHaveHLTData; // true if it just changed from true to false |
202 | while (!result) { | |
203 | if (firstParentCycle) { | |
204 | firstParentCycle=kFALSE; | |
205 | // reset and set the selection back to the original one | |
206 | fpParentReader->Reset(); | |
207 | fpParentReader->SelectEquipment(fSelectEquipmentType, fSelectMinEquipmentId, fSelectMaxEquipmentId); | |
208 | } | |
e94eb049 | 209 | |
d3833f99 | 210 | if (!(result=fpParentReader->ReadHeader())) { |
211 | fHeader=NULL; | |
212 | break; | |
213 | } | |
e94eb049 | 214 | fHeader=const_cast<AliRawDataHeader*>(fpParentReader->GetDataHeader()); |
d3833f99 | 215 | |
216 | // filter out all equipment ids which should be taken from the HLT stream | |
217 | int id=fpParentReader->GetEquipmentId(); | |
218 | if (result=!IsHLTInput(id)) break; | |
e94eb049 | 219 | } |
e3917543 | 220 | return result; |
9c7b5023 | 221 | } |
222 | ||
223 | Bool_t AliRawReaderHLT::ReadNextData(UChar_t*& data) | |
224 | { | |
225 | // see header file for class documentation | |
13b78f4c | 226 | |
227 | // this function is the backbone of the ReadNext functions, it gets the | |
228 | // whole data block either from the HLT stream or the parent raw reader. | |
229 | // Each call of ReadNextData directly jumps to the next data set. | |
d3833f99 | 230 | Bool_t result=kTRUE; |
231 | ||
232 | // read new header if data already read | |
233 | if (fPosition<fDataSize || (result=ReadHeader())) { | |
44dc7683 | 234 | if (fbHaveHLTData && fpHLTOUT!=NULL) { |
d3833f99 | 235 | // all internal data variables set |
236 | result=kTRUE; | |
237 | data=const_cast<AliHLTUInt8_t*>(fpData+sizeof(AliRawDataHeader)); | |
13b78f4c | 238 | } else { |
d3833f99 | 239 | // no data in the HLT stream, read real data |
240 | //AliInfo(Form("read from parent reader: min=%d max=%d", fSelectMinEquipmentId, fSelectMaxEquipmentId)); | |
241 | ||
242 | // read data | |
243 | result=fpParentReader->ReadNextData(data); | |
244 | if (result) { | |
245 | fpData=data; | |
246 | fDataSize=fpParentReader->GetDataSize(); | |
247 | } else { | |
248 | fpData=NULL; | |
249 | fDataSize=0; | |
250 | } | |
251 | ||
252 | fEquipmentId=-1; | |
13b78f4c | 253 | } |
d3833f99 | 254 | fOffset=sizeof(AliRawDataHeader); |
255 | fPosition=fDataSize; | |
13b78f4c | 256 | } |
e3917543 | 257 | return result; |
9c7b5023 | 258 | } |
259 | ||
260 | Bool_t AliRawReaderHLT::ReadNextInt(UInt_t& data) | |
261 | { | |
262 | // see header file for class documentation | |
13b78f4c | 263 | int iCopy=sizeof(UInt_t); |
264 | UChar_t* dummy=NULL; | |
265 | do { | |
266 | if (fpData && (fDataSize-fOffset)>=iCopy) { | |
267 | data=*reinterpret_cast<const UInt_t*>(fpData+fOffset); | |
268 | fOffset+=iCopy; | |
269 | return kTRUE; | |
270 | } | |
271 | } while (ReadNextData(dummy)); | |
272 | return kFALSE; | |
9c7b5023 | 273 | } |
274 | ||
275 | Bool_t AliRawReaderHLT::ReadNextShort(UShort_t& data) | |
276 | { | |
277 | // see header file for class documentation | |
13b78f4c | 278 | int iCopy=sizeof(UShort_t); |
279 | UChar_t* dummy=NULL; | |
280 | do { | |
281 | if (fpData && (fDataSize-fOffset)>=iCopy) { | |
282 | data=*reinterpret_cast<const UShort_t*>(fpData+fOffset); | |
283 | fOffset+=iCopy; | |
284 | return kTRUE; | |
285 | } | |
286 | } while (ReadNextData(dummy)); | |
287 | return kFALSE; | |
9c7b5023 | 288 | } |
289 | ||
290 | Bool_t AliRawReaderHLT::ReadNextChar(UChar_t& data) | |
291 | { | |
292 | // see header file for class documentation | |
13b78f4c | 293 | int iCopy=sizeof(UChar_t); |
294 | UChar_t* dummy=NULL; | |
295 | do { | |
296 | if (fpData && (fDataSize-fOffset)>=iCopy) { | |
297 | data=*reinterpret_cast<const UChar_t*>(fpData+fOffset); | |
298 | fOffset+=iCopy; | |
299 | return kTRUE; | |
300 | } | |
301 | } while (ReadNextData(dummy)); | |
302 | return kFALSE; | |
9c7b5023 | 303 | } |
304 | ||
305 | Bool_t AliRawReaderHLT::ReadNext(UChar_t* data, Int_t size) | |
306 | { | |
307 | // see header file for class documentation | |
13b78f4c | 308 | UChar_t* dummy=NULL; |
309 | do { | |
310 | if (fpData && (fDataSize-fOffset)>=size) { | |
311 | // copy remaining data | |
312 | int iCopy=fDataSize-fOffset; | |
313 | if (iCopy>size) iCopy=size; | |
314 | memcpy(data, fpData+fOffset, iCopy); | |
315 | fOffset+=iCopy; | |
316 | return kTRUE; | |
317 | } | |
318 | } while (ReadNextData(dummy)); | |
319 | return kFALSE; | |
9c7b5023 | 320 | } |
321 | ||
322 | Bool_t AliRawReaderHLT::Reset() | |
323 | { | |
324 | // see header file for class documentation | |
44dc7683 | 325 | ReleaseHLTData(false/* keep HLTOUT instance */); |
13b78f4c | 326 | Bool_t result=fpParentReader->Reset(); |
13b78f4c | 327 | fEquipmentId=-1; |
626bfcc1 | 328 | |
d3833f99 | 329 | // check if redirection is enabled for at least one detector in the selected range |
330 | fbHaveHLTData=EvaluateSelection(); | |
626bfcc1 | 331 | |
44dc7683 | 332 | // start reading HLTOUT data blocks from the beginning |
333 | fbReadFirst=true; | |
334 | ||
13b78f4c | 335 | return result; |
9c7b5023 | 336 | } |
337 | ||
338 | Bool_t AliRawReaderHLT::NextEvent() | |
339 | { | |
340 | // see header file for class documentation | |
44dc7683 | 341 | |
342 | ReleaseHLTData(); | |
343 | ||
e3917543 | 344 | Bool_t result=fpParentReader->NextEvent(); |
13b78f4c | 345 | if (result) { |
346 | fEventNumber++; | |
347 | Reset(); | |
348 | } | |
e3917543 | 349 | return result; |
9c7b5023 | 350 | } |
351 | ||
352 | Bool_t AliRawReaderHLT::RewindEvents() | |
353 | { | |
354 | // see header file for class documentation | |
e3917543 | 355 | fEventNumber=-1; |
13b78f4c | 356 | Reset(); |
9c7b5023 | 357 | return fpParentReader->RewindEvents(); |
358 | } | |
359 | ||
e3917543 | 360 | void AliRawReaderHLT::Select(Int_t detectorID, Int_t minDDLID, Int_t maxDDLID) |
361 | { | |
13b78f4c | 362 | // see header file for class documentation |
e3917543 | 363 | AliRawReader::Select(detectorID, minDDLID, maxDDLID); |
364 | fpParentReader->Select(detectorID, minDDLID, maxDDLID); | |
d3833f99 | 365 | fbHaveHLTData=EvaluateSelection(); |
e3917543 | 366 | } |
367 | ||
368 | // most likely we do not need this method since the base class directly forwards | |
369 | // to this method | |
370 | // void AliRawReaderHLT::Select(const char *detectorName, Int_t minDDLID, Int_t maxDDLID) | |
371 | // { | |
372 | // AliInfo(Form("detectorName=%s, minDDLID=%d, maxDDLID=%d", detectorName, minDDLID, maxDDLID)); | |
373 | // AliRawReader::Select(detectorName, minDDLID, maxDDLID); | |
374 | // fpParentReader->Select(detectorName, minDDLID, maxDDLID); | |
375 | // } | |
376 | ||
377 | void AliRawReaderHLT::SelectEquipment(Int_t equipmentType, Int_t minEquipmentId, Int_t maxEquipmentId) | |
378 | { | |
13b78f4c | 379 | // see header file for class documentation |
380 | ||
093f4dba | 381 | //AliInfo(Form("equipmentType=%d, minEquipmentId=%d, maxEquipmentId=%d", equipmentType, minEquipmentId, maxEquipmentId)); |
d3833f99 | 382 | AliRawReader::SelectEquipment(equipmentType, minEquipmentId, maxEquipmentId); |
383 | fpParentReader->SelectEquipment(equipmentType, minEquipmentId, maxEquipmentId); | |
384 | fbHaveHLTData=EvaluateSelection(); | |
e3917543 | 385 | } |
386 | ||
387 | void AliRawReaderHLT::SkipInvalid(Bool_t skip) | |
388 | { | |
13b78f4c | 389 | // see header file for class documentation |
390 | ||
e3917543 | 391 | AliRawReader::SkipInvalid(skip); |
392 | fpParentReader->SkipInvalid(skip); | |
393 | } | |
394 | ||
395 | void AliRawReaderHLT::SelectEvents(Int_t type) | |
396 | { | |
13b78f4c | 397 | // see header file for class documentation |
398 | ||
093f4dba | 399 | //AliInfo(Form("type=%d", type)); |
e3917543 | 400 | AliRawReader::SelectEvents(type); |
401 | fpParentReader->SelectEvents(type); | |
402 | } | |
403 | ||
13b78f4c | 404 | int AliRawReaderHLT::ScanOptions(const char* options) |
405 | { | |
406 | // see header file for class documentation | |
407 | int iResult=0; | |
408 | TString optString(options); | |
409 | TString argument; | |
410 | TString parameter; | |
411 | TObjArray* pTokens=optString.Tokenize(" "); | |
412 | if (pTokens) { | |
413 | int iEntries=pTokens->GetEntries(); | |
414 | for (int i =0; i<iEntries; i++) { | |
415 | argument=((TObjString*)pTokens->At(i))->GetString(); | |
416 | // first scan all the other options | |
417 | // no other options for the moment | |
418 | ||
419 | // it must be a detector name | |
420 | int detId=AliDAQ::DetectorID(argument.Data()); | |
421 | if (detId>=0) { | |
422 | fDetectors.push_back(detId); | |
a3ef3c1d | 423 | } else { |
424 | if (!fSystemOptions.IsNull()) fSystemOptions+=" "; | |
425 | fSystemOptions+=argument; | |
13b78f4c | 426 | } |
427 | } | |
428 | delete pTokens; | |
429 | } | |
430 | ||
431 | return iResult; | |
432 | } | |
433 | ||
434 | Bool_t AliRawReaderHLT::ReadNextHLTData() | |
435 | { | |
436 | // see header file for class documentation | |
437 | bool result=kTRUE; | |
44dc7683 | 438 | if (fbReadFirst || !fpHLTOUT) { |
439 | if (!fpHLTOUT) { | |
13b78f4c | 440 | fpHLTOUT=new AliHLTOUTRawReader(fpParentReader); |
441 | if (result=(fpHLTOUT!=NULL)) { | |
a3ef3c1d | 442 | AliHLTSystem* pSystem=GetInstance(); |
443 | if (pSystem) { | |
444 | pSystem->ScanOptions(fSystemOptions.Data()); | |
445 | } | |
13b78f4c | 446 | if (result=(fpHLTOUT->Init()>=0)) { |
13b78f4c | 447 | } |
448 | } | |
44dc7683 | 449 | } |
450 | if (result) { | |
451 | result=fpHLTOUT->SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec, | |
452 | AliHLTModuleAgent::kRawReader)>=0; | |
453 | } | |
454 | fbReadFirst=false; | |
13b78f4c | 455 | } else { |
626bfcc1 | 456 | // first release the data buffer |
d3833f99 | 457 | ReleaseHLTData(false /* keep HLTOUT instance */); |
458 | result=fpHLTOUT->SelectNextDataBlock()>=0; | |
13b78f4c | 459 | } |
460 | if (result) { | |
626bfcc1 | 461 | AliHLTComponentDataType dt=kAliHLTVoidDataType; |
462 | AliHLTUInt32_t spec=kAliHLTVoidDataSpec; | |
463 | fpHLTOUT->GetDataBlockDescription(dt, spec); | |
13b78f4c | 464 | AliHLTUInt32_t size=0; |
626bfcc1 | 465 | AliHLTOUTHandler* pHandler=fpHLTOUT->GetHandler(); |
466 | if (pHandler) { | |
467 | if (dynamic_cast<AliHLTOUTHandlerEquId*>(pHandler)!=NULL) { | |
468 | AliHLTOUT::AliHLTOUTLockGuard g(fpHLTOUT); | |
469 | fEquipmentId=pHandler->ProcessData(fpHLTOUT); | |
470 | fpData=NULL; | |
471 | fDataSize=pHandler->GetProcessedData(fpData); | |
472 | if (!fpData) { | |
473 | result=fpHLTOUT->GetDataBuffer(fpData, size)>=0; | |
44dc7683 | 474 | fpDataHandler=NULL; |
626bfcc1 | 475 | AliDebug(AliLog::kDebug, Form("forward data block from HLTOUT stream to equipment %d", fEquipmentId)); |
476 | fDataSize=(int)size; | |
477 | } else { | |
478 | // remember the current handler in order to properly release the data buffer | |
479 | fpDataHandler=pHandler; | |
480 | AliDebug(AliLog::kDebug, Form("forward decoded data block provided by handler to equipment %d", fEquipmentId)); | |
481 | } | |
e94eb049 | 482 | return kTRUE; |
626bfcc1 | 483 | } else { |
484 | AliError(Form("handler is not of type AliHLTOUTHandlerEquId for block %x data type %s spec %#x; data block skipped", | |
485 | fpHLTOUT->GetDataBlockIndex(), AliHLTComponent::DataType2Text(dt).c_str(), spec)); | |
486 | } | |
487 | } else { | |
488 | AliWarning(Form("no data handler found for block %x data type %s spec %#x; data block skipped", | |
489 | fpHLTOUT->GetDataBlockIndex(), AliHLTComponent::DataType2Text(dt).c_str(), spec)); | |
490 | } | |
13b78f4c | 491 | } else { |
44dc7683 | 492 | ReleaseHLTData(false /* keep HLTOUT instance */); |
13b78f4c | 493 | } |
e94eb049 | 494 | return kFALSE; |
13b78f4c | 495 | } |
496 | ||
497 | Bool_t AliRawReaderHLT::IsHLTInput(int ddlid) | |
498 | { | |
499 | // see header file for class documentation | |
500 | vector<int>::iterator detector=fDetectors.begin(); | |
501 | for (; detector!=fDetectors.end(); detector++) { | |
502 | int ddlOffset=AliDAQ::DdlIDOffset(*detector); | |
503 | int nofDDLs=AliDAQ::NumberOfDdls(*detector); | |
504 | if (ddlid>=ddlOffset && ddlid<ddlOffset+nofDDLs) | |
505 | return kTRUE; | |
506 | } | |
507 | return kFALSE; | |
508 | } | |
509 | ||
d3833f99 | 510 | int AliRawReaderHLT::ReleaseHLTData(bool bReleaseHLTOUT) |
511 | { | |
512 | // see header file for class documentation | |
513 | if (fpHLTOUT) { | |
514 | if (fpDataHandler) fpDataHandler->ReleaseProcessedData(fpData, fDataSize); | |
515 | else fpHLTOUT->ReleaseDataBuffer(fpData); | |
516 | fpDataHandler=NULL; | |
517 | if (bReleaseHLTOUT) { | |
518 | delete fpHLTOUT; | |
519 | fpHLTOUT=NULL; | |
520 | } | |
521 | } | |
522 | ||
523 | fpData=NULL; | |
524 | fDataSize=0; | |
525 | fOffset=0; | |
526 | fPosition=0; | |
527 | fEquipmentId=-1; | |
528 | ||
529 | return 0; | |
530 | } | |
531 | ||
532 | Bool_t AliRawReaderHLT::EvaluateSelection() | |
533 | { | |
534 | // see header file for class documentation | |
535 | Bool_t bHaveHLTData=kFALSE; | |
536 | if (bHaveHLTData=(fDetectors.size()>0)) { | |
537 | vector<int>::iterator detector=fDetectors.begin(); | |
538 | for (; detector!=fDetectors.end(); detector++) { | |
539 | int ddlOffset=AliDAQ::DdlIDOffset(*detector); | |
540 | int nofDDLs=AliDAQ::NumberOfDdls(*detector); | |
541 | if ((fSelectMinEquipmentId<0 || fSelectMinEquipmentId<ddlOffset+nofDDLs) && | |
542 | (fSelectMaxEquipmentId<0 || fSelectMaxEquipmentId>=ddlOffset)) | |
543 | break; | |
544 | } | |
545 | bHaveHLTData=detector!=fDetectors.end(); | |
546 | } | |
547 | return bHaveHLTData; | |
548 | } | |
549 | ||
9c7b5023 | 550 | AliRawReader* AliRawReaderHLTCreateInstance(AliRawReader* pParentReader, const char* options) |
551 | { | |
552 | // see header file for class documentation | |
e3917543 | 553 | if (!pParentReader) return NULL; |
9c7b5023 | 554 | return new AliRawReaderHLT(pParentReader, options); |
555 | } |