[u/mrichter/AliRoot.git] / HLT / TRD / AliHLTTRDMonitorComponent.cxx

// $Id$
//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        *
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Felix Rettig, Stefan Kirsch                           *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* Permission to use, copy, modify and distribute this software and its   *
//* documentation strictly for non-commercial purposes is hereby granted   *
//* without fee, provided that the above copyright notice appears in all   *
//* copies and that both the copyright notice and this permission notice   *
//* appear in the supporting documentation. The authors make no claims     *
//* about the suitability of this software for any purpose. It is          *
//* provided "as is" without express or implied warranty.                  *
//**************************************************************************

/// @file   AliHLTTRDMonitorComponent.cxx
/// @author Felix Rettig, Stefan Kirsch
/// @date   2012-08-16
/// @brief  The TRD monitoring component
///

#include <cstdlib>
#include "TH1I.h"
#include "TH2I.h"
#include "TH2F.h"
#include "TObjString.h"
#include "TObjArray.h"
#include "TClonesArray.h"
#include "TFile.h"
#include "AliESDtrack.h"
#include "AliHLTDataTypes.h"
#include "AliHLTTRDDefinitions.h"
#include "AliHLTLogging.h"
#include "AliHLTTRDMonitorComponent.h"
#include "AliTRDonlineTrackingDataContainer.h"

#define TRDMODULES 18

ClassImp(AliHLTTRDMonitorComponent)

#define LogError( ... ) { HLTError(__VA_ARGS__); if (fDebugLevel >= 1) { DbgLog("ERROR", __VA_ARGS__); } }
#define LogInfo( ... ) { HLTInfo(__VA_ARGS__); if (fDebugLevel >= 1) { DbgLog("INFO", __VA_ARGS__); } }
#define LogInspect( ... ) { HLTDebug(__VA_ARGS__); if (fDebugLevel >= 1) { DbgLog("INSPECT", __VA_ARGS__); } }
#define LogDebug( ... ) { if (fDebugLevel >= 1) { HLTInfo(__VA_ARGS__); DbgLog("DEBUG", __VA_ARGS__); } }

AliHLTTRDMonitorComponent::AliHLTTRDMonitorComponent() : AliHLTProcessor(),
  fTrackHighPtThreshold(2.3),
  fHistoMode(1),
  fTrackingDataDebugOutput(kFALSE),
  fDebugLevel(0),
  fWriteHistos(kFALSE),
  fEventId(fgkInvalidEventId),
  fTrackingData(NULL),
  fHistArray(NULL),
  fHistEventTypes(NULL),
  fHistTrackletY(NULL),
  fHistTrackletDy(NULL),
  fHistTrackletYDy(NULL),
  fHistTrackletZ(NULL),
  fHistTrackletPID(NULL),
  fHistTrackletsHCId(NULL),
  fHistTrackPt(NULL),
  fHistTrackPID(NULL),
  fHistTrackLayers(NULL),
  fHistTrackLayersHighPt(NULL),
  fHistTracksStack(NULL),
  fHistTrackletTimingStack(NULL),
  fHistTrackingTiming(NULL),
  fHistTriggerContribs(NULL)
{
}

AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent() {
}

const char* AliHLTTRDMonitorComponent::GetComponentID() {
  return "TRDMonitorComponent";
}

void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
  list.push_back(kAliHLTDataTypeTObject | kAliHLTDataOriginTRD);
}

AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType() {
  return (kAliHLTDataTypeTObjArray | kAliHLTDataOriginTRD);
}

void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
  constBase = 10000000;
  inputMultiplier = 0;
}

AliHLTComponent* AliHLTTRDMonitorComponent::Spawn() {
  return new AliHLTTRDMonitorComponent;
}

int AliHLTTRDMonitorComponent::Configure(const char* /*arguments*/) {
  return 0;
}

int AliHLTTRDMonitorComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) {
  return 0;
}

