ROOT Workshop 2007

Europe/Zurich
Council Chamber ()

Council Chamber

    • 08:00 09:00
      Registration 1h
    • 09:00 09:30
      ROOT: Development status and the roadmap 30m
      The major developments since the previous workshop will be summarized and the current development roadmap will be presented.
      Speaker: Rene Brun (CERN/SFT)
      Slides
    • 09:30 10:00
      CINT and Reflex merge 30m
      The internals of the CINT interpreter is currently restructured. The (C array) way it stores its information about available types, functions, and members is replaced by a C++ library called Reflex. We present the benefits for speed, usability, and maintenance, the current implementation, and the planned schedule for making this new version of CINT the default. We also present our planned changes for the next 18 months: removal of function wrappers, persistency of the dictionary in ROOT files, and on-the-fly dictionary generation. All of this will considerably improve the ease of use, library sizes, and compile time.
      Speaker: Axel Naumann (CERN/SFT)
      Slides
    • 10:00 10:20
      Break & Posters 20m
      Several posters will be presented in the coffee break room
    • 10:20 10:40
      Infrastructure changes 20m
      Review of what has changed in the ROOT infrastructure since the last workshop. Topics that will be covered include the plugin manager, rootmap files, library organization, new plugins, new platforms, optimizations, code management and build system improvements, packaging, etc.
      Speaker: Fons Rademakers (CERN/SFT)
      Slides
    • 10:40 11:25
      From ROOT to BOOT, from BOOT to ROOT 45m
      The ROOT system is currently undergoing an important evolution. The aim is to provide a very small kernel, called BOOT, easy to install on all systems and very stable. Using the BOOT executable module, all the other ROOT libraries (and later on users and experiments code) will be automatically imported via the web from central source repositories. This should greatly facilitate the installation of the system on a new computer and provide automatic updates too. The following 3 phases of the project have been defined: -Phase 1: Restructuring of the CORE ROOT framework such that only a small subset will be required to start a running ROOT application (including user libraries). This phase is well advanced and will be presented in details. Thanks to this first phase, the virtual address space required by the interactive version has been reduced by a factor 2. -Phase 2: Instead of generating (via rootcint) the code for the dictionaries that can represent a substantial fraction of the total code to be compiled and linked, the dictionary information will be written to small ROOT files stored together with the shared libraries. In particular the CINT interface stubs to call compiled code will be replaced by generic inline calls. The dictionaries will be loaded from the ROOT files only when really necessary. This will also minimize the amount of information to be stored in memory and it will decrease substantially the size of the shared libraries, in particular in case of templated classes. -Phase 3: Autoloading of the code on demand from a central source repository and online compilation of the code with local storage(cache) of the compiled code. This will facilitate considerably the installation of new versions. This feature will become important in the future when the percentage of code really used in a running application will be a very small subset of the total code in the source repository (or currently shared libraries). I will discuss the implications of this Phase when considering the C++ language evolution or interface with other languages.
      Speaker: Rene Brun (CERN/SFT)
      Slides
    • 11:30 11:50
      Improvements in the Reference Manual and the THtml doc generator 20m
      ROOT's documentation system has been renovated a bit. We will show what the new ingredients are, how they work, and how you can document your own libraries with THtml, including customized layout, module documentation, and cross-library referencing. We will also present some of THtml's tools that can help write better code.
      Speaker: Axel Naumann (CERN/SFT)
      Slides
    • 12:00 14:00
      Lunch Break 2h
    • 14:00 14:30
      Web based HEP Analysis powered by Ajax 30m
      Ajax is a web development technique that empowers web pages with the richness and interactivity usually found in desktop applications, thus significantly enhancing the user experience. In this talk we shall outline the Ajax processing model and present an online analysis tool based on a simple pattern where the presentation layer is an intuitive User Interface and the server side is a CGI program that uses Root for the analysis.
      Speaker: Subir Sarkar (INFN/CMS)
      Slides
    • 14:30 15:00
      Math Libs developments and restructure 30m
      An overview of the recent developments, compared to the last workshop, of the ROOT Math libraries will be presented. The functionality and the design of the new Math packages will be described in detail together with the planned improvements and re-structuring of the previously existing ROOT classes to use the new mathematical algorithms.
      Speaker: Lorenzo Moneta (CERN/SFT)
      Slides
    • 15:00 15:30
      News in ROOT I/O 30m
      For the last several months the main focus of development in the ROOT I/O package has been consolidation. In addition to reducing the coupling with the core module and becoming its owns library (libRIO) (See separate talk on the restructuration of the ROOT libraries), the I/O package has been enhanced in the area of XML and SQL support, thread safetly, schema evolution and TTreeFormula, and many other areas. We will also review a few new utilities, including a generic mechanism for object references and a faster implementation of TTree cloning.
      Speaker: Philippe Canal (FNAL/CD)
      Slides
    • 15:30 16:00
      Break & Posters 30m
    • 16:00 16:30
      TEntryList: A new class to support large and scalable event lists 30m
      TEntryList is a class recently introduced in the Tree library. It is a nice alternative to TEventlist. The new class is designed to support a large set of event lists in a modular way. TEntryList objects can easily be combined when processing large chains of event data. The data structure is optimum for the two extreme cases of high or low selectivity.
      Speaker: Anna Kreshuk (CERN/SFT)
      Slides
    • 16:30 17:00
      Recent Improvements in the ROOT Tree cache. 30m
      Interactive analysis of remote data is always limited by the quality of the network, where the main parameters are bandwidth and latency. The former is not usually a problem but the latter will always be proportional to the distance between the client and server. The only way to deal with this issue is by minimizing the number of transactions between both sites, which is usually done by predicting future requests and transferring them as whole. We will show how we implemented this technique in the new ROOT's cache and how well it works in different conditions. Another big improvement for the cache is the ability to unzip its content in parallel (by using an additional core). This is a direct consequence of the new cache since we need to predict the data that is going to be transfered and unzipped. In the talk, we will give an estimate of the gain we obtain with such algorithm.
      Speaker: Leandro Franco (CERN/SFT)
      Slides
    • 17:00 17:30
      Status of SQL and XML I/O in ROOT 30m
      New developments since last ROOT workshop will be presented. Main topics will be: * new ODBC driver, improvements in MySQL and Oracle plugins; * new TSQLStatement class for work with prepared SQL statements and native data types; * new TSQLFile class for storage of ROOT objects in SQL data bases; * support of custom streamers and subdirectories in XML/SQL files; * improvements in XML I/O; * practical examples of XML and SQL I/O usage.
      Speaker: Sergey Linev (GSI)
      Slides
    • 17:30 18:00
      xrootd performance improvement 30m
      The aspects related to the performance of the data transfer with an xrootd/Scalla file server cluster has been under constant focus since a while. This presentation gives an overview of the new techniques that are exploited in the xrootd client side to enhance its performance in the situations where the network latency is high. Since the xrootd/Scalla system is not aimed only at moving files, but gives a way to directly access remote information where it resides, the main effort has been given to techniques able to enhance the data transfer throughput and overlap the access latency and chunk transfer time with the processing phases of the application which needs the data. In this talk we shortly describe how multistreamed and asynchronous data transfer techniques can be used by data analysis applications or frameworks in a very transparent way.
      Speaker: Fabrizio Furano (INFN/Babar)
      Slides
    • 09:00 09:20
      The LHCb Online Data Quality Monitoring Framework 20m
      LHCb is one of the four major experiments under completion at the Large Hadron Collider (LHC). The expected data rate at the LHC is so high, that the majority of events will be rejected by the trigger system. Thus the monitoring of the trigger performance and the quality of the data in general is of crucial importance. To this end a Data Quality Monitoring project was setup. One part of this project is the presentation tool for Histograms: the "Histogram Presenter", which is developed as part of a "Histogramming Framework". The Histogram Presenter is one of the main instruments to understand the quality of the experimental data. The Presenter is fully integrated within the Experiment's Control System. It allows the visualisation, in a coherent and understandable manner, of several thousand histograms and counters as well as displaying warning or alarm messages generated by automatic analysis tools.
      Speaker: Peter Somogyi (CERN/LHCb)
      Slides
    • 09:20 09:40
      The ALICE Online Data Quality Monitoring Framework 20m
      ALICE is one of the experiments under installation at CERN Large Hadron Collider, dedicated to the study of Heavy-Ion Collisions. The final ALICE Data acquisition system has been installed and is being used for the testing and commissioning of detectors. The Online Data Quality monitoring is an important part of the DAQ software framework (DATE). In this presentation we overview the implementation and usage experience of the interactive tool MOOD used for the commissioning period of ALICE and we present an architectural preview of the upcoming Data Quality Monitoring framework, a distributed application aimed to collect, analyze, visualize and store monitoring data in a large, experiment wide scale.
      Speaker: Filimon Roukoutakis (CERN/Alice)
      Slides
    • 09:40 10:00
      GENDARC, the Geel Neutron physics data acquisition 20m
      GENDARC, the Geel Neutron physics data acquisition, analysis and run control program, based on the object-oriented framework ROOT, has been started in the EC-JRC-Institute of Reference Materials and Measurements in Geel, Belgium. On the one hand, the program improves existing data acquisition, monitoring and data analysis capabilities with respect to existing analogue electronics used in nuclear measurements. On the other hand, it is extended to use new digital hardware in the form of Waveform Digitizers for measuring physical quantities with digital signal processing (DSP) methods to reconstruct and analyse them. At the same time it allows the re-use of existing analysis procedures already used in publications due to a specially created C++ -software interface.
      Speaker: Imrich Fabry (GEEL)
      Slides
    • 10:00 10:30
      Break & Posters 30m
    • 10:30 10:50
      ROOT Graphics 20m
      Current status of the ROOT graphics including the more recent developments in 2D representations and the latest developments in the 3D area based on OpenGL.
      Speaker: Olivier Couet (CERN/SFT)
      Slides
    • 10:50 11:10
      3D graphics with OpenGL: recent improvements and plans 20m
      Last year's changes in ROOT's 3D graphics with OpenGL can be divided in two main lines of work. First, there were many new renderers implemented for 2D histograms, functions and parametric surfaces that allow these objects to be rotated, clipped and projected in real-time. Second, OpenGL viewer was extended to automatically instantiate external rendering objects from user-provided class to achieve maximum level of flexibility. These objects remain in viewer's memory-cache during scene-updates and thus reduce the cost of the scene refresh when only a few objects actually change. OpenGL rendering infrastructure has just undergone a major re-modularization that allows free mixing of 2D and 3D graphics and makes implementation of ROOT canvas in pure GL possible. Scene representation was removed from inside of the viewer, allowing scene-data to be shared among several viewers and providing for natural implementation of multi-view canvas layouts. Via extensions of the TVirtualViewer3D API a finer, per-object control over scene-updates is available to the user, allowing overhead-free maintenance of dynamic 3D scenes. User-input handling was modularized as well, making it easy to write application-specific scene navigation, selection handling and tool management.
      Speaker: Matevz Tadel (CERN/Alice)
      Slides
    • 11:10 11:30
      QtRoot project status and examples of its use at STAR 20m
      The talk present the current status and overview of the QtRoot project that is split in two major subsystems, namely Qt-layer (avaiable from CERN ROOT ) and Qt-Extension (available from BNL) Each component of each subsystem is an Qt-based implementation of the existent ROOT abstract interface. Such approach makes the end-user code independent of either Qt or ROOT built-in implementations of the said interfaces. The QtRoot can be build against of X11 or Win32 or \"native\" MAC version of Qt with the regular Qt \"qmake\" utility and no change to the package source codes. The various examples of the STAR applications for offline production, online monitoring and the detector simulation will also be presented.
      Speaker: Valeri Fine (BNL/Star)
      Slides
    • 11:30 12:00
      Event Visualization Environment of the ALICE experiment 30m
      The foundation of the framework is based on ROOT and its GUI, 2D & 3D graphics classes. A small application kernel provides for registration and management of visualization objects and CINT scripts are used as an extensible mechanism for data extraction, selection and processing as well as for steering of frequent event-related tasks. Several new components, frequently needed for visualization of event related data, including raw-data visualization, have been developed. ALICE specific part of EVE is rather minimalistic, mostly due to the fact that ALICE uses ROOT's data-management facilities for data-storage. It consists mostly of CINT scripts that perform filling and registration of visualization data-structures. A small number of compiled classes is needed for very specific tasks (e.g. for interface to ALICE event-data management system, for TPC raw-data visualization, etc). A demonstration of the system will be given.
      Speaker: Matevz Tadel (CERN/Alice)
      Slides
    • 12:30 14:00
      Lunch break 1h 30m
    • 14:00 14:30
      Pyroot: developments 30m
      Automated Inner Loop Optimization in Python Python does not, as a rule, allow many optimizations, because there are too many things that can change dynamically. However, in a lot of ROOT analysis work (e.g. plotting, fitting, and looping over TTrees), code blocks are used in a logically immutable way and called many times. Then, optimizations normally reserved to static programming languages can also be applied to Python. In this presentation, I will show how this is accomplished automatically in PyROOT.
      Speaker: Wim Lavrijsen (LBL/Atlas)
      Slides
    • 14:30 15:00
      User Interface developments in ROOT 30m
      Presentation about the progress made in User Interface developments in ROOT since the last ROOT workshop: - New GUI widgets - Fit panel - Graphics editor improvements - New object editors - GUI builder development
      Speaker: Ilka Antcheva (CERN/SFT)
      Slides
    • 15:00 15:30
      the ROOT GUI Builder: Status, Plans and demo 30m
      he ROOT GUI builder provides graphical user-interface (GUI) tools for developing user interfaces based on the ROOT GUI classes. It includes over 30 advanced widgets and has as a goal to offer the complete set of features needed for developing GUI projects. It gives developers an effective object-oriented development environment and accelerates the GUI development life cycles. The generated GUI can be saved at any time in a C macro file. The new version of the GUI builder has a new look and better appearance. Presentation of current status with a demo. Embedding ROOT in external applications/frameworks/toolkits Presentation of the few steps and conditions needed to create an application using any toolkit as QT, FOX, or MFC, with an embedded ROOT canvas. With short demos.
      Speaker: Bertrand Bellenot (CERN/SFT)
      Slides
    • 15:30 16:00
      Break & Posters 30m
    • 16:00 16:30
      The Castor2/xrootd integration -- the details 30m
      Scalla, Structured Cluster Architecture for Low Latency Access, is widely used to provide data for High Energy Physics anlysis. It packages together xrootd and olbd servers to provide a highly scalable online storage system with very low system overhead. While used mainly for the BaBar experiment, it is quickly gaining acceptance in other experiments such as Alice, GLAST, and STAR. The Scalla system currently interfaces with HPSS, RALMSS, and CLEO/Store in order to make large stores of archived data transparently available. Two new additions have recently decome available: DPM from G-Lite and Castor. This talk will present detailed information on how the Castor integration was accomplished, including the high and low points of that integration.
      Speaker: Andy Hanushevsky (SLAC)
      Slides
    • 16:30 17:00
      Data access on widely distributed worker nodes with xrootd/SRM 30m
      Data access on widely distributed worker nodes within ROOT framework Using cheap disks attached to processing nodes becomes extremely economically beneficial over expensive centralized storage. Nevertheless, an aggregation of those many distributed storage elements into a single usable pool turned to be problematic. However, the ROOT/Xrootd project allows such aggregation with data access optimization and dynamic population capabilities unique to this package. We would like to present a use case of Xrootd in a production environment (RHIC/STAR) data analysis framework its performance monitoring and performance tuning exercise we have applied. We would like to present how, in production analysis environment, large amount of widely distributed data is managed within the ROOT framework using low latency data access software suite Xrootd/Scalla. The RHIC/STAR use case, its performance monitoring and performance tuning will be explained. Furthermore, we will present the status of he integration of grid middleware component SRM (Storage resource manager) in Xrootd for space management. We will give an architectural overview of this solution showing integration of these two technologies as well as status of development and testing phase. Our focus would be also oriented on presenting future plans such as multi-caches support within a one node, improving access to a mass storage system or interoperability with other SRM-aware tools.
      Speaker: Pavel Jakl (BNL/Star)
      Slides
    • 17:00 17:30
      PROOF: status and perspectives 30m
      The goal of PROOF (Parallel ROOt Facility) is to enable the interactive analysis of distributed data sets in a transparent way. PROOF represents an alternative to a batch-oriented usage of a distributed computing system. The system is being successfully used by the PHOBOS experiment since a few years. In view of the startup of the LHC analysis PROOF underwent several developments and improvements mainly with the purpose to adapt it to the large multi-user analysis environments found at LHC. The ALICE collaboration has pioneered test-stressing of the system using the first CAF (Central Analysis Facility), composed by 40 machines located at CERN. The test-CAF represents a realistic environment for LHC analysis, with a non-negligible amount of local disk space managed by the XROOTD daemon populated with dedicated upload facilities (e.g. on-demand stage-in from the CASTOR system). The ALICE tests have brought in several new developments, among which: * augmentation and fine-tuning of package management and environment setting facilities; * a new "packetizer" (the system element responsible for work distribution) optimizing the load balancing algorithm at the level of a single query; the new packetizer minimizes network transfers, reducing hot spots in accessing a specific data server and avoiding in this way bottleneck effects at the end of jobs. A new dynamic way of calculating packet sizes as a time quantum has also been introduced. * the integration of the system with a user-scheduling facility with the main purpose of increasing fairness in the cluster usage and to provide a handle for the implementation of quota policies. In this talk we will describe in detail the status of the new developments and outline the future plans to bring PROOF in production for LHC analysis.
      Speaker: Gerardo Ganis (CERN/SFT)
      Slides
    • 17:30 18:00
      PROOF use in the Alice CAF + demo 30m
      ALICE at the LHC plans to use a cluster at CERN (CAF - Cern Analysis Facility) for fast analysis of first data as well as calibration and alignment. A test setup consisting of 40 machines exists for evaluation since May 2006. PROOF enables the distributed usage and xrootd the access to locally distributed files. The talk will present the current setup, performance tests that have been done and future plans. The integration of PROOF into ALICE\'s software framework (AliRoot) will be shown in a demo.
      Speaker: Jan Fiete Grosse-Oetringhaus (CERN/Alice)
      Slides
    • 09:00 09:20
      OpRelease, a framework for event simulation and analysis in OPERA 20m
      Since few years, in the OPERA Collaboration, a new software framework (OpRelease) has been realized. It consists of a set of packages and sub-packages integrated by using the CMT tool and fully interfaced to the OPERA ROOT persistent data model (OpRData) through an Input/Output standard package called OpIO. The OpRelease framework is based on a modular architecture of Object Oriented packages, so that the development of each package can be performed independently of the others and all the improvements can be easily. The software chain takes into account of event simulation (OpSim), digitization (OpDigit) and reconstruction (OpRec) A software model of the OPERA detector geometry (OpGeom) has been realized by using ROOT-VMC, in such a way the geometry is independent from the choice between GEANT3, GEANT4 and FLUKA. Last but not least, the use of the ROOT/TGeomManager class and its associated objects offer the chance to transfer the OPERA detector geometry description implemented at any step of the analysis chain.
      Speaker: Alberto Marotta (INFN/Opera)
      Slides
    • 09:20 09:40
      FairRoot, Simulation and analysis framework 20m
      The CbmRoot framework, originally developed for the CBM collaboration is now used by other FAIR experiments at the GSI. The framework is now renamed to FairRoot. The status and usage of this VMC based framework will be presented.
      Speaker: Denis Bertini (GSI)
      Slides
    • 09:40 10:00
      Rediscovering Geane in the VMC as track follower for FairROOT 20m
      Geane is a tool to calculate extrapolated track parameters and propagated errors through dense materials. It was written in Fortran 15 years ago and still today is successfully used by many experiments in connection with Geant3. The VMC concept of ROOT is the ideal method to preserve this knowledge and to make it available, with an updated version, to ROOT based experiments that can use it in a straighforward way with the ROOT geometry modeler. The talk will show how the TGeant3 interface has been extended for the FairROOT framework developed at GSI (see talk by M. Al-Turany) to allow the use of Geane in the context of the modern VMC approach. It will also report the experience of the PANDA collaboration regarding its use for the Kalman filter currently in development for the global reconstruction.
      Speaker: Andrea Fontana
      Slides
    • 10:00 10:30
      Usage of ROOT geometry with GEANT4 30m
      A new interface G4ROOT was recently introduced in ROOT. This allows running GEANT4-based simulations using TGeo geometry and navigation. The presentation will cover the interface usage and recent results in the context of ALICE GEANT4 simulation framework.
      Speaker: Andrei Gheata (CERN/Alice)
    • 10:30 11:00
      Break 30m
    • 11:00 11:30
      UNU.RAN - A library for Universal Non-Uniform RANdom variate generators 30m
      ROOT like other libraries for scientific computing provide routines especially tailored for sampling from standard distributions, e.g. the Gaussian distribution. This approach provides fast and easy to use algorithms for frequently used distributions. However, for specialized simulation problems or for sampling from non-standard distributions there are only a few algorithm which provide approximate solutions. The UNU.RAN library for non-uniform random variates is based on the idea of universal (also called black-box) methods. A single piece of code which is implemented and tested only once can generate from many target distributions. The user has to provide some information like the density function and sometimes the mode. The resulting routines are exact, carefully tested, quite fast, and often they do not depend on the target distribution. In this talk we explain the design principles of the UNU.RAN library and show by means of some examples how it can be used within ROOT.
      Speaker: Josef Leydold (Univ Vienna)
      Slides
    • 11:30 12:00
      TMVA -- Toolkit for Multivariate Data Analysis with ROOT 30m
      The use of machine learning techniques for the mining of data from high-energy physics experiments has become more and more popular in recent years. The machine learning techniques themselves have significantly evolved, also driven by developments in other areas in and outside science. TMVA is a toolkit (integrated in ROOT) which implements a large variety of sophisticated multivariate classification algorithms ranging from rectangular cut optimisation using genetics algorithm and likelihood estimators, over linear and non-linear discriminants (neural networks) to more recent developments like boosted decision trees and rule ensemble fitting. TMVA allows the simultaneous training, testing and evaluation of all these classifiers.
      Speaker: Helge Voss (MPI/Heidelberg/Atlas)
      Slides
    • 12:00 12:30
      The MadTools/StatTools package 30m
      The MadTools/StatTools package provides a unified interface for several methods to perform single-channel and multiple-channel confidence level calculations. We briefly review the general structure of the code and the algorithms already implemented, and we discuss efforts presently underway to incorporate fit-based confidence level calculations.
      Speaker: William Quayle (Wisconsin/Atlas)
      Slides
    • 12:50 14:00
      Lunch break 1h 10m
    • 14:00 14:30
      Roofit: status and plans 30m
      The RooFit package is an advanced data modeling language for the ROOT environment. It represents modeling concepts such as observables, parameters and probability density functions as C++ objects and provides operator objects for addition, multiplication, convolution etc to to build data models of arbitrary complexity. In my presentation I will focus on a number of recent redesign activities that include new project management tools that incorporate past user experience from BaBar on building complex analyses. These new tools also provide the interface for the high-level statistical analysis package RooStats that is currently being designed.
      Speaker: Wouter Verkerke (NIKHEF/Atlas)
      Slides
    • 14:30 15:00
      RooStats: A high-level statistical framework based on RooFit 30m
      The LHC has enormous discovery potential and poses many new statistical challenges. We will review the requirements for statistical toolkit for the LHC experiments, including the ability to combine the results of multiple measurements, incorporate systematic uncertainty, and facilitate the technical aspects of sharing code. In recent years, several statistical methods have been proposed to incorporate systematic uncertainty ranging from Bayesian, to fully Frequentist, to hybrid techniques. It will be shown that these various methods can have quite different properties, which makes it imperative that the toolkit allows for one to simultaneously evaluate the same problem with multiple techniques. With these considerations in mind, we set out to develop a statistical toolkit for ROOT. The RooFit package has a large user community and an abstract PDF class that can support both Bayesian and Frequentist interpretations; thus, we decided to base the statistical toolkit on the existing RooFit components and call the package RooStats. Finally, we will give some examples and outline our plans for further development.
      Speaker: Kyle Cranmer (BNL/Atlas)
      Slides
    • 15:00 15:30
      The Alice AOD analysis model 30m
      The talk will describe the ALICE analysis model and in particular the usage and structure of AODs. As most of the analysis will be performed with these objects, both on the Grid and locally, with or without PROOF, their structure and functionality is critical for the performance of the analysis of the experiment. The talk will describe the particular choices made for the structure of the AODs and the first results of their usage in different conditions.
      Speaker: Federico Carminati (CERN/Alice)
      Slides
    • 15:30 16:00
      Break 30m
    • 16:00 16:30
      The CMS AOD model 30m
      CMS experiment uses ROOT as storage technology for all its data formats. Interactive access is foreseen both in bare-ROOT mode and with loading of data formats shared libraries. The extensibility and modularity of CMS data formats and the native interactive capabilities make CMS event data model a suitable medium for data analysis from batch processing to interactive plots.
      Speaker: Luca Lista (INFN Napoli/CMS)
      Slides
    • 16:30 17:00
      The LHCb AOD model 30m
      The presentation will illustrate the LHCb analysis model. Starting with a short overview of the data processing chain, the datasets physicists use for the extraction of physics quantities (FullDST) will be presented. These datasets, which are expected to be replicated on all TIER1 centers will consist of several streams defined by the different physics working groups. The talk will describe the interactive and batch usage as well as the creation mechanism and the expected size of the different FullDST streams.
      Speaker: Markus Frank (CERN/LHCb)
      Slides
    • 17:00 18:00
      General discussion 1h