add calibration histograms for vzero centroids
[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDMonitorComponent.cxx
CommitLineData
ce6fd1b1 1// $Id$
2//**************************************************************************
3//* This file is property of and copyright by the ALICE HLT Project *
4//* ALICE Experiment at CERN, All rights reserved. *
5//* *
6//* *
7//* Permission to use, copy, modify and distribute this software and its *
8//* documentation strictly for non-commercial purposes is hereby granted *
9//* without fee, provided that the above copyright notice appears in all *
10//* copies and that both the copyright notice and this permission notice *
11//* appear in the supporting documentation. The authors make no claims *
12//* about the suitability of this software for any purpose. It is *
13//* provided "as is" without express or implied warranty. *
14//**************************************************************************
15
16/// @file AliHLTTRDMonitorComponent.cxx
17/// @author Felix Rettig, Stefan Kirsch
18/// @date 2011-08-02
19/// @brief A processing component for TRD tracking/trigger data on FEP-level
20/// @ingroup alihlt_trd_components
21
22#include "AliHLTTRDMonitorComponent.h"
23#include "AliLog.h"
24#include "AliHLTDataTypes.h"
25#include "AliRawReaderMemory.h"
26#include "AliHLTTRDDefinitions.h"
27
28#include "AliTRDdigitsManager.h"
29#include "AliTRDrawStream.h"
30#include "AliTRDtrackletWord.h"
31#include "AliESDTrdTracklet.h"
32#include "AliESDTrdTrack.h"
33
34#include "TH1I.h"
35#include "TH2I.h"
36#include "TH1F.h"
37
38
39/** ROOT macro for the implementation of ROOT specific class methods */
40ClassImp(AliHLTTRDMonitorComponent)
41
42AliHLTTRDMonitorComponent::AliHLTTRDMonitorComponent()
43 : AliHLTProcessor()
44 , fTrackletArray(NULL)
45 , fGtuTrackArray(NULL)
46 , fRawReaderMem(NULL)
47 , fDigitsManagerTrd(NULL)
48 , fRawReaderTrd(NULL)
49 , fHistArray(NULL)
50 , fHistTrackletY(NULL)
51 , fHistTrackletDy(NULL)
52 , fHistTrackletZ(NULL)
53 , fHistTrackletPID(NULL)
54 , fHistTrackletYDy(NULL)
55 , fHistTrackletHC(NULL)
56 , fHistTrackletBadY(NULL)
57 , fHistTrackletBadPID(NULL)
58 , fHistFirstTrackletTime(NULL)
59 , fHistLastTrackletTime(NULL)
60 , fHistTmuTime(NULL)
61 , fHistSmuTime(NULL)
62 , fHistTrackPt(NULL)
63 , fHistTrackStack(NULL)
64 , fHistTrackletsTrack(NULL)
65 , fHistTrackletsTrackHpt(NULL)
66 , fHistTrackPID(NULL)
67 , fHistTriggerContribs(NULL)
68{
69 // constructor
70}
71
72AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent()
73{
74 // destructor
75}
76
77const char* AliHLTTRDMonitorComponent::GetComponentID()
78{
79 // component property: id
80 return "TRDMonitorComponent";
81}
82
83void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
84{
85 // component property: list of input data types
86 list.push_back(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD);
87}
88
89AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType()
90{
91 // component property: output data type
92 return kAliHLTMultipleDataType;
93}
94
95int AliHLTTRDMonitorComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
96
97{
98 // see header file for class documentation
99 tgtList.clear();
100 // tgtList.push_back(AliHLTTRDDefinitions::fgkSimpleIntegerDataType);
101 tgtList.push_back(kAliHLTDataTypeTObject | kAliHLTDataOriginTRD);
102 return tgtList.size();
103}
104
105void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
106{
107 // component property: output size estimator
108 constBase = 5000000;
109 inputMultiplier = 0;
110}
111
112void AliHLTTRDMonitorComponent::GetOCDBObjectDescription( TMap* const /*targetMap*/)
113{
114 // Get a list of OCDB object description.
115 // The list of objects is provided in a TMap
116 // - key: complete OCDB path, e.g. GRP/GRP/Data
117 // - value: short description why the object is needed
118 // Key and value objects created inside this class go into ownership of
119 // target TMap.
120 //if (!targetMap) return;
121 //targetMap->Add(new TObjString("HLT/ConfigSample/SampleRawAnalysis"),
122 // new TObjString("configuration object"));
123}
124
125AliHLTComponent* AliHLTTRDMonitorComponent::Spawn()
126{
127 // Spawn function, return new class instance
128 return new AliHLTTRDMonitorComponent;
129}
130
131int AliHLTTRDMonitorComponent::DoInit( int /*argc*/, const char** /*argv*/ )
132{
133
134 int iResult=0;
135
136 // init stage 1: default values for all data members
137
138 // init stage 2: read configuration object
139 // ScanConfigurationArgument() needs to be implemented
140 // HLT component configuration objects are located in the HLT/ConfigDET
141 // of the OCDB. TObjString configuration objects can be generated with
142 // the macro HLT/exa/makeComponentConfigurationObject.C, e.g.
143 // aliroot -b -q -l $ALICE_ROOT/HLT/exa/makeComponentConfigurationObject.C'("HLT/ConfigSample/SampleRawAnalysis", "")'
144 //TString cdbPath="HLT/ConfigSample/";
145 //cdbPath+=GetComponentID();
146 //iResult=ConfigureFromCDBTObjString(cdbPath);
147
148 // init stage 3: read the component arguments
149 //if (iResult>=0) {
150 // iResult=ConfigureFromArgumentString(argc, argv);
151 //}
152
153 // implement the component initialization
154 do {
155 if (iResult<0) break;
156
157 fRawReaderMem = new AliRawReaderMemory;
158 if (!fRawReaderMem) {
159 iResult=-ENOMEM;
160 break;
161 }
162
163 fTrackletArray = new TClonesArray("AliTRDtrackletWord", 500);
164 if (!fTrackletArray) {
165 iResult=-ENOMEM;
166 break;
167 }
168
169 fGtuTrackArray = new TClonesArray("AliESDTrdTrack", 50);
170 if (!fGtuTrackArray){
171 iResult=-ENOMEM;
172 break;
173 }
174
175 fDigitsManagerTrd = new AliTRDdigitsManager();
176 if (!fDigitsManagerTrd) {
177 iResult=-ENOMEM;
178 break;
179 }
180 fDigitsManagerTrd->CreateArrays();
181
182 fRawReaderTrd = new AliTRDrawStream(fRawReaderMem);
183 if (!fRawReaderTrd) {
184 iResult=-ENOMEM;
185 break;
186 }
187
188 fRawReaderTrd->SetDigitsManager(fDigitsManagerTrd);
189 // fRawReaderTrd->SetDigitsManager(NULL); // FIXME may be used to improve performance, needs a fix to be committed by TRD
190 fRawReaderTrd->SetTrackletArray(fTrackletArray);
191 fRawReaderTrd->SetTrackArray(fGtuTrackArray);
192
193 // Disable raw reader error messages that could flood HLT logbook
194 fRawReaderTrd->SetErrorDebugLevel( AliTRDrawStream::kLinkMonitor, 1 );
195
196 fHistArray = new TObjArray(25);
197 if(!fHistArray){
198 return -ENOMEM;
199 break;
200 }
201 fHistArray->SetOwner(kTRUE);
202
203 fHistTrackletY = new TH1I("hist_tracklets_y", "Y-Position of online tracklets", 256, -4096, 4096);
204 if (!fHistTrackletY){
205 return -ENOMEM;
206 break;
207 }
208 fHistArray->AddLast(fHistTrackletY);
209
210 fHistTrackletDy = new TH1I("hist_tracklets_dy", "Deflection of online tracklets", 128, -64, 64);
211 if (!fHistTrackletDy){
212 return -ENOMEM;
213 break;
214 }
215 fHistArray->AddLast(fHistTrackletDy);
216
217 fHistTrackletZ = new TH1I("hist_tracklets_z", "Z-Position of online tracklets", 12, 0, 12);
218 if (!fHistTrackletZ){
219 return -ENOMEM;
220 break;
221 }
222 fHistArray->AddLast(fHistTrackletZ);
223
224 fHistTrackletPID = new TH1I("hist_tracklets_pid", "PID of online tracklets", 256, 0, 256);
225 if (!fHistTrackletPID){
226 return -ENOMEM;
227 break;
228 }
229 fHistArray->AddLast(fHistTrackletPID);
230
231 fHistTrackletYDy = new TH2I("hist_tracklets_y_dy", "Tracklet deflection vs. tracklet position", 256, -4096, 4096, 64, -64, 64);
232 if (!fHistTrackletYDy){
233 return -ENOMEM;
234 break;
235 }
236 fHistArray->AddLast(fHistTrackletYDy);
237
238 fHistTrackletHC = new TH2I("hist_tracklets_hc", "Number of online tracklets by HC", 18, 0, 18, 60, 0, 60);
239 if (!fHistTrackletHC){
240 return -ENOMEM;
241 break;
242 }
243 fHistArray->AddLast(fHistTrackletHC);
244
245 fHistTrackletBadY = new TH2I("hist_tracklets_bad_y", "Number of online tracklets with bad y-position by HC", 18, 0, 18, 5, 0, 5);
246 if (!fHistTrackletBadY){
247 return -ENOMEM;
248 break;
249 }
250 fHistArray->AddLast(fHistTrackletBadY);
251
252 fHistTrackletBadPID = new TH2I("hist_tracklets_bad_pid", "Number of online tracklets with bad y-position by HC", 18, 0, 18, 5, 0, 5);
253 if (!fHistTrackletBadPID){
254 return -ENOMEM;
255 break;
256 }
257 fHistArray->AddLast(fHistTrackletBadPID);
258
259 fHistFirstTrackletTime = new TH1F("hist_first_tracklet_time", "Arrival time of first tracklet", 160, 0., 8.);
260 if (!fHistFirstTrackletTime){
261 return -ENOMEM;
262 break;
263 }
264 fHistArray->AddLast(fHistFirstTrackletTime);
265
266 fHistLastTrackletTime = new TH1F("hist_last_tracklet_time", "Arrival time of last tracklet", 160, 0., 8.);
267 if (!fHistLastTrackletTime){
268 return -ENOMEM;
269 break;
270 }
271 fHistArray->AddLast(fHistLastTrackletTime);
272
273 fHistTmuTime = new TH1F("hist_tmu_time", "Tracking done time at TMU-level", 160, 0., 8.);
274 if (!fHistTmuTime){
275 return -ENOMEM;
276 break;
277 }
278 fHistArray->AddLast(fHistTmuTime);
279
280 fHistSmuTime = new TH1F("hist_smu_time", "Tracking done time at SMU-level", 160, 0., 8.);
281 if (!fHistSmuTime){
282 return -ENOMEM;
283 break;
284 }
285 fHistArray->AddLast(fHistSmuTime);
286
287 fHistTrackPt = new TH1F("hist_tracks_pt", "Transverse momentum of GTU tracks", 100, 0., 20.);
288 if (!fHistTrackPt){
289 return -ENOMEM;
290 break;
291 }
292 fHistArray->AddLast(fHistTrackPt);
293
294 fHistTrackPID = new TH1I("hist_tracks_pid", "PID of online tracks", 256, 0, 256);
295 if (!fHistTrackPID){
296 return -ENOMEM;
297 break;
298 }
299 fHistArray->AddLast(fHistTrackPID);
300
301 fHistTrackStack = new TH2I("hist_tracks_stack", "Number of GTU tracks by stack", 18, 0, 18, 5, 0, 5);
302 if (!fHistTrackStack){
303 return -ENOMEM;
304 break;
305 }
306 fHistArray->AddLast(fHistTrackStack);
307
308 fHistTrackletsTrack = new TH1I("hist_tracklets_track", "Tracklets per GTU track", 7, 0, 7);
309 if (!fHistTrackletsTrack){
310 return -ENOMEM;
311 break;
312 }
313 fHistArray->AddLast(fHistTrackletsTrack);
314
315 fHistTrackletsTrackHpt = new TH1I("hist_tracklets_track_hpt", "Tracklets per high-pt GTU track", 7, 0, 7);
316 if (!fHistTrackletsTrackHpt){
317 return -ENOMEM;
318 break;
319 }
320 fHistArray->AddLast(fHistTrackletsTrackHpt);
321
322 fHistTriggerContribs = new TH2I("hist_trigger_contribs", "Trigger contributions by segment", 18, 0, 18, 12, 0, 12);
323 if (!fHistTriggerContribs){
324 return -ENOMEM;
325 break;
326 }
327 fHistArray->AddLast(fHistTriggerContribs);
328
329 } while (0);
330
331 if (iResult<0) {
332 // implement cleanup
333 if (fRawReaderMem) delete fRawReaderMem;
334 fRawReaderMem=NULL;
335
336 if (fRawReaderTrd) delete fRawReaderTrd;
337 fRawReaderTrd=NULL;
338
339 if (fTrackletArray) delete fTrackletArray;
340 fTrackletArray = NULL;
341
342 if (fGtuTrackArray) delete fGtuTrackArray;
343 fGtuTrackArray = NULL;
344
345 if (fHistArray) delete fHistArray;
346 fHistArray = NULL;
347
348 fHistTrackletY = NULL;
349 fHistTrackletDy = NULL;
350 fHistTrackletZ = NULL;
351 fHistTrackletPID = NULL;
352 fHistTrackletYDy = NULL;
353 fHistTrackletHC = NULL;
354 fHistTrackletBadY = NULL;
355 fHistTrackletBadPID = NULL;
356 fHistTrackPt = NULL;
357 fHistTrackStack = NULL;
358 fHistFirstTrackletTime = NULL;
359 fHistLastTrackletTime = NULL;
360 fHistTmuTime = NULL;
361 fHistSmuTime = NULL;
362 fHistTrackPt = NULL;
363 fHistTrackStack = NULL;
364 fHistTrackletsTrack = NULL;
365 fHistTrackletsTrackHpt = NULL;
366 fHistTrackPID = NULL;
367 fHistTriggerContribs = NULL;
368 }
369
370 return iResult;
371}
372
373int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int /*argc*/, const char** /*argv*/)
374{
375 // Scan configuration arguments
376 // Return the number of processed arguments
377 // -EPROTO if argument format error (e.g. number expected but not found)
378 //
379 // The AliHLTComponent base class implements a parsing loop for argument strings and
380 // arrays of strings which is invoked by ConfigureFromArgumentString/ConfigureFromCDBTObjString
381 // The component needs to implement ScanConfigurationArgument in order to decode the arguments.
382
383 /*
384 int i=0;
385 TString argument=argv[i];
386
387 if (argument.IsNull()) return 0;
388
389 // -mandatory1 arg
390 if (argument.CompareTo("-mandatory1")==0) {
391 if (++i>=argc) return -EINVAL;
392 HLTInfo("got \'-mandatory1\' argument: %s", argv[i]);
393 return 2; // keyword + 1 argument
394 }
395
396 // -optional1 arg
397 if (argument.CompareTo("-optional1")==0) {
398 if (++i>=argc) return -EINVAL;
399 HLTInfo("got \'-optional1\' argument: %s", argv[i]);
400 return 2; // keyword + 1 argument
401 }
402
403 // -verbose
404 if (argument.CompareTo("-verbose")==0) {
405 fVerbosity=1;
406 return 1; // only keyword
407 }
408 */
409 return 0;
410}
411
412int AliHLTTRDMonitorComponent::DoDeinit()
413{
414 // component cleanup, delete all instances of helper classes here
415 if (fRawReaderMem) delete fRawReaderMem;
416 fRawReaderMem=NULL;
417
418 if (fRawReaderTrd) delete fRawReaderTrd;
419 fRawReaderTrd=NULL;
420
421 if (fTrackletArray) delete fTrackletArray;
422 fTrackletArray = NULL;
423
424 if (fGtuTrackArray) delete fGtuTrackArray;
425 fGtuTrackArray = NULL;
426
427 if (fHistArray) delete fHistArray;
428 fHistArray = NULL;
429
430 fHistTrackletY = NULL;
431 fHistTrackletDy = NULL;
432 fHistTrackletY = NULL;
433 fHistTrackletDy = NULL;
434 fHistTrackletZ = NULL;
435 fHistTrackletPID = NULL;
436 fHistTrackletHC = NULL;
437 fHistTrackletBadY = NULL;
438 fHistTrackletBadPID = NULL;
439 fHistFirstTrackletTime = NULL;
440 fHistLastTrackletTime = NULL;
441 fHistTmuTime = NULL;
442 fHistSmuTime = NULL;
443 fHistTrackPt = NULL;
444 fHistTrackStack = NULL;
445 fHistTrackletsTrack = NULL;
446 fHistTrackletsTrackHpt = NULL;
447 fHistTrackPID = NULL;
448 fHistTriggerContribs = NULL;
449
450 return 0;
451}
452
453int AliHLTTRDMonitorComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/,
454 AliHLTComponentTriggerData& /*trigData*/)
455{
456 // event processing function
457 int iResult=0;
458
459 // check if this is a data event, there are a couple of special events
460 // which should be ignored for normal processing
461 if (!IsDataEvent()) return 0;
462
463 // #FIXME: Also take care of SOR, EOR, etc...
464
465 // loop over the raw input data blocks and set up the rawreader
466 for (const AliHLTComponentBlockData* pBlock = GetFirstInputBlock(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTRD);
467 pBlock!=NULL && iResult>=0;
468 pBlock=GetNextInputBlock()) {
469 // extract DDL id from specification
470 int ddlnum=-1;
471 for (unsigned pos=0; pos<8*sizeof(AliHLTUInt32_t); pos++) {
472 if (pBlock->fSpecification & (0x1<<pos)) {
473 if (ddlnum>=0) {
474 // this is just an example, please avoid warnings in every event since those will
475 // saturate the logging system. Consider AliHLTErrorGuard for such cases, e.g.
476 // ALIHLTERRORGUARD(5, "nasty error, first occurence in event %d", event);
477 // this will show the error 5 times and then a summary at the end
478 HLTWarning("Can not uniquely identify DDL number from specification, skipping data block %s 0x%08x",
479 DataType2Text(pBlock->fDataType).c_str(),
480 pBlock->fSpecification);
481 ddlnum=-1;
482 break;
483 }
484 ddlnum=pos;
485 }
486 }
487 if (ddlnum<0) continue;
488 ddlnum += 1024;
489
490 // add data block to rawreader
491 if(!fRawReaderMem->AddBuffer((UChar_t*) pBlock->fPtr, pBlock->fSize, ddlnum)){
492 HLTError("Could not add buffer of data block %s, 0x%08x to rawreader",
493 DataType2Text(pBlock->fDataType).c_str(),
494 pBlock->fSpecification);
495 continue;
496 }
497
498 // read and process TRD tracklet and GTU tracks from event
499 fTrackletArray->Clear();
500 fGtuTrackArray->Clear();
501 fRawReaderTrd->ReadEvent();
502
503 // read and process tracking/trigger flags
504 UInt_t iSector = ddlnum-1024;
505 UInt_t trgflags = fRawReaderTrd->GetTriggerFlags(iSector);
506 //UInt_t done_tmu = (trgflags >> 27) & 0x1f;
507 //UInt_t done_smu = (trgflags >> 22) & 0x1f;
508 Float_t smu_timing = ((trgflags >> 12) & 0x3ff) * 0.0083333; // tracking finished after L0, in us
509 UInt_t ctb_fired = trgflags & 0xfff;
510
511 /*
512 printf("Trigger flags sector %02d: 0x%08x - ctb=0x%03x tmu-done=0x%x smu-done=0x%x smu-time: %.2fus\n",
513 iSector, trgflags,
514 ctb_fired,
515 done_tmu,
516 done_smu,
517 smu_timing
518 );
519 */
520 fHistSmuTime->Fill(smu_timing);
521
522 for (int iCtb=0; iCtb<12; iCtb++){
523 if ((ctb_fired >> iCtb) & 1)
524 fHistTriggerContribs->Fill(iSector, iCtb, 1);
525 }
526
527 Float_t first_tracklet_timing[5]={0};
528 Float_t last_tracklet_timing[5]={0};
529 Float_t tmu_timing[5]={0};
530 ULong64_t trkflags;
531
532 for (int iStack=0; iStack<5; iStack++){
533 trkflags = fRawReaderTrd->GetTrkFlags(iSector, iStack);
534 tmu_timing[iStack]=(trkflags & 0x3ff) * 0.02;
535 first_tracklet_timing[iStack]=((trkflags >> 20) & 0x3ff) * 0.008;
536 last_tracklet_timing[iStack]=((trkflags >> 10) & 0x3ff) * 0.008;
537 /*
538 printf(" Stack %02d_%d: 0x%016llx - first tracklet: %.2fus last tracklet: %.2fus tmu timing: %.2fus\n",
539 iSector, iStack, trkflags,
540 first_tracklet_timing[iStack], last_tracklet_timing[iStack], tmu_timing[iStack]
541 );
542 */
543 fHistFirstTrackletTime->Fill(first_tracklet_timing[iStack]);
544 fHistLastTrackletTime->Fill(last_tracklet_timing[iStack]);
545 fHistTmuTime->Fill(tmu_timing[iStack]);
546 }
547
548 for (int iTracklet = 0; iTracklet < fTrackletArray->GetEntriesFast(); iTracklet++) {
549 AliTRDtrackletWord *trackletWord = (AliTRDtrackletWord*) ((*fTrackletArray)[iTracklet]);
550 AliESDTrdTracklet *tracklet = new AliESDTrdTracklet(trackletWord->GetTrackletWord(), trackletWord->GetHCId());
551 /*
552 printf("TRDMSG: TRD tracklet found: 0x%08x - y=%+5d dy=%+3d pid=%3d\n",
553 tracklet->GetTrackletWord(),
554 tracklet->GetBinY(),
555 tracklet->GetBinDy(),
556 tracklet->GetPID());
557 */
558 // fill some basic histograms right here
559 fHistTrackletY->Fill(tracklet->GetBinY());
560 fHistTrackletDy->Fill(tracklet->GetBinDy());
561 fHistTrackletZ->Fill(tracklet->GetBinZ());
562 fHistTrackletPID->Fill(tracklet->GetPID());
563 fHistTrackletYDy->Fill(tracklet->GetBinY(), tracklet->GetBinDy());
564 fHistTrackletHC->Fill(tracklet->GetHCId()/60, tracklet->GetHCId()%60);
565
566 if (TMath::Abs(tracklet->GetBinY()) >= 3682)
567 fHistTrackletBadY->Fill(tracklet->GetHCId()/60, (tracklet->GetHCId()%60)/12);
568
569 if (tracklet->GetPID() < 40)
570 fHistTrackletBadPID->Fill(tracklet->GetHCId()/60, (tracklet->GetHCId()%60)/12);
571
572 }
573
574 for (int iTrack = 0; iTrack < fGtuTrackArray->GetEntriesFast(); iTrack++) {
575 AliESDTrdTrack *trdTrack = (AliESDTrdTrack*) ((*fGtuTrackArray)[iTrack]);
576 /*
577 printf("TRDMSG: GTU track found: 0x%016llx - Stack %02d_%d pt=%.3fGeV/c\n",
578 trdTrack->GetTrackWord(0),
579 trdTrack->GetSector(), trdTrack->GetStack(),
580 trdTrack->Pt());
581 */
582 fHistTrackPt->Fill(trdTrack->Pt());
583 fHistTrackStack->Fill(trdTrack->GetSector(), trdTrack->GetStack());
584 fHistTrackPID->Fill(trdTrack->GetPID());
585
586 Int_t layers=0;
587 Int_t layer_mask = trdTrack->GetLayerMask();
588 for (Int_t iLayer=0; iLayer<6; iLayer++)
589 if ((layer_mask >> iLayer) & 1)
590 layers++;
591 fHistTrackletsTrack->Fill(layers);
592 if (TMath::Abs(trdTrack->Pt()) >= 3.)
593 fHistTrackletsTrackHpt->Fill(layers);
594 }
595
596 // do more complex processing here, preferably in a dedicated class
597
598 // push TObject-based data to output
599 iResult = PushBack(fHistArray,
600 (kAliHLTDataTypeTObject | kAliHLTDataOriginTRD),
601 pBlock->fSpecification);
602
603 if (iResult != 0)
604 break;
605
606 // clear the rawreader
607 fRawReaderMem->ClearBuffers();
608 if (iResult != 0)
609 break;
610 }
611
612 return iResult;
613}
614
615int AliHLTTRDMonitorComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
616{
617 // reconfigure the component from the specified CDB entry, or default CDB entry
618 // function is invoked by the framework if a reconfigure command was received.
619 //
620 int iResult=0;
621 /*
622 TString cdbPath;
623 if (cdbEntry) {
624 cdbPath=cdbEntry;
625 } else {
626 cdbPath="HLT/ConfigSample/";
627 cdbPath+=GetComponentID();
628 }
629 AliInfoClass(Form("reconfigure '%s' from entry %s%s", chainId, cdbPath.Data(), cdbEntry?"":" (default)"));
630 iResult=ConfigureFromCDBTObjString(cdbPath);
631 */
632 return iResult;
633}
634
635int AliHLTTRDMonitorComponent::ReadPreprocessorValues(const char* /*modules*/)
636{
637 // read the preprocessor values for the detectors in the modules list
638 // function is invoked by the framework if the pendolino indivates an update
639 // of online calibration objects, e.g temperature and pressure measurements.
640 int iResult=0;
641 /*
642 TString detectors(modules!=NULL?modules:"");
643 AliInfoClass(Form("read preprocessor values for detector(s): %s", detectors.IsNull()?"none":detectors.Data()));
644 */
645 return iResult;
646}