HLT/TRD/AliHLTTRDMonitorComponent.cxx

   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 //* Primary Authors: Felix Rettig, Stefan Kirsch                           *
   7 //*                  for The ALICE HLT Project.                            *
   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
  18 /// @file   AliHLTTRDMonitorComponent.cxx
  19 /// @author Felix Rettig, Stefan Kirsch
  20 /// @date   2012-08-16
  21 /// @brief  The TRD monitoring component
  22 ///
  23
  24 #include <cstdlib>
  25 #include "TH1I.h"
  26 #include "TH2I.h"
  27 #include "TH2F.h"
  28 #include "TObjString.h"
  29 #include "TObjArray.h"
  30 #include "TClonesArray.h"
  31 #include "TFile.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"
  38
  39 #define TRDMODULES 18
  40
  41 ClassImp(AliHLTTRDMonitorComponent)
  42
  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__); } }
  47
  48 AliHLTTRDMonitorComponent::AliHLTTRDMonitorComponent() : AliHLTProcessor(),
  49   fTrackHighPtThreshold(2.3),
  50   fHistoMode(1),
  51   fTrackingDataDebugOutput(kFALSE),
  52   fDebugLevel(0),
  53   fWriteHistos(kFALSE),
  54   fEventId(fgkInvalidEventId),
  55   fTrackingData(NULL),
  56   fHistArray(NULL),
  57   fHistEventTypes(NULL),
  58   fHistTrackletY(NULL),
  59   fHistTrackletDy(NULL),
  60   fHistTrackletYDy(NULL),
  61   fHistTrackletZ(NULL),
  62   fHistTrackletPID(NULL),
  63   fHistTrackletsHCId(NULL),
  64   fHistTrackPt(NULL),
  65   fHistTrackPID(NULL),
  66   fHistTrackLayers(NULL),
  67   fHistTrackLayersHighPt(NULL),
  68   fHistTracksStack(NULL),
  69   fHistTrackletTimingStack(NULL),
  70   fHistTrackingTiming(NULL),
  71   fHistTriggerContribs(NULL)
  72 {
  73 }
  74
  75 AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent() {
  76 }
  77
  78 const char* AliHLTTRDMonitorComponent::GetComponentID() {
  79   return "TRDMonitorComponent";
  80 }
  81
  82 void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
  83   list.push_back(kAliHLTDataTypeTObject | kAliHLTDataOriginTRD);
  84 }
  85
  86 AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType() {
  87   return (kAliHLTDataTypeTObjArray | kAliHLTDataOriginTRD);
  88 }
  89
  90 void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
  91   constBase = 10000000;
  92   inputMultiplier = 0;
  93 }
  94
  95 AliHLTComponent* AliHLTTRDMonitorComponent::Spawn() {
  96   return new AliHLTTRDMonitorComponent;
  97 }
  98
  99 int AliHLTTRDMonitorComponent::Configure(const char* /*arguments*/) {
 100   return 0;
 101 }
 102
 103 int AliHLTTRDMonitorComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) {
 104   return 0;
 105 }
 106
 107 int AliHLTTRDMonitorComponent::DoInit(int argc, const char** argv) {
 108
 109   int iResult = 0;
 110
 111   do {
 112
 113     fTrackingData = new AliTRDonlineTrackingDataContainer();
 114     fTrackingData->SetGtuPtMultiplier(-1.); // this component does not know about the B-field direction
 115     if (!fTrackingData) {
 116       iResult = -ENOMEM;
 117       break;
 118     }
 119
 120     fHistArray = new TObjArray(25);
 121     if(!fHistArray)
 122       return -ENOMEM;
 123     fHistArray->SetOwner(kTRUE);
 124
 125   } while (0);
 126
 127   if (iResult < 0){
 128
 129     if (fHistArray) delete fHistArray;
 130     fHistArray = NULL;
 131
 132     if (fTrackingData) delete fTrackingData;
 133     fTrackingData = NULL;
 134
 135   }
 136
 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);
 142
 143   fHistTrackletY = new TH1I("trdmon_tracklet_y", "tracklet y-position;y (cm);abundance", 125, -75, 75);
 144   fHistArray->AddLast(fHistTrackletY);
 145
 146   fHistTrackletDy = new TH1I("trdmon_tracklet_dy", "tracklet deflection;#Delta y (140 #mu m);abundance", 140, -70, 70);
 147   fHistArray->AddLast(fHistTrackletDy);
 148
 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);
 151
 152   fHistTrackletZ = new TH1I("trdmon_tracklet_z", "tracklet z-position;z (padrow);abundance", 16, 0, 16);
 153   fHistArray->AddLast(fHistTrackletZ);
 154
 155   fHistTrackletPID = new TH1I("trdmon_tracklet_pid", "tracklet PID;PID (a.u.);abundance", 256, 0, 256);
 156   fHistArray->AddLast(fHistTrackletPID);
 157
 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);
 161
 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);
 165
 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);
 168
 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);
 171
 172   fHistTrackLayers = new TH1I("trdmon_track_layers", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
 173   fHistArray->AddLast(fHistTrackLayers);
 174
 175   fHistTrackLayersHighPt = new TH1I("trdmon_track_layers_hpt", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
 176   fHistArray->AddLast(fHistTrackLayersHighPt);
 177
 178   fHistTracksStack = new TH2F("trdmon_tracks_stack", "tracks by stack;TRD sector;TRD stack",
 179                                 18, 0, 18, 5, 0, 5);
 180   fHistArray->AddLast(fHistTracksStack);
 181
 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);
 191
 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);
 203
 204  vector<const char*> remainingArgs;
 205  for (int i = 0; i < argc; ++i)
 206    remainingArgs.push_back(argv[i]);
 207
 208  if (argc > 0)
 209    ConfigureFromArgumentString(remainingArgs.size(), &(remainingArgs[0]));
 210
 211   return 0;
 212 }
 213
 214 int AliHLTTRDMonitorComponent::DoDeinit() {
 215
 216   if ((fHistoMode == 1) && (fWriteHistos)){
 217     TFile out("mon_out/mon_hists.root", "RECREATE");
 218     if (!out.IsZombie()) {
 219       out.cd();
 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();
 224       out.Close();
 225     }
 226   }
 227
 228   if (fHistArray) delete fHistArray;
 229   fHistArray = NULL;
 230
 231   if (fTrackingData) delete fTrackingData;
 232   fTrackingData = NULL;
 233
 234   return 0;
 235 }
 236
 237 int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int argc, const char** argv)
 238 {
 239
 240   if (argc <= 0)
 241     return 0;
 242
 243   UShort_t iArg = 0;
 244   TString argument(argv[iArg]);
 245
 246   if (!argument.CompareTo("-write-histograms")){
 247     LogInfo("writing of histograms enabled.");
 248     fWriteHistos = kTRUE; // enable histogram writing, for debugging/tuning only!
 249     return 1;
 250   }
 251
 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);
 257     return 2;
 258   }
 259
 260   return 0;
 261
 262 }
 263
 264 void AliHLTTRDMonitorComponent::DbgLog(const char* prefix, ...){
 265 #ifdef __TRDHLTDEBUG
 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) : "");
 272 #endif
 273   va_list args;
 274   va_start(args, prefix);
 275   char* fmt = va_arg(args, char*);
 276   vprintf(fmt, args);
 277   printf("\n");
 278   va_end(args);
 279 }
 280
 281 int AliHLTTRDMonitorComponent::PrepareTRDData() {
 282
 283   int result = 1;
 284
 285   fTrackingData->Clear();
 286   for (const AliHLTComponentBlockData* datablock = GetFirstInputBlock(AliHLTTRDDefinitions::fgkOnlineDataType);
 287        datablock != NULL;
 288        datablock = GetNextInputBlock())
 289     {
 290       fTrackingData->Decompress(datablock->fPtr, datablock->fSize, kTRUE);
 291     }
 292
 293   fTrackingData->PrintSummary("monitor component");
 294
 295   return result;
 296
 297 }
 298
 299 void AliHLTTRDMonitorComponent::DumpTrackingData(){
 300   TString trklStr("");
 301   TString matchStr("");
 302   UShort_t layerMask;
 303
 304   if (fTrackingData->GetNumTracklets() + fTrackingData->GetNumTracks() == 0)
 305     return;
 306
 307   for (UShort_t iStack = 0; iStack < fkTRDStacks; ++iStack){
 308     for (Int_t iTrk = 0; iTrk < fTrackingData->GetNumTracks(iStack); ++iTrk){
 309
 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));
 317         else
 318           trklStr += "---------------------  ";
 319       } // loop over layers
 320       trklStr.Remove(trklStr.Length() - 2, 2);
 321
 322       if (fTrackingDataDebugOutput){
 323
 324         printf("###DOTDB EV%04llu  GTU TRACK - S%02d-%d  pt: %+7.2f  pid: %3d  lm: 0x%02x %s\n",
 325                fEventId,
 326                iStack/5, iStack%5, fTrackingData->GetTrackPt(iStack, iTrk), fTrackingData->GetTrackPID(iStack, iTrk),
 327                layerMask, trklStr.Data());
 328       }
 329
 330       // paranoia checks
 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", "");
 334
 335         if ((((layerMask >> iLayer) & 1) == 0) && (fTrackingData->GetTrackTrackletWord(iStack, iTrk, iLayer) != 0x10001000))
 336           LogError("invalid layer mask / tracklet value combination B", "");
 337       }
 338
 339     } // loop over tracks in stack
 340   } // loop over stacks
 341
 342 }
 343
 344
 345 int AliHLTTRDMonitorComponent::ProcessTRDData(){
 346
 347   UInt_t numTracklets;
 348   UInt_t numTracks;
 349
 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         dynamic_cast<TH1*>(fHistArray->At(iHist))->Reset();
 355   }
 356
 357   // tracklets
 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);
 368     }
 369   }
 370
 371   for (UShort_t iStack = 0; iStack < fkTRDStacks; ++iStack){
 372     // timing
 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));
 378
 379     // GTU tracks
 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
 391
 392   for (UShort_t iSector = 0; iSector < fkTRDSectors; ++iSector){
 393     fHistTrackingTiming->Fill(3., fTrackingData->GetSMUTrackingDoneTime(iSector), fkTRDStacksPerSector);
 394
 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);
 399   }
 400
 401   return kTRUE;
 402 }
 403
 404 int AliHLTTRDMonitorComponent::DoEvent(const AliHLTComponentEventData& evtData,
 405                                        AliHLTComponentTriggerData& /*trigData*/) {
 406
 407   int iResult = 0;
 408   fEventId = evtData.fEventID;
 409   fHistEventTypes->Fill(0.);
 410
 411   LogDebug("### START DoEvent [event id: %llu, %d blocks, size: %d]",
 412            fEventId, evtData.fBlockCnt, evtData.fStructSize);
 413
 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);
 417     return iResult;
 418   }
 419
 420   fHistEventTypes->Fill(1.);
 421
 422   fTrackingData->SetLogPrefix(Form("TRDHLTGM XXXXXX-%05llu: [MON] {TrkDat} ", fEventId));
 423
 424   do {
 425
 426     // access to TRD specific data from AliHLTTRDPreprocessorComponent
 427     if (!PrepareTRDData()){
 428       LogError("access to TRD data failed. Skipping event...", "");
 429       break;
 430     }
 431
 432     if (fTrackingData->GetNumTracks() + fTrackingData->GetNumTracklets() == 0) {
 433       LogDebug("no TRD-relevant information, skipping further event processing");
 434       break;
 435     }
 436
 437     fHistEventTypes->Fill(2.);
 438
 439     // DumpTrackingData();
 440
 441     if (!ProcessTRDData()) {
 442       LogError("processing of TRD data failed, skipping further event processing");
 443       break;
 444     }
 445
 446     break;
 447
 448   } while (1);
 449
 450   PushBack(fHistArray, (kAliHLTDataTypeTObjArray | kAliHLTDataOriginTRD), 0x3fffff);
 451
 452   LogDebug("### END   DoEvent [event id: %llu, %d blocks, size: %d]",
 453                       fEventId, evtData.fBlockCnt, evtData.fStructSize);
 454
 455   return iResult;
 456 }