2 //**************************************************************************
3 //* This file is property of and copyright by the ALICE HLT Project *
4 //* ALICE Experiment at CERN, All rights reserved. *
6 //* Primary Authors: Felix Rettig, Stefan Kirsch *
7 //* for The ALICE HLT Project. *
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 //**************************************************************************
18 /// @file AliHLTTRDMonitorComponent.cxx
19 /// @author Felix Rettig, Stefan Kirsch
21 /// @brief The TRD monitoring component
28 #include "TObjString.h"
29 #include "TObjArray.h"
30 #include "TClonesArray.h"
32 #include "AliESDtrack.h"
33 #include "AliHLTDataTypes.h"
34 #include "AliHLTTRDDefinitions.h"
35 #include "AliHLTLogging.h"
36 #include "AliHLTTRDMonitorComponent.h"
37 #include "AliTRDonlineTrackingDataContainer.h"
41 ClassImp(AliHLTTRDMonitorComponent)
43 #define LogError( ... ) { HLTError(__VA_ARGS__); if (fDebugLevel >= 1) { DbgLog("ERROR", __VA_ARGS__); } }
44 #define LogInfo( ... ) { HLTInfo(__VA_ARGS__); if (fDebugLevel >= 1) { DbgLog("INFO", __VA_ARGS__); } }
45 #define LogInspect( ... ) { HLTDebug(__VA_ARGS__); if (fDebugLevel >= 1) { DbgLog("INSPECT", __VA_ARGS__); } }
46 #define LogDebug( ... ) { if (fDebugLevel >= 1) { HLTInfo(__VA_ARGS__); DbgLog("DEBUG", __VA_ARGS__); } }
48 AliHLTTRDMonitorComponent::AliHLTTRDMonitorComponent() : AliHLTProcessor(),
49 fTrackHighPtThreshold(2.3),
51 fTrackingDataDebugOutput(kFALSE),
54 fEventId(fgkInvalidEventId),
57 fHistEventTypes(NULL),
59 fHistTrackletDy(NULL),
60 fHistTrackletYDy(NULL),
62 fHistTrackletPID(NULL),
63 fHistTrackletsHCId(NULL),
66 fHistTrackLayers(NULL),
67 fHistTrackLayersHighPt(NULL),
68 fHistTracksStack(NULL),
69 fHistTrackletTimingStack(NULL),
70 fHistTrackingTiming(NULL),
71 fHistTriggerContribs(NULL)
75 AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent() {
78 const char* AliHLTTRDMonitorComponent::GetComponentID() {
79 return "TRDMonitorComponent";
82 void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
83 list.push_back(kAliHLTDataTypeTObject | kAliHLTDataOriginTRD);
86 AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType() {
87 return (kAliHLTDataTypeTObjArray | kAliHLTDataOriginTRD);
90 void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
95 AliHLTComponent* AliHLTTRDMonitorComponent::Spawn() {
96 return new AliHLTTRDMonitorComponent;
99 int AliHLTTRDMonitorComponent::Configure(const char* /*arguments*/) {
103 int AliHLTTRDMonitorComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) {
107 int AliHLTTRDMonitorComponent::DoInit(int argc, const char** argv) {
113 fTrackingData = new AliTRDonlineTrackingDataContainer();
114 if (!fTrackingData) {
118 fTrackingData->SetGtuPtMultiplier(-1.); // this component does not know about the B-field direction
120 fHistArray = new TObjArray(25);
123 fHistArray->SetOwner(kTRUE);
129 if (fHistArray) delete fHistArray;
132 if (fTrackingData) delete fTrackingData;
133 fTrackingData = NULL;
137 fHistEventTypes = new TH1I("trdmon_event_types", "event types analysed;event type;abundance", 10, 0, 10);
138 fHistEventTypes->GetXaxis()->SetBinLabel(1, "any");
139 fHistEventTypes->GetXaxis()->SetBinLabel(2, "data");
140 fHistEventTypes->GetXaxis()->SetBinLabel(3, "track(lets) present");
141 fHistArray->AddLast(fHistEventTypes);
143 fHistTrackletY = new TH1I("trdmon_tracklet_y", "tracklet y-position;y (cm);abundance", 125, -75, 75);
144 fHistArray->AddLast(fHistTrackletY);
146 fHistTrackletDy = new TH1I("trdmon_tracklet_dy", "tracklet deflection;#Delta y (140 #mu m);abundance", 140, -70, 70);
147 fHistArray->AddLast(fHistTrackletDy);
149 fHistTrackletYDy = new TH2I("trdmon_tracklet_y_dy", "tracklet y-deflection vs. y-position;y (160 #mu m);#Delta y (140 #mu m);", 256, -4096, 4096, 140, -70, 70);
150 fHistArray->AddLast(fHistTrackletYDy);
152 fHistTrackletZ = new TH1I("trdmon_tracklet_z", "tracklet z-position;z (padrow);abundance", 16, 0, 16);
153 fHistArray->AddLast(fHistTrackletZ);
155 fHistTrackletPID = new TH1I("trdmon_tracklet_pid", "tracklet PID;PID (a.u.);abundance", 256, 0, 256);
156 fHistArray->AddLast(fHistTrackletPID);
158 fHistTrackletsHCId = new TH2F("trdmon_tracklets_hc", "tracklet number by HC;TRD sector;TRD half-chamber",
159 18, 0, 18, 60, 0, 60);
160 fHistArray->AddLast(fHistTrackletsHCId);
162 fHistTrackletTimingStack = new TH2I("trdmon_tracklet_timing_stack", "tracklet timing;TRD stack; time after L0 (us)",
163 90, 0., 90, 270, 0., 9.);
164 fHistArray->AddLast(fHistTrackletTimingStack);
166 fHistTrackPt = new TH1I("trdmon_track_pt", "p_{T} of TRD online tracks;p_{T}^{TRD, online} (GeV/c);abundance", 200, -20, 20.);
167 fHistArray->AddLast(fHistTrackPt);
169 fHistTrackPID = new TH1I("trdmon_track_pid", "PID of TRD online tracks;PID^{TRD, online} (a.u.);abundance", 256, 0, 256);
170 fHistArray->AddLast(fHistTrackPID);
172 fHistTrackLayers = new TH1I("trdmon_track_layers", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
173 fHistArray->AddLast(fHistTrackLayers);
175 fHistTrackLayersHighPt = new TH1I("trdmon_track_layers_hpt", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
176 fHistArray->AddLast(fHistTrackLayersHighPt);
178 fHistTracksStack = new TH2F("trdmon_tracks_stack", "tracks by stack;TRD sector;TRD stack",
180 fHistArray->AddLast(fHistTracksStack);
182 const Double_t trackingTimesTimeBin = 0.025; // us
183 const Double_t trackingTimesMaxTime = 12.; // us
184 fHistTrackingTiming = new TH2I("trdmon_tracking_timing", "tracking timing;;time after L0 (#mu s);",
185 4, 0, 4, (Int_t)(trackingTimesMaxTime/trackingTimesTimeBin), 0., trackingTimesMaxTime);
186 fHistTrackingTiming->GetXaxis()->SetBinLabel(1, "tracklet start");
187 fHistTrackingTiming->GetXaxis()->SetBinLabel(2, "tracklet end");
188 fHistTrackingTiming->GetXaxis()->SetBinLabel(3, "stack done");
189 fHistTrackingTiming->GetXaxis()->SetBinLabel(4, "sector done");
190 fHistArray->AddLast(fHistTrackingTiming);
192 fHistTriggerContribs = new TH2I("trdmon_trigger_contribs", "TRD internal contributions by sector;TRD sector;trigger contribution;",
193 18, 0, 18, 12, 0, 12);
194 fHistTrackingTiming->GetYaxis()->SetBinLabel(1, "trg0");
195 fHistTrackingTiming->GetYaxis()->SetBinLabel(2, "trg1");
196 fHistTrackingTiming->GetYaxis()->SetBinLabel(3, "trg2");
197 fHistTrackingTiming->GetYaxis()->SetBinLabel(4, "trg3");
198 fHistTrackingTiming->GetYaxis()->SetBinLabel(5, "trg4");
199 fHistTrackingTiming->GetYaxis()->SetBinLabel(6, "trg5");
200 fHistTrackingTiming->GetYaxis()->SetBinLabel(7, "trg5");
201 fHistTrackingTiming->GetYaxis()->SetBinLabel(8, "T");
202 fHistArray->AddLast(fHistTriggerContribs);
204 vector<const char*> remainingArgs;
205 for (int i = 0; i < argc; ++i)
206 remainingArgs.push_back(argv[i]);
209 ConfigureFromArgumentString(remainingArgs.size(), &(remainingArgs[0]));
214 int AliHLTTRDMonitorComponent::DoDeinit() {
216 if ((fHistoMode == 1) && (fWriteHistos)){
217 TFile out("mon_out/mon_hists.root", "RECREATE");
218 if (!out.IsZombie()) {
220 UInt_t numHists = fHistArray->GetEntries();
221 for (UInt_t iHist = 0; iHist < numHists; ++iHist)
222 if (fHistArray->At(iHist))
223 fHistArray->At(iHist)->Write();
228 if (fHistArray) delete fHistArray;
231 if (fTrackingData) delete fTrackingData;
232 fTrackingData = NULL;
237 int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int argc, const char** argv)
244 TString argument(argv[iArg]);
246 if (!argument.CompareTo("-write-histograms")){
247 LogInfo("writing of histograms enabled.");
248 fWriteHistos = kTRUE; // enable histogram writing, for debugging/tuning only!
252 if (!argument.CompareTo("-debug")){
253 if (++iArg >= argc) return -EPROTO;
254 argument = argv[iArg];
255 fDebugLevel = argument.Atoi();
256 LogInfo("debug level set to %d.", fDebugLevel);
264 void AliHLTTRDMonitorComponent::DbgLog(const char* prefix, ...){
266 AliHLTEventID_t eventNumber = fEventId;
267 Int_t fRunNumber = -1;
268 printf("TRDHLTGM %s-X-%s: [MON] %s",
269 (fRunNumber >= 0) ? Form("%06d", fRunNumber) : "XXXXXX",
270 (eventNumber != fgkInvalidEventId) ? Form("%05llu", eventNumber) : "XXXXX",
271 (strlen(prefix) > 0) ? Form("<%s> ", prefix) : "");
274 va_start(args, prefix);
275 char* fmt = va_arg(args, char*);
281 int AliHLTTRDMonitorComponent::PrepareTRDData() {
285 fTrackingData->Clear();
286 for (const AliHLTComponentBlockData* datablock = GetFirstInputBlock(AliHLTTRDDefinitions::fgkOnlineDataType);
288 datablock = GetNextInputBlock())
290 fTrackingData->Decompress(datablock->fPtr, datablock->fSize, kTRUE);
293 fTrackingData->PrintSummary("monitor component");
299 void AliHLTTRDMonitorComponent::DumpTrackingData(){
301 TString matchStr("");
304 if (fTrackingData->GetNumTracklets() + fTrackingData->GetNumTracks() == 0)
307 for (UShort_t iStack = 0; iStack < fkTRDStacks; ++iStack){
308 for (Int_t iTrk = 0; iTrk < fTrackingData->GetNumTracks(iStack); ++iTrk){
310 layerMask = fTrackingData->GetTrackLayerMask(iStack, iTrk);
311 trklStr = Form("trkl: ");
312 for (Short_t iLayer = 5; iLayer >= 0; --iLayer){
313 if ((layerMask >> iLayer) & 1)
314 trklStr += Form("0x%08x (%+8.3f) ",
315 fTrackingData->GetTrackTrackletWord(iStack, iTrk, iLayer),
316 fTrackingData->GetTrackTrackletLocalY(iStack, iTrk, iLayer));
318 trklStr += "--------------------- ";
319 } // loop over layers
320 trklStr.Remove(trklStr.Length() - 2, 2);
322 if (fTrackingDataDebugOutput){
324 printf("###DOTDB EV%04llu GTU TRACK - S%02d-%d pt: %+7.2f pid: %3d lm: 0x%02x %s\n",
326 iStack/5, iStack%5, fTrackingData->GetTrackPt(iStack, iTrk), fTrackingData->GetTrackPID(iStack, iTrk),
327 layerMask, trklStr.Data());
331 for (Short_t iLayer = 5; iLayer >= 0; --iLayer){
332 if (((layerMask >> iLayer) & 1) && (fTrackingData->GetTrackTrackletWord(iStack, iTrk, iLayer) == 0x10001000))
333 LogError("invalid layer mask / tracklet value combination A", "");
335 if ((((layerMask >> iLayer) & 1) == 0) && (fTrackingData->GetTrackTrackletWord(iStack, iTrk, iLayer) != 0x10001000))
336 LogError("invalid layer mask / tracklet value combination B", "");
339 } // loop over tracks in stack
340 } // loop over stacks
345 int AliHLTTRDMonitorComponent::ProcessTRDData(){
350 if (fHistoMode == 0){
351 UInt_t numHists = fHistArray->GetEntries();
352 for (UInt_t iHist = 0; iHist < numHists; ++iHist)
353 if (fHistArray->At(iHist))
354 ((TH1*) (fHistArray->At(iHist)))->Reset();
358 for (UInt_t iDet = 0; iDet < fkTRDChambers; ++iDet){
359 numTracklets = fTrackingData->GetNumTracklets(iDet);
360 for (UInt_t iTrkl = 0; iTrkl < numTracklets; ++iTrkl){
361 fHistTrackletY->Fill(fTrackingData->GetTrackletLocalY(iDet, iTrkl));
362 fHistTrackletDy->Fill(fTrackingData->GetTrackletBinDy(iDet, iTrkl));
363 fHistTrackletYDy->Fill(fTrackingData->GetTrackletBinY(iDet, iTrkl), fTrackingData->GetTrackletBinDy(iDet, iTrkl));
364 fHistTrackletZ->Fill(fTrackingData->GetTrackletBinZ(iDet, iTrkl));
365 fHistTrackletPID->Fill(fTrackingData->GetTrackletPID(iDet, iTrkl));
366 Int_t hc = fTrackingData->GetTrackletHCId(iDet, iTrkl);
367 fHistTrackletsHCId->Fill(hc/60, hc%60);
371 for (UShort_t iStack = 0; iStack < fkTRDStacks; ++iStack){
373 fHistTrackletTimingStack->Fill(iStack, fTrackingData->GetTrackletStartTime(iStack/5, iStack%5));
374 fHistTrackletTimingStack->Fill(iStack, fTrackingData->GetTrackletEndTime(iStack/5, iStack%5));
375 fHistTrackingTiming->Fill(0., fTrackingData->GetTrackletStartTime(iStack/5, iStack%5));
376 fHistTrackingTiming->Fill(1., fTrackingData->GetTrackletEndTime(iStack/5, iStack%5));
377 fHistTrackingTiming->Fill(2., fTrackingData->GetTMUTrackingDoneTime(iStack/5, iStack%5));
380 numTracks = fTrackingData->GetNumTracks(iStack);
381 fHistTracksStack->Fill(iStack/5, iStack%5, numTracks);
382 for (UInt_t iTrk = 0; iTrk < numTracks; ++iTrk){
383 Double_t gpt = fTrackingData->GetTrackPt(iStack, iTrk);
384 fHistTrackPt->Fill(gpt);
385 fHistTrackPID->Fill(fTrackingData->GetTrackPID(iStack, iTrk));
386 fHistTrackLayers->Fill(fTrackingData->GetTrackLayerNum(iStack, iTrk));
387 if (gpt >= fTrackHighPtThreshold)
388 fHistTrackLayersHighPt->Fill(fTrackingData->GetTrackLayerNum(iStack, iTrk));
389 } // loop over tracks in stack
390 } // loop over stacks
392 for (UShort_t iSector = 0; iSector < fkTRDSectors; ++iSector){
393 fHistTrackingTiming->Fill(3., fTrackingData->GetSMUTrackingDoneTime(iSector), fkTRDStacksPerSector);
395 UInt_t sectorTrgFlags = fTrackingData->GetSectorTrgContribs(iSector);
396 for (UShort_t iTrgCtb = 0; iTrgCtb < 12; ++iTrgCtb)
397 if ((sectorTrgFlags >> iTrgCtb) & 1)
398 fHistTriggerContribs->Fill(iSector, iTrgCtb);
404 int AliHLTTRDMonitorComponent::DoEvent(const AliHLTComponentEventData& evtData,
405 AliHLTComponentTriggerData& /*trigData*/) {
408 fEventId = evtData.fEventID;
409 fHistEventTypes->Fill(0.);
411 LogDebug("### START DoEvent [event id: %llu, %d blocks, size: %d]",
412 fEventId, evtData.fBlockCnt, evtData.fStructSize);
414 if (!IsDataEvent()) { // process data events only
415 LogDebug("### END DoEvent [event id: %llu, %d blocks, size: %d] (skipped: no data event)",
416 fEventId, evtData.fBlockCnt, evtData.fStructSize);
420 fHistEventTypes->Fill(1.);
422 fTrackingData->SetLogPrefix(Form("TRDHLTGM XXXXXX-%05llu: [MON] {TrkDat} ", fEventId));
426 // access to TRD specific data from AliHLTTRDPreprocessorComponent
427 if (!PrepareTRDData()){
428 LogError("access to TRD data failed. Skipping event...", "");
432 if (fTrackingData->GetNumTracks() + fTrackingData->GetNumTracklets() == 0) {
433 LogDebug("no TRD-relevant information, skipping further event processing");
437 fHistEventTypes->Fill(2.);
439 // DumpTrackingData();
441 if (!ProcessTRDData()) {
442 LogError("processing of TRD data failed, skipping further event processing");
450 PushBack(fHistArray, (kAliHLTDataTypeTObjArray | kAliHLTDataOriginTRD), 0x3fffff);
452 LogDebug("### END DoEvent [event id: %llu, %d blocks, size: %d]",
453 fEventId, evtData.fBlockCnt, evtData.fStructSize);