#include "AliMonitor.h"
+#include "AliMonitorTrend.h"
+#include <TFolder.h>
#include <TH1.h>
#include <TH2.h>
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*)
{
/* $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,
#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)
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
}
//_____________________________________________________________________________
-AliMonitorStringDlg::~AliMonitorStringDlg()
+AliMonitorClient::AliMonitorStringDlg::~AliMonitorStringDlg()
{
// clean up
}
//_____________________________________________________________________________
-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
}
//_____________________________________________________________________________
-AliMonitorNumberDlg::~AliMonitorNumberDlg()
+AliMonitorClient::AliMonitorNumberDlg::~AliMonitorNumberDlg()
{
// clean up
}
//_____________________________________________________________________________
-void AliMonitorNumberDlg::OnOkClicked()
+void AliMonitorClient::AliMonitorNumberDlg::OnOkClicked()
{
fNumber = fNumberEntry->GetNumber();
}
LoadSettings();
}
+//_____________________________________________________________________________
+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()
{
//_____________________________________________________________________________
-TFolder* AliMonitorClient::CreateTopFolder()
+TFolder* AliMonitorClient::CreateTopFolder() const
{
// create a top folder for monitor histograms
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;
}
//_____________________________________________________________________________
-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
/* $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 {
public:
AliMonitorClient();
+ AliMonitorClient(const AliMonitorClient& client);
+ AliMonitorClient& operator = (const AliMonitorClient& client);
virtual ~AliMonitorClient();
void CloseWindow();
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);
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();
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
};
#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
}
//_____________________________________________________________________________
-AliMonitorBufferDlg::~AliMonitorBufferDlg()
+AliMonitorControl::AliMonitorBufferDlg::~AliMonitorBufferDlg()
{
// clean up
}
//_____________________________________________________________________________
-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
}
//_____________________________________________________________________________
-AliMonitorClientsDlg::~AliMonitorClientsDlg()
+AliMonitorControl::AliMonitorClientsDlg::~AliMonitorClientsDlg()
{
// clean up
fTimer->TurnOn();
}
+//_____________________________________________________________________________
+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()
{
/* $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 {
public:
AliMonitorControl(AliMonitorProcess* process);
+ AliMonitorControl(const AliMonitorControl& control);
+ AliMonitorControl& operator = (const AliMonitorControl& control);
virtual ~AliMonitorControl();
void HandleMenu(Int_t id);
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
};
--- /dev/null
+/**************************************************************************
+ * 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;
+}
--- /dev/null
+#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
#include "AliMonitorDialog.h"
+#include <TGFrame.h>
+#include <TGButton.h>
ClassImp(AliMonitorDialog)
fMain->MapWindow();
}
+//_____________________________________________________________________________
+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()
{
}
//_____________________________________________________________________________
-void AliMonitorDialog::CloseWindow()
+void AliMonitorDialog::CloseWindow() const
{
// called when the window is closed
/* $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 {
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
};
#include "AliMonitorHLT.h"
+#include "AliMonitorTrend.h"
+#include "AliTPCParam.h"
+#include <TFolder.h>
#ifdef ALI_HLT
#include <stdlib.h>
#include "AliL3MemHandler.h"
}
//_____________________________________________________________________________
-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;
}
}
-#include <TCanvas.h>
//_____________________________________________________________________________
void AliMonitorHLT::FillHistos(AliRunLoader* /*runLoader*/,
AliRawReader* /*rawReader*/)
/* $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,
TH1::AddDirectory(addStatus);
}
+//_____________________________________________________________________________
+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())
/* $Id$ */
#include "AliMonitorPlot.h"
-#include <TH1.h>
#include <TList.h>
-#include <TString.h>
class AliMonitorHisto : public AliMonitorPlot {
AliMonitorHisto();
AliMonitorHisto(const AliMonitorHisto& histo);
+ AliMonitorHisto& operator =(const AliMonitorHisto& histo);
AliMonitorHisto(TH1* histo, ENorm norm = kNormIntegral);
virtual ~AliMonitorHisto();
#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)
}
+//_____________________________________________________________________________
+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)
{
/* $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,
fNumberOfEvents = plot.fNumberOfEvents;
}
+//_____________________________________________________________________________
+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)
/* $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;
#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;
//_____________________________________________________________________________
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
}
gROOT->cd();
- fServerSocket = new TServerSocket(kgPort, kTRUE);
+ fServerSocket = new TServerSocket(fgkPort, kTRUE);
fServerSocket->SetOption(kNoBlock, 1);
fDisplaySocket = NULL;
CheckForConnections();
fStopping = kFALSE;
}
+//_____________________________________________________________________________
+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()
{
//_____________________________________________________________________________
void AliMonitorProcess::SetStatus(EStatus status)
{
+// set the current status and process system events
+
fStatus = status;
gSystem->ProcessEvents();
}
//_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventPeriodNumber()
+UInt_t AliMonitorProcess::GetEventPeriodNumber() const
{
// get the period number from the event id
}
//_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventOrbitNumber()
+UInt_t AliMonitorProcess::GetEventOrbitNumber() const
{
// get the orbit number from the event id
}
//_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventBunchNumber()
+UInt_t AliMonitorProcess::GetEventBunchNumber() const
{
// get the bunch number from the event id
}
//_____________________________________________________________________________
-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
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;
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/");
/* $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
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();
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();
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
};
#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;
}
//_____________________________________________________________________________
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());
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;
/* $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);
#include "AliMonitorTrend.h"
+#include <TH1.h>
#include <TVirtualPad.h>
#include <TLine.h>
fHistoCompare = NULL;
}
+//_____________________________________________________________________________
+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) :
}
//_____________________________________________________________________________
-Double_t AliMonitorTrend::GetMean()
+Double_t AliMonitorTrend::GetMean() const
{
// get the mean value
}
//_____________________________________________________________________________
-Double_t AliMonitorTrend::GetSigma()
+Double_t AliMonitorTrend::GetSigma() const
{
// get the rms value
/* $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();
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);
#include "AliMonitorHisto.h"
#include "AliITSLoader.h"
#include "AliV0vertex.h"
+#include "AliRunLoader.h"
+#include <TFolder.h>
+#include <TTree.h>
#include <TPDGCode.h>
}
+//_____________________________________________________________________________
+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)
/* $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,
AliMonitor.cxx \
AliMonitorTPC.cxx AliMonitorITS.cxx AliMonitorV0s.cxx \
AliMonitorHLT.cxx \
+ AliMonitorDataTPC.cxx \
AliMonitorProcess.cxx AliMonitorControl.cxx \
AliMonitorDialog.cxx AliMonitorClient.cxx
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff