Quality assurance for the ALICE Monte Carlo procedure

We implement the already existing macro,$ALICE_ROOT/STEER /CheckESD.C that is ran after reconstruction to compute the physics efficiency, as a task that will run on proof framework like CAF. The task was implemented in a C++ class called AliAnalysisTaskCheckESD and it inherits from AliAnalysisTaskSE base class. The function of AliAnalysisTaskCheckESD is to compute the ratio of the number of reconstructed particles to the number of particle generated by the Monte Carlo generator.The class AliAnalysisTaskCheckESD was successfully implemented. It was used during the production for first physics and permitted to discover several problems (missing track in the MUON arm reconstruction, low efficiency in the PHOS detector etc.). The code is committed to the SVN repository and will become standard tool for quality assurance.Comment: 7 pages, 7 figure

Low pT Hadronic Physics with CMS

The pixel detector of CMS can be used to reconstruct very low pT charged particles down to about 0.1 GeV/c. This can be achieved with high efficiency, good resolution and a negligible fake rate for elementary collisions. In the case of central PbPb collisions the fake rate can be kept low for pT > 0.4 GeV/c. In addition, the detector can be employed for identification of neutral hadrons (V0s) and converted photons.Comment: 6 pages. Presented at the Poster Session of Quark Matter 2006 Conference, Shanghai, 14-20 November 2006. Submitted to IJMP

Numerical reproducibility in HPC: issues in interval arithmetic

International audienceThe problem of numerical reproducibility is the problem of getting the same result when a numerical computation is run several times, whether on the same machine or on different machines. The accuracy of the result is a different issue. As far as interval arithmetic is concerned, the relevant issue is the inclusion property, that is, the guarantee that the exact result belongs to the computed resulting interval

Parallel Implementation of Interval Matrix Multiplication

International audienceTwo main and not necessarily compatible objectives when implementing the product of two dense matrices with interval coefficients are accuracy and efficiency. In this work, we focus on an implementation on multicore architectures. One direction successfully explored to gain performance in execution time is the representation of intervals by their midpoints and radii rather than the classical representation by endpoints. Computing with the midpoint-radius representation enables the use of optimized floating-point BLAS and consequently the performances benefit from the performances of the BLAS routines. Several variants of interval matrix multiplication have been proposed, that correspond to various trade-offs between accuracy and efficiency, including some efficient ones proposed by Rump in 2012. However, in order to guarantee that the computed result encloses the exact one, these efficient algorithms rely on an assumption on the order of execution of floating-point operations which is not verified by most implementations of BLAS. In this paper, an algorithm for interval matrix product is proposed that verifies this assumption. Furthermore, several optimizations are proposed and the implementation on a multicore architecture compares reasonably well with a non-guaranteed implementation based on MKL, the optimized BLAS of Intel: the overhead is most of the time less than 2 and never exceeds 3. This implementation also exhibits a good scalability

Certification of a Numerical Result: Use of Interval Arithmetic and Multiple Precision

International audienceUsing floating-point arithmetic to solve a numerical problem yields a computed result, which is an approximation of the exact solution because of roundoff errors. In this paper, we present an approach to certify the computed solution. Here, "certify" means computing a guaranteed enclosure of the error between the computed, approximate, result and the exact, unknown result. We discuss an iterative refinement method: classically, such methods aim at computing an approximation of the error and they add it to the previous result to improve its accuracy. We add two ingredients: interval arithmetic is used to get an enclosure of the error instead of an approximation, and multiple precision is used to reach higher accuracy. We exemplify this approach on the certification of the solution of a linear system

Refining and verifying the solution of a linear system

International audienceThe problem considered here is to refine an approximate, numerical, solution of a linear system and simultaneously give an enclosure of the error between this approximate solution and the exact one: this is the verification step. Desirable properties for an algorithm solving this problem are accuracy of the results, complexity and performance of the actual implementation. A new algorithm is given, which has been designed with these desirable properties in mind. It is based on iterative refinement for accuracy, with well-chosen computing precisions, and uses interval arithmetic for verification

First steps towards more numerical reproducibility

International audienceQuestions whether numerical simulation is reproducible or not have been reported in several sensitive applications. Numerical reproducibility failure mainly comes from the finite precision of computer arithmetic. Results of floating-point computation depends on the computer arithmetic precision and on the order of arithmetic operations. Massive parallel HPC which merges, for instance, many-core CPU and GPU, clearly modifies these two parameters even from run to run on a given computing platform. How to trust such computed results? This paper presents how three classic approaches in computer arithmetic may provide some first steps towards more numerical reproducibility

A Taylor Function Calculus for Hybrid System Analysis: Validation in Coq

International audienceWe present a framework for the verification of the numerical algorithms used in Ariadne, a tool for analysis of nonlinear hybrid system. In particular, in Ariadne, smooth functions are approximated by Taylor models based on sparse polynomials. We use the Coq theorem prover for developing Taylor models as sparse polynomials with floating-point coefficients. This development is based on the formalisation of an abstract data type of basic floating-point arithmetic . We show how to devise a type of continuous function models and thereby parametrise the framework with respect to the used approximation, which will allow us to plug in alternatives to Taylor models

Taylor models and floating-point arithmetic: proof that arithmetic operations are validated in COSY

The goal of this paper is to prove that the implementation of Taylor models in COSY, based on floating-point arithmetic, computes results satisfyin- g the «containment property», i.e. guaranteed results. First, Taylor models are defined and their implementation in the COSY software by Makino and Berz is detailed. Afterwards IEEE-754 floating-point arithmetic is introduced. Then the core of this paper is given: the algorithms implemented in COSY for multiplying a Taylor model by a scalar, for adding or multiplying two Taylor models are given and are proven to return Taylor models satisfying the containment property.L'objectif de ce travail est de démontrer que l'implantation des modèles de Taylor, telle qu'elle est réalisée dans le logiciel COSY, calcule des résultats qui sont garantis, c'est à dire qu''ils satisfont la propriété d'inclusion.Tout d'abord, les modèles de Taylor sont définis et leur implantation par Makino et Berz dans le logiciel COSY est détaillée. Ensuite l'arithmétique flottante, telle qu'elle est spécifiée par la norme IEEE-754, est présentée. Enfin on arrive au cœur du sujet : les algorithmes implantés dans COSY pour la multiplication d'un modèle de Taylor par un scalaire et pour la somme et le produit de deux modèles de Taylor sont donnés; il est démontré que ces algorithmes retournent de s modèles de Taylor qui satisfont la propriété d'inclusion