List of Abstracts Submitted for ROOT 2004


The following abstracts have been submitted for the ROOT 2004 workshop:

30 abstracts

nameinstituteexperiment
 
Nikolay MalitskyBrookhaven National LaboratoryAccelerator Computational Physics
Integration of UAL and ROOT N.Malitsky and R.Fliller III The Unified Accelerator Libraries (UAL, http://www.ual.bnl.gov) software is an open accelerator simulation environment addressing a broad spectrum of accelerator applications ranging from online-oriented efficient models to full-scale realistic beam dynamics studies. The modularity and extensibility of the UAL architecture has been achieved with the Element-Algorithm-Probe framework and a Perl-based Application Programming Interface (API). The UAL framework introduced a mechanism for building many-to-many associations between a collection of accelerator algorithms and diverse accelerator applications, and the Perl API facilitated a control of different C++ and Perl modules in complex scenarios. Connecting UAL with ROOT aims to offer accelerator physicists a new common integrated environment comprising together simulation, analysis, and visualization components. The CINT/UAL interface is built according to the present UAL C++/Perl approach based on additional module-associated wrappers, which, in the CINT case, are produced by the CINT dictionary generator. This scheme preserves the integrity of the UAL and ROOT frameworks, and, at the same time, provides fine-grain access to their classes, allowing users the freedom for combining different components on the application level. The various features of the UAL-ROOT environment are illustrated by examples, such as collimator and space charge modeling, monitoring of virtual devices, and others
 
Lionel ChaussardIPN LyonOpera
The ROOT framework is extensively used in the software developments of the OPERA Collaboration (high energy physics experiment planned to study neutrino oscillations on the CERN to Gran Sasso beam). Data persistency and data access take benefit from the TTree characteristics, with both ROOT direct access and ROOT-to-STL translation for non-ROOT specialists. Detector description is being translated to the ROOT TGeoMananger language, and simulation is performed using ROOT Virtual Monte Carlo concepts (starting from VMC \"ancestor\" model AliRoot). Last but not least, data analyses are also based on ROOT structures : GUI classes for event display, Tree manipulation and ROOT-based code for track reconstruction in the OPERA emulsions.
 
Christophe DelaereNUCLEAR PHYSICS INSTITUTE - UNIVERSITY OF LOUVAIN (BELGIUM)cms
Using Neural Networks within ROOT ***** Neural Networks are widely used for data analysis and multivariate function fitting in fields as various as medicine, meteorology, finance, marketing or particle physics. Although several types of Neural Networks exist, most of the applications are using so-called Multi-Layer Perceptrons (MLP). MLPs have been implemented in ROOT and are part of the standard distribution since ROOT 3.10/01. This allows easy neural networks design and training from predefined TTrees, direct use of the trained function as well as export as a C++ (standalone) class. MLPs and their implementation within ROOT will be presented as well as examples for both signal discrimination and fitting. Performances issues will also be considered.
 
Kilian Schwarz-alice
To be prepared for the parallel analysis of distributed datasets the different options of setting up a PROOF cluster are investigated at GSI and GridKa. One method is to set up an independent PROOF cluster where the PROOF daemons are started on dedicated machines as standard Linux daemons via /etc/services and xinetd. To avoid empty resources during low usage times we check another option, which is how to integrate PROOF into the local batch system. Herefore a set of scripts have been created via which each user can start his individual PROOF daemons which would run as standard batch jobs under his personal user ID in a high priority queue. As input parameters the user can chose the number of proofd he likes to start and how long he plans to wait until he would start his interactive PROOF session. After this predefined waiting period the system will work with as many PROOF daemons as are available until then. When the interactive analysis will be finished or after a certain time the PROOF session including all proofd shuts down automatically.
 
Andrew Hanushevsky-babar
The next generation root data server, xrootd, provides substantial enahmncements in the areas of scalability, configurability, and fault tolerance. Additionally, xrootd is upwardly and downwardly compatible with rootd, making the transition to xrootd transparent. This talk describes xrootd\'s many features, together with the underlying implementation, that provide a new level of performance that strives to make sure that every job runs to completion regardless of external circumstances.
 
Gerardo GanisFZKLCG
The new Client/Server authentication scheme, included in ROOT from version 3.10/00, will be described. Additional supported features include: three additional authentication methods (with Globus certificates; via the sshd daemon; using UserID/GroupID); RSA asymmetric encryption of password exchanges; server access control; simple Client/Server negotation; improved credential export to Master/Slave in PROOF. The new scheme integrates authentication at TSocket level, introducing the concept of \'authenticated\' socket, and it has also been extended to the TServerSocket class; this allows simple ROOT interactive sessions to act as authentication daemons.
 
Rene BrunCERN-
I will review the recent versions and give an overview of the current major developments.
 
Philippe CanalFermilab-
I will present details on the new implementation in the I/O in particular to STL containers (including split them), on the improvement in TTree::Draw, TTree::Scan, TTreeFormua and TFormula, on the enhancements in ACLiC, etc.
 
Maarten BallintijnMITcms
The Parallel ROOT Facility, PROOF, enables a physicist to analyze and understand very large data sets on an interactive time scale. It makes use of the inherent parallelism in event data and implements an architecture that optimizes I/O and CPU utilization in heterogeneous clusters with distributed storage. We will describe the latest developments in PROOF including the new TSelector, integration with CONDOR Computing On Demand and Grid prototypes.
 
Ilka AntchevaCERN-
An overview of the last development of the GUI classes in ROOT will be presented. It will point out the new widgets since the last workshop; the saving feature that allows to get easily the source for any GUI as a macro which can then be inspected or used to create other GUI\'s; the new GUI builder ideas and how it uses the GUI saving feature.
 
Dimitri BourilkovUniversity of Floridacms
The CAVES Project - Collaborative Analysis Versioning Environment System D.Bourilkov and M.Kulkarni University of Florida, Gainesville, FL 32611, USA The Collaborative Analysis Versioning Environment System (CAVES) project concentrates on the interactions between users performing data and/or computing intensive analyses on large data sets, as encountered in many contemporary scientific disciplines. In modern science increasingly larger groups of researchers collaborate on a given topic over extended periods of time. The logging and sharing of knowledge about how analyses are performed or how results are obtained is important throughout the lifetime of a project. Here is where virtual data concepts play a major role. The ability to seamlessly log, exchange and reproduce results and the methods, algorithms and computer programs used in obtaining them enhances in a qualitative way the level of collaboration in a group or between groups in larger organizations. The CAVES project takes a pragmatic approach in assessing the needs of a community of scientists by building series of prototypes with increasing sophistication. In extending the functionality of existing data analysis packages with virtual data capabilities these prototypes provide an easy and habitual entry point for researchers to explore virtual data concepts in real life applications and to provide valuable feedback for refining the system design. The architecture is modular based on Web, Grid and other services which can be plugged in as desired. As a proof of principle we build a first system by extending the very popular data analysis framework ROOT, widely used in high energy physics and other fields, making it virtual data enabled. The architecture and the implementation of the ROOT analysis clients and the virtual data services is described.
 
Andrei Gheata, Mihaela Gheata-alice
Several new features and improvements have been implemented in the ROOT geometrical modeller. The talk will present the most important ones related to navigation, composite shapes, geometry checker an post-build supported operations, as well as the future development plans.
 
Andrei GheataCERNalice
The ROOT geometrical modeller provides a navigation interface that can be used directly by MC tracking engines via the ALICE-ROOT Virtual MC scheme. It provides a single geometry description and transient model representation usable by other MC applications. The talk will describe some preliminary results and experience that we are having for TGeo-based navigation in ALICE.
 
Wim LavrijsenLBNLlcg
PyROOT, a ROOT - Python bridge: Python is a popular open-source scripting language and many software applications provide bindings for it. PyROOT allows for the integration of ROOT into Python and vice versa.
 
Sergey LinevGSI Darmstadt-
Possibility of XML I/O support in ROOT As it is now, the ROOT file I/O system supports only ROOT binary files. Without the ROOT environment the data stored in such files is not accessible. Storing objects in XML format makes it easy to view and edit (with some restriction) these objects. Several levels of integration of XML into ROOT are possible and can be discussed: without touching ROOT code only a limited set of classes can be stored/read to/from XML file; with a slight change of TBuffer class one can store nearly any object to XML file; with careful review of TFile, TKey and TBuffer classes the ROOT I/O concept can be extended to full support of XML files.
 
Tony Johnson-Linear Collider
The FreeHEP Java library contains a complete (currently read-only) implementation of Root IO for Java. The library uses the \"Streamer Info\" embedded in files created by Root 3.x to dynamically create high performance Java proxies for Root objects. In this presentation we will discuss the status of this code, its implementation and performance, as well as future plans for extending it. We will also discuss some current and future uses of this library, including using JAS3 to analyze Root data, using the WIRED event display to visualize data from Root files, and making Root data web accessible via AIDA and Tomcat.
 
Joern AdamczewskiGSI-
Analysis organisation: Go4 analysis steps and TTask The GSI online-offline analysis system Go4 is a ROOT based framework for medium energy ion- and nuclear physics experiments. Its main features are a multithreaded online mode with a non-blocking Qt GUI, and an eventloop with abstract user interface classes. The analysis process itself is organised as a list of subsequent analysis steps. Each step has its own event objects and a processor instance, and it can handle its event i/o independently. With respect to the more complex experiments planned at GSI, a tree like structure of event processing, and a mesh-like data flow mechanism are required. To handle this, the Go4 analysis step manager will be upgraded. The enhanced concept will be discussed in comparison to the ROOT TTask approach.
 
Eddy OffermannCERN-
The ROOT matrix package has been invigorated . The hierarchical structure has been improved allowing different flavors of matrices, like dens and symmetric . A fairly complete set of matrix decompositions has been added to support matrix inversions and solving linear equations . Special attention has been paid to speed and accuracy control . Further extensions of the package will be discussed .
 
Susan KasaharaUniversity of MNminos
The Minos experiment makes extensive use of ROOT in its software system. The Minos site report will be given, with emphasis on data model, I/O and our beginning experience with the new TGeo package.
 
Alvise Dorigo - Fabrizio FuranoINFN Padovababar
An extension of the ROOT\'s TNetFile class, called XTNetFile, has been developed for use with the next generation server xrootd. XTNetFile provides a new enriched communication protocol and is fault tolerant in case of xrootd daemon crashes or server outages; XTNetFile also supports a redirection mechanism provided by xrootd in order to be able to setup load balanced environments. The XTNetFile is integrated in the ROOT framework and exploiting the ROOT\'s plugin manager, every application can use it without changing any line of code. The plugin also has a backward compatibility mode when connecting to an \"old\" rootd daemon. The presentation will describe the new plugin and its protocol, integration with ROOT, the implementation of the fault tolerance and describe how it is being used in the BaBar environment.
 
Valeri FineBrookhaven National Laboratorystar
This is to present the current status and trend of the Qt-layers for ROOT. One can find 3 approaches to interface ROOT and Qt: 1. Qt layer on the top of ROOT developed for X11 platform only driven by GSI Analysis Framework (Go4) needs. 2. Qt-layer that allowed creating the Qt GUI to embed in it the basic ROOT components like Canvas, Browser, Inspector. (driven by STAR Event Display needs). 3. Full support of ROOT gui classes, that allow to mix ROOT and Qt Widget as desired driven by broad ROOT users community interest to deliver the high quality interactive application based on re-use as Qt as ROOT C++ object models and classes. The 3 present layers do not substitute each other rather complement Qt ROOT interface. This talk presents the implementation of the third approach. As result the ROOT code can be built from a single code both Unix (X11) and Windows OS\'s and no correction of the existent user\'s ROOT-based code including the GUI ones is required.
 
William TanenbaumFermilabcms
The POOL project is the persistency solution for the Large Hadron Collider Computing Grid project at CERN. POOL uses ROOT/IO for its persistent store. This report will discuss the current status of POOL, with particular emphasis on its use of ROOT.
 
Mario BondioliINFN Pisababar
Sts (Svt Test Stand) is a ROOT based framework used during the BaBar SVT module production as a testing, debugging and measurement tool. The system is based on a multi-processor, multi-threaded model that relies heavily on ROOT classes serialized over a tcp/ip link and executed at a remote node. The silicon modules are read out through VME processors running the VxWorks operating system. To use the same source code and class structure at the two ends of the communication pipe, we have ported some ROOT classes to VxWorks. The execution of a command implies the instantiation of an object that is then serialized and transferred to the server process. The server is then responsible of the execution of the class Run method and of the creation and serialization of a reply object to the client side. The same strategy has been used to allow communication to Gpib controlled instruments (connected to a linux pc) and also to additional hardware controlled by a vme single board computer running EPICS. The system has been used with success during the whole production of SVT spare modules. Recently it has allowed the implementation of a Charge Collection Efficiency test stand, thanks to the integration of instrument control with the CINT c++ macro facilities. We describe the architecture and performances of the system with an emphasis on the usage of the ROOT data model to allow exchange of commands and data (c++ classes) between different computing architectures.
 
Fons RademakersCERNalice
In this talk the integration of PROOF with AliEn, the ALICE Grid middleware system, will be presented. In addition to providing the file catalog AliEn takes care of starting the PROOF slave servers on the clusters where the data resides. These clusters typically are in geograhpically diverse locations. The AliEn \"TCP routers\" provide the mechanism that allows the PROOF master to talk to its slaves through the firewalls shielding the cluster nodes from the outside.
 
Richard DuboisSLACglast
I will present an overview of GLAST\'s offline use of Root - including using it as the persistent store for Gaudi; and growing use in astronomical analysis. I will describe the status of our port of AstroRoot to windows.
 
Axel NaumannNKHEF / University of Nijmegend0
ROOT\'s documentation generator THtml is planned to be replaced by a new implementation. Major planned improvements are: support of the full c++ standard (inlined methods, templates, friends, public methods, namespaces); documentation of multiple source files belonging to one class and of classes not known to Cint; versioned documentation; documentation in a .root file, which can be part of ROOT distributions and the source for ROOT\'s future online-help; cleaner html output with customizable templates and views, showing e.g. accessible base class methods for a given class; support of multiple documentation formats (ROOT and javadoc / doxygen). Many of the improvements are targeted towards integrating \"foreign code\" into the ROOT framework, allowing code maintainers (or users) to create documentation for custom libraries which links seamlessly into ROOT\'s documentation. Features, current status, and plans of the new implementation will be presented. A first design preview of the new documentation pages will be shown.
 
Eric CharelsLBNLbabar
Recently BaBar has shifted from using objectivity to using ROOT as the primary data storage application. This presented an oppurtunity to build a user interface that allows users to directly access the persistent data in their analysis. I will present these developments in excrutiating detail.
 
Peter Elmer (speaker TBD)Princeton/BaBarbabar
BaBar currently runs an initial xrootd system at SLAC with ~1000 clients accessing about 50TB of disk servers and has plans to expand well beyond that (including use at a number of computing centers around the world). The operational deployment, use and adminstration of the xrootd server at for BaBar will be described.
 
Peter Elmer (speaker TBD)Princeton/BaBarbabar
The RooFit packages provide a toolkit for modeling the expected distribution of events in a physics analysis. Models can be used to perform likelihood fits, produce plots, and generate \"toy Monte Carlo\" samples for various studies. The RooFit tools are integrated with the object-oriented and interactive ROOT graphical environment. RooFit has been developed for the BaBar collaboration, a high energy physics experiment at the Stanford Linear Accelerator Center, and is primarily targeted to the high-energy physicists using the ROOT analysis environment, but the general nature of the package make it suitable for adoption in different disciplines as well. The presentation will introduce the RooFit toolkit and present some concrete use cases from the BaBar collaboration.
 
Masaharu Goto--
I\'ll explain recent development of Cint. 1: Review basics of Cint, 2: Qt library on Cint , 3: DLL loading without dictionary (Intel CPU only), 4: New compiler and OS support(Cygwin/gcc3.x, Win/VC++7.x)
 


Back to the ROOT Home Page