Brief Descriptions of ZOOM Packages

• Provide a way to browse and find out what is available in ZOOM.
• Help to decide whether a ZOOM package may be applicable meet some need

Contents:

• Allocator
• CLHEP
• CLHEP HepPDT
• CLHEP HepMC
• CLHEP Matrix
• CLHEP StdHep
• CLHEP Random
• CLHEP Random Validation
• CLHEP Vector
• CovMatrices
• ErrLogEx
• ErrorLogger
• Exceptions
• HepTuple
• HistTools
• LinearAlgebra
• PhysicsVectors
• SpecialFunctions
• ValuePtr
• ZMtimer
• ZMtools
• ZMutility

Allocator module (Walter Brown)

A simple allocator that greatly speed up code that frequently builds up many std::vectors of objects. The Zoom Allocator package provides a memory-management subsystem. This subsystem has an interface whose design follows the model of the std::allocator class, while featuring significantly improved performance for dynamic memory management. This performance benefit is achieved by takes advantage of known fixed-size properties to reduce the average per-allocation performance overhead, and using the strategies of recycling deleted storage and bulk allocation.

CLHEP module (Mark Fischler)

A common version of the CLHEP library, with all sub-packages compilable on the ZOOM-supported platforms. CLHEP is a collection of routines written by physicists around the world, and an organization for assigning "editor" responsibility to those packages.

For ZOOM purposes, we categorize the sub-packages that make up CLHEP by level of support:

• PRESENT -- These have been tried out on each of the ZOOM platforms and put into a form where they compile and build with no apparent problems. However, no claim is made as to quality, applicability, or correctness, and no responsibility is taken for bug fixes (beyond reporting bugs to package editors).
• VALIDATED -- These are components of CLHEP that ZOOM recommends Run II users employ wherever needed. Beyond compiling, they have been validated for at least rudimentary correctness against ZOOM (and/or other) tests. ZOOM will not be creating packages that duplicate the semantics of these validated parts of CLHEP.

CLHEP Random (Mark Fischler)

The CLHEP Random package has two principal types of classes:
• Engines to generate uniform random sequences, for example, RanecuEngine. The user can choose among about 10 such engines, generally with excellent stochiastic properties.
• Distributions, which use an engine to generate numbers sampling standard probability distributions. All the distributions in the Review of Particle Physics (for example, RandPoisson) are implemented.

CLHEP Random validation (John Marraffino and Mark Fischler)

Validation against randomness test suite, completion of set of distributions, and additional random engines.
Page is not up to date with regard to validation of distributions.

CLHEP StdHepC++ (Lynn Garren)

StdHep contains a set of translation routines which convert Herwig, Jetset, Isajet, or QQ events to and from the standard HEP event format. StdHep also contains utility routines to work with the HEPEVT common block and a set of I/O routines.

StdHepC++ implements that functionallity in C++, and takes advantage of the object-oriented nature to provide conceptually clean interfaces.

CovMatrices module (David Sachs)

Lean and mean classes representing moderate-sized symmetric positive definite matrices. Optimized for high speed in the sort of computations need for Kalman filter and related tracking calculations. Special case classes for up to 6x6, and templates for larger matrices. The classes include matrices and column vectors and two-column BiVectors for tracking through two-diminsional planes.

ErrLogEx module (Mark Fischler)

Tools involving both the Exceptions and the ErrorLogger packages. For example, a way to route messages produced by ZMexceptions, through the output destinations associated with an ErrorLog.

ErrorLogger module (Mark Fischler)

Flexible multi-destination logging and statistics facility designed for use in the D0 and CDF frameworks.
• Central control of logging to multiple destination logs
• Uniform formatting,
• Filtering by severity level at each destination
• Throttling of multiple appearences of messages
• Error statistics summaries
• Automatic appending of time, module/package, and context (run/event) information
• Provision for multi-cpu or multi-threaded jobs

Exceptions module (Mark Fischler)

A mechanism to permit, under user control, selective ignoring, handling, and throwing of any exceptions potentially raised by ZOOM modules. Selected features include:
• coodinates with C++ throw/try/catch mechanisms but may be used with C++ exceptions disabled
• a standard handler for exception objects, while permitting installation of custom handlers
• a standard mechanism for logging, to user-specified destinations, both raised exceptions and user-generated explicit log messages
• user-selectable logging policies (e.g., by exception severity), while permitting installation of custom loggers
• an extensible design to allow users to define, handle, and log their own exception objects via the same machinery used by ZOOM-generated exceptions
• a base class and special logger to connect user or ZOOM exceptions to the ErrorLogger package, so that statistics and multiple destinations are available

HepTuple module (Philippe Canal)

An interface to several underlying HEP histogramming and Ntuple collection packages including HBOOK, Histoscope, and ROOT.

HistTools module (Joe Boudreau)

Utilities for comparing pairs of histograms produced by HepTuple using (often different) collection packages (file managers).

ISOcxx module (Walter Brown)

The goals of the ISOcxx C++ Portability package are to:
• document known features and defects of C++ development environments for supported Run II platforms
• provide, to the extent possible, C++ standard-compliant fixes and workarounds that serve as cures for known defects' consequences
• provide a framework for testing known defects and for testing compliance code proposed as cures for defects
• provide a centralized source of information regarding known problems and possible cures for various platforms
• provide a framework for easily adding newly-discovered defects and new (or improved) defect cures to the package

