User's Guide


Table of Contents


Concept

Above, there is a sketch showing the concept of ROME. The ROMEBuilder is the central object. It takes the ROME-classes and the xml file, containing the user's framework specifications, and generates the experiment dependent classes. It also links all classes together and creates an executable and it generates a documentation of the generated framework. After running the ROMEBuilder the experimenter has to add the calculation code to predefined event methods of the generated task classes (see objects in ROME). Then the ROMEBuilder should be run again to generate an executable containing also the calculation code.

The steps needed to generate a framework are therefore :

For a detailed instruction of downloading ROME and creating a framework, please visit the download section.


Objects in ROME

Frameworks generated with ROME contain objects. These objects have to be defined in the xml definition file. All objects are discussed in this section.

Tasks

Tasks are objects, that provide some actions. Therefore, this is the place to write the analysis code. They are created with predefined but empty event methods, that have to be filled by the user. Please check out the 'TaskDesc' section of the XML framework definition schema documentation for a description of allowed xml tags for a task definition. Please check out also the stepbystep example in the ROME distribution.

After running the ROMEBuilder the user should add code to the generated task classes. The source file (.cpp) is placed under [Project Directory]/src/tasks. The header file (.h) is placed under [Project Directory]/include/tasks. Both files can be editted by the user. The source file containes the predifened event methods : Init(), BeginOfRun(), Event(), EndOfRun(), Terminate(). They are called by the framework at the given time. The user should fill these methods with code.

Tasks can contain histograms, that can be used to mirror the tasks action. Histograms are described here.

Tasks can be hierarchically arranged. Therefore a task may have sub tasks, that are executed after the task itself has been executed. To arrange the tasks in a hierarchical way they have to be added to a task hierarchy. Please check out the 'TaskHierarchyDesc' section of the XML framework definition schema documentation for a description of allowed xml tags for a task hierarchy definition. Please check out also the taskhierarchy example in the ROME distribution.

The ROME tasks are based on ROOT tasks. The main differences are, that the ROME tasks contain not only one Exec() function but five event methods (Init(), BeginOfRun(), Event(), EndOfRun(), Terminate()) and that a ROME task can contain histograms. More information about ROOT tasks is available on the ROOT home page.

Folders

Folders are data storage objects. They are classes which are stored in ROOT folders. Every folder class goes into its own ROOT folder. ROME folders can only store the data of one event. For the storage of the hole data, trees are used. After each event the framework writes automatically all folders to trees. To tell the framework if an event should be filled to the tree or not, the following method is available :

voidSetFillEvent(Bool_t fillEvent = true)

Please check out the 'FolderDesc' section of the XML framework definition schema documentation for a description of allowed xml tags for a folder definition. Please check out also the stepbystep example in the ROME distribution.

Trees

Trees are data storage objects, which can contain large data quantity. A ROME tree is virtually a ROOT tree. A tree may have several branches. The data of each branch is linked to the data of a folder. More information about trees is available on the ROOT home page.

Histograms

The histograms are ROOT histograms. Histograms always belong to a task, they are used to mirror the output of a task graphically.

Steering Parameters

To steer the functionality of tasks and also the functionality of the whole framework, the user can define steering parameters. These are values, which the user can set just before runtime. There are steering parameters for each task and global steering parameters valid for the whole framework.

Midas Banks

If the input data is stored in midas files, the framework provides access to the banks in these files. Information about midas banks is available on the MIDAS home page.


The ROMEBuilder

The ROMEBuilder translates object descriptions in a xml file into c++ code. Therefore all objects inside the generated framework, have to be defined in a xml file in a certain format, which will be discussed in this section.

Command Line

The builder can be steered form the command line. The options are :

-i The argument is the xml definition file.
-o The argument is the output path, where the generated classes are written to.
-v The builder prints output to show the progress of the program. This option has no arguments.
-nl The builder only generates the classes but does not link them together. This option has no arguments.
-dl During 'make' procedure, a dynamic link library is created from object files. Then it is linked to the executable binary. It makes linking faster.
-a Enable specified affiliation. For detaile, please click question mark on the right of "Affiliation" in this page.
-f Define specified macro when compiling project.
-pch The generated program will be compiled with using precompiled headers. It makes compile faster. This feature is available when you use GCC 3.4 or later. This option has no arguments.
-nopch The generated program will not be compiled with using precompiled headers. This option has no arguments.
-qm Quiet make. Not print compile commands in make procedure.. This option is available under UNIX like system. This option has no arguments.
-midas The generated program can be connected to a midas online system. This option has no arguments.
-xz The generated program can read midas files compressed by xz. xz development library is required. This option has no arguments.
-bzip2 The generated program can read midas files compressed by bzip2. bz2 development library is required. This option has no arguments.
-mysql The MySQL library is linked to the generated framework. It is necessary to do "make -k distclean" when you change this option. This option has no arguments.
-pgsql The PostgreSQL library is linked to the generated framework. It is necessary to do "make -k distclean" when you change this option. This option has no arguments.
-sqlite The SQLite library is linked to the generated framework. It is necessary to do "make -k distclean" when you change this option. This option has no arguments.
-sqlite3 The SQLite3 library is linked to the generated framework. It is necessary to do "make -k distclean" when you change this option. This option has no arguments.

XML Definition File

The xml definition file describes all objects inside the generated framework. The syntax of this file is described in the rome framework definition schema documentation file. For a general introduction to XML please visit the W3 Schools home page.

An example of an xml definition file can be found in the sample application.

It is allowed to specify code instead of values for the xml values. This way one can for example link an array size to a folder value or a steering parameter.

<ArraySize>gAnalyzer->GetMyFolder()->GetMyValue()</ArraySize>
or
<HistArraySize>gAnalyzer->GetGSP()->GetMyValue()</HistArraySize>.

The statement must be a correct method call of the framework, that will be generated. Therefore, you can use methods of the framework also to define your framework. This mechanism is especially useful for array sizes, which are not fixed for the whole data taking. However, for data base folders, there's a little restriction. Array sizes of folders can only be linked to values of folders, which them self are not arrays.


The generated Framework

After creating a framework with the ROMEBuilder, the event methods of the task classes have to be filled with code. Then the ROMEBuilder should be run again to relink the program. To write the experiment specific code to the task's methods, the framework provides the user with access methods to all the objects inside the framework. These methods can be accessed over the 'gAnalyzer' handle.

Command Line

The framework has to be steered over the xml configuration file. Nevertheless, some steering can also be done on the command line. The command line parameters are :

-i The argument is the xml configuration file. Default is 'romeConfig.xml'.
-r The argument are the numbers of the runs, which have to be analyzed.
-e The argument are the numbers of the events, which have to be analyzed.
-m The argument is the analyzing mode. It can be 'online' or 'offline'.Default is 'offline'.
-p Program Mode : (0:analyzer, 1:monitor, 2:analyzer and monitor, 3:monitor connected to an analyzer)
-o The program runs in step by step mode. Program will be paused after every events. This option has no arguments.
-b The program runs in batch mode. This option has no arguments.
-D The program runs in daemon mode. This option has no arguments.
-q The program runs in quit mode. Program exits process after finishing analysis. This option has no arguments.
-v Verbose level. It can be 'mute', 'error', 'warning', 'normal', 'verbose' or 'debug')
-ng The program runs in no graphic mode. This option has no arguments.
-c Turn on graphical config panel.
-nc Turn off graphical config panel.
-ns The splash screen is not shown. This option has no arguments.
-docu Creates a root documentation of all classes of the framework. This option has no arguments.
-I The program goes into interactive mode immediately. All other options are passed to ROOT session.
-R Go into remote session. Other options are ignored. -R hostname:port (e.g -R localhost:9090)
-h Show usage. This option has no arguments.

mode stdin stdout stderr graphical config and ARGUS
batch no accessnormal normal off
daemon no accessredirect to /dev/nullredirect to /dev/nulloff
no graphicnormal normal normal off

XML Configuration File

The generated framework is steered with a xml configuration file. This file has to be edited by the user before runtime. If no configuration file is available at runtime the framework will generate such a file containing default values. The syntax of this file is described in the rome configuration schema documentation file.

Access Methods

In this chapter all access methods to objects inside the generated framework are discussed.

Folders

To access a folder one has to get a handle to it with the following methods :

Get[Folder Name]At([Index])   for object arrays. The return value is a pointer on a TClonesArray.
Get[Folder Name]()   for single objects. The return value is a pointer on the folder class [Short Cut][Folder Name].

Folder Name stands for the name of the folder specified in the xml file.
Index stands for the array index of the object.

These methods return a pointer on the class of this folder.

The get or set the content of a folder one has to use the following methods :

For object arrays :

Get[Field Name]At([Index])   Returns an element of the array.
Get[Field Name]()   Returns a pointer on the array.
Set[Field Name]At([Index],[Value])   Sets an element of the array.

For single object :

Get[Field Name]()   Returns the value.
Set[Field Name]([Value])   Sets the value.

Field Name stands for the name of the field to access specified in the xml file.
Value stands for the value given to the Field.
Index stands for the array index of the Field.

Example: To give the field 'YY' of the 9th folder of a folder array 'XX' the value 99 one has to type this :

      gAnalyzer->GetXXAt(9)->SetYY(99)

Data Base

To add an entry to the data base the following methods are available :

Write[Folder Name]DataBase(this)

Folder Name   stands for the name of the folder, which is to be written to the data base.

Histograms

Histograms belong to a task. So a task can only access his own histograms. To do this the following methods are available :
Fill[Histo Name]([xValue],[weight])    fills a single 1D histogram.
Fill[Histo Name]([xValue],[yValue],[weight])    fills a single 2D histogram.
Fill[Histo Name]([xValue],[yValue],[zValue],[weight])    fills a single 3D histogram.
Draw[Histo Name]()    draws a single histogram.
Get[Histo Name]()    gets the handle to a single histogram.
Fill[Histo Name]At([Index],[xValue],[weight])   fills a 1D histogram of a histogram array.
Fill[Histo Name]At([Index],[xValue],[yValue],[weight])   fills a 2D histogram of a histogram array.
Fill[Histo Name]At([Index],[xValue],[yValue],[zValue],[weight])   fills a 3D histogram of a histogram array.
Draw[Histo Name]At([Index])    draws a histogram of a histogram array.
Get[Histo Name]At([Index])   gets the handle to a histogram of a histogram array.

Histo Name stands for the name of the histogram.
Index stands for the array index of the histogram.
xValue x value to be filled to the histogram.
yValue y value to be filled to the histogram.
zValue z value to be filled to the histogram.
weight weight of the value.

Steering Parameters

Global steering parameters can be accessed over the global handle gAnalyzer->GetGSP(). Task dependent steering parameters can only be accessed inside the task and over the GetSP() handle.

A steering parameter group handle can be accessed with the following methods :

Get[Group Name]()

A steering parameter value can be accessed with the following methods :

Get[Field Name]()
Set[Field Name](Value)

Group Name stands for the name of the steering parameter group specified in the xml file.
Field Name stands for the name of the steering parameter field specified in the xml file.
Value is the new field value.

Example: To get the field 'ZZ' of a global steering parameter group 'YY' of a steering parameter group 'XX' type :

      gAnalyzer->GetGSP()->GetXX()->GetYY()->GetZZ()

Midas Banks

To access a bank in a midas input file one has to use the gAnalyzer->GetMidasDAQ() handle.
The following methods are available :

One can get the entries in a bank with the following method :

Get[Bank Name]BankEntries()

The data can be accessed with :

For single banks :

Get[Bank Name]BankAt([ValueIndex])

The method returns a value of type Bank Type, which must be specified in the XML framework definition file.

For bank arrays :

Get[Bank Name]BankAt([BankIndex],[ValueIndex])

Bank Name stands for the name of the bank.
ValueIndex stands for the array index of the value.
BankIndex stands for the array index of the bank.

If the bank is a structured bank, the data access method returns a pointer on the structure.

Example: To get the 9th value 'YY' of a structured bank 'XX' one has to type this :

      gAnalyzer->GetMidasDAQ()->GetXXBankAt(9)->YY

General

A ROME generated framework provides some general methods for the user.

The following method is accessable over the 'this->' handle:

voidStartRootInterpreter(const char* message = NULL) : Starts the ROOT interpreter. The message is displayed on the screen.

These methods are accessable over the 'gAnalyzer->' handle:

Program mode :
Bool_tIsStandAloneROME() : checks if the program runs in a stand alone ROME mode.
Bool_tIsStandAloneARGUS() : checks if the program runs in a stand alone ARGUS mode.
Bool_tIsROMEAndARGUS() : checks if the program runs in a combined ROME-ARGUS mode.
void SetStandAloneROME() : acivates stand alone ROME mode.
void SetStandAloneARGUS() : acivates stand alone ARGUS mode.
void SetROMEAndARGUS() : acivates combined ROME-ARGUS mode.

Modes :
Bool_tisSplashScreen() : checks if a splash screen is shown at start up.
Bool_tisBatchMode() : checks if batch mode is active.
Bool_tisQuitMode() : checks if quit mode is active.
Bool_tisGraphicalConfigEdit() : checks if a configuration GUI is shown at start up.
void SetSplashScreen(Bool_t flag=true) : sets the splash screen mode.
void SetBatchMode(Bool_t flag=true) : sets the batch mode.
void SetQuitMode(Bool_t flag=true) : sets the quit mode.
void SetGraphicalConfigEdit(Bool_t flag=true) : sets the configuration GUI mode.

Analysis Modes :
Bool_tisOnline() : checks if the program runs online.
Bool_tisOffline() : checks if the program runs offline.
void SetOnline() : sets online mode.
void SetOffline() : sets offline mode.

Directories :
const char*GetInputDir() : returns the path to the input directory.
const char*GetOutputDir() : returns the path to the output directory.
const char*GetDataBaseDir() : returns the path to the database directory.
const char*GetConfigDir() : returns the path to the configuration directory.
void SetInputDir(const char *dir) : sets the path to the input directory.
void SetOutputDir(const char *dir) : sets the path to the output directory.
void SetDataBaseDir(const char *dir) : sets the path to the database directory.
void SetConfigDir(const char *dir) : sets the path to the configuration directory.

Run Number :
voidGetRunNumberStringAt(ROMEString &buffer,Int_t i) : returns the ith runnumber as a string.
Long64_t GetRunNumberAt(Int_t i) : returns the ith runnumber.
void GetCurrentRunNumberString(ROMEString &buffer) : returns the current runnumber as a string.
Long64_t GetCurrentRunNumber() : returns the current runnumber.
Int_t GetNumberOfRunNumbers() : returns the number of runnumbers.
const char*GetRunNumberStringOriginal() : returns the runnumber string as given in the configuration file.
void SetCurrentRunNumber(Long64_t runNumber) : sets the current runnumber.
void SetRunNumbers(ROMEString &numbers) : sets all runnumbers.
void SetRunNumbers(const char *numbers) : sets all runnumbers.
Long64_t GetNextRunNumber(const Long64_t runNumber) : returns the next runnumber.
void DecodeNumbers(ROMEString &str,TArrayL64 &arr) : Decodes run and event numbers.
Int_t CheckRunNumber(Long64_t runNumber) : Checks a run number.
Int_t CheckNumber(Long64_t eventNumber,TArrayL64 &numbers) : Checks a run or an event number.

Event Number :
Long64_tGetCurrentEventNumber() : returns the current eventnumber.
const char*GetEventNumberStringOriginal() : returns the eventnumber string as given in the configuration file.
void SetCurrentEventNumber(Long64_t eventNumber) : sets the current eventnumber.
void SetEventNumbers(ROMEString &numbers) : sets all eventnumbers.
void SetEventNumbers(const char *numbers) : sets all eventnumbers.
Int_t CheckEventNumber(Long64_t eventNumber) : Checks an event number.

Input File Names :
ROMEStringGetInputFileNameAt(Int_t i) : returns the ith input file name.
ROMEString GetCurrentInputFileName() : returns the current input file name.
Int_t GetNumberOfInputFileNames() : returns the number of input file names.
const char*GetInputFileNamesStringOriginal() : returns the input file name string as given in the configuration file.
void SetCurrentInputFileName(Long64_t runNumber) : sets the current input file name.
void SetInputFileNames(ROMEString &numbers) : sets all input file names.
void SetInputFileNames(const char *numbers) : sets all input file names.
void DecodeInputFileNames(ROMEString &str,ROMEStrArray &arr) : Decodes input file names.

IO Type :
Bool_tIsRunNumberBasedIO() : checks if the io is run number based.
Bool_tIsRunNumberAndFileNameBasedIO() : checks if the io is both run number and file name based.
Bool_tIsFileNameBasedIO() : checks if the io is file name based.
void SetIOType(Int_t type) : sets the io type. Valid arguments are kRunNumberBased, kFileNameBased and kRunNumberAndFileNameBased.

Framework Flags :
Bool_tisTerminationFlag() : checks if the program is about to terminate.
void SetTerminationFlag() : sets the termination flag.
Bool_tisFillEvent() : checks if the event should be filled to the tree.
void SetFillEvent(Bool_t fillEvent = true) : sets the fill event flag.
Bool_tIsDontReadNextEvent() : checks if the next event should be read in form the active DAQ.
void SetDontReadNextEvent(Bool_t flag = true) : sets the read next event flag.
Bool_tisTreeAccumulation() : checks if the trees are accumulated over several runs.
void SetTreeAccumulation(Bool_t flag = true) : sets the tree accumulation flag.

Output :
voidPrintText(char text) : prints out one character.
voidPrintText(const char *text="") : prints out a character string without an ending line feed.
voidPrintLine(const char *text="") : prints out a character string with an ending line feed.
voidPrintFlush(const char *text="") : flushes the output buffer.

DAQ System :
const char*GetNameOfActiveDAQ() : returns the name of the active DAQ system.
ROMEDAQSystem*GetActiveDAQ() : returns a handle to the active DAQ system.
Bool_t isActiveDAQSet() : checks if a DAQ system is active.
void SetActiveDAQ(ROMEDAQSystem *handle) : sets the active DAQ system.

Data Base :
const char*GetDataBaseConnection(Int_t i) : returns the connection string of a database.
void SetDataBaseConnection(Int_t i,const char *connection) : sets the connection string of a database.
ROMEDataBase*GetDataBase(Int_t i) : returns a database.
ROMEDataBase*GetDataBase(const char *name) : returns a database.
Bool_t isDataBaseActive(const char *name) : checks if a database is active.
void SetDataBase(Int_t i,ROMEDataBase *dataBase) : adds a database.
Int_t GetNumberOfDataBases() : returns the number of databases.
void InitDataBases(Int_t number) : initializes a database.

Tasks :
voidAddTask(TTask *task) : adds a task to the list of tasks.
ROMETask*GetTaskObjectAt(Int_t index) : returns a task.
Int_t GetTaskObjectEntries() : returns the number of tasks.
TTask* GetMainTask() : returns the main task.

Folders :
TFolder*GetMainFolder(TTask *task) : returns the main folder.
Bool_tDumpFolders(const char* filename, Bool_t only_database) : creates a folder dump.
Bool_tLoadFolders(const char* filename, Bool_t only_database) : loads a folder dump.

Trees :
voidAddTree(TTree *tree) : adds a tree to the list of trees.
ROMETree*GetTreeObjectAt(Int_t index) : returns a tree.
Int_t GetTreeObjectEntries() : returns the number of trees.

Histograms :
TFolder*GetMainHistoFolder() : returns the root histogram folder.
TFolder*GetHistoFolderAt(int index) : returns a histogram folder.
Bool_t IsHistosRead() : checks if histograms are read in at start up.
Int_t GetHistosRun() : returns the run number from which the histograms should be read in.
void SetHistosRead(Bool_t flag) : sets the histogram read flag.
void SetHistosRun(Int_t runNumber) : sets run number for the histogram read.
TFile* GetHistoFileHandle() : returns a handle to the file containing the histograms.
void SetHistoFileHandle(TFile *file) : sets the file containing the histograms.

Sockets :
Int_tGetPortNumber() : returns the port number for the socket connection.
Bool_tisSocketOffline() : checks if the socket connection is available for offline analysis.
void SetPortNumber(Int_t portNumber) : sets the port number for the socket connection.
void SetPortNumber(const char *portNumber) : sets the port number for the socket connection.
void SetSocketOffline(Bool_t flag=true) : tells the framework if the socket connection should be available for offline analysis.

Socket to ROME :
Bool_tIsSocketToROMEActive() : checks if the socket connection to the ROME analyzer is active.
const char* GetSocketToROMEHost() : returns the host of the the ROME analyzer.
Int_t GetSocketToROMEPort() : returns the port number used for the socket to the ROME analyzer.
ROMENetFolder*GetSocketToROMENetFolder() : returns the net folder used for the socket to the ROME analyzer.
void SetSocketToROMEActive(Bool_t flag) : tells the framework if the socket connection to the ROME analyzer should be active.
void SetSocketToROMEHost(const char *host) : sets the host name of the socket connection to the ROME analyzer.
void SetSocketToROMEPort(Int_t portNumber) : sets the port number used for the socket connection to the ROME analyzer.
void SetSocketToROMEPort(const char *portNumber) : sets the port number used for the socket connection to the ROME analyzer.

Net Folder :
Bool_tIsNetFolderActive(const char *name) : checks if the net folder is active.
ROMENetFolder*GetNetFolder(const char *name) : returns the net folder.
char* GetNetFolderName(Int_t i) : returns the name of the net folder.
char* GetNetFolderHost(Int_t i) : returns the host name of the net folder.
Int_t GetNetFolderPort(Int_t i) : returns the port number of net folder.
char* GetNetFolderRoot(Int_t i) : returns the root folder name of the net folder.
Bool_t GetNetFolderActive(Int_t i) : checks if the net folder is active.
Bool_t GetNetFolderReconnect(Int_t i) : returns if the net folder is automatically reconnected after a connection break up.
void SetNetFolderName(Int_t i,const char *name) : sets the name of the net folder.
void SetNetFolderHost(Int_t i,const char *host) : sets the host name of the net folder.
void SetNetFolderPort(Int_t i,Int_t port) : sets the port number of the net folder.
void SetNetFolderPort(Int_t i,const char *port) : sets the port number of the net folder.
void SetNetFolderRoot(Int_t i,const char *root) : sets the root folder name of the net folder.
void SetNetFolderActive(Int_t i,Bool_t active) : sets the active state of the net folder.
void SetNetFolderReconnect(Int_t i,Bool_t reconnect) : sets the reconnection flag of the net folder.
Int_t GetNumberOfNetFolders() : returns the number of net folders.
Bool_t ConnectNetFolder(const char *name) : Connects a net folder.
Bool_t ConnectNetFolder(Int_t i) : Connects a net folder.
Bool_t DisconnectNetFolder(const char *name) : Disconnects a net folder.
Bool_t DisconnectNetFolder(Int_t i) : Disconnects a net folder.
Bool_t ConnectNetFolders() : Connects all net folders.
Bool_t DisconnectNetFolders() : Disconnects all net folders.
void InitNetFolders(Int_t number) : Initializes net folders.

Online :
const char*GetOnlineHost() : returns the host name of the online experiment.
const char*GetOnlineExperiment() : returns the name of the online experiment.
void SetOnlineHost(const char *host) : sets the host name of the online experiment.
void SetOnlineExperiment(const char *experiment) : sets the name of the online experiment.

Database :
voidSetEventBasedDataBase(Bool_t flag=true) : sets the event based data base flag.
Bool_tIsEventBasedDataBase() : checks if the database should be updated every event. Default is update every run.
Bool_tReadSingleDataBaseFolders() : reads a folder with database access.
Bool_tReadArrayDataBaseFolders() : reads an array folder with database access.

User Events :
voidSetUserEventQ() : sets user event : q pressed.
void SetUserEventE() : sets user event : e pressed.
void SetUserEventS() : sets user event : s pressed.
void SetUserEventR() : sets user event : r pressed.
void SetUserEventO() : sets user event : o pressed.
void SetUserEventC() : sets user event : c pressed.
void SetUserEventG(Long64_t runNumber,Long64_t eventNumber) : sets user event : g pressed.
void SetUserEventI() : sets user event : i pressed.
Bool_t HasUserEvent() : checks if a user event occured.
void DeleteUserEvent() : deletes all user events.
Bool_t IsUserEventQ() : checks if user event q has occured.
Bool_t IsUserEventE() : checks if user event e has occured.
Bool_t IsUserEventS() : checks if user event s has occured.
Bool_t IsUserEventR() : checks if user event r has occured.
Bool_t IsUserEventO() : checks if user event o has occured.
Bool_t IsUserEventC() : checks if user event c has occured.
Bool_t IsUserEventG() : checks if user event g has occured.
Long64_tGetUserEventGRunNumber() : returns the run number for user event g.
Long64_tGetUserEventGEventNumber() : returns the event number for user event g.
Bool_t IsUserEventI() : checks if user event i has occured.

Monitor :
Bool_tIsWindowClosed() : checks if the Argus monitor is closed.
void WindowClosed() : called by the framework when the Arggus monitor has closed.
ArgusWindow*GetWindow() : returns a handle to the Argus monitor.
Bool_t StartWindow() : starts the Argus monitor.
Int_t GetUpdateFrequency() : returns the window update frequency.
void SetUpdateFrequency(Int_t frequency) : sets the window update frequency.
Bool_t IsWindowBusy() : checks if the Argus monitor is busy.
Bool_t IsEventFilled() : checks if the event is filled.
void SetEventFilled(Bool_t flag) : sets the event filled flag.

Configuration :
ROMEConfig*GetConfiguration() : returns a handle to the configuration.
Bool_tShowConfigurationFile() : shows a configuration edit GUI.

Run Statistics :
voidShowRunStat(Bool_t flag=true) : Sets the run statistics flag.
Bool_t IsShowRunStat() : checks if the program should print out run diagnostics.
Double_tGetProcessedEvents) : Returns the number of processed events.

Midas :
HNDLEGetMidasOnlineDataBase() : returns a handle to the midas odb.
HNDLE* GetMidasOnlineDataBasePointer() : returns the address of a handle to the midas odb.
Statistics*GetTriggerStatistics() : returns a handle to the trigger statistics.
Statistics*GetScalerStatistics() : returns a handle to the scaler statistics.
Int_t GetEventID() : returns the id of the event.
void SetEventID(Int_t eventID) : sets the id of the event.

Application and Cint :
ROMERint*GetApplication() : returns a handle to the ROOT application.
const char*GetCintInitialisation() : returns the command line used to initialize the Cint for ROME.
void SetCintInitialisation(const char *str) : sets the command line used to initialize the Cint for ROME.

Utility Functions :
Int_tss_getchar(UInt_t reset) : returns a keyboard input character.
UInt_t ss_kbhit() : checks the keyboard input buffer.
Bool_t strtobool(const char *str) : converts a string to a boolean.
Int_t stricmp(const char*,const char*) : compares two strings.
Bool_t toBool(Int_t value) : converts an integer to a boolean.
void redirectOutput() : redirects the standard output.
void restoreOutput() : restores the standard output.
const char*GetProgramName() : returns the program name.

Special running modes

Interactive mode

Interactive mode is prepared mainly for analyzing output ROOT files interactively. The difference from the normal ROOT is that generated framework knows classes written in output trees.

Example. (please replace command name with yours)

Start interactive session.
$ ./myanalyzer -I

You can retrieve objects from another running analyzer. <SocketServer> in the server side analyzer must be turned on.

Configuration XML for server side analyzer

Example. (please replace command name with yours)

      <SocketServer>
        <Active>true</Active>
        <PortNumber>9090</PortNumber>
      </SocketServer>
Example of drawing a tree.
$ ./myanalyzer -I
myanalyzer [0] MyAnalyzer *a = new MyAnalyzer()
myanalyzer [1] a->ConnectSocketClient("remote_host_name", 9090)
myanalyzer [2] ((TTree*)a->GetSocketClientNetFolder()->FindObjectAny("tree_name"))->Draw("leaf_name")

Remote interactive mode

This mode is prepared mainly for debugging. In this mode, interactive session is started with connecting to remote running analyzer. All command lines are executed in the remote host. <SocketServer> in the server side analyzer must be turned on.

Example. (please replace command name with yours)

Configuration XML for server side analyzer
      <SocketServer>
        <Active>true</Active>
        <PortNumber>9090</PortNumber>
      </SocketServer>
Start client side analyzer in remote interactive mode.
$ ./myanalyzer -R localhost:9090


Matthias Schneebeli, Ryu Sawada
e-mail: ryu.sawada@psi.ch