int AliHLTTRDMonitorComponent::DoInit(int argc, const char** argv) {

  int iResult = 0;

  do {

    fTrackingData = new AliTRDonlineTrackingDataContainer();
    if (!fTrackingData) {
      iResult = -ENOMEM;
      break;
    }
    fTrackingData->SetGtuPtMultiplier(-1.); // this component does not know about the B-field direction

    fHistArray = new TObjArray(25);
    if(!fHistArray)
      return -ENOMEM;
    fHistArray->SetOwner(kTRUE);

  } while (0);

  if (iResult < 0){

    if (fHistArray) delete fHistArray;
    fHistArray = NULL;

    if (fTrackingData) delete fTrackingData;
    fTrackingData = NULL;

  }

  fHistEventTypes = new TH1I("trdmon_event_types", "event types analysed;event type;abundance", 10, 0, 10);
  fHistEventTypes->GetXaxis()->SetBinLabel(1, "any");
  fHistEventTypes->GetXaxis()->SetBinLabel(2, "data");
  fHistEventTypes->GetXaxis()->SetBinLabel(3, "track(lets) present");
  fHistArray->AddLast(fHistEventTypes);

  fHistTrackletY = new TH1I("trdmon_tracklet_y", "tracklet y-position;y (cm);abundance", 125, -75, 75);
  fHistArray->AddLast(fHistTrackletY);

  fHistTrackletDy = new TH1I("trdmon_tracklet_dy", "tracklet deflection;#Delta y (140 #mu m);abundance", 140, -70, 70);
  fHistArray->AddLast(fHistTrackletDy);

  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);
  fHistArray->AddLast(fHistTrackletYDy);

  fHistTrackletZ = new TH1I("trdmon_tracklet_z", "tracklet z-position;z (padrow);abundance", 16, 0, 16);
  fHistArray->AddLast(fHistTrackletZ);

  fHistTrackletPID = new TH1I("trdmon_tracklet_pid", "tracklet PID;PID (a.u.);abundance", 256, 0, 256);
  fHistArray->AddLast(fHistTrackletPID);

  fHistTrackletsHCId = new TH2F("trdmon_tracklets_hc", "tracklet number by HC;TRD sector;TRD half-chamber",
				18, 0, 18, 60, 0, 60);
  fHistArray->AddLast(fHistTrackletsHCId);

  fHistTrackletTimingStack = new TH2I("trdmon_tracklet_timing_stack", "tracklet timing;TRD stack; time after L0 (us)",
				       90, 0., 90, 270, 0., 9.);
  fHistArray->AddLast(fHistTrackletTimingStack);

  fHistTrackPt = new TH1I("trdmon_track_pt", "p_{T} of TRD online tracks;p_{T}^{TRD, online} (GeV/c);abundance", 200, -20, 20.);
  fHistArray->AddLast(fHistTrackPt);

  fHistTrackPID = new TH1I("trdmon_track_pid", "PID of TRD online tracks;PID^{TRD, online} (a.u.);abundance", 256, 0, 256);
  fHistArray->AddLast(fHistTrackPID);

  fHistTrackLayers = new TH1I("trdmon_track_layers", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
  fHistArray->AddLast(fHistTrackLayers);

  fHistTrackLayersHighPt = new TH1I("trdmon_track_layers_hpt", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
  fHistArray->AddLast(fHistTrackLayersHighPt);

  fHistTracksStack = new TH2F("trdmon_tracks_stack", "tracks by stack;TRD sector;TRD stack",
				18, 0, 18, 5, 0, 5);
  fHistArray->AddLast(fHistTracksStack);

  const Double_t trackingTimesTimeBin = 0.025; // us
  const Double_t trackingTimesMaxTime = 12.;   // us
  fHistTrackingTiming = new TH2I("trdmon_tracking_timing", "tracking timing;;time after L0 (#mu s);",
	       4, 0, 4, (Int_t)(trackingTimesMaxTime/trackingTimesTimeBin), 0., trackingTimesMaxTime);
  fHistTrackingTiming->GetXaxis()->SetBinLabel(1, "tracklet start");
  fHistTrackingTiming->GetXaxis()->SetBinLabel(2, "tracklet end");
  fHistTrackingTiming->GetXaxis()->SetBinLabel(3, "stack done");
  fHistTrackingTiming->GetXaxis()->SetBinLabel(4, "sector done");
  fHistArray->AddLast(fHistTrackingTiming);

  fHistTriggerContribs = new TH2I("trdmon_trigger_contribs", "TRD internal contributions by sector;TRD sector;trigger contribution;",
				  18, 0, 18, 12, 0, 12);
  fHistTrackingTiming->GetYaxis()->SetBinLabel(1, "trg0");
  fHistTrackingTiming->GetYaxis()->SetBinLabel(2, "trg1");
  fHistTrackingTiming->GetYaxis()->SetBinLabel(3, "trg2");
  fHistTrackingTiming->GetYaxis()->SetBinLabel(4, "trg3");
  fHistTrackingTiming->GetYaxis()->SetBinLabel(5, "trg4");
  fHistTrackingTiming->GetYaxis()->SetBinLabel(6, "trg5");
  fHistTrackingTiming->GetYaxis()->SetBinLabel(7, "trg5");
  fHistTrackingTiming->GetYaxis()->SetBinLabel(8, "T");
  fHistArray->AddLast(fHistTriggerContribs);

 vector<const char*> remainingArgs;
 for (int i = 0; i < argc; ++i)
   remainingArgs.push_back(argv[i]);

 if (argc > 0)
   ConfigureFromArgumentString(remainingArgs.size(), &(remainingArgs[0]));

  return 0;
}

int AliHLTTRDMonitorComponent::DoDeinit() {

  if ((fHistoMode == 1) && (fWriteHistos)){
    TFile out("mon_out/mon_hists.root", "RECREATE");
    if (!out.IsZombie()) {
      out.cd();
      UInt_t numHists = fHistArray->GetEntries();
      for (UInt_t iHist = 0; iHist < numHists; ++iHist)
	if (fHistArray->At(iHist))
	  fHistArray->At(iHist)->Write();
      out.Close();
    }
  }

  if (fHistArray) delete fHistArray;
  fHistArray = NULL;

  if (fTrackingData) delete fTrackingData;
  fTrackingData = NULL;

  return 0;
}

int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int argc, const char** argv)
{

  if (argc <= 0)
    return 0;

  UShort_t iArg = 0;
  TString argument(argv[iArg]);

  if (!argument.CompareTo("-write-histograms")){
    LogInfo("writing of histograms enabled.");
    fWriteHistos = kTRUE; // enable histogram writing, for debugging/tuning only!
    return 1;
  }

  if (!argument.CompareTo("-debug")){
    if (++iArg >= argc) return -EPROTO;
    argument = argv[iArg];
    fDebugLevel = argument.Atoi();
    LogInfo("debug level set to %d.", fDebugLevel);
    return 2;
  }

  return 0;

}

void AliHLTTRDMonitorComponent::DbgLog(const char* prefix, ...){
#ifdef __TRDHLTDEBUG
  AliHLTEventID_t eventNumber = fEventId;
  Int_t fRunNumber = -1;
  printf("TRDHLTGM %s-X-%s: [MON] %s",
 	 (fRunNumber >= 0) ? Form("%06d", fRunNumber) : "XXXXXX",
 	 (eventNumber != fgkInvalidEventId) ? Form("%05llu", eventNumber) : "XXXXX",
 	 (strlen(prefix) > 0) ? Form("<%s> ", prefix) : "");
#endif
  va_list args;
  va_start(args, prefix);
  char* fmt = va_arg(args, char*);
  vprintf(fmt, args);
  printf("\n");
  va_end(args);
}

int AliHLTTRDMonitorComponent::PrepareTRDData() {

  int result = 1;

  fTrackingData->Clear();
  for (const AliHLTComponentBlockData* datablock = GetFirstInputBlock(AliHLTTRDDefinitions::fgkOnlineDataType);
       datablock != NULL;
       datablock = GetNextInputBlock())
    {
      fTrackingData->Decompress(datablock->fPtr, datablock->fSize, kTRUE);
    }

  fTrackingData->PrintSummary("monitor component");

  return result;

}

void AliHLTTRDMonitorComponent::DumpTrackingData(){
  TString trklStr("");
  TString matchStr("");
  UShort_t layerMask;

  if (fTrackingData->GetNumTracklets() + fTrackingData->GetNumTracks() == 0)
    return;

  for (UShort_t iStack = 0; iStack < fkTRDStacks; ++iStack){
    for (Int_t iTrk = 0; iTrk < fTrackingData->GetNumTracks(iStack); ++iTrk){

      layerMask = fTrackingData->GetTrackLayerMask(iStack, iTrk);
      trklStr = Form("trkl: ");
      for (Short_t iLayer = 5; iLayer >= 0; --iLayer){
	if ((layerMask >> iLayer) & 1)
	  trklStr += Form("0x%08x (%+8.3f)  ",
			  fTrackingData->GetTrackTrackletWord(iStack, iTrk, iLayer),
			  fTrackingData->GetTrackTrackletLocalY(iStack, iTrk, iLayer));
	else
	  trklStr += "---------------------  ";
      } // loop over layers
      trklStr.Remove(trklStr.Length() - 2, 2);

      if (fTrackingDataDebugOutput){

	printf("###DOTDB EV%04llu  GTU TRACK - S%02d-%d  pt: %+7.2f  pid: %3d  lm: 0x%02x %s\n",
	       fEventId,
	       iStack/5, iStack%5, fTrackingData->GetTrackPt(iStack, iTrk), fTrackingData->GetTrackPID(iStack, iTrk),
	       layerMask, trklStr.Data());
      }

      // paranoia checks
      for (Short_t iLayer = 5; iLayer >= 0; --iLayer){
	if (((layerMask >> iLayer) & 1) && (fTrackingData->GetTrackTrackletWord(iStack, iTrk, iLayer) == 0x10001000))
	  LogError("invalid layer mask / tracklet value combination A", "");

	if ((((layerMask >> iLayer) & 1) == 0) && (fTrackingData->GetTrackTrackletWord(iStack, iTrk, iLayer) != 0x10001000))
	  LogError("invalid layer mask / tracklet value combination B", "");
      }

    } // loop over tracks in stack
  } // loop over stacks

}


int AliHLTTRDMonitorComponent::ProcessTRDData(){

  UInt_t numTracklets;
  UInt_t numTracks;

  if (fHistoMode == 0){
    UInt_t numHists = fHistArray->GetEntries();
    for (UInt_t iHist = 0; iHist < numHists; ++iHist)
      if (fHistArray->At(iHist))
	((TH1*) (fHistArray->At(iHist)))->Reset();
  }

  // tracklets
  for (UInt_t iDet = 0; iDet < fkTRDChambers; ++iDet){
    numTracklets = fTrackingData->GetNumTracklets(iDet);
    for (UInt_t iTrkl = 0; iTrkl < numTracklets; ++iTrkl){
      fHistTrackletY->Fill(fTrackingData->GetTrackletLocalY(iDet, iTrkl));
      fHistTrackletDy->Fill(fTrackingData->GetTrackletBinDy(iDet, iTrkl));
      fHistTrackletYDy->Fill(fTrackingData->GetTrackletBinY(iDet, iTrkl), fTrackingData->GetTrackletBinDy(iDet, iTrkl));
      fHistTrackletZ->Fill(fTrackingData->GetTrackletBinZ(iDet, iTrkl));
      fHistTrackletPID->Fill(fTrackingData->GetTrackletPID(iDet, iTrkl));
      Int_t hc = fTrackingData->GetTrackletHCId(iDet, iTrkl);
      fHistTrackletsHCId->Fill(hc/60, hc%60);
    }
  }

  for (UShort_t iStack = 0; iStack < fkTRDStacks; ++iStack){
    // timing
    fHistTrackletTimingStack->Fill(iStack, fTrackingData->GetTrackletStartTime(iStack/5, iStack%5));
    fHistTrackletTimingStack->Fill(iStack, fTrackingData->GetTrackletEndTime(iStack/5, iStack%5));
    fHistTrackingTiming->Fill(0., fTrackingData->GetTrackletStartTime(iStack/5, iStack%5));
    fHistTrackingTiming->Fill(1., fTrackingData->GetTrackletEndTime(iStack/5, iStack%5));
    fHistTrackingTiming->Fill(2., fTrackingData->GetTMUTrackingDoneTime(iStack/5, iStack%5));

    // GTU tracks
    numTracks = fTrackingData->GetNumTracks(iStack);
    fHistTracksStack->Fill(iStack/5, iStack%5, numTracks);
    for (UInt_t iTrk = 0; iTrk < numTracks; ++iTrk){
      Double_t gpt = fTrackingData->GetTrackPt(iStack, iTrk);
      fHistTrackPt->Fill(gpt);
      fHistTrackPID->Fill(fTrackingData->GetTrackPID(iStack, iTrk));
      fHistTrackLayers->Fill(fTrackingData->GetTrackLayerNum(iStack, iTrk));
      if (gpt >= fTrackHighPtThreshold)
	fHistTrackLayersHighPt->Fill(fTrackingData->GetTrackLayerNum(iStack, iTrk));
    } // loop over tracks in stack
  } // loop over stacks

  for (UShort_t iSector = 0; iSector < fkTRDSectors; ++iSector){
    fHistTrackingTiming->Fill(3., fTrackingData->GetSMUTrackingDoneTime(iSector), fkTRDStacksPerSector);

    UInt_t sectorTrgFlags = fTrackingData->GetSectorTrgContribs(iSector);
    for (UShort_t iTrgCtb = 0; iTrgCtb < 12; ++iTrgCtb)
      if ((sectorTrgFlags >> iTrgCtb) & 1)
	fHistTriggerContribs->Fill(iSector, iTrgCtb);
  }

  return kTRUE;
}

int AliHLTTRDMonitorComponent::DoEvent(const AliHLTComponentEventData& evtData,
				       AliHLTComponentTriggerData& /*trigData*/) {

  int iResult = 0;
  fEventId = evtData.fEventID;
  fHistEventTypes->Fill(0.);

  LogDebug("### START DoEvent [event id: %llu, %d blocks, size: %d]",
	   fEventId, evtData.fBlockCnt, evtData.fStructSize);

  if (!IsDataEvent()) {  // process data events only
    LogDebug("### END   DoEvent [event id: %llu, %d blocks, size: %d] (skipped: no data event)",
	     fEventId, evtData.fBlockCnt, evtData.fStructSize);
    return iResult;
  }

  fHistEventTypes->Fill(1.);

  fTrackingData->SetLogPrefix(Form("TRDHLTGM XXXXXX-%05llu: [MON] {TrkDat} ", fEventId));

  do {

    // access to TRD specific data from AliHLTTRDPreprocessorComponent
    if (!PrepareTRDData()){
      LogError("access to TRD data failed. Skipping event...", "");
      break;
    }

    if (fTrackingData->GetNumTracks() + fTrackingData->GetNumTracklets() == 0) {
      LogDebug("no TRD-relevant information, skipping further event processing");
      break;
    }

    fHistEventTypes->Fill(2.);

    // DumpTrackingData();

    if (!ProcessTRDData()) {
      LogError("processing of TRD data failed, skipping further event processing");
      break;
    }

    break;

  } while (1);

  PushBack(fHistArray, (kAliHLTDataTypeTObjArray | kAliHLTDataOriginTRD), 0x3fffff);

  LogDebug("### END   DoEvent [event id: %llu, %d blocks, size: %d]",
		      fEventId, evtData.fBlockCnt, evtData.fStructSize);

  return iResult;
}
Commit	Line	Data
ce6fd1b1	1	// $Id$
ce6fd1b1	2	//**************************************************************************
c7b7f445	3	//* This file is property of and copyright by the ALICE HLT Project *
ce6fd1b1	4	//* ALICE Experiment at CERN, All rights reserved. *
ce6fd1b1	5	//* *
c7b7f445	6	//* Primary Authors: Felix Rettig, Stefan Kirsch *
c7b7f445	7	//* for The ALICE HLT Project. *
ce6fd1b1	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
c7b7f445	20	/// @date 2012-08-16
	21	/// @brief The TRD monitoring component
	22	///
ce6fd1b1	23
c7b7f445	24	#include <cstdlib>
ce6fd1b1	25	#include "TH1I.h"
ce6fd1b1	26	#include "TH2I.h"
c7b7f445	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"
ce6fd1b1	38
c7b7f445	39	#define TRDMODULES 18
ce6fd1b1	40
ce6fd1b1	41	ClassImp(AliHLTTRDMonitorComponent)
ce6fd1b1	42
c7b7f445	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)
ce6fd1b1	72	{
ce6fd1b1	73	}
ce6fd1b1	74
c7b7f445	75	AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent() {
ce6fd1b1	76	}
ce6fd1b1	77
c7b7f445	78	const char* AliHLTTRDMonitorComponent::GetComponentID() {
ce6fd1b1	79	return "TRDMonitorComponent";
	80	}
	81
c7b7f445	82	void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
c7b7f445	83	list.push_back(kAliHLTDataTypeTObject \| kAliHLTDataOriginTRD);
ce6fd1b1	84	}
ce6fd1b1	85
c7b7f445	86	AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType() {
c7b7f445	87	return (kAliHLTDataTypeTObjArray \| kAliHLTDataOriginTRD);
ce6fd1b1	88	}
ce6fd1b1	89
c7b7f445	90	void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
c7b7f445	91	constBase = 10000000;
ce6fd1b1	92	inputMultiplier = 0;
	93	}
	94
c7b7f445	95	AliHLTComponent* AliHLTTRDMonitorComponent::Spawn() {
ce6fd1b1	96	return new AliHLTTRDMonitorComponent;
	97	}
	98
c7b7f445	99	int AliHLTTRDMonitorComponent::Configure(const char* /arguments/) {
	100	return 0;
	101	}
ce6fd1b1	102
c7b7f445	103	int AliHLTTRDMonitorComponent::Reconfigure(const char* /cdbEntry/, const char* /chainId/) {
	104	return 0;
	105	}
ce6fd1b1	106
c7b7f445	107	int AliHLTTRDMonitorComponent::DoInit(int argc, const char** argv) {
ce6fd1b1	108
c7b7f445	109	int iResult = 0;
ce6fd1b1	110
ce6fd1b1	111	do {
ce6fd1b1	112
c7b7f445	113	fTrackingData = new AliTRDonlineTrackingDataContainer();
c7b7f445	114	if (!fTrackingData) {
c7b7f445	115	iResult = -ENOMEM;
ce6fd1b1	116	break;
ce6fd1b1	117	}
ca892663	118	fTrackingData->SetGtuPtMultiplier(-1.); // this component does not know about the B-field direction
ce6fd1b1	119
ce6fd1b1	120	fHistArray = new TObjArray(25);
c7b7f445	121	if(!fHistArray)
ce6fd1b1	122	return -ENOMEM;
ce6fd1b1	123	fHistArray->SetOwner(kTRUE);
ce6fd1b1	124
c7b7f445	125	} while (0);
ce6fd1b1	126
c7b7f445	127	if (iResult < 0){
ce6fd1b1	128
c7b7f445	129	if (fHistArray) delete fHistArray;
c7b7f445	130	fHistArray = NULL;
ce6fd1b1	131
c7b7f445	132	if (fTrackingData) delete fTrackingData;
c7b7f445	133	fTrackingData = NULL;
ce6fd1b1	134
c7b7f445	135	}
ce6fd1b1	136
c7b7f445	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);
ce6fd1b1	142
c7b7f445	143	fHistTrackletY = new TH1I("trdmon_tracklet_y", "tracklet y-position;y (cm);abundance", 125, -75, 75);
c7b7f445	144	fHistArray->AddLast(fHistTrackletY);
ce6fd1b1	145
c7b7f445	146	fHistTrackletDy = new TH1I("trdmon_tracklet_dy", "tracklet deflection;#Delta y (140 #mu m);abundance", 140, -70, 70);
c7b7f445	147	fHistArray->AddLast(fHistTrackletDy);
ce6fd1b1	148
c7b7f445	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);
c7b7f445	150	fHistArray->AddLast(fHistTrackletYDy);
ce6fd1b1	151
c7b7f445	152	fHistTrackletZ = new TH1I("trdmon_tracklet_z", "tracklet z-position;z (padrow);abundance", 16, 0, 16);
c7b7f445	153	fHistArray->AddLast(fHistTrackletZ);
ce6fd1b1	154
c7b7f445	155	fHistTrackletPID = new TH1I("trdmon_tracklet_pid", "tracklet PID;PID (a.u.);abundance", 256, 0, 256);
c7b7f445	156	fHistArray->AddLast(fHistTrackletPID);
ce6fd1b1	157
c7b7f445	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);
ce6fd1b1	161
c7b7f445	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);
ce6fd1b1	165
c7b7f445	166	fHistTrackPt = new TH1I("trdmon_track_pt", "p_{T} of TRD online tracks;p_{T}^{TRD, online} (GeV/c);abundance", 200, -20, 20.);
c7b7f445	167	fHistArray->AddLast(fHistTrackPt);
ce6fd1b1	168
c7b7f445	169	fHistTrackPID = new TH1I("trdmon_track_pid", "PID of TRD online tracks;PID^{TRD, online} (a.u.);abundance", 256, 0, 256);
c7b7f445	170	fHistArray->AddLast(fHistTrackPID);
ce6fd1b1	171
c7b7f445	172	fHistTrackLayers = new TH1I("trdmon_track_layers", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
c7b7f445	173	fHistArray->AddLast(fHistTrackLayers);
ce6fd1b1	174
c7b7f445	175	fHistTrackLayersHighPt = new TH1I("trdmon_track_layers_hpt", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
c7b7f445	176	fHistArray->AddLast(fHistTrackLayersHighPt);
ce6fd1b1	177
c7b7f445	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);
ce6fd1b1	181
c7b7f445	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);
ce6fd1b1	191
c7b7f445	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);
ce6fd1b1	203
c7b7f445	204	vector<const char*> remainingArgs;
	205	for (int i = 0; i < argc; ++i)
	206	remainingArgs.push_back(argv[i]);
ce6fd1b1	207
c7b7f445	208	if (argc > 0)
c7b7f445	209	ConfigureFromArgumentString(remainingArgs.size(), &(remainingArgs[0]));
ce6fd1b1	210
c7b7f445	211	return 0;
c7b7f445	212	}
ce6fd1b1	213
c7b7f445	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	}
ce6fd1b1	226	}
ce6fd1b1	227
c7b7f445	228	if (fHistArray) delete fHistArray;
	229	fHistArray = NULL;
	230
	231	if (fTrackingData) delete fTrackingData;
	232	fTrackingData = NULL;
	233
	234	return 0;
ce6fd1b1	235	}
ce6fd1b1	236
c7b7f445	237	int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int argc, const char** argv)
ce6fd1b1	238	{
ce6fd1b1	239
c7b7f445	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;
ce6fd1b1	250	}
ce6fd1b1	251
c7b7f445	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;
ce6fd1b1	258	}
c7b7f445	259
ce6fd1b1	260	return 0;
c7b7f445	261
ce6fd1b1	262	}
ce6fd1b1	263
c7b7f445	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	}
ce6fd1b1	280
c7b7f445	281	int AliHLTTRDMonitorComponent::PrepareTRDData() {
ce6fd1b1	282
c7b7f445	283	int result = 1;
ce6fd1b1	284
c7b7f445	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	}
ce6fd1b1	292
c7b7f445	293	fTrackingData->PrintSummary("monitor component");
	294
	295	return result;
ce6fd1b1	296
ce6fd1b1	297	}
ce6fd1b1	298
c7b7f445	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());
ce6fd1b1	328	}
ce6fd1b1	329
c7b7f445	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
ce6fd1b1	344
c7b7f445	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))
ca892663	354	((TH1*) (fHistArray->At(iHist)))->Reset();
c7b7f445	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);
ce6fd1b1	368	}
c7b7f445	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/) {
ce6fd1b1	406
c7b7f445	407	int iResult = 0;
	408	fEventId = evtData.fEventID;
	409	fHistEventTypes->Fill(0.);
ce6fd1b1	410
c7b7f445	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;
ce6fd1b1	430	}
ce6fd1b1	431
c7b7f445	432	if (fTrackingData->GetNumTracks() + fTrackingData->GetNumTracklets() == 0) {
	433	LogDebug("no TRD-relevant information, skipping further event processing");
	434	break;
ce6fd1b1	435	}
ce6fd1b1	436
c7b7f445	437	fHistEventTypes->Fill(2.);
ce6fd1b1	438
c7b7f445	439	// DumpTrackingData();
ce6fd1b1	440
c7b7f445	441	if (!ProcessTRDData()) {
c7b7f445	442	LogError("processing of TRD data failed, skipping further event processing");
79f07cf4	443	break;
c7b7f445	444	}
ce6fd1b1	445
c7b7f445	446	break;
ce6fd1b1	447
c7b7f445	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);
ce6fd1b1	454
ce6fd1b1	455	return iResult;
ce6fd1b1	456	}