The package is designed to be used independently but, for Run II projects, interfaces with the Fermilab SoftRelTools (SRT) package for environment definitions.

LinearAlgebra module (Leo Michelotti)

Matrix manipulations, with specific attention paid to efficient operations for small-matrix cases.

Currently in beta release, with the following restrictions/dependencies:
• math functions (like cos, sin) have not been implemented
• does not use the Exception package yet
• not available on gcc yet due to problems with dynamic_cast
• requires ZMutility v0.02

CLHEP HepPDT Package (Lynn Garren)

HepPDT is a package in CLHEP providing particle properties and decay channel information. It is the lowest layer of the trio of packages replacing the Fortran STDHEP. It provides all properties (including uncertainties in the values) listed in the Review of Particle Physics, and includes decay mode information. The user can force custom decay tables and entire decay chains, access properties assumed by various generators including Herwig, Pythia, and QQ, and utilize multiple active Particle Data Tables.

CLHEP HepMC Package (Lynn Garren)

HepMC is a package in CLHEP providing a concrete particla class (with momentum, vertices, and so forth) and event and collision container classes. It is the middle layer of the trio of packages replacing the Fortran STDHEP. HepMC originated in a package of the same name developed for ATLAS by Matt Dobbs.

CLHEP StdHep Package (Lynn Garren)

StdHep is a package in CLHEP providing an interface to event generators such as Pythia, event I/O, and connection to the standard common blocks defined by the Fortran STDHEP package. It is the middle layer of the trio of packages replacing the Fortran STDHEP, depending on HepMC and HepPDT.

CLHEP Matrix Package (Mark Fischler)

Matrix and Vector (Nx1 matrix) operations. Includes optimized inversion for matrices no larger than 6x6, and more optimization for symmetric positive definite matrices.

Other than speed considerations and certain flexibility features of LinearAlgebra, including changing the shape or nature of a matrix and a design that accomodates defining new specialized matrix models, this package covers much the same area as ZOOM Linear algebra. The ZOOM support group is neutral on the question of whether one `should' use CLHEP Matrix or LinearAlgebra. Applications which directly interact with Geant4 may wish to use CLHEP Matrix , which Geant4 uses.

PhysicsVectors (3- and 4-Vectors) module (Mark Fischler)

3-vector and Lorentz Vector concepts commonly used in High Energy Physics calculations; boosts, rotations, invariant masses, and so forth.

Now these classes are derived from CLHEP Vector classes (which have been given the added ZOOM capabilities).

CLHEP Vector Package (Mark Fischler)

3-vector and Lorentz Vector concepts commonly used in High Energy Physics calculations; boosts, rotations, invariant masses, and so forth.

This package is merged with PhysicsVectors, and the classes are the same except:

• The CLHEP classes are not placed into any namespace (e.g., zmpv).
• CLHEP Vector can be compiled so as not to depend on the ZOOM Exceptions package.

SpecialFunctions (GNU Scientific Library) module (John Marafino)

Based on the Special Functions section of the Gnu Scientific Library, this provides various functions such as Bessel functions, Legendre polynomials, Elliptic integrals, and so forth.

ValuePtr module (Marc Paterno )

Simple templated class that can serve as a pointer to an object, with the property that when the ValuePtr is copied, it creates its own copy of the object pointed to as well.

ZMtimer module ( Walter Brown )

Simple timer classes, providing semantics similar to those in Tools.h++, and more. (This builds on work independently contributed by Randy Herber and Fritz Bartlett.)

ZMtools module (Walter Brown)

A collection of useful codes contributed by non-ZOOM physicists (generally at FNAL) who have solved specific problems that others may share. Also includes codes developed by ZOOM as needed auxiliaries, which may be useful to physicists in their own right.

assertN.h

A set of graded assert macros.
Related macros that employ the ErrorLogger mechanism are given in ErrorLogger/ELassertN.h .
Block
Simple templated class that behaves like an STL container but can also be block-initialized like a fixed-size native C++ array.
IteratorFilter
Provides a simple means of selecting certain of a container's members while traversing (iterating through) the container.

ZMutility module (Walter Brown)

A collection of auxiliary headers and small routines that were needed for other ZOOM packages, many of which may also be of use to users.

FixedTypes

Uniform nomenclature for 32, 64, and 128-bit floats, and 1, 2, 4, and 8-byte integers, along with defines allowing the compiler to use the appropriate types for Float8, Int2, and so forth.

Reference-counting

Counter and handle classes, useful for general-purpose reference-counting. (Inspired by code published separately by Bjarne Stroustrup and Andrew Koenig.)

ZOOM contact information:

zoom@fnal.gov

ZOOM task force mailing list. Open participation; D0 and CDF experimenters particularly encouraged to subscribe.

zoom-support@fnal.gov

ZOOM Product Support mailing list. Users are encouraged to report problems with ZOOM packages or to request assistance in finding, setting up, and using packages, via this address. Please use the package name as the first word of the subject.

Author: