corrections to obey coding conventions
authortkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Nov 2003 17:11:04 +0000 (17:11 +0000)
committertkuhr <tkuhr@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 3 Nov 2003 17:11:04 +0000 (17:11 +0000)
27 files changed:
MONITOR/AliMonitor.cxx
MONITOR/AliMonitor.h
MONITOR/AliMonitorClient.cxx
MONITOR/AliMonitorClient.h
MONITOR/AliMonitorControl.cxx
MONITOR/AliMonitorControl.h
MONITOR/AliMonitorDataTPC.cxx [new file with mode: 0644]
MONITOR/AliMonitorDataTPC.h [new file with mode: 0644]
MONITOR/AliMonitorDialog.cxx
MONITOR/AliMonitorDialog.h
MONITOR/AliMonitorHLT.cxx
MONITOR/AliMonitorHLT.h
MONITOR/AliMonitorHisto.cxx
MONITOR/AliMonitorHisto.h
MONITOR/AliMonitorITS.cxx
MONITOR/AliMonitorITS.h
MONITOR/AliMonitorPlot.cxx
MONITOR/AliMonitorPlot.h
MONITOR/AliMonitorProcess.cxx
MONITOR/AliMonitorProcess.h
MONITOR/AliMonitorTPC.cxx
MONITOR/AliMonitorTPC.h
MONITOR/AliMonitorTrend.cxx
MONITOR/AliMonitorTrend.h
MONITOR/AliMonitorV0s.cxx
MONITOR/AliMonitorV0s.h
MONITOR/libMONITOR.pkg

index b6ed4a6..c84d711 100644 (file)
@@ -29,6 +29,8 @@
 
 
 #include "AliMonitor.h"
+#include "AliMonitorTrend.h"
+#include <TFolder.h>
 #include <TH1.h>
 #include <TH2.h>
 
@@ -37,6 +39,26 @@ ClassImp(AliMonitor)
 
 
 //_____________________________________________________________________________
+AliMonitor::AliMonitor()
+{
+  fFolder = NULL;
+}
+
+//_____________________________________________________________________________
+AliMonitor::AliMonitor(const AliMonitor& monitor) :
+  TObject(monitor)
+{
+  Fatal("AliMonitor", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitor& AliMonitor::operator = (const AliMonitor& /*monitor*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+//_____________________________________________________________________________
 void AliMonitor::CreateBranches(TTree*)
 {
 // add branches to the monitor tree
index e438507..ffb22ac 100644 (file)
@@ -6,16 +6,22 @@
 /* $Id$ */
 
 #include <TObject.h>
-#include <TFolder.h>
-#include <TTree.h>
-#include "AliRunLoader.h"
-#include "AliRawReader.h"
 #include "AliMonitorHisto.h"
-#include "AliMonitorTrend.h"
+
+class TFolder;
+class TTree;
+class AliRunLoader;
+class AliRawReader;
+class AliMonitorTrend;
 
 
 class AliMonitor : public TObject {
 public:
+  AliMonitor();
+  AliMonitor(const AliMonitor& monitor);
+  AliMonitor& operator = (const AliMonitor& monitor);
+  virtual ~AliMonitor() {};
+
   virtual void     CreateHistos(TFolder* folder) = 0;
   virtual void     CreateBranches(TTree* tree);
   virtual void     FillHistos(AliRunLoader* runLoader, 
index 6c700cd..6468ef4 100644 (file)
 
 
 #include "AliMonitorClient.h"
-#include "AliMonitorDialog.h"
 #include "AliMonitorProcess.h"
 #include <TGMsgBox.h>
 #include <TGFileDialog.h>
-#include <TSystem.h>
 #include <TMessage.h>
 #include <TCanvas.h>
 #include <TApplication.h>
 #include <TStyle.h>
+#include <TGMenu.h>
+#include <TGButton.h>
+#include <TGLabel.h>
+#include <TGTextEntry.h>
+#include <TGToolBar.h>
+#include <TG3DLine.h>
+#include <TGNumberEntry.h>
+#include <TGCanvas.h>
+#include <TGSplitter.h>
+#include <TGListTree.h>
+#include <TRootEmbeddedCanvas.h>
+#include <TGTextView.h>
+#include <TFolder.h>
+#include <TSocket.h>
+#include <TTimer.h>
+#include <TFile.h>
+#include "AliMonitorHisto.h"
 
 
 ClassImp(AliMonitorClient) 
@@ -41,29 +56,12 @@ ClassImp(AliMonitorClient)
 
 const char* AliMonitorClient::fgSettingsFileName = ".AliMonitorClient";
 
-//_____________________________________________________________________________
-class AliMonitorStringDlg : public AliMonitorDialog {
-
-public:
-  AliMonitorStringDlg(TString& string, TGFrame* main, const char* title,
-                     const char* label);
-  virtual ~AliMonitorStringDlg();
-
-  virtual void       OnOkClicked();
-
-private:
-  TGLayoutHints*     fStringLayout;
-  TGLabel*           fStringLabel;
-  TGTextEntry*       fStringEntry;
-
-  TString&           fString;
-};
-
 
 //_____________________________________________________________________________
-AliMonitorStringDlg::AliMonitorStringDlg(TString& string, TGFrame* main, 
-                                        const char* title, 
-                                        const char* label) :
+AliMonitorClient::AliMonitorStringDlg::AliMonitorStringDlg(TString& string, 
+                                                          TGFrame* main, 
+                                                          const char* title, 
+                                                          const char* label) :
   AliMonitorDialog(main, 300, 80), fString(string)
 {
 // create a dialog for connecting to a monitor process
@@ -84,7 +82,7 @@ AliMonitorStringDlg::AliMonitorStringDlg(TString& string, TGFrame* main,
 }
 
 //_____________________________________________________________________________
-AliMonitorStringDlg::~AliMonitorStringDlg()
+AliMonitorClient::AliMonitorStringDlg::~AliMonitorStringDlg()
 {
 // clean up
 
@@ -94,36 +92,18 @@ AliMonitorStringDlg::~AliMonitorStringDlg()
 }
 
 //_____________________________________________________________________________
-void AliMonitorStringDlg::OnOkClicked()
+void AliMonitorClient::AliMonitorStringDlg::OnOkClicked()
 {
   fString = fStringEntry->GetText();
 }
 
 
-
-//_____________________________________________________________________________
-class AliMonitorNumberDlg : public AliMonitorDialog {
-
-public:
-  AliMonitorNumberDlg(Float_t& value, TGFrame* main, const char* title,
-                     const char* label, Float_t min);
-  virtual ~AliMonitorNumberDlg();
-
-  virtual void       OnOkClicked();
-
-private:
-  TGLayoutHints*     fNumberLayout;
-  TGLabel*           fNumberLabel;
-  TGNumberEntry*     fNumberEntry;
-
-  Float_t&           fNumber;
-};
-
-
 //_____________________________________________________________________________
-AliMonitorNumberDlg::AliMonitorNumberDlg(Float_t& value, TGFrame* main, 
-                                        const char* title, const char* label, 
-                                        Float_t min) :
+AliMonitorClient::AliMonitorNumberDlg::AliMonitorNumberDlg(Float_t& value, 
+                                                          TGFrame* main, 
+                                                          const char* title, 
+                                                          const char* label, 
+                                                          Float_t min) :
   AliMonitorDialog(main, 250, 80), fNumber(value)
 {
 // create a dialog for getting a number
@@ -145,7 +125,7 @@ AliMonitorNumberDlg::AliMonitorNumberDlg(Float_t& value, TGFrame* main,
 }
 
 //_____________________________________________________________________________
-AliMonitorNumberDlg::~AliMonitorNumberDlg()
+AliMonitorClient::AliMonitorNumberDlg::~AliMonitorNumberDlg()
 {
 // clean up
 
@@ -155,7 +135,7 @@ AliMonitorNumberDlg::~AliMonitorNumberDlg()
 }
 
 //_____________________________________________________________________________
-void AliMonitorNumberDlg::OnOkClicked()
+void AliMonitorClient::AliMonitorNumberDlg::OnOkClicked()
 {
   fNumber = fNumberEntry->GetNumber();
 }
@@ -476,6 +456,21 @@ AliMonitorClient::AliMonitorClient():
 }
 
 //_____________________________________________________________________________
+AliMonitorClient::AliMonitorClient(const AliMonitorClient& client) :
+  TGMainFrame(client)
+{
+  Fatal("AliMonitorClient", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorClient& AliMonitorClient::operator = (const AliMonitorClient& 
+                                               /*client*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+//_____________________________________________________________________________
 AliMonitorClient::~AliMonitorClient()
 {
 // clean up
@@ -938,7 +933,7 @@ void AliMonitorClient::OnLoopTimer()
 
 
 //_____________________________________________________________________________
-TFolder* AliMonitorClient::CreateTopFolder()
+TFolder* AliMonitorClient::CreateTopFolder() const
 {
 // create a top folder for monitor histograms
 
@@ -1001,7 +996,7 @@ Bool_t AliMonitorClient::ConnectToServer()
     if (serverName.IsNull()) return kFALSE;
 
     // connect to the server
-    fSocket = new TSocket(serverName, AliMonitorProcess::kgPort);
+    fSocket = new TSocket(serverName, AliMonitorProcess::GetPort());
     if (!fSocket || !fSocket->IsValid() || (fSocket->Send("client") <= 0)) {
       if (fSocket) delete fSocket;
       fSocket = NULL;
@@ -1894,7 +1889,7 @@ Bool_t AliMonitorClient::CheckForNewData()
 }
 
 //_____________________________________________________________________________
-void AliMonitorClient::ClearItems(TGListTreeItem* base)
+void AliMonitorClient::ClearItems(TGListTreeItem* base) const
 {
 // remove the references to the histograms from all subitems of the 
 // given tree item
index ddeae72..064ea83 100644 (file)
@@ -6,24 +6,31 @@
 /* $Id$ */
 
 #include <TGFrame.h>
-#include <TGMenu.h>
-#include <TGButton.h>
-#include <TGLabel.h>
-#include <TGTextEntry.h>
-#include <TGToolBar.h>
-#include <TG3DLine.h>
-#include <TGNumberEntry.h>
-#include <TGCanvas.h>
-#include <TGSplitter.h>
-#include <TGListTree.h>
-#include <TRootEmbeddedCanvas.h>
-#include <TGTextView.h>
 #include <RQ_OBJECT.h>
-#include <TFolder.h>
-#include <TSocket.h>
-#include <TTimer.h>
-#include <TFile.h>
-#include "AliMonitorHisto.h"
+#include "AliMonitorDialog.h"
+
+class TGListTreeItem;
+class TGLayoutHints;
+class TGPopupMenu;
+class TGMenuBar;
+class TGHorizontal3DLine;
+class TGToolBar;
+class TGNumberEntry;
+class TGPicture;
+class TGButton;
+class TGCanvas;
+class TGListTree;
+class TGVSplitter;
+class TGHSplitter;
+class TRootEmbeddedCanvas;
+class TGTextView;
+class TGLabel;
+class TGTextEntry;
+class TSocket;
+class TFileHandler;
+class TFolder;
+class TTimer;
+class AliMonitorHisto;
 
 
 class AliMonitorClient : public TGMainFrame {
@@ -32,6 +39,8 @@ RQ_OBJECT("AliMonitorClient")
 
 public:
   AliMonitorClient();
+  AliMonitorClient(const AliMonitorClient& client);
+  AliMonitorClient& operator = (const AliMonitorClient& client);
   virtual ~AliMonitorClient();
 
   void               CloseWindow();
@@ -57,7 +66,7 @@ public:
   void               OnLoopTimer();
 
 private:
-  TFolder*           CreateTopFolder();
+  TFolder*           CreateTopFolder() const;
   AliMonitorHisto*   GetHisto(const char* folderName, const char* histoName);
   TGListTreeItem*    GetItem(TGListTreeItem* base, const char* folderName, 
                             const char* histoName, Bool_t create);
@@ -97,7 +106,7 @@ private:
   void               UpdateItem(Bool_t highlight);
 
   Bool_t             CheckForNewData();
-  void               ClearItems(TGListTreeItem* base);
+  void               ClearItems(TGListTreeItem* base) const;
   void               CleanUpTree(TGListTreeItem* base);
   void               UpdateTree();
   void               UpdateFavoritesTree();
@@ -106,78 +115,131 @@ private:
   void               UpdateHisto();
   void               UpdateAll();
 
-  TGLayoutHints*     fMenuBarLayout;
-  TGLayoutHints*     fMenuBarItemLayout;
-  TGLayoutHints*     fMenuBarHelpLayout;
-  TGPopupMenu*       fMenuFile;
-  TGPopupMenu*       fMenuView;
-  TGPopupMenu*       fMenuFavorites;
-  TGPopupMenu*       fMenuReference;
-  TGPopupMenu*       fMenuOptions;
-  TGPopupMenu*       fMenuHelp;
-  TGMenuBar*         fMenuBar;
-
-  TGLayoutHints*     fToolBarLayout;
-  TGHorizontal3DLine* fToolBarSep;
-  TGToolBar*         fToolBar;
-  TGLayoutHints*     fEventNumberLayout;
-  TGNumberEntry*     fEventNumber;
-  TGButton*          fEventButton;
-  TGButton*          fSumButton;
-  TGButton*          fRunButton;
-  TGButton*          fLoopButton;
-  const TGPicture*   fLoopOnPicture;
-  const TGPicture*   fLoopOffPicture;
-  TGButton*          fPreviousButton;
-  TGButton*          fNextButton;
-  TGButton*          fCopyButton;
-  TGButton*          fSaveButton;
-  TGButton*          fPrintButton;
-
-  TGLayoutHints*     fBottomLayout;
-  TGLayoutHints*     fLeftLayout;
-  TGLayoutHints*     fExpandLayout;
-
-  TGVerticalFrame*   fVerticalFrame;
-  TGHorizontalFrame* fHorizontalFrame;
-
-  TGCompositeFrame*  fTreeFrame;
-  TGCanvas*          fTreeCanvas;
-  TGListTree*        fTree;
-  const TGPicture*   fHistoPicture;
-  TGListTreeItem*    fAllItem;
-  TGListTreeItem*    fFavoritesItem;
-  TGListTreeItem*    fComparisonItem;
-
-  TGVSplitter*       fTreeSplitter;
-
-  TGCompositeFrame*  fDrawFrame;
-  TRootEmbeddedCanvas* fDrawCanvas;
-
-  TGHSplitter*       fDescriptionSplitter;
-
-  TGCompositeFrame*  fDescriptionFrame;
-  TGTextView*        fDescription;
-
-  TString            fServerName;
-  TSocket*           fSocket;
-  TFileHandler*      fSocketHandler;
-
-  TFolder*           fFolder;
-
-  TGListTreeItem*    fCurrentItem;
-  TGListTreeItem*    fBaseItem;
-  TTimer*            fLoopTimer;
-  Int_t              fLoopInterval;
-
-  TString            fFavoritesFileName;
-
-  TString            fReferenceFileName;
-  TFolder*           fReference;
-
-  TString            fPrintCommand;
-
-  static const char* fgSettingsFileName;
+  TGLayoutHints*     fMenuBarLayout;           // layout of the menu bar
+  TGLayoutHints*     fMenuBarItemLayout;       // layout of the menu items
+  TGLayoutHints*     fMenuBarHelpLayout;       // layout of the help menu
+  TGPopupMenu*       fMenuFile;                // the file menu
+  TGPopupMenu*       fMenuView;                // the view menu
+  TGPopupMenu*       fMenuFavorites;           // the favorites menu
+  TGPopupMenu*       fMenuReference;           // the reference menu
+  TGPopupMenu*       fMenuOptions;             // the options menu
+  TGPopupMenu*       fMenuHelp;                // the help menu
+  TGMenuBar*         fMenuBar;                 // the menu bar
+
+  TGLayoutHints*     fToolBarLayout;           // layout of the tool bar
+  TGHorizontal3DLine* fToolBarSep;             // separation of the tool bar
+  TGToolBar*         fToolBar;                 // the tool bar
+  TGLayoutHints*     fEventNumberLayout;       // layout of the event number
+  TGNumberEntry*     fEventNumber;             // the event number
+  TGButton*          fEventButton;             // the button for one event
+  TGButton*          fSumButton;               // the button for the sum of events
+  TGButton*          fRunButton;               // the button for a run
+  TGButton*          fLoopButton;              // the botton for the loop
+  const TGPicture*   fLoopOnPicture;           // the picture for running loop
+  const TGPicture*   fLoopOffPicture;          // the picture for stoped loop
+  TGButton*          fPreviousButton;          // the button for previous histo
+  TGButton*          fNextButton;              // the button for next histo
+  TGButton*          fCopyButton;              // the button for copy histo
+  TGButton*          fSaveButton;              // the button for save histo
+  TGButton*          fPrintButton;             // the button for print histo
+
+  TGLayoutHints*     fBottomLayout;            // layout at bottom
+  TGLayoutHints*     fLeftLayout;              // layout at left
+  TGLayoutHints*     fExpandLayout;            // expanded layout
+
+  TGVerticalFrame*   fVerticalFrame;           // frame for tree/histo and description
+  TGHorizontalFrame* fHorizontalFrame;         // frame for tree and histo
+
+  TGCompositeFrame*  fTreeFrame;               // frame for tree
+  TGCanvas*          fTreeCanvas;              // canvas for tree
+  TGListTree*        fTree;                    // tree with histos
+  const TGPicture*   fHistoPicture;            // picture for histo item
+  TGListTreeItem*    fAllItem;                 // top item for all histos
+  TGListTreeItem*    fFavoritesItem;           // top item for favorites
+  TGListTreeItem*    fComparisonItem;          // top item for comparison
+
+  TGVSplitter*       fTreeSplitter;            // splitter for tree and histo
+
+  TGCompositeFrame*  fDrawFrame;               // frame for histo
+  TRootEmbeddedCanvas* fDrawCanvas;            // canvas for histo
+
+  TGHSplitter*       fDescriptionSplitter;     // splitter tree/histo and description
+
+  TGCompositeFrame*  fDescriptionFrame;        // frame for description
+  TGTextView*        fDescription;             // description text
+
+  TString            fServerName;              // name of the monitor server
+  TSocket*           fSocket;                  // socket to the monitor server
+  TFileHandler*      fSocketHandler;           // handler for fSocket
+
+  TFolder*           fFolder;                  // folder with histos
+
+  TGListTreeItem*    fCurrentItem;             // current tree item
+  TGListTreeItem*    fBaseItem;                // base item of current item
+  TTimer*            fLoopTimer;               // timer for loop over histos
+  Int_t              fLoopInterval;            // loop interval
+
+  TString            fFavoritesFileName;       // file name of favorites
+
+  TString            fReferenceFileName;       // file name with reference histos
+  TFolder*           fReference;               // folder with reference histos
+
+  TString            fPrintCommand;            // print command
+
+  static const char* fgSettingsFileName;       // file name of settings
+
+
+  class AliMonitorStringDlg : public AliMonitorDialog {
+
+  public:
+    AliMonitorStringDlg(TString& string, TGFrame* main, const char* title,
+                       const char* label);
+    AliMonitorStringDlg(const AliMonitorStringDlg& dlg) : 
+      AliMonitorDialog(dlg), fString(dlg.fString) {
+      Fatal("AliMonitorStringDlg", "copy constructor not implemented");
+    }
+    AliMonitorStringDlg& operator = (const AliMonitorStringDlg& dlg) {
+      Fatal("operator =", "assignment operator not implemented");
+      return *this;
+    }
+    virtual ~AliMonitorStringDlg();
+
+    virtual void       OnOkClicked();
+
+  private:
+    TGLayoutHints*     fStringLayout;    // layout of the text entry
+    TGLabel*           fStringLabel;     // label for the text entry
+    TGTextEntry*       fStringEntry;     // the text enty
+
+    TString&           fString;          // result
+  };
+
+
+  class AliMonitorNumberDlg : public AliMonitorDialog {
+
+  public:
+    AliMonitorNumberDlg(Float_t& value, TGFrame* main, const char* title,
+                       const char* label, Float_t min);
+    AliMonitorNumberDlg(const AliMonitorNumberDlg& dlg) : 
+      AliMonitorDialog(dlg), fNumber(dlg.fNumber) {
+      Fatal("AliMonitorNumberDlg", "copy constructor not implemented");
+    }
+    AliMonitorNumberDlg& operator = (const AliMonitorNumberDlg& dlg) {
+      Fatal("operator =", "assignment operator not implemented");
+      return *this;
+    }
+    virtual ~AliMonitorNumberDlg();
+
+    virtual void       OnOkClicked();
+
+  private:
+    TGLayoutHints*     fNumberLayout;    // layout of the number entry
+    TGLabel*           fNumberLabel;     // label for the number entry
+    TGNumberEntry*     fNumberEntry;     // the number entry
+
+    Float_t&           fNumber;          // result
+  };
+
 
   ClassDef(AliMonitorClient, 0)   // class for receiving and displaying monitor histograms
 };
index a0d10e4..83c803d 100644 (file)
 
 #include "AliMonitorControl.h"
 #include "AliMonitorHisto.h"
-#include "AliMonitorDialog.h"
 #include <TGNumberEntry.h>
 #include <TGTextView.h>
 #include <TGMsgBox.h>
 #include <TSystem.h>
-#include <TROOT.h>
+#include <TSocket.h>
+#include <TGFrame.h>
+#include <TGMenu.h>
+#include <TGButton.h>
+#include <TGLabel.h>
+#include <TGTextEntry.h>
+#include <TTimer.h>
+#include "AliMonitorProcess.h"
 
 
 ClassImp(AliMonitorControl) 
 
 
-//_____________________________________________________________________________
-class AliMonitorBufferDlg : public AliMonitorDialog {
-
-public:
-  AliMonitorBufferDlg(Int_t& size, TGFrame* main);
-  virtual ~AliMonitorBufferDlg();
-
-  virtual void       OnOkClicked();
-
-private:
-  TGLayoutHints*     fBufferLayout;
-  TGLabel*           fBufferLabel;
-  TGNumberEntry*     fBufferEntry;
-
-  Int_t&             fSize;
-};
-
 
 //_____________________________________________________________________________
-AliMonitorBufferDlg::AliMonitorBufferDlg(Int_t& size, TGFrame* main) :
+AliMonitorControl::AliMonitorBufferDlg::AliMonitorBufferDlg(Int_t& size, 
+                                                           TGFrame* main) :
   AliMonitorDialog(main, 250, 80), fSize(size)
 {
 // create a dialog for setting the size of the buffer for monitor histos
@@ -76,7 +66,7 @@ AliMonitorBufferDlg::AliMonitorBufferDlg(Int_t& size, TGFrame* main) :
 }
 
 //_____________________________________________________________________________
-AliMonitorBufferDlg::~AliMonitorBufferDlg()
+AliMonitorControl::AliMonitorBufferDlg::~AliMonitorBufferDlg()
 {
 // clean up
 
@@ -86,27 +76,15 @@ AliMonitorBufferDlg::~AliMonitorBufferDlg()
 }
 
 //_____________________________________________________________________________
-void AliMonitorBufferDlg::OnOkClicked()
+void AliMonitorControl::AliMonitorBufferDlg::OnOkClicked()
 {
   fSize = fBufferEntry->GetIntNumber();
 }
 
 
 //_____________________________________________________________________________
-class AliMonitorClientsDlg : public AliMonitorDialog {
-
-public:
-  AliMonitorClientsDlg(TObjArray* clients, TGFrame* main);
-  virtual ~AliMonitorClientsDlg();
-
-private:
-  TGLayoutHints*     fClientsLayout;
-  TGTextView*        fClients;
-};
-
-
-//_____________________________________________________________________________
-AliMonitorClientsDlg::AliMonitorClientsDlg(TObjArray* clients, TGFrame* main) :
+AliMonitorControl::AliMonitorClientsDlg::AliMonitorClientsDlg(TObjArray* clients, 
+                                                             TGFrame* main) :
   AliMonitorDialog(main, 450, 300, kFALSE)
 {
 // create a dialog to display the list of clients
@@ -144,7 +122,7 @@ AliMonitorClientsDlg::AliMonitorClientsDlg(TObjArray* clients, TGFrame* main) :
 }
 
 //_____________________________________________________________________________
-AliMonitorClientsDlg::~AliMonitorClientsDlg()
+AliMonitorControl::AliMonitorClientsDlg::~AliMonitorClientsDlg()
 {
 // clean up
 
@@ -319,6 +297,21 @@ AliMonitorControl::AliMonitorControl(AliMonitorProcess* process)
 }
 
 //_____________________________________________________________________________
+AliMonitorControl::AliMonitorControl(const AliMonitorControl& control) :
+  TObject(control)
+{
+  Fatal("AliMonitorControl", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorControl& AliMonitorControl::operator = (const AliMonitorControl& 
+                                                 /*control*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+//_____________________________________________________________________________
 AliMonitorControl::~AliMonitorControl()
 {
 // clean up
index c9ee0b4..ba91e9b 100644 (file)
@@ -5,15 +5,23 @@
 
 /* $Id$ */
 
-#include <TGFrame.h>
-#include <TGMenu.h>
-#include <TGButton.h>
-#include <TGLabel.h>
-#include <TGTextEntry.h>
+#include <TObject.h>
 #include <RQ_OBJECT.h>
-#include <TSysEvtHandler.h>
-#include <TTimer.h>
-#include "AliMonitorProcess.h"
+#include "AliMonitorDialog.h"
+
+class AliMonitorProcess;
+class TTimer;
+class TGMainFrame;
+class TGLayoutHints;
+class TGPopupMenu;
+class TGMenuBar;
+class TGVerticalFrame;
+class TGHorizontalFrame;
+class TGLabel;
+class TGTextEntry;
+class TGTextButton;
+class TGNumberEntry;
+class TGTextView;
 
 
 class AliMonitorControl : public TObject {
@@ -22,6 +30,8 @@ RQ_OBJECT("AliMonitorControl")
 
 public:
   AliMonitorControl(AliMonitorProcess* process);
+  AliMonitorControl(const AliMonitorControl& control);
+  AliMonitorControl& operator = (const AliMonitorControl& control);
   virtual ~AliMonitorControl();
 
   void               HandleMenu(Int_t id);
@@ -33,53 +43,99 @@ private:
 
   void               UpdateStatus();
 
-  AliMonitorProcess* fMonitorProcess;
-
-  ULong_t            fColorStatus;
-  ULong_t            fColorStart;
-  ULong_t            fColorStop;
-
-  TGMainFrame*       fMain;
-
-  TGLayoutHints*     fMenuBarLayout;
-  TGLayoutHints*     fMenuBarItemLayout;
-  TGLayoutHints*     fMenuBarHelpLayout;
-  TGPopupMenu*       fMenuFile;
-  TGPopupMenu*       fMenuOptions;
-  TGPopupMenu*       fMenuHelp;
-  TGMenuBar*         fMenuBar;
-
-  TGLayoutHints*     fFrameLayout;
-  TGVerticalFrame*   fFrame;
-  TGLayoutHints*     fStatusLayout;
-  TGLayoutHints*     fStatusFrameLayout;
-
-  TGHorizontalFrame* fStatus1Frame;
-  TGLabel*           fRunNumberLabel;
-  TGTextEntry*       fRunNumber;
-  TGLabel*           fEventNumberLabel;
-  TGTextEntry*       fEventNumber;
-
-  TGHorizontalFrame* fStatus2Frame;
-  TGLabel*           fStatusLabel;
-  TGTextEntry*       fStatus;
-
-  TGHorizontalFrame* fStatus3Frame;
-  TGLabel*           fEventsLabel;
-  TGTextEntry*       fEvents;
-  TGLabel*           fClientsLabel;
-  TGTextEntry*       fClients;
-
-  TGLayoutHints*     fButtonFrameLayout;
-  TGHorizontalFrame* fButtonFrame;
-  TGLayoutHints*     fButtonLayout;
-  TGTextButton*      fResetButton;
-  TGTextButton*      fStartStopButton;
-  Bool_t             fStartButtonStatus;
-
-  Bool_t             fTerminating;
-
-  TTimer*            fTimer;
+  AliMonitorProcess* fMonitorProcess;       // the controlled monitor process
+
+  ULong_t            fColorStatus;          // color for status info
+  ULong_t            fColorStart;           // color for start button
+  ULong_t            fColorStop;            // color for stop button
+
+  TGMainFrame*       fMain;                 // the main window
+
+  TGLayoutHints*     fMenuBarLayout;        // layout of the menu bar
+  TGLayoutHints*     fMenuBarItemLayout;    // layout of the menu items
+  TGLayoutHints*     fMenuBarHelpLayout;    // layout of the help menu
+  TGPopupMenu*       fMenuFile;             // the file menu
+  TGPopupMenu*       fMenuOptions;          // the options menu
+  TGPopupMenu*       fMenuHelp;             // the help menu
+  TGMenuBar*         fMenuBar;              // the menu bar
+
+  TGLayoutHints*     fFrameLayout;          // layout of the main frame
+  TGVerticalFrame*   fFrame;                // the main frame
+  TGLayoutHints*     fStatusLayout;         // layout of status info
+  TGLayoutHints*     fStatusFrameLayout;    // layout of status frames
+
+  TGHorizontalFrame* fStatus1Frame;         // frame for run/event number
+  TGLabel*           fRunNumberLabel;       // label for run number
+  TGTextEntry*       fRunNumber;            // run number display
+  TGLabel*           fEventNumberLabel;     // label for event number
+  TGTextEntry*       fEventNumber;          // event number display
+
+  TGHorizontalFrame* fStatus2Frame;         // frame for current status
+  TGLabel*           fStatusLabel;          // label for status
+  TGTextEntry*       fStatus;               // current status display
+
+  TGHorizontalFrame* fStatus3Frame;         // frame for number of event/clients
+  TGLabel*           fEventsLabel;          // label for number of events
+  TGTextEntry*       fEvents;               // number of monitored events display
+  TGLabel*           fClientsLabel;         // label for number of clients
+  TGTextEntry*       fClients;              // number of clients display
+
+  TGLayoutHints*     fButtonFrameLayout;    // layout of frame with buttons
+  TGHorizontalFrame* fButtonFrame;          // frame for buttons
+  TGLayoutHints*     fButtonLayout;         // layout of buttons
+  TGTextButton*      fResetButton;          // the rest button
+  TGTextButton*      fStartStopButton;      // the start/stop button
+  Bool_t             fStartButtonStatus;    // current status of the start/stop button
+
+  Bool_t             fTerminating;          // true if program will be terminated
+
+  TTimer*            fTimer;                // timer for X update
+
+
+  class AliMonitorBufferDlg : public AliMonitorDialog {
+
+  public:
+    AliMonitorBufferDlg(Int_t& size, TGFrame* main);
+    AliMonitorBufferDlg(const AliMonitorBufferDlg& dlg) : 
+      AliMonitorDialog(dlg), fSize(dlg.fSize) {
+      Fatal("AliMonitorBufferDlg", "copy constructor not implemented");
+    }
+    AliMonitorBufferDlg& operator = (const AliMonitorBufferDlg& dlg) {
+      Fatal("operator =", "assignment operator not implemented");
+      return *this;
+    }
+    virtual ~AliMonitorBufferDlg();
+
+    virtual void       OnOkClicked();
+
+  private:
+    TGLayoutHints*     fBufferLayout;       // layout of buffer entry
+    TGLabel*           fBufferLabel;        // label for buffer entry
+    TGNumberEntry*     fBufferEntry;        // buffer number entry
+
+    Int_t&             fSize;               // result
+  };
+
+
+  class AliMonitorClientsDlg : public AliMonitorDialog {
+
+  public:
+    AliMonitorClientsDlg(TObjArray* clients, TGFrame* main);
+    AliMonitorClientsDlg(const AliMonitorClientsDlg& dlg) : 
+      AliMonitorDialog(dlg) {
+      Fatal("AliMonitorClientsDlg", "copy constructor not implemented");
+    }
+    AliMonitorClientsDlg& operator = (const AliMonitorClientsDlg& dlg) {
+      Fatal("operator =", "assignment operator not implemented");
+      return *this;
+    }
+    virtual ~AliMonitorClientsDlg();
+
+  private:
+    TGLayoutHints*     fClientsLayout;      // layout of clients list
+    TGTextView*        fClients;            // list of clients
+  };
+
 
   ClassDef(AliMonitorControl, 0)   // class for controlling the AliMonitorProcess
 };
diff --git a/MONITOR/AliMonitorDataTPC.cxx b/MONITOR/AliMonitorDataTPC.cxx
new file mode 100644 (file)
index 0000000..02a44ab
--- /dev/null
@@ -0,0 +1,113 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+//  Data structure for the TPC monitor tree branch                           //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+
+#include "AliMonitorDataTPC.h"
+
+
+ClassImp(AliMonitorDataTPC) 
+
+
+//_____________________________________________________________________________
+AliMonitorDataTPC::AliMonitorDataTPC()
+{
+// default constructor
+
+  fPt = fEta = fPhi = NULL;
+  fSize = 0;
+}
+
+//_____________________________________________________________________________
+AliMonitorDataTPC::AliMonitorDataTPC(const AliMonitorDataTPC& data) :
+  TObject(data)
+{
+  Fatal("AliMonitorDataTPC", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorDataTPC& AliMonitorDataTPC::operator = (const AliMonitorDataTPC& 
+                                                 /*data*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+//_____________________________________________________________________________
+AliMonitorDataTPC::AliMonitorDataTPC(Int_t size)
+{
+// constructor with given size
+
+  fPt = new Float_t[size];
+  fEta = new Float_t[size];
+  fPhi = new Float_t[size];
+  fSize = size;
+}
+
+//_____________________________________________________________________________
+AliMonitorDataTPC::~AliMonitorDataTPC()
+{
+// destructor: free allocated memory
+
+  delete[] fPt;
+  delete[] fEta;
+  delete[] fPhi;
+}
+
+//_____________________________________________________________________________
+void AliMonitorDataTPC::SetSize(Int_t size)
+{
+// set a new array size and allocate memory if necessary
+
+  if (size > fSize) {
+    delete[] fPt;
+    delete[] fEta;
+    delete[] fPhi;
+    fPt = new Float_t[size];
+    fEta = new Float_t[size];
+    fPhi = new Float_t[size];
+    fSize = size;
+  }
+}
+
+//_____________________________________________________________________________
+void AliMonitorDataTPC::SetNTracks(Int_t nTracks)
+{
+// set the number of tracks
+
+  SetSize(nTracks);
+  fNTracks = nTracks;
+}
+
+//_____________________________________________________________________________
+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);
+    return;
+  }
+  fPt[i] = pt;
+  fEta[i] = eta;
+  fPhi[i] = phi;
+}
diff --git a/MONITOR/AliMonitorDataTPC.h b/MONITOR/AliMonitorDataTPC.h
new file mode 100644 (file)
index 0000000..fdda9eb
--- /dev/null
@@ -0,0 +1,34 @@
+#ifndef ALIMONITORDATATPC_H
+#define ALIMONITORDATATPC_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include <TObject.h>
+
+
+class AliMonitorDataTPC : public TObject {
+public:
+  AliMonitorDataTPC();
+  AliMonitorDataTPC(const AliMonitorDataTPC& data);
+  AliMonitorDataTPC& operator = (const AliMonitorDataTPC& data);
+  AliMonitorDataTPC(Int_t size);
+  virtual ~AliMonitorDataTPC();
+  void     SetSize(Int_t size);
+  void     SetNTracks(Int_t nTracks);
+  void     SetData(Int_t i, Float_t pt, Float_t eta, Float_t phi);
+
+private:
+  Int_t    fNTracks;   // number of TPC tracks
+  Float_t* fPt;        //[fNTracks]
+  Float_t* fEta;       //[fNTracks]
+  Float_t* fPhi;       //[fNTracks]
+
+  Int_t    fSize;      //! size of the arrays
+
+  ClassDef(AliMonitorDataTPC, 1)   // data structure for the TPC monitor tree branch
+};
+
+#endif
index a5dfc63..32094ad 100644 (file)
@@ -23,6 +23,8 @@
 
 
 #include "AliMonitorDialog.h"
+#include <TGFrame.h>
+#include <TGButton.h>
 
 
 ClassImp(AliMonitorDialog) 
@@ -80,6 +82,21 @@ AliMonitorDialog::AliMonitorDialog(TGFrame* main, Int_t width, Int_t height,
 }
 
 //_____________________________________________________________________________
+AliMonitorDialog::AliMonitorDialog(const AliMonitorDialog& dlg) :
+  TObject(dlg)
+{
+  Fatal("AliMonitorDialog", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorDialog& AliMonitorDialog::operator = (const AliMonitorDialog& 
+                                               /*dlg*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+//_____________________________________________________________________________
 AliMonitorDialog::~AliMonitorDialog()
 {
 // clean up
@@ -96,7 +113,7 @@ AliMonitorDialog::~AliMonitorDialog()
 }
 
 //_____________________________________________________________________________
-void AliMonitorDialog::CloseWindow()
+void AliMonitorDialog::CloseWindow() const
 {
 // called when the window is closed
 
index 81e22db..9d7e5b4 100644 (file)
@@ -5,11 +5,14 @@
 
 /* $Id$ */
 
-#include <TGFrame.h>
-#include <TGButton.h>
-#include <TGLabel.h>
 #include <RQ_OBJECT.h>
 
+class TGFrame;
+class TGTransientFrame;
+class TGLayoutHints;
+class TGHorizontalFrame;
+class TGTextButton;
+
 
 class AliMonitorDialog : public TObject {
 
@@ -18,23 +21,25 @@ RQ_OBJECT("AliMonitorDialog")
 public:
   AliMonitorDialog(TGFrame* main, Int_t width = 300, Int_t height = 80,
                   Bool_t cancelBtn = kTRUE);
+  AliMonitorDialog(const AliMonitorDialog& dlg);
+  AliMonitorDialog& operator = (const AliMonitorDialog& dlg);
   virtual ~AliMonitorDialog();
 
-  void               CloseWindow();
+  void               CloseWindow() const;
   void               DoOk();
   virtual void       OnOkClicked() {};
   void               DoCancel();
   virtual void       OnCancelClicked() {};
 
 protected:
-  TGTransientFrame*  fMain;
-  TGLayoutHints*     fFrameLayout;
-  TGHorizontalFrame* fFrame;
-  TGLayoutHints*     fButtonFrameLayout;
-  TGHorizontalFrame* fButtonFrame;
-  TGLayoutHints*     fButtonLayout;
-  TGTextButton*      fOkButton;
-  TGTextButton*      fCancelButton;
+  TGTransientFrame*  fMain;                // the main window
+  TGLayoutHints*     fFrameLayout;         // layout of the main frame
+  TGHorizontalFrame* fFrame;               // the main frame
+  TGLayoutHints*     fButtonFrameLayout;   // layout of the buttons frame
+  TGHorizontalFrame* fButtonFrame;         // the frame for buttons
+  TGLayoutHints*     fButtonLayout;        // layout of the buttons
+  TGTextButton*      fOkButton;            // the Ok button
+  TGTextButton*      fCancelButton;        // the cancel button
 
   ClassDef(AliMonitorDialog, 0)   // base class for dialogs with ok and cancel button
 };
index 0ca4b34..341a9fb 100644 (file)
@@ -23,6 +23,9 @@
 
 
 #include "AliMonitorHLT.h"
+#include "AliMonitorTrend.h"
+#include "AliTPCParam.h"
+#include <TFolder.h>
 #ifdef ALI_HLT
 #include <stdlib.h>
 #include "AliL3MemHandler.h"
@@ -41,8 +44,17 @@ AliMonitorHLT::AliMonitorHLT(AliTPCParam* param)
 }
 
 //_____________________________________________________________________________
-AliMonitorHLT::~AliMonitorHLT()
+AliMonitorHLT::AliMonitorHLT(const AliMonitorHLT& monitor) :
+  AliMonitor(monitor)
 {
+  Fatal("AliMonitorHLT", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorHLT& AliMonitorHLT::operator = (const AliMonitorHLT& /*monitor*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
 }
 
 
@@ -111,7 +123,6 @@ void AliMonitorHLT::CreateHistos(TFolder* folder)
 }
 
 
-#include <TCanvas.h>
 //_____________________________________________________________________________
 void AliMonitorHLT::FillHistos(AliRunLoader* /*runLoader*/, 
                               AliRawReader* /*rawReader*/)
index de9b4e3..3a08cd5 100644 (file)
@@ -6,15 +6,16 @@
 /* $Id$ */
 
 #include "AliMonitor.h"
-#include "AliMonitorHisto.h"
-#include "AliMonitorTrend.h"
-#include "AliTPCParam.h"
+
+class AliTPCParam;
 
 
 class AliMonitorHLT : public AliMonitor {
 public:
   AliMonitorHLT(AliTPCParam* param);
-  virtual ~AliMonitorHLT();
+  AliMonitorHLT(const AliMonitorHLT& monitor);
+  AliMonitorHLT& operator = (const AliMonitorHLT& monitor);
+  virtual ~AliMonitorHLT() {};
 
   virtual void     CreateHistos(TFolder* folder);
   virtual void     FillHistos(AliRunLoader* runLoader, 
index 42f4c8a..92ad928 100644 (file)
@@ -80,6 +80,35 @@ AliMonitorHisto::AliMonitorHisto(const AliMonitorHisto& histo) :
 }
 
 //_____________________________________________________________________________
+AliMonitorHisto& AliMonitorHisto::operator =(const AliMonitorHisto& histo)
+{
+// assignment operatore
+
+  AliMonitorPlot::operator =(histo);
+
+  Bool_t addStatus = TH1::AddDirectoryStatus();
+  TH1::AddDirectory(kFALSE);
+  fHisto = NULL;
+  if (histo.fHisto) fHisto = (TH1*) histo.fHisto->Clone();
+  fNHistos = histo.fNHistos;
+  TObjLink* link = histo.fHistoList.FirstLink();
+  for (Int_t i = 0; i < fNHistos; i++) {
+    fHistoList.Add(link->GetObject()->Clone());
+    link = link->Next();
+  }
+  fHistoRun = NULL;
+  if (histo.fHistoRun) fHistoRun = (TH1*) histo.fHistoRun->Clone();
+  fHistoDraw = NULL;
+  fHistoRef = NULL;
+  if (histo.fHistoRef) fHistoRef = (TH1*) histo.fHistoRef->Clone();
+  fHistoCompare = NULL;
+  fNorm = histo.fNorm;
+  TH1::AddDirectory(addStatus);
+
+  return *this;
+}
+
+//_____________________________________________________________________________
 AliMonitorHisto::AliMonitorHisto(TH1* histo, ENorm norm) :
   AliMonitorPlot(histo->GetName(), histo->GetTitle())
 {
index 19069fd..c494908 100644 (file)
@@ -6,9 +6,7 @@
 /* $Id$ */
 
 #include "AliMonitorPlot.h"
-#include <TH1.h>
 #include <TList.h>
-#include <TString.h>
 
 
 class AliMonitorHisto : public AliMonitorPlot {
@@ -17,6 +15,7 @@ public:
 
   AliMonitorHisto();
   AliMonitorHisto(const AliMonitorHisto& histo);
+  AliMonitorHisto& operator =(const AliMonitorHisto& histo);
   AliMonitorHisto(TH1* histo, ENorm norm = kNormIntegral);
   virtual ~AliMonitorHisto();
 
index 24282a1..4c53486 100644 (file)
 
 #include "AliMonitorITS.h"
 #include "AliMonitorHisto.h"
-#include "AliITSRawStreamSPD.h"
+#include "AliITSgeom.h"
 #include "AliITSRawStreamSDD.h"
 #include "AliITSRawStreamSSD.h"
 #include "AliITSclusterV2.h"
 #include "AliITStrackV2.h"
+#include "AliRunLoader.h"
+#include <TFolder.h>
+#include <TTree.h>
 
 
 ClassImp(AliMonitorITS) 
@@ -44,6 +47,20 @@ AliMonitorITS::AliMonitorITS(AliITSgeom* geom)
 
 
 //_____________________________________________________________________________
+AliMonitorITS::AliMonitorITS(const AliMonitorITS& monitor) :
+  AliMonitor(monitor)
+{
+  Fatal("AliMonitorITS", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorITS& AliMonitorITS::operator = (const AliMonitorITS& /*monitor*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+//_____________________________________________________________________________
 void AliMonitorITS::CreateHistos(TFolder* folder)
 {
 // create the ITS monitor histograms
index d188f19..7909847 100644 (file)
@@ -6,13 +6,16 @@
 /* $Id$ */
 
 #include "AliMonitor.h"
-#include "AliMonitorHisto.h"
-#include "AliITSgeom.h"
+
+class AliITSgeom;
 
 
 class AliMonitorITS : public AliMonitor {
 public:
   AliMonitorITS(AliITSgeom* param);
+  AliMonitorITS(const AliMonitorITS& monitor);
+  AliMonitorITS& operator = (const AliMonitorITS& monitor);
+  virtual ~AliMonitorITS() {};
 
   virtual void     CreateHistos(TFolder* folder);
   virtual void     FillHistos(AliRunLoader* runLoader, 
index dba25a0..30d2f8d 100644 (file)
@@ -55,6 +55,16 @@ AliMonitorPlot::AliMonitorPlot(const AliMonitorPlot& plot) :
 }
 
 //_____________________________________________________________________________
+AliMonitorPlot& AliMonitorPlot::operator =(const AliMonitorPlot& plot)
+{
+// assignment operator
+
+  TNamed::operator =(plot);
+  fNumberOfEvents = plot.fNumberOfEvents;
+  return *this;
+}
+
+//_____________________________________________________________________________
 AliMonitorPlot::AliMonitorPlot(const char* name, const char* title) :
   TNamed(name, title)
 {
index 1cc3a44..908b390 100644 (file)
@@ -6,21 +6,26 @@
 /* $Id$ */
 
 #include <TNamed.h>
-#include <TH1.h>
 #include <TString.h>
+#include <Gtypes.h>
+
+
+class TH1;
 
 
 class AliMonitorPlot : public TNamed {
 public:
   AliMonitorPlot();
   AliMonitorPlot(const AliMonitorPlot& plot);
+  AliMonitorPlot& operator = (const AliMonitorPlot& plot);
   AliMonitorPlot(const char* name, const char* title);
+  virtual ~AliMonitorPlot() {};
 
   virtual void    SetReference(TH1* ref) = 0;
   virtual void    SetReference(AliMonitorPlot* ref) = 0;
-  inline void     SetDescription(TString description) 
+  void            SetDescription(TString description) 
                     {fDescription = description;};
-  inline TString  GetDescription() {return fDescription;};
+  TString         GetDescription() const {return fDescription;};
 
   virtual void    Update() = 0;
   virtual void    Add(AliMonitorPlot* plot) = 0;
index 25d5222..8ea2378 100644 (file)
 #include "AliITStrackerV2.h"
 #include "AliITSLoader.h"
 #include "AliV0vertexer.h"
-#include <TSystem.h>
+#include <TGrid.h>
 #include <TSocket.h>
+#include <TServerSocket.h>
 #include <TMessage.h>
 #include <TGridResult.h>
 #include <TROOT.h>
 #ifdef ALI_HLT
+#include <AliLevel3.h>
 #include <AliL3Transform.h>
 #endif
 
 ClassImp(AliMonitorProcess) 
 
 
-const Int_t AliMonitorProcess::kgPort = 9327;
+const Int_t AliMonitorProcess::fgkPort = 9327;
 
 
 //_____________________________________________________________________________
@@ -84,9 +86,9 @@ AliMonitorProcess::AliMonitorProcess(const char* alienDir,
   fRunLoader->LoadgAlice();
   gAlice = fRunLoader->GetAliRun();
   if (!gAlice) Fatal("AliMonitorProcess", "no gAlice object found");
-  AliITS* ITS = (AliITS*) gAlice->GetModule("ITS");
-  if (!ITS) Fatal("AliMonitorProcess", "no ITS detector found");
-  fITSgeom = ITS->GetITSgeom();
+  AliITS* its = (AliITS*) gAlice->GetModule("ITS");
+  if (!its) Fatal("AliMonitorProcess", "no ITS detector found");
+  fITSgeom = its->GetITSgeom();
   if (!fITSgeom) Fatal("AliMonitorProcess", "could not load ITS geometry");
 
 #ifdef ALI_HLT
@@ -132,7 +134,7 @@ AliMonitorProcess::AliMonitorProcess(const char* alienDir,
   }
   gROOT->cd();
 
-  fServerSocket = new TServerSocket(kgPort, kTRUE);
+  fServerSocket = new TServerSocket(fgkPort, kTRUE);
   fServerSocket->SetOption(kNoBlock, 1);
   fDisplaySocket = NULL;
   CheckForConnections();
@@ -145,6 +147,21 @@ AliMonitorProcess::AliMonitorProcess(const char* alienDir,
 }
 
 //_____________________________________________________________________________
+AliMonitorProcess::AliMonitorProcess(const AliMonitorProcess& process) :
+  TObject(process)
+{
+  Fatal("AliMonitorProcess", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorProcess& AliMonitorProcess::operator = (const AliMonitorProcess& 
+                                                 /*process*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
+//_____________________________________________________________________________
 AliMonitorProcess::~AliMonitorProcess()
 {
 // clean up
@@ -180,6 +197,8 @@ const char* AliMonitorProcess::GetRevision()
 //_____________________________________________________________________________
 void AliMonitorProcess::SetStatus(EStatus status)
 {
+// set the current status and process system events
+
   fStatus = status;
   gSystem->ProcessEvents();
 }
@@ -377,7 +396,7 @@ void AliMonitorProcess::Reset()
 
 
 //_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventPeriodNumber()
+UInt_t AliMonitorProcess::GetEventPeriodNumber() const
 {
 // get the period number from the event id
 
@@ -385,7 +404,7 @@ UInt_t AliMonitorProcess::GetEventPeriodNumber()
 }
 
 //_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventOrbitNumber()
+UInt_t AliMonitorProcess::GetEventOrbitNumber() const
 {
 // get the orbit number from the event id
 
@@ -393,7 +412,7 @@ UInt_t AliMonitorProcess::GetEventOrbitNumber()
 }
 
 //_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventBunchNumber()
+UInt_t AliMonitorProcess::GetEventBunchNumber() const
 {
 // get the bunch number from the event id
 
@@ -401,7 +420,7 @@ UInt_t AliMonitorProcess::GetEventBunchNumber()
 }
 
 //_____________________________________________________________________________
-Int_t AliMonitorProcess::GetNumberOfEvents(const char* fileName)
+Int_t AliMonitorProcess::GetNumberOfEvents(const char* fileName) const
 {
 // determine the number of events in the given raw data file
 
@@ -557,13 +576,13 @@ void AliMonitorProcess::CreateHLT(const char* fileName)
 
   fHLT->SetClusterFinderParam(0, 0, kTRUE);
   
-  Int_t phi_segments = 50;
-  Int_t eta_segments = 100;
+  Int_t phiSegments = 50;
+  Int_t etaSegments = 100;
   Int_t trackletlength = 3;
   Int_t tracklength = 40;//40 or 5
   Int_t rowscopetracklet = 2;
   Int_t rowscopetrack = 2;
-  Double_t min_pt_fit = 0;
+  Double_t minPtFit = 0;
   Double_t maxangle = 1.31;
   Double_t goodDist = 5;
   Double_t maxphi = 100;
@@ -571,10 +590,10 @@ void AliMonitorProcess::CreateHLT(const char* fileName)
   Double_t hitChi2Cut = 15;//100 or 15
   Double_t goodHitChi2 = 5;//20 or 5
   Double_t trackChi2Cut = 10;//50 or 10
-  fHLT->SetTrackerParam(phi_segments, eta_segments, 
+  fHLT->SetTrackerParam(phiSegments, etaSegments, 
                        trackletlength, tracklength,
                        rowscopetracklet, rowscopetrack,
-                       min_pt_fit, maxangle, goodDist, hitChi2Cut,
+                       minPtFit, maxangle, goodDist, hitChi2Cut,
                        goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE);
   
   fHLT->WriteFiles("./hlt/");  
index 2bcb859..0184a86 100644 (file)
@@ -6,21 +6,22 @@
 /* $Id$ */
 
 #include <TObject.h>
+#include <TSystem.h>
 #include <TString.h>
-#include <TFolder.h>
-#include <TFile.h>
-#include <TTree.h>
 #include <TObjArray.h>
-#include <TServerSocket.h>
-#include <TTimer.h>
-#include <TGrid.h>
-#include <TSystem.h>
-#include "AliRunLoader.h"
-#include "AliRawReader.h"
-#include "AliTPCParam.h"
-#include "AliITSgeom.h"
+
+class AliRawReader;
+class AliTPCParam;
+class AliITSgeom;
+class AliRunLoader;
+class TFile;
+class TGrid;
+class TTimer;
+class TServerSocket;
+class TFolder;
+class TTree;
 #ifdef ALI_HLT
-#include "AliLevel3.h"
+class AliLevel3;
 #endif
 
 
@@ -28,6 +29,8 @@ class AliMonitorProcess : public TObject {
 public:
   AliMonitorProcess(const char* alienDir,
                    const char* fileNameGalice = "galice.root");
+  AliMonitorProcess(const AliMonitorProcess& process);
+  AliMonitorProcess& operator = (const AliMonitorProcess& process);
   virtual ~AliMonitorProcess();
 
   static const char* GetRevision();
@@ -38,32 +41,34 @@ public:
 
   void             ProcessFile(const char* fileName);
 
-  UInt_t           GetRunNumber() {return fRunNumber;};
-  UInt_t           GetEventPeriodNumber();
-  UInt_t           GetEventOrbitNumber();
-  UInt_t           GetEventBunchNumber();
+  UInt_t           GetRunNumber() const {return fRunNumber;};
+  UInt_t           GetEventPeriodNumber() const;
+  UInt_t           GetEventOrbitNumber() const;
+  UInt_t           GetEventBunchNumber() const;
 
   enum EStatus     {kStopped, kWaiting, kReading, kRecTPC, kRecITS, kRecV0s,
                    kRecHLT, kFilling, kUpdating, kWriting, kResetting, 
                    kConnecting, kBroadcasting};
-  EStatus          GetStatus() {gSystem->ProcessEvents();return fStatus;};
-  Bool_t           WillStop() {return fStopping;};
-  Bool_t           IsStopped() {return (fStatus == kStopped);};
-
-  Int_t            GetNumberOfEvents() {return fNEvents;};
-  Int_t            GetNumberOfClients() {return fSockets.GetEntriesFast();};
+  EStatus          GetStatus() const 
+    {gSystem->ProcessEvents(); return fStatus;};
+  Bool_t           WillStop() const {return fStopping;};
+  Bool_t           IsStopped() const {return (fStatus == kStopped);};
+
+  Int_t            GetNumberOfEvents() const {return fNEvents;};
+  Int_t            GetNumberOfClients() const 
+    {return fSockets.GetEntriesFast();};
   TObjArray*       GetListOfClients() {return &fSockets;};
-  Int_t            GetNEventsMin() {return fNEventsMin;};
+  Int_t            GetNEventsMin() const {return fNEventsMin;};
   void             SetNEventsMin(Int_t nEventsMin) {fNEventsMin = nEventsMin;};
   void             SetWriteHistoList(Bool_t writeHistoList = kTRUE) 
                                          {fWriteHistoList = writeHistoList;};
-  
-  static const Int_t kgPort;
 
+  static Int_t     GetPort() {return fgkPort;};
+  
 private:
   Bool_t           CheckForNewFile();
   Bool_t           ProcessFile();
-  Int_t            GetNumberOfEvents(const char* fileName);
+  Int_t            GetNumberOfEvents(const char* fileName) const;
   Bool_t           ReconstructTPC(AliRawReader* rawReader);
   Bool_t           ReconstructITS(AliRawReader* rawReader);
   Bool_t           ReconstructV0s();
@@ -79,34 +84,36 @@ private:
   void             BroadcastHistos();
   void             SetStatus(EStatus);
 
-  TGrid*           fGrid;
-  AliRunLoader*    fRunLoader;
-  AliTPCParam*     fTPCParam;
-  AliITSgeom*      fITSgeom;
-  TString          fLogicalFileName;
-  TString          fFileName;
+  static const Int_t fgkPort;          // port number for client connections
+
+  TGrid*           fGrid;               // pointer to AliEn
+  AliRunLoader*    fRunLoader;          // the current run loader
+  AliTPCParam*     fTPCParam;           // TPC parameters
+  AliITSgeom*      fITSgeom;            // ITS parameters
+  TString          fLogicalFileName;    // logical AliEn file name
+  TString          fFileName;           // physical file name
 #ifdef ALI_HLT
-  AliLevel3*       fHLT;
+  AliLevel3*       fHLT;                // the HLT tracker
 #endif
 
-  UInt_t           fRunNumber;
-  UInt_t           fSubRunNumber;
-  UInt_t           fEventNumber[2];
-  Int_t            fNEvents;
-  Int_t            fNEventsMin;
-  Bool_t           fWriteHistoList;
+  UInt_t           fRunNumber;          // current run number
+  UInt_t           fSubRunNumber;       // current part (=resets per run)
+  UInt_t           fEventNumber[2];     // current event number
+  Int_t            fNEvents;            // total number of monitored events
+  Int_t            fNEventsMin;         // threshold for writing
+  Bool_t           fWriteHistoList;     // write event histos or not
 
-  TFolder*         fTopFolder;
-  TObjArray        fMonitors;
-  TFile*           fFile;
-  TTree*           fTree;
+  TFolder*         fTopFolder;          // folder with histos
+  TObjArray        fMonitors;           // array of monitor objects
+  TFile*           fFile;               // file with tree
+  TTree*           fTree;               // monitor tree
 
-  TServerSocket*   fServerSocket;
-  TObjArray        fSockets;
-  TSocket*         fDisplaySocket;
+  TServerSocket*   fServerSocket;       // socket for client connections
+  TObjArray        fSockets;            // array of client sockets
+  TSocket*         fDisplaySocket;      // socket for an event display
 
-  EStatus          fStatus;
-  Bool_t           fStopping;
+  EStatus          fStatus;             // current status
+  Bool_t           fStopping;           // stop of process requested or not
 
   ClassDef(AliMonitorProcess, 0)   // class for performing the monitoring
 };
index 89251da..7cfca84 100644 (file)
 
 
 #include "AliMonitorTPC.h"
+#include "AliMonitorDataTPC.h"
+#include "AliMonitorHisto.h"
+#include "AliMonitorTrend.h"
+#include "AliTPCParam.h"
 #include "AliTPCRawStream.h"
 #include "AliTPCClustersRow.h"
 #include "AliTPCclusterMI.h"
 #include "AliTPCtrack.h"
+#include "AliRunLoader.h"
+#include <TFolder.h>
+#include <TTree.h>
 
 
-ClassImp(AliMonitorDataTPC) 
+ClassImp(AliMonitorTPC) 
 
 
 //_____________________________________________________________________________
-AliMonitorDataTPC::AliMonitorDataTPC()
+AliMonitorTPC::AliMonitorTPC(AliTPCParam* param)
 {
-  fPt = fEta = fPhi = NULL;
-  fSize = 0;
-}
+// create a TPC monitor object with the given parameters
 
-//_____________________________________________________________________________
-AliMonitorDataTPC::AliMonitorDataTPC(Int_t size)
-{
-  fPt = new Float_t[size];
-  fEta = new Float_t[size];
-  fPhi = new Float_t[size];
-  fSize = size;
+  fParam = param;
+  fData = new AliMonitorDataTPC(10000);
 }
 
 //_____________________________________________________________________________
-AliMonitorDataTPC::~AliMonitorDataTPC()
+AliMonitorTPC::AliMonitorTPC(const AliMonitorTPC& monitor) :
+  AliMonitor(monitor)
 {
-  delete[] fPt;
-  delete[] fEta;
-  delete[] fPhi;
+  Fatal("AliMonitorTPC", "copy constructor not implemented");
 }
 
 //_____________________________________________________________________________
-void AliMonitorDataTPC::SetSize(Int_t size)
+AliMonitorTPC& AliMonitorTPC::operator = (const AliMonitorTPC& /*monitor*/)
 {
-  if (size > fSize) {
-    delete[] fPt;
-    delete[] fEta;
-    delete[] fPhi;
-    fPt = new Float_t[size];
-    fEta = new Float_t[size];
-    fPhi = new Float_t[size];
-    fSize = size;
-  }
-}
-
-
-
-ClassImp(AliMonitorTPC) 
-
-
-//_____________________________________________________________________________
-AliMonitorTPC::AliMonitorTPC(AliTPCParam* param)
-{
-// create a TPC monitor object with the given parameters
-
-  fParam = param;
-  fData = new AliMonitorDataTPC(10000);
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
 }
 
 //_____________________________________________________________________________
@@ -209,10 +187,10 @@ void AliMonitorTPC::FillHistos(AliRunLoader* runLoader,
   AliTPCtrack* track = new AliTPCtrack;
   tracks->SetBranchAddress("tracks", &track);
 
-  fNTracks->Fill(tracks->GetEntries());
-  fData->fNTracks = (Int_t) tracks->GetEntries();
-  fData->SetSize(fData->fNTracks);
-  for (Int_t i = 0; i < tracks->GetEntries(); i++) {
+  Int_t nTracks = (Int_t) tracks->GetEntries();
+  fNTracks->Fill(nTracks);
+  fData->SetNTracks(nTracks);
+  for (Int_t i = 0; i < nTracks; i++) {
     tracks->GetEntry(i);
     fTrackPt->Fill(track->Pt());
     fTrackEta->Fill(track->Eta());
@@ -220,9 +198,8 @@ void AliMonitorTPC::FillHistos(AliRunLoader* runLoader,
     fTrackNCl->Fill(track->GetNumberOfClusters());
     fTrackDEdxVsP->Fill(track->P(), track->GetdEdx());
 
-    fData->fPt[i] = track->Pt();
-    fData->fEta[i] = track->Eta();
-    fData->fPhi[i] = track->Phi() * TMath::RadToDeg();
+    fData->SetData(i, track->Pt(), track->Eta(), 
+                  track->Phi() * TMath::RadToDeg());
   }
 
   delete track;
index 88a0e5e..2e4bfe9 100644 (file)
@@ -6,33 +6,16 @@
 /* $Id$ */
 
 #include "AliMonitor.h"
-#include "AliMonitorHisto.h"
-#include "AliMonitorTrend.h"
-#include "AliTPCParam.h"
 
-
-class AliMonitorDataTPC : public TObject {
-public:
-  AliMonitorDataTPC();
-  AliMonitorDataTPC(Int_t size);
-  virtual ~AliMonitorDataTPC();
-  void     SetSize(Int_t size);
-
-  Int_t    fNTracks;   // number of TPC tracks
-  Float_t* fPt;        //[fNTracks]
-  Float_t* fEta;       //[fNTracks]
-  Float_t* fPhi;       //[fNTracks]
-
-private:
-  Int_t    fSize;      //! size of the arrays
-
-  ClassDef(AliMonitorDataTPC, 1)   // data structure for the TPC monitor tree branch
-};
+class AliTPCParam;
+class AliMonitorDataTPC;
 
 
 class AliMonitorTPC : public AliMonitor {
 public:
   AliMonitorTPC(AliTPCParam* param);
+  AliMonitorTPC(const AliMonitorTPC& monitor);
+  AliMonitorTPC& operator = (const AliMonitorTPC& monitor);
   virtual ~AliMonitorTPC();
 
   virtual void     CreateHistos(TFolder* folder);
index 2ae7263..f822591 100644 (file)
@@ -28,6 +28,7 @@
 
 
 #include "AliMonitorTrend.h"
+#include <TH1.h>
 #include <TVirtualPad.h>
 #include <TLine.h>
 
@@ -68,6 +69,26 @@ AliMonitorTrend::AliMonitorTrend(const AliMonitorTrend& trend) :
 }
 
 //_____________________________________________________________________________
+AliMonitorTrend& AliMonitorTrend::operator =(const AliMonitorTrend& trend)
+{
+// assignment operator
+
+  AliMonitorPlot::operator =(trend);
+
+  fLabel = trend.fLabel;
+  fMin = trend.fMin;
+  fMax = trend.fMax;
+  trend.fData.Copy(fData);
+
+  fHistoDraw = NULL;
+  fRefMean = trend.fRefMean;
+  fRefSigma = trend.fRefSigma;
+  fHistoCompare = NULL;
+
+  return *this;
+}
+
+//_____________________________________________________________________________
 AliMonitorTrend::AliMonitorTrend(const char* name, const char* title,
                  const char* label, Double_t min, Double_t max) :
   AliMonitorPlot(name, title)
@@ -345,7 +366,7 @@ TH1* AliMonitorTrend::CreateHisto(Int_t nBins)
 }
 
 //_____________________________________________________________________________
-Double_t AliMonitorTrend::GetMean()
+Double_t AliMonitorTrend::GetMean() const
 {
 // get the mean value
 
@@ -359,7 +380,7 @@ Double_t AliMonitorTrend::GetMean()
 }
 
 //_____________________________________________________________________________
-Double_t AliMonitorTrend::GetSigma()
+Double_t AliMonitorTrend::GetSigma() const
 {
 // get the rms value
 
index cce44b5..fd034ac 100644 (file)
@@ -6,12 +6,14 @@
 /* $Id$ */
 
 #include "AliMonitorPlot.h"
+#include "TArrayD.h"
 
 
 class AliMonitorTrend : public AliMonitorPlot {
 public:
   AliMonitorTrend();
   AliMonitorTrend(const AliMonitorTrend& trend);
+  AliMonitorTrend& operator =(const AliMonitorTrend& trend);
   AliMonitorTrend(const char* name, const char* title,
                  const char* label, Double_t min = 0, Double_t max = 0);
   virtual ~AliMonitorTrend();
@@ -26,8 +28,8 @@ public:
   virtual void    Reset();
   virtual void    ResetList();
 
-  Double_t        GetMean();
-  Double_t        GetSigma();
+  Double_t        GetMean() const;
+  Double_t        GetSigma() const;
 protected:
   virtual Bool_t  ComparePlot();
   virtual Bool_t  GetEvent(Int_t number = 1);
index eebbd54..b1f6baa 100644 (file)
@@ -26,6 +26,9 @@
 #include "AliMonitorHisto.h"
 #include "AliITSLoader.h"
 #include "AliV0vertex.h"
+#include "AliRunLoader.h"
+#include <TFolder.h>
+#include <TTree.h>
 #include <TPDGCode.h>
 
 
@@ -39,6 +42,20 @@ AliMonitorV0s::AliMonitorV0s()
 
 }
 
+//_____________________________________________________________________________
+AliMonitorV0s::AliMonitorV0s(const AliMonitorV0s& monitor) :
+  AliMonitor(monitor)
+{
+  Fatal("AliMonitorV0s", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorV0s& AliMonitorV0s::operator = (const AliMonitorV0s& /*monitor*/)
+{
+  Fatal("operator =", "assignment operator not implemented");
+  return *this;
+}
+
 
 //_____________________________________________________________________________
 void AliMonitorV0s::CreateHistos(TFolder* folder)
index 17ccb58..7b9f2ce 100644 (file)
@@ -6,12 +6,14 @@
 /* $Id$ */
 
 #include "AliMonitor.h"
-#include "AliMonitorHisto.h"
 
 
 class AliMonitorV0s : public AliMonitor {
 public:
   AliMonitorV0s();
+  AliMonitorV0s(const AliMonitorV0s& monitor);
+  AliMonitorV0s& operator = (const AliMonitorV0s& monitor);
+  virtual ~AliMonitorV0s() {};
 
   virtual void     CreateHistos(TFolder* folder);
   virtual void     FillHistos(AliRunLoader* runLoader, 
index d5a214a..7360fad 100644 (file)
@@ -2,6 +2,7 @@ SRCS:=  AliMonitorPlot.cxx AliMonitorHisto.cxx AliMonitorTrend.cxx \
        AliMonitor.cxx \
        AliMonitorTPC.cxx AliMonitorITS.cxx AliMonitorV0s.cxx \
        AliMonitorHLT.cxx \
+       AliMonitorDataTPC.cxx \
        AliMonitorProcess.cxx AliMonitorControl.cxx \
        AliMonitorDialog.cxx AliMonitorClient.cxx