// $Id$
//**************************************************************************
-//* This file is property of and copyright by the ALICE HLT Project *
+//* 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 *
/// @file AliHLTTRDMonitorComponent.cxx
/// @author Felix Rettig, Stefan Kirsch
-/// @date 2011-08-02
-/// @brief A processing component for TRD tracking/trigger data on FEP-level
-/// @ingroup alihlt_trd_components
-
-#include "AliHLTTRDMonitorComponent.h"
-#include "AliLog.h"
-#include "AliHLTDataTypes.h"
-#include "AliRawReaderMemory.h"
-#include "AliHLTTRDDefinitions.h"
-
-#include "AliTRDdigitsManager.h"
-#include "AliTRDrawStream.h"
-#include "AliTRDtrackletWord.h"
-#include "AliESDTrdTracklet.h"
-#include "AliESDTrdTrack.h"
+/// @date 2012-08-16
+/// @brief The TRD monitoring component
+///
+#include <cstdlib>
#include "TH1I.h"
#include "TH2I.h"
-#include "TH1F.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
-/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTRDMonitorComponent)
-AliHLTTRDMonitorComponent::AliHLTTRDMonitorComponent()
- : AliHLTProcessor()
- , fTrackletArray(NULL)
- , fGtuTrackArray(NULL)
- , fRawReaderMem(NULL)
- , fDigitsManagerTrd(NULL)
- , fRawReaderTrd(NULL)
- , fHistArray(NULL)
- , fHistTrackletY(NULL)
- , fHistTrackletDy(NULL)
- , fHistTrackletZ(NULL)
- , fHistTrackletPID(NULL)
- , fHistTrackletYDy(NULL)
- , fHistTrackletHC(NULL)
- , fHistTrackletBadY(NULL)
- , fHistTrackletBadPID(NULL)
- , fHistFirstTrackletTime(NULL)
- , fHistLastTrackletTime(NULL)
- , fHistTmuTime(NULL)
- , fHistSmuTime(NULL)
- , fHistTrackPt(NULL)
- , fHistTrackStack(NULL)
- , fHistTrackletsTrack(NULL)
- , fHistTrackletsTrackHpt(NULL)
- , fHistTrackPID(NULL)
- , fHistTriggerContribs(NULL)
+#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)
{
- // constructor
}
-AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent()
-{
- // destructor
+AliHLTTRDMonitorComponent::~AliHLTTRDMonitorComponent() {
}
-const char* AliHLTTRDMonitorComponent::GetComponentID()
-{
- // component property: id
+const char* AliHLTTRDMonitorComponent::GetComponentID() {
return "TRDMonitorComponent";
}
-void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
-{
- // component property: list of input data types
- list.push_back(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD);
+void AliHLTTRDMonitorComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
+ list.push_back(kAliHLTDataTypeTObject | kAliHLTDataOriginTRD);
}
-AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType()
-{
- // component property: output data type
- return kAliHLTMultipleDataType;
+AliHLTComponentDataType AliHLTTRDMonitorComponent::GetOutputDataType() {
+ return (kAliHLTDataTypeTObjArray | kAliHLTDataOriginTRD);
}
-int AliHLTTRDMonitorComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
-
-{
- // see header file for class documentation
- tgtList.clear();
- // tgtList.push_back(AliHLTTRDDefinitions::fgkSimpleIntegerDataType);
- tgtList.push_back(kAliHLTDataTypeTObject | kAliHLTDataOriginTRD);
- return tgtList.size();
-}
-
-void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
-{
- // component property: output size estimator
- constBase = 5000000;
+void AliHLTTRDMonitorComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
+ constBase = 10000000;
inputMultiplier = 0;
}
-void AliHLTTRDMonitorComponent::GetOCDBObjectDescription( TMap* const /*targetMap*/)
-{
- // Get a list of OCDB object description.
- // The list of objects is provided in a TMap
- // - key: complete OCDB path, e.g. GRP/GRP/Data
- // - value: short description why the object is needed
- // Key and value objects created inside this class go into ownership of
- // target TMap.
- //if (!targetMap) return;
- //targetMap->Add(new TObjString("HLT/ConfigSample/SampleRawAnalysis"),
- // new TObjString("configuration object"));
-}
-
-AliHLTComponent* AliHLTTRDMonitorComponent::Spawn()
-{
- // Spawn function, return new class instance
+AliHLTComponent* AliHLTTRDMonitorComponent::Spawn() {
return new AliHLTTRDMonitorComponent;
}
-int AliHLTTRDMonitorComponent::DoInit( int /*argc*/, const char** /*argv*/ )
-{
-
- int iResult=0;
+int AliHLTTRDMonitorComponent::Configure(const char* /*arguments*/) {
+ return 0;
+}
- // init stage 1: default values for all data members
+int AliHLTTRDMonitorComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) {
+ return 0;
+}
- // init stage 2: read configuration object
- // ScanConfigurationArgument() needs to be implemented
- // HLT component configuration objects are located in the HLT/ConfigDET
- // of the OCDB. TObjString configuration objects can be generated with
- // the macro HLT/exa/makeComponentConfigurationObject.C, e.g.
- // aliroot -b -q -l $ALICE_ROOT/HLT/exa/makeComponentConfigurationObject.C'("HLT/ConfigSample/SampleRawAnalysis", "")'
- //TString cdbPath="HLT/ConfigSample/";
- //cdbPath+=GetComponentID();
- //iResult=ConfigureFromCDBTObjString(cdbPath);
+int AliHLTTRDMonitorComponent::DoInit(int argc, const char** argv) {
- // init stage 3: read the component arguments
- //if (iResult>=0) {
- // iResult=ConfigureFromArgumentString(argc, argv);
- //}
+ int iResult = 0;
- // implement the component initialization
do {
- if (iResult<0) break;
-
- fRawReaderMem = new AliRawReaderMemory;
- if (!fRawReaderMem) {
- iResult=-ENOMEM;
- break;
- }
-
- fTrackletArray = new TClonesArray("AliTRDtrackletWord", 500);
- if (!fTrackletArray) {
- iResult=-ENOMEM;
- break;
- }
-
- fGtuTrackArray = new TClonesArray("AliESDTrdTrack", 50);
- if (!fGtuTrackArray){
- iResult=-ENOMEM;
- break;
- }
-
- fDigitsManagerTrd = new AliTRDdigitsManager();
- if (!fDigitsManagerTrd) {
- iResult=-ENOMEM;
- break;
- }
- fDigitsManagerTrd->CreateArrays();
- fRawReaderTrd = new AliTRDrawStream(fRawReaderMem);
- if (!fRawReaderTrd) {
- iResult=-ENOMEM;
+ fTrackingData = new AliTRDonlineTrackingDataContainer();
+ if (!fTrackingData) {
+ iResult = -ENOMEM;
break;
}
-
- fRawReaderTrd->SetDigitsManager(fDigitsManagerTrd);
- // fRawReaderTrd->SetDigitsManager(NULL); // FIXME may be used to improve performance, needs a fix to be committed by TRD
- fRawReaderTrd->SetTrackletArray(fTrackletArray);
- fRawReaderTrd->SetTrackArray(fGtuTrackArray);
-
- // Disable raw reader error messages that could flood HLT logbook
- fRawReaderTrd->SetErrorDebugLevel( AliTRDrawStream::kLinkMonitor, 1 );
+ fTrackingData->SetGtuPtMultiplier(-1.); // this component does not know about the B-field direction
fHistArray = new TObjArray(25);
- if(!fHistArray){
+ if(!fHistArray)
return -ENOMEM;
- break;
- }
fHistArray->SetOwner(kTRUE);
- fHistTrackletY = new TH1I("hist_tracklets_y", "Y-Position of online tracklets", 256, -4096, 4096);
- if (!fHistTrackletY){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletY);
-
- fHistTrackletDy = new TH1I("hist_tracklets_dy", "Deflection of online tracklets", 128, -64, 64);
- if (!fHistTrackletDy){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletDy);
+ } while (0);
- fHistTrackletZ = new TH1I("hist_tracklets_z", "Z-Position of online tracklets", 12, 0, 12);
- if (!fHistTrackletZ){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletZ);
+ if (iResult < 0){
- fHistTrackletPID = new TH1I("hist_tracklets_pid", "PID of online tracklets", 256, 0, 256);
- if (!fHistTrackletPID){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletPID);
+ if (fHistArray) delete fHistArray;
+ fHistArray = NULL;
- fHistTrackletYDy = new TH2I("hist_tracklets_y_dy", "Tracklet deflection vs. tracklet position", 256, -4096, 4096, 64, -64, 64);
- if (!fHistTrackletYDy){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletYDy);
+ if (fTrackingData) delete fTrackingData;
+ fTrackingData = NULL;
- fHistTrackletHC = new TH2I("hist_tracklets_hc", "Number of online tracklets by HC", 18, 0, 18, 60, 0, 60);
- if (!fHistTrackletHC){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletHC);
+ }
- fHistTrackletBadY = new TH2I("hist_tracklets_bad_y", "Number of online tracklets with bad y-position by HC", 18, 0, 18, 5, 0, 5);
- if (!fHistTrackletBadY){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletBadY);
+ 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);
- fHistTrackletBadPID = new TH2I("hist_tracklets_bad_pid", "Number of online tracklets with bad y-position by HC", 18, 0, 18, 5, 0, 5);
- if (!fHistTrackletBadPID){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletBadPID);
+ fHistTrackletY = new TH1I("trdmon_tracklet_y", "tracklet y-position;y (cm);abundance", 125, -75, 75);
+ fHistArray->AddLast(fHistTrackletY);
- fHistFirstTrackletTime = new TH1F("hist_first_tracklet_time", "Arrival time of first tracklet", 160, 0., 8.);
- if (!fHistFirstTrackletTime){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistFirstTrackletTime);
+ fHistTrackletDy = new TH1I("trdmon_tracklet_dy", "tracklet deflection;#Delta y (140 #mu m);abundance", 140, -70, 70);
+ fHistArray->AddLast(fHistTrackletDy);
- fHistLastTrackletTime = new TH1F("hist_last_tracklet_time", "Arrival time of last tracklet", 160, 0., 8.);
- if (!fHistLastTrackletTime){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistLastTrackletTime);
+ 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);
- fHistTmuTime = new TH1F("hist_tmu_time", "Tracking done time at TMU-level", 160, 0., 8.);
- if (!fHistTmuTime){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTmuTime);
+ fHistTrackletZ = new TH1I("trdmon_tracklet_z", "tracklet z-position;z (padrow);abundance", 16, 0, 16);
+ fHistArray->AddLast(fHistTrackletZ);
- fHistSmuTime = new TH1F("hist_smu_time", "Tracking done time at SMU-level", 160, 0., 8.);
- if (!fHistSmuTime){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistSmuTime);
+ fHistTrackletPID = new TH1I("trdmon_tracklet_pid", "tracklet PID;PID (a.u.);abundance", 256, 0, 256);
+ fHistArray->AddLast(fHistTrackletPID);
- fHistTrackPt = new TH1F("hist_tracks_pt", "Transverse momentum of GTU tracks", 100, 0., 20.);
- if (!fHistTrackPt){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackPt);
+ fHistTrackletsHCId = new TH2F("trdmon_tracklets_hc", "tracklet number by HC;TRD sector;TRD half-chamber",
+ 18, 0, 18, 60, 0, 60);
+ fHistArray->AddLast(fHistTrackletsHCId);
- fHistTrackPID = new TH1I("hist_tracks_pid", "PID of online tracks", 256, 0, 256);
- if (!fHistTrackPID){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackPID);
+ fHistTrackletTimingStack = new TH2I("trdmon_tracklet_timing_stack", "tracklet timing;TRD stack; time after L0 (us)",
+ 90, 0., 90, 270, 0., 9.);
+ fHistArray->AddLast(fHistTrackletTimingStack);
- fHistTrackStack = new TH2I("hist_tracks_stack", "Number of GTU tracks by stack", 18, 0, 18, 5, 0, 5);
- if (!fHistTrackStack){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackStack);
+ 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);
- fHistTrackletsTrack = new TH1I("hist_tracklets_track", "Tracklets per GTU track", 7, 0, 7);
- if (!fHistTrackletsTrack){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletsTrack);
+ fHistTrackPID = new TH1I("trdmon_track_pid", "PID of TRD online tracks;PID^{TRD, online} (a.u.);abundance", 256, 0, 256);
+ fHistArray->AddLast(fHistTrackPID);
- fHistTrackletsTrackHpt = new TH1I("hist_tracklets_track_hpt", "Tracklets per high-pt GTU track", 7, 0, 7);
- if (!fHistTrackletsTrackHpt){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTrackletsTrackHpt);
+ fHistTrackLayers = new TH1I("trdmon_track_layers", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
+ fHistArray->AddLast(fHistTrackLayers);
- fHistTriggerContribs = new TH2I("hist_trigger_contribs", "Trigger contributions by segment", 18, 0, 18, 12, 0, 12);
- if (!fHistTriggerContribs){
- return -ENOMEM;
- break;
- }
- fHistArray->AddLast(fHistTriggerContribs);
+ fHistTrackLayersHighPt = new TH1I("trdmon_track_layers_hpt", "contributing layers to TRD online tracks;contributing layers;abundance", 7, 0, 7);
+ fHistArray->AddLast(fHistTrackLayersHighPt);
- } while (0);
+ fHistTracksStack = new TH2F("trdmon_tracks_stack", "tracks by stack;TRD sector;TRD stack",
+ 18, 0, 18, 5, 0, 5);
+ fHistArray->AddLast(fHistTracksStack);
- if (iResult<0) {
- // implement cleanup
- if (fRawReaderMem) delete fRawReaderMem;
- fRawReaderMem=NULL;
+ 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);
- if (fRawReaderTrd) delete fRawReaderTrd;
- fRawReaderTrd=NULL;
+ 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);
- if (fTrackletArray) delete fTrackletArray;
- fTrackletArray = NULL;
+ vector<const char*> remainingArgs;
+ for (int i = 0; i < argc; ++i)
+ remainingArgs.push_back(argv[i]);
- if (fGtuTrackArray) delete fGtuTrackArray;
- fGtuTrackArray = NULL;
+ if (argc > 0)
+ ConfigureFromArgumentString(remainingArgs.size(), &(remainingArgs[0]));
- if (fHistArray) delete fHistArray;
- fHistArray = NULL;
+ return 0;
+}
- fHistTrackletY = NULL;
- fHistTrackletDy = NULL;
- fHistTrackletZ = NULL;
- fHistTrackletPID = NULL;
- fHistTrackletYDy = NULL;
- fHistTrackletHC = NULL;
- fHistTrackletBadY = NULL;
- fHistTrackletBadPID = NULL;
- fHistTrackPt = NULL;
- fHistTrackStack = NULL;
- fHistFirstTrackletTime = NULL;
- fHistLastTrackletTime = NULL;
- fHistTmuTime = NULL;
- fHistSmuTime = NULL;
- fHistTrackPt = NULL;
- fHistTrackStack = NULL;
- fHistTrackletsTrack = NULL;
- fHistTrackletsTrackHpt = NULL;
- fHistTrackPID = NULL;
- fHistTriggerContribs = NULL;
+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();
+ }
}
- return iResult;
+ if (fHistArray) delete fHistArray;
+ fHistArray = NULL;
+
+ if (fTrackingData) delete fTrackingData;
+ fTrackingData = NULL;
+
+ return 0;
}
-int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int /*argc*/, const char** /*argv*/)
+int AliHLTTRDMonitorComponent::ScanConfigurationArgument(int argc, const char** argv)
{
- // Scan configuration arguments
- // Return the number of processed arguments
- // -EPROTO if argument format error (e.g. number expected but not found)
- //
- // The AliHLTComponent base class implements a parsing loop for argument strings and
- // arrays of strings which is invoked by ConfigureFromArgumentString/ConfigureFromCDBTObjString
- // The component needs to implement ScanConfigurationArgument in order to decode the arguments.
-
- /*
- int i=0;
- TString argument=argv[i];
-
- if (argument.IsNull()) return 0;
-
- // -mandatory1 arg
- if (argument.CompareTo("-mandatory1")==0) {
- if (++i>=argc) return -EINVAL;
- HLTInfo("got \'-mandatory1\' argument: %s", argv[i]);
- return 2; // keyword + 1 argument
- }
- // -optional1 arg
- if (argument.CompareTo("-optional1")==0) {
- if (++i>=argc) return -EINVAL;
- HLTInfo("got \'-optional1\' argument: %s", argv[i]);
- return 2; // keyword + 1 argument
+ 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;
}
- // -verbose
- if (argument.CompareTo("-verbose")==0) {
- fVerbosity=1;
- return 1; // only keyword
+ 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;
+
}
-int AliHLTTRDMonitorComponent::DoDeinit()
-{
- // component cleanup, delete all instances of helper classes here
- if (fRawReaderMem) delete fRawReaderMem;
- fRawReaderMem=NULL;
+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);
+}
- if (fRawReaderTrd) delete fRawReaderTrd;
- fRawReaderTrd=NULL;
+int AliHLTTRDMonitorComponent::PrepareTRDData() {
- if (fTrackletArray) delete fTrackletArray;
- fTrackletArray = NULL;
+ int result = 1;
- if (fGtuTrackArray) delete fGtuTrackArray;
- fGtuTrackArray = NULL;
-
- if (fHistArray) delete fHistArray;
- fHistArray = NULL;
+ fTrackingData->Clear();
+ for (const AliHLTComponentBlockData* datablock = GetFirstInputBlock(AliHLTTRDDefinitions::fgkOnlineDataType);
+ datablock != NULL;
+ datablock = GetNextInputBlock())
+ {
+ fTrackingData->Decompress(datablock->fPtr, datablock->fSize, kTRUE);
+ }
- fHistTrackletY = NULL;
- fHistTrackletDy = NULL;
- fHistTrackletY = NULL;
- fHistTrackletDy = NULL;
- fHistTrackletZ = NULL;
- fHistTrackletPID = NULL;
- fHistTrackletHC = NULL;
- fHistTrackletBadY = NULL;
- fHistTrackletBadPID = NULL;
- fHistFirstTrackletTime = NULL;
- fHistLastTrackletTime = NULL;
- fHistTmuTime = NULL;
- fHistSmuTime = NULL;
- fHistTrackPt = NULL;
- fHistTrackStack = NULL;
- fHistTrackletsTrack = NULL;
- fHistTrackletsTrackHpt = NULL;
- fHistTrackPID = NULL;
- fHistTriggerContribs = NULL;
+ fTrackingData->PrintSummary("monitor component");
+
+ return result;
- return 0;
}
-int AliHLTTRDMonitorComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/,
- AliHLTComponentTriggerData& /*trigData*/)
-{
- // event processing function
- int iResult=0;
-
- // check if this is a data event, there are a couple of special events
- // which should be ignored for normal processing
- if (!IsDataEvent()) return 0;
-
- // #FIXME: Also take care of SOR, EOR, etc...
-
- // loop over the raw input data blocks and set up the rawreader
- for (const AliHLTComponentBlockData* pBlock = GetFirstInputBlock(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTRD);
- pBlock!=NULL && iResult>=0;
- pBlock=GetNextInputBlock()) {
- // extract DDL id from specification
- int ddlnum=-1;
- for (unsigned pos=0; pos<8*sizeof(AliHLTUInt32_t); pos++) {
- if (pBlock->fSpecification & (0x1<<pos)) {
- if (ddlnum>=0) {
- // this is just an example, please avoid warnings in every event since those will
- // saturate the logging system. Consider AliHLTErrorGuard for such cases, e.g.
- // ALIHLTERRORGUARD(5, "nasty error, first occurence in event %d", event);
- // this will show the error 5 times and then a summary at the end
- HLTWarning("Can not uniquely identify DDL number from specification, skipping data block %s 0x%08x",
- DataType2Text(pBlock->fDataType).c_str(),
- pBlock->fSpecification);
- ddlnum=-1;
- break;
- }
- ddlnum=pos;
+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());
}
- }
- if (ddlnum<0) continue;
- ddlnum += 1024;
-
- // add data block to rawreader
- if(!fRawReaderMem->AddBuffer((UChar_t*) pBlock->fPtr, pBlock->fSize, ddlnum)){
- HLTError("Could not add buffer of data block %s, 0x%08x to rawreader",
- DataType2Text(pBlock->fDataType).c_str(),
- pBlock->fSpecification);
- continue;
- }
- // read and process TRD tracklet and GTU tracks from event
- fTrackletArray->Clear();
- fGtuTrackArray->Clear();
- fRawReaderTrd->ReadEvent();
-
- // read and process tracking/trigger flags
- UInt_t iSector = ddlnum-1024;
- UInt_t trgflags = fRawReaderTrd->GetTriggerFlags(iSector);
- //UInt_t done_tmu = (trgflags >> 27) & 0x1f;
- //UInt_t done_smu = (trgflags >> 22) & 0x1f;
- Float_t smu_timing = ((trgflags >> 12) & 0x3ff) * 0.0083333; // tracking finished after L0, in us
- UInt_t ctb_fired = trgflags & 0xfff;
-
- /*
- printf("Trigger flags sector %02d: 0x%08x - ctb=0x%03x tmu-done=0x%x smu-done=0x%x smu-time: %.2fus\n",
- iSector, trgflags,
- ctb_fired,
- done_tmu,
- done_smu,
- smu_timing
- );
- */
- fHistSmuTime->Fill(smu_timing);
-
- for (int iCtb=0; iCtb<12; iCtb++){
- if ((ctb_fired >> iCtb) & 1)
- fHistTriggerContribs->Fill(iSector, iCtb, 1);
- }
+ // 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
+
+}
+
- Float_t first_tracklet_timing[5]={0};
- Float_t last_tracklet_timing[5]={0};
- Float_t tmu_timing[5]={0};
- ULong64_t trkflags;
-
- for (int iStack=0; iStack<5; iStack++){
- trkflags = fRawReaderTrd->GetTrkFlags(iSector, iStack);
- tmu_timing[iStack]=(trkflags & 0x3ff) * 0.02;
- first_tracklet_timing[iStack]=((trkflags >> 20) & 0x3ff) * 0.008;
- last_tracklet_timing[iStack]=((trkflags >> 10) & 0x3ff) * 0.008;
- /*
- printf(" Stack %02d_%d: 0x%016llx - first tracklet: %.2fus last tracklet: %.2fus tmu timing: %.2fus\n",
- iSector, iStack, trkflags,
- first_tracklet_timing[iStack], last_tracklet_timing[iStack], tmu_timing[iStack]
- );
- */
- fHistFirstTrackletTime->Fill(first_tracklet_timing[iStack]);
- fHistLastTrackletTime->Fill(last_tracklet_timing[iStack]);
- fHistTmuTime->Fill(tmu_timing[iStack]);
+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*/) {
- for (int iTracklet = 0; iTracklet < fTrackletArray->GetEntriesFast(); iTracklet++) {
- AliTRDtrackletWord *trackletWord = (AliTRDtrackletWord*) ((*fTrackletArray)[iTracklet]);
- AliESDTrdTracklet *tracklet = new AliESDTrdTracklet(trackletWord->GetTrackletWord(), trackletWord->GetHCId());
- /*
- printf("TRDMSG: TRD tracklet found: 0x%08x - y=%+5d dy=%+3d pid=%3d\n",
- tracklet->GetTrackletWord(),
- tracklet->GetBinY(),
- tracklet->GetBinDy(),
- tracklet->GetPID());
- */
- // fill some basic histograms right here
- fHistTrackletY->Fill(tracklet->GetBinY());
- fHistTrackletDy->Fill(tracklet->GetBinDy());
- fHistTrackletZ->Fill(tracklet->GetBinZ());
- fHistTrackletPID->Fill(tracklet->GetPID());
- fHistTrackletYDy->Fill(tracklet->GetBinY(), tracklet->GetBinDy());
- fHistTrackletHC->Fill(tracklet->GetHCId()/60, tracklet->GetHCId()%60);
-
- if (TMath::Abs(tracklet->GetBinY()) >= 3682)
- fHistTrackletBadY->Fill(tracklet->GetHCId()/60, (tracklet->GetHCId()%60)/12);
-
- if (tracklet->GetPID() < 40)
- fHistTrackletBadPID->Fill(tracklet->GetHCId()/60, (tracklet->GetHCId()%60)/12);
+ 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;
}
- for (int iTrack = 0; iTrack < fGtuTrackArray->GetEntriesFast(); iTrack++) {
- AliESDTrdTrack *trdTrack = (AliESDTrdTrack*) ((*fGtuTrackArray)[iTrack]);
- /*
- printf("TRDMSG: GTU track found: 0x%016llx - Stack %02d_%d pt=%.3fGeV/c\n",
- trdTrack->GetTrackWord(0),
- trdTrack->GetSector(), trdTrack->GetStack(),
- trdTrack->Pt());
- */
- fHistTrackPt->Fill(trdTrack->Pt());
- fHistTrackStack->Fill(trdTrack->GetSector(), trdTrack->GetStack());
- fHistTrackPID->Fill(trdTrack->GetPID());
-
- Int_t layers=0;
- Int_t layer_mask = trdTrack->GetLayerMask();
- for (Int_t iLayer=0; iLayer<6; iLayer++)
- if ((layer_mask >> iLayer) & 1)
- layers++;
- fHistTrackletsTrack->Fill(layers);
- if (TMath::Abs(trdTrack->Pt()) >= 3.)
- fHistTrackletsTrackHpt->Fill(layers);
+ if (fTrackingData->GetNumTracks() + fTrackingData->GetNumTracklets() == 0) {
+ LogDebug("no TRD-relevant information, skipping further event processing");
+ break;
}
- // do more complex processing here, preferably in a dedicated class
+ fHistEventTypes->Fill(2.);
- // push TObject-based data to output
- iResult = PushBack(fHistArray,
- (kAliHLTDataTypeTObject | kAliHLTDataOriginTRD),
- pBlock->fSpecification);
+ // DumpTrackingData();
- if (iResult != 0)
- break;
-
- // clear the rawreader
- fRawReaderMem->ClearBuffers();
- if (iResult != 0)
+ if (!ProcessTRDData()) {
+ LogError("processing of TRD data failed, skipping further event processing");
break;
- }
+ }
- return iResult;
-}
+ break;
-int AliHLTTRDMonitorComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
-{
- // reconfigure the component from the specified CDB entry, or default CDB entry
- // function is invoked by the framework if a reconfigure command was received.
- //
- int iResult=0;
- /*
- TString cdbPath;
- if (cdbEntry) {
- cdbPath=cdbEntry;
- } else {
- cdbPath="HLT/ConfigSample/";
- cdbPath+=GetComponentID();
- }
- AliInfoClass(Form("reconfigure '%s' from entry %s%s", chainId, cdbPath.Data(), cdbEntry?"":" (default)"));
- iResult=ConfigureFromCDBTObjString(cdbPath);
- */
- return iResult;
-}
+ } while (1);
+
+ PushBack(fHistArray, (kAliHLTDataTypeTObjArray | kAliHLTDataOriginTRD), 0x3fffff);
+
+ LogDebug("### END DoEvent [event id: %llu, %d blocks, size: %d]",
+ fEventId, evtData.fBlockCnt, evtData.fStructSize);
-int AliHLTTRDMonitorComponent::ReadPreprocessorValues(const char* /*modules*/)
-{
- // read the preprocessor values for the detectors in the modules list
- // function is invoked by the framework if the pendolino indivates an update
- // of online calibration objects, e.g temperature and pressure measurements.
- int iResult=0;
- /*
- TString detectors(modules!=NULL?modules:"");
- AliInfoClass(Form("read preprocessor values for detector(s): %s", detectors.IsNull()?"none":detectors.Data()));
- */
return iResult;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff