GAUDI User Guide

Chapter 3
Release notes and software installation

3.1  Release History


Package List



Gaudi[v5], LHCbEvent[v6], SicbCnv[v6], RootCnv[v3], HbookCnv[v5], DestDesc[v2], GaudiLab[v1], GaudiExamples[v6]



Gaudi[v4], LHCbEvent[v5], SicbCnv[v5], RootCnv[v2], HbookCnv[v4], DestDesc[v1], GaudiExamples[v5]



Gaudi[v1], LHCbEvent[v1], SicbCnv[v1], HbookCnv[v1], GaudiExamples[v1]

3.2  Current Functionality

We use an incremental and iterative approach for producing the Gaudi software. We started in the first release with very basic functionality and we plan to expand its capabilities release by release. The basic functionality offered in the first release allowed you to read the already generated SicB Monte Carlo data sets (Zebra files). The data in these files is used to build C++ objects which can be used as input for the new software.

In current release has incorporated most of the essential features which are needed for developing data processing applications (reconstruction, analysis, etc.). The functionality list that follows is organized by categories.

A set of interfaces that facilitates the interaction between the different components of the framework. Mainly these are interfaces to services.
Basic framework services
This set of services offer the minimal functionality needed for constructing applications. These services are described in detail in Chapter 11 . An example of these services is the message service that is used to send and format messages generated in the code. A severity is associated to each message that is used for filtering and dispatching them. Another of these basic services is the job options service that allows the configuration of the application by end users assigning values to properties defined within the code.
Data services provide the access to the transient data objects (event, detector and statistical data). The data services are describer in Chapter 6 .
Event data model
The event model for the Monte Carlo data is reasonably complete and presented in Chapter 7. The following classes are actually implemented and available: Run, Event, MCCalorimeterHit, MCRichPhotodetectorHit, MCRichRadiatorHit, MCTrackingHit, MCECalFacePlaneHit, MCParticle, MCVertex, AxPartCandidate
Event data persistent storage
The current version supports event data files (or tapes) as input produced by SicB in Zebra format (RZ). The Zebra banks are converted to C++ objects by specialized fragments of code (SicB converters). This conversion is available in the framework for a number of SicB banks. Adding more converters is possible and will be done on request. The event data produced by the application can be stored in ROOT files (Root I/O) and retrieved later. This also requires to write specialized converters. Refer to Chapter 12 for more details.
Histograms & N-tuples
The framework provides facilities for creating histograms (1 and 2 dimensional) and n-tuples (row and column wise) from user algorithms. Saving histograms and n-tuples is currently implemented using the HBOOK format. Other persistent representations will be made available if requested. The interface to histograms and N-tuples from the user code should not be affected if the persistency representation is changed later. Details of the histogram and n-tuple facilities can be found in Chapter 9 and 10 respectively.
Detector description and geometry
The framework provides facilities for describing the logical structure of the detector in terms of a hierarchy of detector elements and also the basic geometry description in terms of volumes, solids and materials. Facilities for customizing the generic description to many specific detector needs are also provided. This should allow to develop detector specific code which can provide geometry answers to questions from the physics algorithms (simulation, reconstruction and analysis). The persistent representation of the detector description is based on text files in XML format. a detailed description can be found in Chapter 8 .
Analysis services
A number of facilities and services are included in the current release to facilitate writing physics analysis code. One service is the Particle Properties service that provides the properties of all the elementary particles. Access to the CLHEP and NAG C libraries provide numerical utilities for writing physics algorithms.
Visualization services
The framework provides very basic facilities (at the prototype level) for visualization of event and detector data. These services are currently based on the packages that constitutes the Open Scientist suite (OpenGL, OpenInventor(soFree), Lab,...) The idea is that any data object in the event or detector store can be represented graphically by providing a specific graphical converter. A prototype implementation of an interactive graphical user interface service is included in the release.
SicB services
A number of services are included in the current release to facilitate the access to SicB data (detector description, magnetic field, etc.) and to facilitate re-using existing Fortran code with the framework. These services can be extended to accommodate new concrete requests when integrating big parts of the current legacy code (SicB). Refer to Chapter 13 for more details.
Dynamic loading of libraries
The framework will be used to implement different data processing applications for different environments. It is important that the services and their concrete implementations are extendable and configurable dynamically at run time and not statically. The latter would imply linking with all the available libraries producing huge executables. And in certain applications and environments some of the libraries will surely never be used. This release provides support for dynamic libraries for the NT platform. Support for the unix platforms will come soon.

3.3  Availability

The application framework is supported on the following platforms:

Support for IBM AIX has been dropped as of release 3.

The code, documentation and installation instructions are available from the LHCb web site at:

3.4  Using the framework on NT with Developer Studio

The Framework sources are available via AFS or can be downloaded from the web. The libraries for NT have been built in the LHCb NT server (\\alntsb\packages\LHCb\LHCbSoft\...).

Using the framework on NT requires the following components being available in your system:

Some environment variables needs to be defined (using Control Panel/System/Environment) before starting Developer Studio application to take effect. The following is the list of these variables with their values for the CERN local installation.

SICB environment (N.B. do not use versions > v116 in Gaudi) 
LHCBROOT       = S:\LHCb\Sicb\ 
LHCBVERS       = v116 
LHCBPATH       = \LHCb\Sicb\ 
LHCBSHARE      = S: 
Append to the PATH environment variable 

Copy or check-out from the CVS repository the package you would like to work with. For example the package GaudiExamples. The Developer Studio workspace and projects are generated using the CMT command cmt build msdev and put in the Visual folder of the project. Open the workspace with Developer Studio.
At CERN both the CVS check-out and CMT build msdev can be done at once using the application GetPack (/Start Menu/Aleph-LHCb Applications/CMT/GetPack)

3.5  Using the framework in Unix

The framework libraries have been built for various Unix platforms and are available via AFS. These libraries have been built using the Configuration Management Tool (CMT). Therefore, using the CMT tool is the recommended way to modify existing packages or re-build the examples included in the release. Complete and up to date information about using CMT is available at the URL: Here we give only simple instructions on how to get started with the Gaudi software under CMT on Unix.

Getting a copy of a package:
Suppose you want to build the latest released version of the GaudiExamples package:

[1] cd mycmt

[2] getpack GaudiExamples

following versions are available - v6 v5r1 v5 v4 v3

Enter version number [<CR>=v6]->

Building and running an example:
Now that you have the code, suppose you want to modify the Histograms example, then build it and run it:

[3] cd GaudiExamples/v6/Histograms

[4] emacs HistoAlgorithm.cpp

----- Make your modification, then

[5] cd ../mgr

[6] emacs requirements

----- Uncomment Histograms and comment all the others

[7] gmake

[8] cd ../Histograms

[9] emacs jobOptions.txt

----- Make any modification if needed

[10] ../$CMTCONFIG/Histograms.exe

Modifying a library and rerunning the example:
Suppose now you want to modify one of the Gaudi libraries, build it, then relink the Histograms example and run it:

[11] cd $HOME/mycmt

[12] getpack HbookCnv v5

[13] cd HbookCnv/v5/HbookCnv

[14] emacs ....Make your modification...

[15] cd ../mgr

[16] gmake

[17] cd $HOME/mycmt/GaudiExamples/v6/mgr

[18] cmt show uses

----- Make sure that you are using the modified version (v5) of

----- HbookCnv. If not, edit the requirements file to use this version

[19] gmake

[20] cd ../Histograms

[21] ../$CMTCONFIG/Histograms.exe