Prototype of the ALICE Event Visualization Framework

Authors: Alja & Matevz Tadel

Contents

• Introduction

• Basic Considerations & Design Guidelines

• History

• Status

• Availability

• Future

Introduction

Definition

Event display is an application offering "graphical user interface to" and "visualization of":

Necessarily

• detector geometry

• event data

  • simulation records: kinematics, hits

  • raw data

  • reconstructed objects: clusters, tracks, VO's, primary vertex

• reconstruction & analysis algorithms

Possibly

• grid interface for visualization of remote-data and resources

• calibration and alignment data

• simulation algorithms

Hardly

• on-line monitoring

• detailed detector status

Purpose

1. visual debugging ---> need complex selections and simultaneous display of many elements

2. facilitate preparation of "scientific results" and "documentary material"

3. help users understand the detector, event structure and reconstruction algorithms

4. presentations, demonstrations & outreach activities

Basic Considerations & Design Guidelines

Scope

Very wide ---> "event display" is a many headed dragon.

Instead of designing it as a monolithic application ... build the skeleton and internal organs first. Call these an

Event Visualization Framework (EVF)

Common base on which different and specialized front-ends can be attached (eg. for on-line monitoring).

Basic elements/operations:

1. convert ALICE data into visualization-optimized structures

   ALICE is an extreme case (event size, # of tracks)

2. visualization of basic components (geometry, kinematics, hits, ...)

3. provide mechanisms for data-selection

   queries that consider simulated AND reconstructed data (cross-selections)

4. open design ---> allow extensions/specializations by user-code on all levels

5. support for custom front-end building

Software prerequisites

ROOT

Absolute prerequisite --- the mother of everything.

Rely heavily on ROOT I/O and advanced features of TTree's (indices, friends).

Ideally would only need a thin library including:

• data-structures

• I/O steering & state management

• selection algorithms

• visualization code

AliROOT

ALICE specific part mandatory for:

1. data conversion

2. raw-data or digit visualization

3. interaction with reconstruction & analysis algorithms

It should be possible to run basic visualization without ALICE libraries.

GLED

ROOT-based framework for object-collection management, dynamic visualization & distributed computing (http://www.gled.org/).

• allows rapid code development and provides powerful GUI elements for object interaction (setting values, calling methods, browsing)

• flexible and modular OpenGL rendering infrastructure

• directly supports multi-threaded execution (threaded method execution and exclusion locks provided at the base-class level)

General plan

Build a complete prototype of Event Visualization Framework

Complete: reading & displaying all levels of ALICE data

Prototype: can be somewhat sloppy about implementation details; provide only rudimentary GUI elements

Needed to:

• estimate operational parameters (memory consumption, execution speed, rendering refresh rate)

• develop, test and assess selection mechanisms and display modes

• see how it looks ---> find reasonable default representations

• allow early users to try it out and influence further development

The prototye is basically done.

Sorely missing: visualization of digits raw-data (only TPC done).

History

Family project: Alja working since mid Nov-04, I began contributing directly in Jan-05

Jan-05

ROOT geometry (TGeo) visualization

Mar-05

basic interface to AliROOT; kinematics

Apr-05

simulated hits, TPC digits

Beginning of Jun-05

TPC clusters, reconstructed tracks and V0's, prototype of cross-selections

End of Jun-05

ITS clusters (trivial) and digits (painful)

Status

No separation on ALICE specific .vs. VisCore part yet.

Read ALICE data and produce Visualization Summary Data (VSD) file.

The VSD can be read back and used without the presence of ALICE data.

Geometry

A general visualization tool for ROOT TGeo geometries

Features:

• loading from ROOT file; selection of volumes for browsing/viewing

• interface to overlap checking

• export simplified geometry

• save visual representation of geometry (volume selection, colors)

ALICE geometry: a) geo-volume browser; b) overlaps and extrusions

Simulation data

Kinematics done

Hits done for ITS, TPC, TRD, TOF (easy to add others)

TPC hits are thinned by a factor of 10.

a) primary charged particles in a central event; b) kinematics and hits

Digits & Clusters

Done for TPC and ITS.

Clusters for other sub-detectors easy to add.

Digits diplay is detector specific, need further input.

Creating a complete digit-viewer is a daunting task (need special layout of elements, navigation mechanisms, histogram output ...).

TPC

a) TPC clusters and digits; b) hits also added

Maximal pad-value is drawn.

ITS

a) coctail 10k: full its digits; b) small event (coctail 100): z-view of ITS clusters and reconstructed tracks

coctail 10k: a) pixels; b) silicon drift

Reconstructed tracks and V0's

a) Reconstructed tracks, clusters and kinematics; b) reconstructed V0

Availability

Installation available on afs, eg:

 /afs/cern.ch/alice/library/gled/bin/aligled -- AliLoader.C

Use 'aligled -help' to get confused.

Available scripts:

Random notes

1. If possible, use hardware accelerated graphics drivers.

   For ATI and NVIDIA this might help http://www-f9.ijs.si/~matevz/ati_nvidia/

2. To navigate in the 3D window, use:

    left-drag          forward/backwards slide left/right
    ctrl-left-drag     slide up/down     slide left/right
    mid-drag           turn up/down      turn left/right
    ctrl-mid-drag      turn down/up      roll left/right
    <Home>		    return to the origin
    <F1>               spawn view-control window
    <F2>               spawn camera-position window

3. Some documentation available from http://www.gled.org/docs/. Somewhat rotten and/or incomplete, but not misleading.

Future

Split development of functionality and framework structure

Functionality: be pragmatic and opportunistic

1. keep the prototype working (in case somebody needs a picture for his talk)

2. fill-in the missing parts and extend it to accommodate user's needs

3. raw-data visualization

Framework structure:

1. separate ALICE specific part

2. prepare mechanisms for attachment of specialized GUI front-ends (especially for pure ROOT GUI)

3. bridge the gaps between ROOT and GLED GUI & OpenGL rendering