use AliLog message scheme
authortkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 16 Sep 2004 10:05:07 +0000 (10:05 +0000)
committertkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 16 Sep 2004 10:05:07 +0000 (10:05 +0000)
14 files changed:
MONITOR/AliMonitor.cxx
MONITOR/AliMonitorClient.cxx
MONITOR/AliMonitorControl.cxx
MONITOR/AliMonitorDataTPC.cxx
MONITOR/AliMonitorDialog.cxx
MONITOR/AliMonitorHLT.cxx
MONITOR/AliMonitorHLTHough.cxx
MONITOR/AliMonitorHisto.cxx
MONITOR/AliMonitorITS.cxx
MONITOR/AliMonitorProcess.cxx
MONITOR/AliMonitorTPC.cxx
MONITOR/AliMonitorTrend.cxx
MONITOR/AliMonitorV0s.cxx
MONITOR/client.C

index c84d711..95d5dda 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 
-#include "AliMonitor.h"
-#include "AliMonitorTrend.h"
 #include <TFolder.h>
 #include <TH1.h>
 #include <TH2.h>
 
+#include "AliLog.h"
+#include "AliMonitorTrend.h"
+
+#include "AliMonitor.h"
+
 
 ClassImp(AliMonitor) 
 
@@ -48,13 +51,13 @@ AliMonitor::AliMonitor()
 AliMonitor::AliMonitor(const AliMonitor& monitor) :
   TObject(monitor)
 {
-  Fatal("AliMonitor", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitor& AliMonitor::operator = (const AliMonitor& /*monitor*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
index c1cec6f..81b3987 100644 (file)
@@ -26,6 +26,7 @@
 
 #include "AliMonitorClient.h"
 #include "AliMonitorProcess.h"
+#include "AliLog.h"
 #include <TGMsgBox.h>
 #include <TGFileDialog.h>
 #include <TMessage.h>
@@ -459,14 +460,14 @@ AliMonitorClient::AliMonitorClient():
 AliMonitorClient::AliMonitorClient(const AliMonitorClient& client) :
   TGMainFrame(client)
 {
-  Fatal("AliMonitorClient", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorClient& AliMonitorClient::operator = (const AliMonitorClient& 
                                                /*client*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
@@ -1025,8 +1026,8 @@ Bool_t AliMonitorClient::ConnectToServer()
                              "OnNewData()");
       fSocketHandler->Add();
       TInetAddress adr = fSocket->GetInetAddress();
-      Info("ConnectToServer", "connected to server:\n %s (%s), port %d\n",
-          adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliInfo(Form("connected to server: %s (%s), port %d",
+                  adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
       fMenuFile->HideEntry(kMenuFileConnect);
       fMenuFile->HideEntry(kMenuFileOpen);
       fMenuFile->EnableEntry(kMenuFileDisconnect);
@@ -1351,8 +1352,7 @@ Bool_t AliMonitorClient::SaveFavorites()
   }
 
   fclose(file);
-  Info("SaveFavorites", "favorites saved to file %s", 
-       fFavoritesFileName.Data());
+  AliInfo(Form("favorites saved to file %s", fFavoritesFileName.Data()));
   return kTRUE;
 }
 
@@ -1558,8 +1558,8 @@ Bool_t AliMonitorClient::SaveReference()
   fReference->Write();
   file->Close();
   delete file;
-  Info("SaveReference", "reference histograms saved to file %s", 
-       fReferenceFileName.Data());
+  AliInfo(Form("reference histograms saved to file %s", 
+              fReferenceFileName.Data()));
   return kTRUE;
 }
 
@@ -1666,7 +1666,7 @@ void AliMonitorClient::LoadSettings()
   }
 
   fclose(file);
-  Info("LoadSettings", "settings from file %s applied", fileName);
+  AliDebug(1, Form("settings from file %s applied", fileName));
   free(fileName);
 }
 
@@ -1719,7 +1719,7 @@ void AliMonitorClient::SaveSettings()
          fMenuOptions->IsEntryChecked(kMenuOptSaveOnExit));
 
   fclose(file);
-  Info("SaveSettings", "settings saved to file %s", fileName);
+  AliInfo(Form("settings saved to file %s", fileName));
   free(fileName);
 }
 
index 2fdf7ca..ead3bc8 100644 (file)
@@ -24,6 +24,7 @@
 
 #include "AliMonitorControl.h"
 #include "AliMonitorHisto.h"
+#include "AliLog.h"
 #include <TGNumberEntry.h>
 #include <TGTextView.h>
 #include <TGMsgBox.h>
@@ -301,14 +302,14 @@ AliMonitorControl::AliMonitorControl(AliMonitorProcess* process)
 AliMonitorControl::AliMonitorControl(const AliMonitorControl& control) :
   TObject(control)
 {
-  Fatal("AliMonitorControl", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorControl& AliMonitorControl::operator = (const AliMonitorControl& 
                                                  /*control*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
index 02a44ab..8c720ca 100644 (file)
@@ -22,6 +22,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 
+#include "AliLog.h"
 #include "AliMonitorDataTPC.h"
 
 
@@ -41,14 +42,14 @@ AliMonitorDataTPC::AliMonitorDataTPC()
 AliMonitorDataTPC::AliMonitorDataTPC(const AliMonitorDataTPC& data) :
   TObject(data)
 {
-  Fatal("AliMonitorDataTPC", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorDataTPC& AliMonitorDataTPC::operator = (const AliMonitorDataTPC& 
                                                  /*data*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
@@ -104,7 +105,7 @@ void AliMonitorDataTPC::SetData(Int_t i, Float_t pt, Float_t eta, Float_t phi)
 // set the data of the i-th track
 
   if ((i < 0) || (i >= fSize)) {
-    Error("SetData", "index %d out of range (0-%d)", i, fSize);
+    AliError(Form("index %d out of range (0-%d)", i, fSize));
     return;
   }
   fPt[i] = pt;
index 32094ad..22afcd3 100644 (file)
@@ -23,6 +23,7 @@
 
 
 #include "AliMonitorDialog.h"
+#include "AliLog.h"
 #include <TGFrame.h>
 #include <TGButton.h>
 
@@ -85,14 +86,14 @@ AliMonitorDialog::AliMonitorDialog(TGFrame* main, Int_t width, Int_t height,
 AliMonitorDialog::AliMonitorDialog(const AliMonitorDialog& dlg) :
   TObject(dlg)
 {
-  Fatal("AliMonitorDialog", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorDialog& AliMonitorDialog::operator = (const AliMonitorDialog& 
                                                /*dlg*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
index 1b95f30..c546ee6 100644 (file)
@@ -25,6 +25,7 @@
 #include "AliMonitorHLT.h"
 #include "AliMonitorTrend.h"
 #include "AliTPCParam.h"
+#include "AliLog.h"
 #include <TFolder.h>
 #include <stdlib.h>
 #include "AliL3MemHandler.h"
@@ -46,13 +47,13 @@ AliMonitorHLT::AliMonitorHLT(AliTPCParam* param)
 AliMonitorHLT::AliMonitorHLT(const AliMonitorHLT& monitor) :
   AliMonitor(monitor)
 {
-  Fatal("AliMonitorHLT", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorHLT& AliMonitorHLT::operator = (const AliMonitorHLT& /*monitor*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
@@ -155,7 +156,7 @@ void AliMonitorHLT::FillHistos(AliRunLoader* /*runLoader*/,
     char fileName[256];
     sprintf(fileName, "hlt/points_%d_-1.raw", iSector);
     if (!clusterHandler[iSector].SetBinaryInput(fileName)) {
-      Warning("FillHistos", "could not open file %s", fileName);
+      AliWarning(Form("could not open file %s", fileName));
       continue;
     }
     clusters[iSector] = (AliL3SpacePointData*) clusterHandler[iSector].Allocate();
@@ -176,7 +177,7 @@ void AliMonitorHLT::FillHistos(AliRunLoader* /*runLoader*/,
 
   AliL3MemHandler memHandler;
   if (!memHandler.SetBinaryInput("hlt/tracks.raw")) {
-    Warning("FillHistos", "could not open file hlt/tracks.raw");
+    AliWarning("could not open file hlt/tracks.raw");
     return;
   }
   AliL3TrackArray* tracks = new AliL3TrackArray;
index f8e30a5..7571dee 100644 (file)
@@ -25,6 +25,7 @@
 #include "AliMonitorHisto.h"
 #include "AliMonitorTrend.h"
 #include "AliTPCParam.h"
+#include "AliLog.h"
 #include <TFolder.h>
 #include <stdlib.h>
 #include <AliL3MemHandler.h>
@@ -45,14 +46,14 @@ AliMonitorHLTHough::AliMonitorHLTHough(AliTPCParam* param)
 AliMonitorHLTHough::AliMonitorHLTHough(const AliMonitorHLTHough& monitor) :
   AliMonitor(monitor)
 {
-  Fatal("AliMonitorHLTHough", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorHLTHough& AliMonitorHLTHough::operator = (const AliMonitorHLTHough& 
                                                    /*monitor*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
@@ -139,7 +140,7 @@ void AliMonitorHLTHough::FillHistos(AliRunLoader* /*runLoader*/,
       char fileName[256];
       sprintf(fileName, "hlt/fitter/points_%d_%d.raw", iSector,iPatch);
       if (!clusterHandler[iSector][iPatch].SetBinaryInput(fileName)) {
-       Warning("FillHistos", "could not open file %s", fileName);
+       AliWarning(Form("could not open file %s", fileName));
        continue;
       }
       clusters[iSector][iPatch] = (AliL3SpacePointData*) clusterHandler[iSector][iPatch].Allocate();
@@ -166,7 +167,7 @@ void AliMonitorHLTHough::FillHistos(AliRunLoader* /*runLoader*/,
   char fileName[256];
   sprintf(fileName, "hlt/fitter/tracks.raw");
   if (!memHandler.SetBinaryInput(fileName)) {
-    Warning("FillHistos", "could not open file hlt/fitter/tracks.raw");
+    AliWarning("could not open file hlt/fitter/tracks.raw");
     return;
   }
   AliL3TrackArray* tracks = new AliL3TrackArray;
index c57eb55..f2545c2 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 
-#include "AliMonitorHisto.h"
 #include <TProfile.h>
 #include <TH2.h>
 #include <TVirtualPad.h>
 
+#include "AliLog.h"
+
+#include "AliMonitorHisto.h"
+
 
 ClassImp(AliMonitorHisto) 
 
@@ -115,7 +118,7 @@ AliMonitorHisto::AliMonitorHisto(TH1* histo, ENorm norm) :
 // create a monitor histogram from the given histogram
 
   if (histo->GetDimension() > 2) {
-    Fatal("AliMonitorHisto", "3 dimensional histograms are not supported");
+    AliFatal("3 dimensional histograms are not supported");
   }
 
   histo->SetDirectory(NULL);
@@ -196,7 +199,7 @@ void AliMonitorHisto::Fill(Axis_t x, Axis_t y, Stat_t w)
   } else if (fHisto->InheritsFrom(TProfile::Class())) {
     ((TProfile*)fHisto)->Fill(x, y, w);
   } else {
-    Error("Fill", "trying to fill x and y of a 1 dimensinal histogram");
+    AliError("trying to fill x and y of a 1 dimensinal histogram");
     return;
   }
 }
@@ -325,7 +328,7 @@ Bool_t AliMonitorHisto::ComparePlot()
   if (!fHistoRef) return kTRUE;
   if (fgThreshold <= 0) return kTRUE;
   if (!fHistoDraw) {
-    Info("Compare", "no data histogram available for comparison\ncall DrawEvent, DrawSum or DrawRaw before calling Compare");
+    AliWarning("no data histogram available for comparison\ncall DrawEvent, DrawSum or DrawRaw before calling Compare");
     return kTRUE;
   }
   if (fHistoCompare) delete fHistoCompare;
@@ -365,12 +368,12 @@ Bool_t AliMonitorHisto::GetEvent(Int_t number)
 // get the normalized monitor histogram for the "number"th last event
 
   if (fNHistos == 0) {
-    Info("GetEvent", "there are no histograms for single events available");
+    AliWarning("there are no histograms for single events available");
     return kFALSE;
   }
   if (number > fNHistos) {
-    Error("GetEvent", "requested event number (%d) exceeds range of available events (%d)\n", 
-         number, fNHistos);
+    AliError(Form("requested event number (%d) exceeds range of available events (%d)", 
+                 number, fNHistos));
     return kFALSE;
   }
   if (number <= 0) return kFALSE;
@@ -397,12 +400,12 @@ Bool_t AliMonitorHisto::GetSum(Int_t number)
 // "number" events
 
   if (fNHistos == 0) {
-    Info("GetSum", "there are no histograms for single events available");
+    AliWarning("there are no histograms for single events available");
     return kFALSE;
   }
   if (number > fNHistos) {
-    Info("GetSum", "requested number of events (%d) exceeds range of available events (%d)\nusing last %d event(s)", 
-         number, fNHistos, fNHistos);
+    AliError(Form("requested number of events (%d) exceeds range of available events (%d)\nusing last %d event(s)", 
+                 number, fNHistos, fNHistos));
     number = fNHistos;
   }
   if (number <= 0) return kFALSE;
index 30e78e1..c98d898 100644 (file)
@@ -25,6 +25,7 @@
 #include <TTree.h>
 #include <TVector3.h>
 
+#include "AliLog.h"
 #include "AliESD.h"
 #include "AliITSRawStreamSDD.h"
 #include "AliITSRawStreamSSD.h"
@@ -51,13 +52,13 @@ AliMonitorITS::AliMonitorITS(AliITSgeom* geom)
 AliMonitorITS::AliMonitorITS(const AliMonitorITS& monitor) :
   AliMonitor(monitor)
 {
-  Fatal("AliMonitorITS", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorITS& AliMonitorITS::operator = (const AliMonitorITS& /*monitor*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
index 1e561d4..0ce60c8 100644 (file)
@@ -33,6 +33,7 @@
 #include <TServerSocket.h>
 #include <TSocket.h>
 
+#include "AliLog.h"
 #include "AliESD.h"
 #include "AliITS.h"
 #include "AliITSclustererV2.h"
@@ -122,33 +123,32 @@ AliMonitorProcess::AliMonitorProcess(
 #endif
   if (!fGrid || fGrid->IsZombie() || !fGrid->IsConnected()) {
     delete fGrid;
-    Fatal("AliMonitorProcess", "could not connect to alien");
+    AliFatal("could not connect to alien");
   }
 #if ROOT_VERSION_CODE <= 199169   // 3.10/01
   fGrid->cd(alienDir);
 #endif
 
   fRunLoader = AliRunLoader::Open(fileNameGalice);
-  if (!fRunLoader) Fatal("AliMonitorProcess", 
-                        "could not get run loader from file %s", 
-                        fileNameGalice);
+  if (!fRunLoader) AliFatal(Form("could not get run loader from file %s", 
+                                fileNameGalice));
 
   fRunLoader->CdGAFile();
   fTPCParam = AliTPC::LoadTPCParam(gFile);
-  if (!fTPCParam) Fatal("AliMonitorProcess", "could not load TPC parameters");
+  if (!fTPCParam) AliFatal("could not load TPC parameters");
 
   fRunLoader->LoadgAlice();
   gAlice = fRunLoader->GetAliRun();
-  if (!gAlice) Fatal("AliMonitorProcess", "no gAlice object found");
+  if (!gAlice) AliFatal("no gAlice object found");
   AliITS* its = (AliITS*) gAlice->GetModule("ITS");
-  if (!its) Fatal("AliMonitorProcess", "no ITS detector found");
+  if (!its) AliFatal("no ITS detector found");
   fITSgeom = its->GetITSgeom();
-  if (!fITSgeom) Fatal("AliMonitorProcess", "could not load ITS geometry");
+  if (!fITSgeom) AliFatal("could not load ITS geometry");
 
   // Init TPC parameters for HLT
   Bool_t isinit=AliL3Transform::Init(const_cast<char*>(fileNameGalice),kTRUE);
   if(!isinit){
-    Fatal("AliMonitorProcess", "Could not create transform settings, please check log for error messages!");
+    AliFatal("Could not create transform settings, please check log for error messages!");
   }
 
   fTopFolder = new TFolder("Monitor", "monitor histograms");
@@ -170,7 +170,7 @@ AliMonitorProcess::AliMonitorProcess(
 
   fFile = TFile::Open("monitor_tree.root", "RECREATE");
   if (!fFile || !fFile->IsOpen()) {
-    Fatal("AliMonitorProcess", "could not open file for tree");
+    AliFatal("could not open file for tree");
   }
   fTree = new TTree("MonitorTree", "tree for monitoring");
   for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
@@ -222,14 +222,14 @@ AliMonitorProcess::AliMonitorProcess(const AliMonitorProcess& process) :
   fInterruptHandler(NULL)
 
 {
-  Fatal("AliMonitorProcess", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorProcess& AliMonitorProcess::operator = (const AliMonitorProcess& 
                                                  /*process*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
@@ -324,8 +324,8 @@ void AliMonitorProcess::ProcessFile(const char* fileName)
 // create a file with monitor histograms for a single file
 
   if (GetStatus() != kStopped) {
-    Error("ProcessFile", "ProcessFile can not be called"
-         " while the monitor process is running");
+    AliError("ProcessFile can not be called"
+            " while the monitor process is running");
     return;
   }
 
@@ -354,8 +354,8 @@ Bool_t AliMonitorProcess::CheckForNewFile()
   sprintf(findName, "*.root");
   Grid_ResultHandle_t handle = fGrid->Find(dirName, findName);
   if (!handle) {
-    Error("CheckForNewFile", "could not open alien directory %s", 
-         dirName);
+    AliError(Form("could not open alien directory %s", 
+                 dirName));
     return kFALSE;
   }
   TGridResult* result = fGrid->CreateGridResult(handle);
@@ -401,16 +401,16 @@ Bool_t AliMonitorProcess::CheckForNewFile()
   fileName = dirName + ("/" + fLogicalFileName);
   handle = fGrid->GetPhysicalFileNames(fileName.Data());
   if (!handle) {
-    Error("CheckForNewFile", "could not get physical file names for %s", 
-         fileName.Data());
+    AliError(Form("could not get physical file names for %s", 
+                 fileName.Data()));
     return kFALSE;
   }
   result = fGrid->CreateGridResult(handle);
   result->Reset();
   Grid_Result_t* resultEntry = result->Next();
   if (!resultEntry) {
-    Error("CheckForNewFile", "could not get physical file names for %s", 
-         fileName.Data());
+    AliError(Form("could not get physical file names for %s", 
+                 fileName.Data()));
     return kFALSE;
   }
   fFileName = resultEntry->name2.c_str();
@@ -429,8 +429,8 @@ Bool_t AliMonitorProcess::ProcessFile()
 
   Int_t nEvents = GetNumberOfEvents(fFileName);
   if (nEvents <= 0) return kFALSE;
-  Info("ProcessFile", "found %d event(s) in file %s", 
-       nEvents, fFileName.Data());
+  AliDebug(1, Form("found %d event(s) in file %s", 
+                  nEvents, fFileName.Data()));
   if (IsSelected("HLTConfMap")) CreateHLT(fFileName);
   if (IsSelected("HLTHough")) CreateHLTHough(fFileName);
 
@@ -454,8 +454,8 @@ Bool_t AliMonitorProcess::ProcessFile()
     // monitor only central physics events
     if (rawReader.GetType() != 7) continue;
     if ((rawReader.GetAttributes()[0] & 0x02) == 0) continue;
-    Info("ProcessFile", "run: %d  event: %d %d\n", rawReader.GetRunNumber(), 
-        rawReader.GetEventId()[0], rawReader.GetEventId()[1]);
+    AliInfo(Form("run: %d  event: %d %d\n", rawReader.GetRunNumber(), 
+                rawReader.GetEventId()[0], rawReader.GetEventId()[1]));
 
     AliESD esd;
     if (IsSelected("TPC")) {
@@ -486,7 +486,7 @@ Bool_t AliMonitorProcess::ProcessFile()
 
     if (fDisplaySocket) fDisplaySocket->Send("new event");
 
-    Info("ProcessFile", "filling histograms...");
+    AliDebug(1, "filling histograms...");
     for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
       CheckForConnections();
       SetStatus(kFilling);
@@ -496,7 +496,7 @@ Bool_t AliMonitorProcess::ProcessFile()
     }
     if (fStopping) break;
 
-    Info("ProcessFile", "updating histograms...");
+    AliDebug(1, "updating histograms...");
     CheckForConnections();
     SetStatus(kUpdating);
     TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
@@ -510,10 +510,10 @@ Bool_t AliMonitorProcess::ProcessFile()
     delete iFolder;
     if (fStopping) break;
 
-    Info("ProcessFile", "filling the tree...");
+    AliDebug(1, "filling the tree...");
     fTree->Fill();
 
-    Info("ProcessFile", "broadcasting histograms...");
+    AliDebug(1, "broadcasting histograms...");
     CheckForConnections();
     BroadcastHistos();
 
@@ -578,14 +578,14 @@ Int_t AliMonitorProcess::GetNumberOfEvents(const char* fileName) const
 
   TFile* file = TFile::Open(fileName);
   if (!file || !file->IsOpen()) {
-    Error("GetNumberOfEvents", "could not open file %s", fileName);
+    AliError(Form("could not open file %s", fileName));
     if (file) delete file;
     return -1;
   }
 
   TTree* tree = (TTree*) file->Get("RAW");
   if (!tree) {
-    Error("GetNumberOfEvents", "could not find tree with raw data");
+    AliError("could not find tree with raw data");
   } else {
     nEvents = (Int_t) tree->GetEntries();
   }
@@ -604,13 +604,13 @@ Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader, AliESD* esd)
 
   AliLoader* tpcLoader = fRunLoader->GetLoader("TPCLoader");
   if (!tpcLoader) {
-    Error("ReconstructTPC", "no TPC loader found");
+    AliError("no TPC loader found");
     return kFALSE;
   }
   gSystem->Unlink("TPC.RecPoints.root");
 
   // cluster finder
-  Info("ReconstructTPC", "reconstructing clusters...");
+  AliDebug(1, "reconstructing clusters...");
   tpcLoader->LoadRecPoints("recreate");
   AliTPCclustererMI clusterer(fTPCParam);
   tpcLoader->MakeRecPointsContainer();
@@ -619,7 +619,7 @@ Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader, AliESD* esd)
   tpcLoader->WriteRecPoints("OVERWRITE");
 
   // track finder
-  Info("ReconstructTPC", "reconstructing tracks...");
+  AliDebug(1, "reconstructing tracks...");
   AliTPCtrackerMI tracker(fTPCParam);
   tracker.LoadClusters(tpcLoader->TreeR());
   tracker.Clusters2Tracks(esd);
@@ -638,20 +638,20 @@ Bool_t AliMonitorProcess::ReconstructITS(AliRawReader* rawReader, AliESD* esd)
 
   AliLoader* itsLoader = fRunLoader->GetLoader("ITSLoader");
   if (!itsLoader) {
-    Error("ReconstructITS", "no ITS loader found");
+    AliError("no ITS loader found");
     return kFALSE;
   }
   gSystem->Unlink("ITS.RecPoints.root");
 
   // cluster finder
-  Info("ReconstructITS", "reconstructing clusters...");
+  AliDebug(1, "reconstructing clusters...");
   itsLoader->LoadRecPoints("recreate");
   AliITSclustererV2 clusterer(fITSgeom);
   itsLoader->MakeRecPointsContainer();
   clusterer.Digits2Clusters(rawReader);
 
   // track finder
-  Info("ReconstructITS", "reconstructing tracks...");
+  AliDebug(1, "reconstructing tracks...");
   AliITStrackerV2 tracker(fITSgeom);
   tracker.LoadClusters(itsLoader->TreeR());
   tracker.Clusters2Tracks(esd);
@@ -669,7 +669,7 @@ Bool_t AliMonitorProcess::ReconstructV0s(AliESD* esd)
   SetStatus(kRecV0s);
 
   // V0 finder
-  Info("ReconstructV0s", "reconstructing V0s...");
+  AliDebug(1, "reconstructing V0s...");
   AliV0vertexer vertexer;
   Double_t vtx[3];
   esd->GetVertex()->GetXYZ(vtx);
@@ -889,7 +889,7 @@ Bool_t AliMonitorProcess::WriteHistos()
 
   fFile = TFile::Open("monitor_tree.root", "RECREATE");
   if (!fFile || !fFile->IsOpen()) {
-    Fatal("WriteHistos", "could not open file for tree");
+    AliFatal("could not open file for tree");
   }
   fTree = new TTree("MonitorTree", "tree for monitoring");
   for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
@@ -919,7 +919,7 @@ Bool_t AliMonitorProcess::WriteHistos()
   }
   TFile* file = TFile::Open(fileName, "recreate");
   if (!file || !file->IsOpen()) {
-    Error("WriteHistos", "could not open file %s", fileName);
+    AliError(Form("could not open file %s", fileName));
     result = kFALSE;
   } else {
     fTopFolder->Write();
@@ -963,9 +963,9 @@ void AliMonitorProcess::CheckForConnections()
       gSystem->Sleep(1000);
       if (socket->Recv(socketType, 255) <= 0) {
        TInetAddress adr = socket->GetInetAddress();
-       Error("CheckForConnections", "no socket type received - "
-             "disconnect client:\n %s (%s), port %d\n",
-             adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+       AliError(Form("no socket type received - "
+                     "disconnect client: %s (%s), port %d",
+                     adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
        delete socket;
        continue;
       }
@@ -973,8 +973,8 @@ void AliMonitorProcess::CheckForConnections()
     if (strcmp(socketType, "client") == 0) {
       fSockets.Add(socket);
       TInetAddress adr = socket->GetInetAddress();
-      Info("CheckForConnections", "new client:\n %s (%s), port %d\n",
-          adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliInfo(Form("new client: %s (%s), port %d",
+                  adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
       if (fNEvents > 0) BroadcastHistos(socket);
     } else if (strcmp(socketType, "display") == 0) {
       if (fDisplaySocket) {
@@ -983,13 +983,13 @@ void AliMonitorProcess::CheckForConnections()
       }
       fDisplaySocket = socket;
       TInetAddress adr = socket->GetInetAddress();
-      Info("CheckForConnections", "new display:\n %s (%s), port %d\n",
-          adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliInfo(Form("new display: %s (%s), port %d",
+                  adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
     } else {
       TInetAddress adr = socket->GetInetAddress();
-      Error("CheckForConnections", "unknown socket type %s - "
-           "disconnect client:\n %s (%s), port %d\n", socketType,
-           adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliError(Form("unknown socket type %s - "
+                   "disconnect client: %s (%s), port %d", socketType,
+                   adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
       delete socket;
       continue;
     }
@@ -1003,9 +1003,8 @@ void AliMonitorProcess::CheckForConnections()
     if (socket->Recv(controlMessage, 255)) {
       if (strcmp(controlMessage, "disconnect") == 0) {
        TInetAddress adr = socket->GetInetAddress();
-       Info("CheckForConnections",
-            "disconnect client:\n %s (%s), port %d\n",
-            adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+       AliInfo(Form("disconnect client: %s (%s), port %d",
+                    adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
        delete fSockets.RemoveAt(iSocket);
        continue;
       }
@@ -1013,9 +1012,8 @@ void AliMonitorProcess::CheckForConnections()
     if (!socket->IsValid()) {
       // remove invalid sockets from the list
       TInetAddress adr = socket->GetInetAddress();
-      Error("CheckForConnections", 
-           "disconnect invalid client:\n %s (%s), port %d\n",
-           adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliError(Form("disconnect invalid client: %s (%s), port %d",
+                   adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
       delete fSockets.RemoveAt(iSocket);
     }
   }
@@ -1039,9 +1037,9 @@ void AliMonitorProcess::BroadcastHistos(TSocket* toSocket)
     // send control message
     if (!socket->IsValid() || (socket->Send("histograms") <= 0)) {
       TInetAddress adr = socket->GetInetAddress();
-      Error("BroadcastHistos", "connection to client failed - "
-           "disconnect client:\n %s (%s), port %d\n",
-           adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliError(Form("connection to client failed - "
+                   "disconnect client: %s (%s), port %d",
+                   adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
       delete fSockets.RemoveAt(iSocket);
     }
 
@@ -1054,17 +1052,17 @@ void AliMonitorProcess::BroadcastHistos(TSocket* toSocket)
     }
     if (result <= 0) {
       TInetAddress adr = socket->GetInetAddress();
-      Error("BroadcastHistos", "no response from client - "
-           "disconnect client:\n %s (%s), port %d\n",
-           adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliError(Form("no response from client - "
+                   "disconnect client: %s (%s), port %d",
+                   adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
       delete fSockets.RemoveAt(iSocket);
       continue;
     }
     if (strcmp(controlMessage, "ok") != 0) {
       TInetAddress adr = socket->GetInetAddress();
-      Error("BroadcastHistos", "no \"ok\" message from client - "
-           "disconnect client:\n %s (%s), port %d\n",
-           adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliError(Form("no \"ok\" message from client - "
+                   "disconnect client: %s (%s), port %d",
+                   adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
       delete fSockets.RemoveAt(iSocket);
       continue;
     }
@@ -1073,9 +1071,9 @@ void AliMonitorProcess::BroadcastHistos(TSocket* toSocket)
     if (socket->Send(message) < 0) {
       // remove the socket from the list if there was an error
       TInetAddress adr = socket->GetInetAddress();
-      Error("BroadcastHistos", "sending histograms failed - "
-           "disconnect client:\n %s (%s), port %d\n",
-           adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+      AliError(Form("sending histograms failed - "
+                   "disconnect client: %s (%s), port %d",
+                   adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
       delete fSockets.RemoveAt(iSocket);
     } else {
       gSystem->Sleep(100);
@@ -1102,7 +1100,7 @@ AliMonitorProcess::AliMonitorInterruptHandler::AliMonitorInterruptHandler
 {
 // copy constructor
 
-  Fatal("AliMonitorInterruptHandler", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
@@ -1112,7 +1110,7 @@ AliMonitorProcess::AliMonitorInterruptHandler&
 {
 // assignment operator
 
-  Fatal("operator =", "assignment operator not implemented"); 
+  AliFatal("assignment operator not implemented"); 
   return *this;
 }
 
@@ -1121,7 +1119,7 @@ Bool_t AliMonitorProcess::AliMonitorInterruptHandler::Notify()
 {
 // interrupt signal -> stop process
 
-  Info("Notify", "the monitoring process will be stopped.");
+  AliInfo("the monitoring process will be stopped.");
   fProcess->Stop(); 
   return kTRUE;
 }
index 48743e7..14a1260 100644 (file)
@@ -25,6 +25,7 @@
 #include <TTree.h>
 #include <TVector3.h>
 
+#include "AliLog.h"
 #include "AliESD.h"
 #include "AliMonitorDataTPC.h"
 #include "AliMonitorHisto.h"
@@ -53,13 +54,13 @@ AliMonitorTPC::AliMonitorTPC(AliTPCParam* param)
 AliMonitorTPC::AliMonitorTPC(const AliMonitorTPC& monitor) :
   AliMonitor(monitor)
 {
-  Fatal("AliMonitorTPC", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorTPC& AliMonitorTPC::operator = (const AliMonitorTPC& /*monitor*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
index f822591..49a8ded 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 
-#include "AliMonitorTrend.h"
 #include <TH1.h>
 #include <TVirtualPad.h>
 #include <TLine.h>
 
+#include "AliLog.h"
+
+#include "AliMonitorTrend.h"
+
 
 ClassImp(AliMonitorTrend) 
 
@@ -214,7 +217,7 @@ Bool_t AliMonitorTrend::ComparePlot()
   if (fRefSigma < 0) return kTRUE;
   if (fgThreshold <= 0) return kTRUE;
   if (!fHistoDraw) {
-    Info("Compare", "no data trend available for comparison\ncall DrawSum or DrawRaw before calling Compare");
+    AliWarning("no data trend available for comparison\ncall DrawSum or DrawRaw before calling Compare");
     return kTRUE;
   }
 
@@ -253,8 +256,8 @@ Bool_t AliMonitorTrend::GetSum(Int_t number)
 // get the monitor trend for the last  "number" events
 
   if (number > fNumberOfEvents) {
-    Info("GetSum", "requested number of events (%d) exceeds range of available events (%d)\nusing last %d event(s)", 
-         number, fNumberOfEvents, fNumberOfEvents);
+    AliError(Form("requested number of events (%d) exceeds range of available events (%d)\nusing last %d event(s)", 
+         number, fNumberOfEvents, fNumberOfEvents));
     number = fNumberOfEvents;
   }
   if (number <= 0) return kFALSE;
index 4fc6d88..84bcaa6 100644 (file)
@@ -25,6 +25,7 @@
 #include "AliMonitorV0s.h"
 #include "AliMonitorHisto.h"
 #include "AliESD.h"
+#include "AliLog.h"
 #include <TFolder.h>
 #include <TPDGCode.h>
 
@@ -43,13 +44,13 @@ AliMonitorV0s::AliMonitorV0s()
 AliMonitorV0s::AliMonitorV0s(const AliMonitorV0s& monitor) :
   AliMonitor(monitor)
 {
-  Fatal("AliMonitorV0s", "copy constructor not implemented");
+  AliFatal("copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
 AliMonitorV0s& AliMonitorV0s::operator = (const AliMonitorV0s& /*monitor*/)
 {
-  Fatal("operator =", "assignment operator not implemented");
+  AliFatal("assignment operator not implemented");
   return *this;
 }
 
index d0b1c3d..869158c 100644 (file)
@@ -6,13 +6,11 @@
 void client()
 {
   // load libraries
-  if (strcmp(gSystem->Getenv("ALIHLT_USEPACKAGE"), "ALIROOT") == 0) {
-    if (!gROOT->GetClass("AliLevel3")) {
-      gSystem->Load("libAliL3Src.so");
-      gSystem->Load("libAliL3Misc.so");
-      gSystem->Load("libAliL3Hough.so");
-      gSystem->Load("libAliL3Comp.so");
-    }
+  if (!gROOT->GetClass("AliLevel3")) {
+    gSystem->Load("libAliL3Src.so");
+    gSystem->Load("libAliL3Misc.so");
+    gSystem->Load("libAliL3Hough.so");
+    gSystem->Load("libAliL3Comp.so");
   }
   if (!gROOT->GetClass("AliMonitorClient")) {
     gSystem->Load("libMONITOR.so");