ROOT Version 5.08/00 Release Notes

 class TMatrixD;
 class TVectorF;
 

 #include "TMatrixDfwh.h"
 #include "TVectorFfwd.h"
 

We STRONGLY recommend to already use these includes with this release 5.08. The includes Txxxfwd.h are simple forward declarations. In the next release, these include will contain the correct declaration of TMatrixD, TVectorF using the corresponding typedefs.

TF1, TF2, TF3

Minimization and fitting

TVirtualFitter

Robust fitting - Least Trimmed Squares regression (LTS)

The method implemented here is based on the article and algorithm: Computing LTS Regression for Large Data Sets by P.J.Rousseeuw and Katrien Van Driessen. The idea of the method is to find the fitting coefficients for a subset of h observations (out of n) with the smallest sum of squared residuals. The size of the subset h should lie between (npoints + nparameters +1)/2 and n, and represents the minimal number of good points in the dataset. The default value is set to (npoints + nparameters +1)/2, but if you are sure that the data contains less outliers it's better to change h according to your data.

To perform a robust fit one can

• when using TLinearFitter directly, call EvalRobust() function instead of Eval() after adding the points and setting the fitting function.
• when using TH1::Fit, TGraph::Fit... functions, call it with option "rob", or, if the fraction of good points in data is known, with this fraction. For example

  myGraph->Fit("pol3", "rob=0.75");
  

TMath

New MathCore Package

This is a new package introduced in ROOT version 5. It provides a collection of functions and C++ classes for HEP numerical computing. This library provides the basic and most used mathematical functionality, while MathMore provides more advanced functionality. MathCore contains up to now:

• Special Functions: Gamma, Beta and Error Function. The naming of the functions is the one proposed to the new version of the C++ standard library. The tutorial mathcoreSpecFunc.C shhows example how to use these functions in comparison with those provided by ROOT::TMath.


• Probability Distribution Functions (PDF): distribution functions of binomial, breit-wigner, cauchy, chi-squared, exponential, fdistribution, gamma, lognormal, normal and poisson, t-distribution. Examples are provided in the tutorial mathcoreStatFunc.C.


• Cumulative Distribution Functions (CDF): lower and upper tail integrals of the probability distribution function. The lower tail are the quantile (for example normal_quant) , while the upper tail are the probabilities (normal_prob). The functions present in mathcore are: breit-wigner, cauchy, normal, exponential and lognormal. More functions are present in the MathMore package.


• GenVector: package for 3D and 4D Vectors. This package provides C++ classes to describe the geometric 3D vectors, the 4D physics Lorentz vectors and their transformations, like rotations in 3D and 4D (boost + 3D rotation). The functionality of this package is similar to the one provided by the CLHEP Vector and Geometry libraries and the ROOT Physics classes. The main characteristics of this package compared to the classes present in CLHEP and in ROOT libPhysics are:
  • possibility to have vectors based on various coordinate systems in 3 and 4 dimensions:
    • Cartesian3D, Polar3D and Cylindrical3D and CylindricalEta3D;
    • PxPyPzE4D, PxPyPxM4D, PtEtaPhiE4D and PtEtaPhiM4D;
  • distinction between points (PositionVector3D class) and vectors (DisplacementVector3D class);
  • possibility to have vector classes based on arbitrary scalar type (they are templated on the scalar value type);
  • optimized performances using inline functions and avoiding to use virtual functions ;
  • an easy connection to the to the CLHEP vector and geometry classes and to the linear algebra vector and matrix classes, in particular to the TMatrix and SMatrix classes. For example, via the templated functions Mult in the VectorUtil namespace, we can multiply all 3D Vectors, Points and LorentzVectors with any linear algebra matrix implementing the operator(i,j).

  Transformations of the 3D and 4D Vector classes are possible by using the following classes:

• various type of 3D rotation classes to describe the various types of rotations, such as Rotation3D for rotations based on 3x3 matrices, EulerAngles, AxisAngle, Quaternion and the axial rotations (RotationX, Y and Z);
• 4D LorentzRotation class represented by a 4x4 matrix and a Boost class to represent a pure Lorentz boost along an arbitrary direction and BoostX, Y and Z for boosts along the axes;
• a class Transform3D to describe the combination of 3D rotation and translations. The transformations can be applied to both DisplacementVector3D and PositionVector3D but with different results. The DisplacementVector3D only rotates, while the PositionVector3D translates and rotates. Transformations can be applied also to the Plane3D class which represents a 2 dimensional surface spanned by two linearly independent vectors.

See here for more information on the GenVector package and for the API documentation. The test program stressVector.cxx in the ROOT test directory show the capabilities of the GenVector classes comparing the performances with the ROOT Physics classes. The new tutorial mathcoreVectorIO.C show how to write and read in a Tree the new mathcore LorentzVector classes and the tutorial mathcoreVectorCollection.C how to store a collection of LorentzVector's in a std::vector container and to archive them in ROOT Treee. The tutorial mathcoreGenVector.C test the package and provide as well examples on how to use the GenVector classes.

MathCore can be built as an independent package from a tar file or directly from CVS. The library built in ROOT contains in addition the CINT dictionary for all mathcore classes and a big fraction of all the templated functions.
All the classes and functions of MathCore are in the namespace ROOT::Math and the header files are installed under $ROOTSYS/include/Math.
More detailed description of the current released MathCore, including the reference documentation and the link to download, can be found at this location.

 

New MathMore Package

• Special Functions: bessel functions with fractional order, elliptic integrals, Laguerre and Legendre polynomials, hypergeometric functions.
  
• Cumulative Distribution Functions and their inverses: cumulative distribution functions of chi-squared, gamma, f and t-distributions and their inverses. There are also the inverses of the CDFs of the Breit-Wigner, exponential, Gaussian, lognormal and uniform distributions.
  
• Function Infrastructure: definition of function classes that the user can inherit from combined with some implementations (for example ParamFunction for parametric functions). Also provides wrappers to encapsulate global C functions and use them in the mathematical operations.
• Derivation: classes for computing numerical derivatives of a function.
  
• Integration: classes for performing numerical integration of a function in one dimension. Various types of adaptive and non-adaptive integration are supported. These include integration over infinite and semi-infinite ranges and singular integrals.
  
• Interpolation: classes for performing function interpolation of points using linear, polynomial, Akima and Akima periodic algorithms.
  
• Root Finding: classes which find the root of one dimensional functions. The possible types of root-finding algorithms are:
• Root Bracketing Algorithms which they do not require function derivatives
• Bisection
• False position
• Brent-Dekker
  
• Root Finding Algorithms using Derivatives
• Secant
• Newton
• Steffenson
  
  
• Chebyshev Polynomials: Class describing a Chebyshev series which can be used to approximate a function
     in a defined range.
  

New Package SMatrix

Add new package for linear algebra matrices and vectors, optimized for small dimension sizes. The matrix and vector classes are templated on the scalar type and on the matrix and vector dimensions. Therefore, they can be used ONLY when the dimensions are known at compile time. The package uses expression templates to achieve an high level optimization by minimizing the creation of temporary objects when performing matrix operations. The package has been developed initially by T. Glebe as part of the HeraB analysis software (see here) and a subset of the original package has been now ported to ROOT and adapted to meet the ROOT coding conventions and to satisfy the requirements of the LHC experiments. In particular the following modifications or improvements have been applied:

• optimized Cramer inversion for matrices up to size 6x6
• methods to invert a matrix and to calculate the determinant which are const (i.e they do not change the original content of the matrix)
• possibility to return, as a copy, a sub vector or a sub matrix
• support for STL like iterators

The test program in smatrix/test directory, testOperation.cxx and testKalman.cxx show how the SMatrix and SVector classes can be used and measure the CPU performances in matrix and vector operations comparing with the TMatrixD and TVectorD classes from the ROOT Matrix library.

More information on the new SMatrix package can be found at this location.

New Package Minuit2

This package contains the new object oriented re-implementation of MINUIT in C++, developed by M. Winkler and F. James in the context of the SEAL project. These new version contains basically all the functionality present in the old Fortran and TMinuit version. Furthermore, it provides the FUMILI algorithm, for least square and log likelihood minimizations. More information on the new C++ can be found on the MINUIT Web Site.

Minuit2 contains the C++ MINUIT package imported in ROOT from the SEAL project. The API has been changed to follow the ROOT coding convention (function names starting with capital letters) and the classes have been moved inside the namespace ROOT::Minuit2. In addition, the ROOT distribution contains classes needed to integrate Minuit2 in the ROOT framework. Two implementation of the TVirtualFitter interface exist: TFitterMinuit and TFitterFumili, which define two different fitter plug-in's: Minuit2 and Fumili2. Some helper classes are present for implementing the objective function interface (FCNBase) required by MINUIT minimization.

Minuit2 can be used through the TVirtualFitter interface or directly using the C++ interface of the ROOT::Minuit2 classes.
For example for fitting an histogram via the TVirtualFitter, one needs to select first the Minuit2 fitter plugin by:

TVirtualFitter::SetDefaultFitter("Minuit2");  // or Fumili2 for the FUMILI algorithm
h1->Fit()
 

TVirtualFitter::SetDefaultFitter(fitter);
TVirtualFitter * minuit2 = TVirtualFitter::Fitter(0,2);
 

and then set the parameters, the FCN and minimize using the TVirtualFitter methods: SetParameter, SetFCN and ExecuteCommand like in the old minuit example tutorial. Examples on how to use the Minuit2 and Fumili2 plug-in's are provided in the tutorials minuit2FitBench.C, minuit2FitBench2D.C and minuit2GausFit.C .

Examples on how to use directly Minuit2, without the ROOT interface are provided in the tests present in the directories minuit2/tests/MnSim and minuit2/test/MnTutorial. More information on the C++ interface can be also found on the new MINUIT user guide or looking at the reference documentation.

Minuit2, without the ROOT TVirtualFitter interface classes, can be built and used as an independent package. See the file minuit2/build/INSTALL.

New class TSPlot

A common method used in High Energy Physics to perform measurements is the maximum Likelihood method, exploiting discriminating variables to disentangle signal from background. The crucial point for such an analysis to be reliable is to use an exhaustive list of sources of events combined with an accurate description of all the Probability Density Functions (PDF).

To assess the validity of the fit, a convincing quality check is to explore further the data sample by examining the distributions of control variables. A control variable can be obtained for instance by removing one of the discriminating variables before performing again the maximum Likelihood fit: this removed variable is a control variable. The expected distribution of this control variable, for signal, is to be compared to the one extracted, for signal, from the data sample. In order to be able to do so, one must be able to unfold from the distribution of the whole data sample.

The TSPlot method allows to reconstruct the distributions for the control variable, independently for each of the various sources of events, without making use of any a priori knowledge on this variable. The aim is thus to use the knowledge available for the discriminating variables to infer the behavior of the individual sources of events with respect to the control variable.

TSPlot is optimal if the control variable is uncorrelated with the discriminating variables.

A detail description of the formalism itself, called sPlot is given in M. Pivk and F.R. Le Diberder, Nucl.Inst.Meth.A(in press), physics/0402083

More information about the method and some examples of usage can be found in the TSPlot class description and tutorials.

New class TGraphQQ

GUI

New features in TRootBrowser

• browsing files in the different image formats:
  xpm, gif, jpeg, png, tiff, tga, ppm, pnm, bmp, xbm, xcf, cur, ico.
• browsing PS, EPS, PDF files (gs, aka GhostScript program must be installed).
• dynamic generation of icons. If some macro after execution creates a new canvas a small image with canvas content becomes a new icon for this macro.

   

• If file is a text file its content will be displayed in the right pane of the browser. If it's a C++ macro after execution it can be editted in the browser and re-executed.
• new toolbar buttons added which allow:
  • forward, backward "history navigation"
  • refresh browser content
  • invoke "find dialog"
  • execute editted macro
  • interrupt editted macro execution
  • save editted macro

   

   

• Implemented a new check box feature to TGListTree widget. This option allows checkboxes on the tree nodes to turn on/off pieces of the tree hierarchy. Used in the ROOT browser to toggle visibility of geometries. The different checkbox states are as follows: - Checked: the list tree item and all its children are checked; - Unchecked: the list tree item and all its children are unchecked; - Checked and greyed: the list tree item is checked, but at least one of its children is not; - Unchecked and greyed: the list tree item is unchecked, but at least one of its children is checked This new feature can be used as shown below:

          TGListTree *fLt;
          fLt = new TGListTree(fTreeView, kHorizontalFrame, fgWhitePixel);
          ...
          // Add an item with a checkbox to the list tree.
          TGListTreeItem *item = fLt->AddItem(0, name, obj, 0, 0, kTRUE);
          // Check or uncheck this item setting the second parameter to kTRUE or kFALSE.
          fLt->CheckItem(item, (Bool_t)check);
     

  Usage of this feature with the TBrowser:

          void AnyClass::Browse(TBrowser b) {
  
             // Add the class 'AnyClass' to the browser.
             b->Add(this); 
  
             // Add a checkbox to the list tree item. The parameter 'ischecked' is Bool_t variable.
             b->AddCheckBox(this, ischecked); 
  
             // Connect the Checked() signal to a slot method of AnyClass.
             Connect("TRootBrowser", "Checked(TObject*,Bool_t)", "AnyClass", this, "SetChecked(TObject*,Bool_t)");
          }
     

  The new methods added to TGListTree class are:
  • CheckItem(TGListTreeItem *item, Bool_t check = kTRUE);
  • SetCheckBox(TGListTreeItem *item, Bool_t on = kTRUE);
  • ToggleItem(TGListTreeItem *item);
  • Checked(TObject *obj, Bool_t check); //*SIGNAL*
  • and the checkbox option in: AddItem(..., Bool_t checkbox);
  In addition, the new icons for list tree item check boxes were created in relation to the existing TGeo shapes. Added mime types linking new icons to the object types.

  Added a new member / option in TGListTree allowing to disable item opening on doubleclick.

   

• TCanvas objects (for example stored in a ROOT file) can be embedded dynamically into a TRootEmbeddedCanvas following way:

          TCanvas* oldCanvas = fEmbeddedCanvas->GetCanvas();
          if (oldCanvas) {
             delete oldCanvas;
          }
          // Get a canvas from the file.
          fCurrentCanvas = (TCanvas *)file->Get(CanvasName);
          if (fCurrentCanvas == 0) 
             return;
          fEmbeddedCanvas->AdoptCanvas(fCurrentCanvas);
          fCurrentCanvas->Draw();
          fCurrentCanvas->Modified();
          fCurrentCanvas->Update(); 
     

• Improvements in the popup menus and cascaded menus behavior. Users are allowed to change the title of the context menu by:

          TObject* anyObj;
          anyObj->IsA()->SetContextMenuTitle("myTitle");
     

• Added two new methods to the TGView class that help to show the top or the bottom of the text viewer page.

• TGListView - support listbox entries with icons in addition to the text.

Style Manager

• This new Graphical User Interface is created to manage the styles in a ROOT session. It allows users to edit styles, to import, export them using macros, to apply a currently selected style on the selected object or on all canvases, to change the gStyle.

   

  The Style Manager interface is composed of two parts:
  • the top level interface that manages a list of styles;
  • the style editor, which deals with the current style settings.
• The top level interface contains:
  • The combo box 'Available Styles' that shows the list of all available styles in the current ROOT session. The field on the right shows the setting of the gStyle. You can set the global variable gStyle to the selected style by clicking on the button in the middle.
  • The group frame 'Apply on' displays information for the currently selected canvas and object in the ROOT session. This selection might be changed by clicking on another object with the middle mouse button You have a choice to apply a style on the selected object or on all available canvases. WARNING: You cannot undo the changes after applying the style! If you are not sure of that action, it may be better to see a preview of what you are going to apply. If the check button 'Preview' is selected, a preview of the selected canvas according to the selected style will be shown. The selection of the next check button 'Run Time Preview' will apply updates of the preview any time a value of the selected style is changed. For drawings that take a time it is better to disable this option.
  • Create a new style: A new style can be created via the Style menu/New... or the toolbar. A clone of the selected style will be used as a base of the new style. All its values can be modified via the style editor later. The dialog that appears will ask for the name and description of the new style.
  • Import a style (from a macro): A style macro can be imported at any time. The new imported style in the ROOT session will become the selected one.
  • Import a style (from a canvas): You can do that selecting the Style menu/Import from.../Canvas or the corresponding Tool bar button. A new style will be created in the ROOT session and will become the selected one. This style is a clone of the gStyle with modified values as they are set in the currently selected canvas. You can import a style from any canvas and apply it later on some objects.
  • Export a style (in a C++ macro file): To store a style longer than for the current ROOT session you can save it in a C++ macro file. This can be done via the menu or the tool bar button. There is a naming convention for the style macros: the name must be 'Style_*.C', where * can be replaced by anything you want.
  • Delete a style: The selected style can be deleted from the list when you use the Style menu/Delete or the corresponding tool bar button. The selected style is removed from the list of all available styles for the current ROOT session. WARRNING: it will be lost if you didn't saved it in a C++ macro file before its deletion. Also, you cannot delete the selected style if it is set to gStyle. A message 'Can not delete gStyle' will be displayed on the CINT prompt.

   

• The style editor interface:
  • Open / close the style editor: The button 'Edit >>' opens the style editor and its label changes to 'Close <<'. For all details of what can be changed and how please see the provided Help.
  • Reset a style (to a previously saved state): When the editor is opened, the 'Reset' button allows you to reset the values of the selected style for editing. Doing that you cancel all changes made since the last time you saved that style in a macro. If the selected style is one of the five ROOT styles (Plain, Bold, Video, Pub or Default), it will be recreated.
  • Update the preview: The button 'Update Preview' is available when a preview is shown and the run time option is not selected. This button allows you to refresh the preview any time you want to see how the style you edit looks like.
  • Help button: Provides a help of the currently selected tab.

Object Editors Improvements

• Marker Editor - the marker pop up window shows 18 predefined marker types for user choice; 3 of them (type 1, 6, 7) have fixed size. The marker size combo box is replaced by a number entry for faster size setting.
• Histogram Editors - improved performance of both TH1/2Editor . The interface of TH1Editor works for histograms drawn with option 'same';

Qt Interface

• Implement TVirtualX::ListFonts method to provide TGFontDialog widget
• New static method TQtWidget::InitRint to instantiate ROOT within Qt-based applications
• Some extra features for rootlibs.pri and rootcintrules.pri to facilitate the Qt build on Mac (native GUI) platform
• Improved behavior of many widgets: tool tips, combo and list boxes, menus, text and number entries, file dialogs.
• Porting the mouse wheel as an input device.
• Two new "Qt project files" added to build Qt-layer alone with Qt "qmake" utility.

               $ROOTSYS/qtroot/qtroot.pro
               $ROOTSYS/qt/qt.pro
        

OpenGL developments:

Features and Interaction

• New code to draw shapes outline style - enable with 't' key. This provide s a 'line-drawing' style, with filled polygons outlined in black - rendering take approx twice as long. Draw styles now:
• Interactive clipping
  • Enable under Scene/Clipping in the side GUI panel
  • Two types - plane and box
    
  • 
  • Adjust via direct entry in properties of GUI boxes, or interactively. Check 'Show/Edit' checkbox - clip object is shown in light brown in viewer. Current manipulator is attached to it allowing in place editing (see below for use)
• Manipulators - widget attached to selected object (limited to clip object s only at present). Allows manipulation along/around local axis (red/X, green/Y, blue/Z). In some cases a manipulation is not permitted (e.g clip plane cannot be scaled) in which case manipu lator component is greyed and inactive. Three types:
  
  • Translation - Translation along local axis (v key)
    
  • Scaling - Scale along local axis (x key)
    
    
  • Rotatation - Rotate local axis (c key)
    
• Extended camera interactions
  • Rotate (Orbit) : LMB + Drag
  • Truck (Pan) : MMB + Drag, or arrow keys.
  • Dolly (interactive move in/out) : RMB + Drag
  • Zoom (field of view) : Mouse Wheel, or 'j' / 'k' keys.
• Modifiers applied to above adjust sensitivity
  • Shift: x 10
  • Ctrl: x 0.1
  • Shift+Ctrl: x 0.01
• Double click any button to reset the camera.
• Moved selected object interaction to:
  • Select : Shift + LMB
  • Move Selected Object : MMB + Shift
  • Context Menu Selected Object: RMB + Shift
• New options for axes (draw at scene edge or through origin) and simple reference position marker - moved to 'Guide' tab under 'Scene' is GUI.
• Transparent objects:
  • Picking - now pick closest opaque objects first, and if none closest transparent one.
  • Ensure transparent selected object is only drawn once.
  • Allocate pro-rata time for transparent drawing - previous assumption that number transparent << number opaque was invalid in some cases.
• Improvement to perspective cameras - level floor formed from 2 of the 3 world axes - avoids tipping of horizon. Added missing two combinations under renamed 'Camera' menu:
  • Perspective (Floor XOZ) - default.
  • Perspective (Floor YOZ)
  • Perspective (Floor XOY)
• Two interaction modes for rotation manipulator
  • Normal - when ring is at reasonable angle - follow ellipse round as previously (with line to dragged point on ring)
  • Shallow - when ring plane is at shaloow angle to eye (very tight ellipse) - use pixel delta (drag) on viewport along ring plane (with movement arrows)
• Improvements to orthographic cameras - Larger range/sensitivities, better auto-framing, lighting.

Performance / Quality

Major internal re-structuring of GL viewer to support:

• Repeated addition of duplicate placed shapes - added new classes TGLLogicalShape (a unique local frame 'shape') and TGLPhysicalShape (a placement of TGLLogicalShape), held in stl::maps in new TGLScene. Previous shape hierarchy TGLScene object moved to local reference frame, and derives from TGLLogicalShape. TGLPhysical shape holds translation matrix, and color/transparency attributes, loads these before asking the referenced TGLLogicalShape to draw.
• Dynamic scene builds: Only accept objects of interest into viewer - fall within expanded camera limits, and above certain size c.f. whole scene. Viewer can prompt external client (pad) to republish objects to it, when camera limits have changed significantly. Logical shapes always retained, physicals ones destroyed and cretaed as camera moves through scene. Enables viewer to connect to very large geometries without being overloaded, pulling required parts on demand. Extended TGLCamera class with OfInterest() + other internals to test.
• Level of detail (LOD) scheme: Calculate a hint for quality of tessellation (by projecting shape bounding box onto screen). Shape's Draw() passed this, based on projected screen size - enable sensible tessellation (TGLSphere only using at present).
• Common display list cache: TGLLogicalShape and TGLPhysicalShape derive from common TGLDrawable, and can enable capture to common TGLDisplayListCache, including LOD hints (caches each Draw of certain quality). TGLDrawable can disable caching of general or LOD basis. (TGLSphere only using at present).
• Multi-pass rendering:
  • Interactive (speed). Reduce all shapes LOD hint (tessellation cost), draw sorted from large -> small objects, terminate after 150msec, discard very low (small) LODs.
  • Final(quality) - full LOD quality, unlimited time, no dropping.

Misc Internals

• TGLPerspectiveCamera/TGLOrthoCamera: Improve near/far clip plane calculations - set using current projected scene limits. Reduces depth buffer precision problems - seen particularly on MESA software GL.
• Added new TGLBoundingBox, supports both axis aligned and orientated BB, with various overlap/projection testing in conjunction with TGL Camera classes.
• Tuning based on VTune examination
  • Cache axes in TGLBoundingBox, reduce creation/destruction of excessive temp objects.
  • Add a cheap sphere/sphere test first in TGLBoundingBox::Overlap
  • Only do scene rebuilds after a final quality draw has completed.

Added several debugging aids:

• Viewer debug mode - enable with 'd' key. Viewer stops automatic scene rebuilds - these can be force explicitly using space key. Also draws out:
  • Scene bounding box + center sphere (Green)
  • Origin (0,0,0) as white sphere
  • Camera interest frustum basis (Red)
  • Camera interest frustum basis as box (Orange)
  • Current interest box (Blue)
  • Previous interest box (Grey)
  • Active light positions (yellow spheres)
• Tracing of viewer scene contents, draw loads, timing etc - variable level of detail from gDebug=3 to gDebug=6

GL-in-TPad

• Reorganize internals of GL viewer to allow it to be embedded directly into TP ad object.
• Removed all GUI components from core TGLViewer, created new TGLSAViewer (SA = Standalone), derives from TGLViewer and contains the TGLSAFrame GUI.
• Created new TGLManager (replacement for TGLKernel/TVirtualGL) a base abstract class, responsible for window creation, gl-context/glpixmap and context creation, manipulation with gl-context and gl-pixmap.
  TGWin32GLManager - concrete implementation for Win32
  TGX11GLManager - concrete implementation for X11.
  
• GL-in-TPad enabled with: gStyle->SetCanvasPreferGL(kTRUE) to turn on GL support.
• Legos and Surfaces can be displayed with GL directly in a TPad. Almost all the standard option are available (SURF, SURF1, LEGO, LEGO1 etc .. )
• File output can be done in gif, jpeg, pgn etc .. formats.
• Development still in progress - notable limitations:
  • Can be used with g3d and geom now (not with hists, polylines or polymarkers, composite shapes do not work).
  • In case of complex geometry the selection is very slow now.
  • It is not yet possible to do the output in a PostScript file.

3D Viewer Infrastructure Overview

The 3D Viewer infrastructure has had a re-design to better support more advanced viewers. It consists of:

• TVirtualViewer3D interface: An abstract handle to the viewer, allowing client to test preferences, add objects, control the viewer via scripting (to be added) etc.
• TBuffer3D class hierarchy: Used to describe 3D objects ("shapes") - filled /added by negotiation with viewer via TVirtualViewer3D.

Together these allow clients to publish objects to any one of the 3D viewers (currently OpenGL/x3d,TPad), free of viewer specific drawing code. They allow our simple x3d viewer, and considerably more sophisticated OpenGL one to both work with both geometry libraries (g3d and geom) efficiently.

Publishing to a viewer consists of the following steps:

1. Create / obtain viewer handle
2. Begin scene on viewer
3. Fill mandatory parts of TBuffer3D describing object
4. Add to viewer
5. Fill optional parts of TBuffer3D if requested by viewer, and add again
   ... repeat 3/4/5 as required
6. End scene on viewer

Creating / Obtaining Viewer

Create/obtain the viewer handle via local/global pad - the viewer is always bound to a TPad object at present [This may be removed as a restriction in the future] . You should perform the publishing to the viewer described below in the Paint() method of the object you attach to the pad (via Draw())

TVirtualViewer3D * v = gPad->GetViewer3D("xxxx");

" xxxx" is viewer type: OpenGL "ogl", X3D "x3d" or Pad "pad" (default). The viewer is created via the plugin manager, attached to pad, and the interface returned.

Begin / End Scene

Objects must be added to viewer between BeginScene/EndScene calls e.g.

v->BeginScene();
.....
v->AddObject(....);
v->AddObject(....);
.....
v->EndScene();

The BeginScene call will cause the viewer to suspend redraws etc, and after the EndScene the viewer will reset the camera to frame the new scene and redraw. [x3d viewer does not support changing of scenes - objects added after the first Open/CloseScene pair will be ignored.]

Filling TBuffer3D and Adding to Viewer

The viewers behind the TVirtualViewer3D interface differ greatly in their capabilities e.g.

• Some know how to draw certain shapes natively (e.g. spheres/tubes in OpenGL) - others always require a raw tessellation description of points/lines/segments.
• Some need the 3D object positions in the global frame, others can cope with local frames + a translation matrix - which can give considerable performance benefits.

To cope with these situations the object buffer is filled out in negotiation with the viewer. TBuffer3D classes are conceptually divided into enumerated sections Core, BoundingBox, Raw etc (see TBuffer3D.h for more details).

The SectionsValid() / SetSectionsValid / ClearSectionsValid() methods of TBuffer3D are used to test/set/clear these section valid flags.

The sections found in TBuffer3D (Core/BoundingBox/Raw Sizes/Raw) are sufficient to describe any tessellated shape in a generic fashion. An additional ShapeSpecific section in derived shape specific classes allows a more abstract shape description ("a sphere of inner radius x, outer radius y"). This enables a viewer which knows how to draw (tessellate) the shape itself to do so, which can bring considerable performance and quality benefits, while providing a generic fallback suitable for all viewers.

The rules for client negotiation with the viewer are:

• If suitable specialized TBuffer3D class exists, use it, otherwise use TBuffer3D.
• Complete the mandatory Core section.
• Complete the ShapeSpecific section if applicable.
• Complete the BoundingBox if you can.
• Pass this buffer to the viewer using one of the AddObject() methods - see below.

If the viewer requires more sections to be completed (Raw/RawSizes) AddObject() will return flags indicating which ones, otherwise it returns kNone. You must fill the buffer and mark these sections valid, and pass the buffer again. A typical code snippet would be:

TBuffer3DSphere sphereBuffer;
// Fill out kCore...
// Fill out kBoundingBox...
// Fill out kShapeSpecific for TBuffer3DSphere
// Try first add to viewer
Int_t reqSections = viewer->AddObject(buffer);
if (reqSections != TBuffer3D::kNone) {
   if (reqSections & TBuffer3D::kRawSizes) {
      // Fill out kRawSizes...
   }
   if (reqSections & TBuffer3D::kRaw) {
      // Fill out kRaw...
   }
   // Add second time to viewer - ignore return cannot do more
   viewer->AddObject(buffer);
   }
}

ShapeSpecific: If the viewer can directly display the buffer without filling of the kRaw/kRawSizes section it will not need to request client side tessellation. Currently we provide the following various shape specific classes, which the OpenGL viewer can take advantage of (see TBuffer3D.h and TBuffer3DTypes.h)

• TBuffer3DSphere - solid, hollow and cut spheres*
• TBuffer3DTubeSeg - angle tube segment
• TBuffer3DCutTube - angle tube segment with plane cut ends.

*OpenGL only supports solid spheres at present - cut/hollow ones will be requested tessellated.

Anyone is free to add new TBuffer3D classes, but it should be clear that the viewers require updating to be able to take advantage of them. The number of native shapes in OpenGL will be expanded over time.

BoundingBox: You are not obliged to complete this, as any viewer requiring one internally (OpenGL) will build one for you if you do not provide. However to do this the viewer will force you to provide the raw tessellation, and the resulting box will be axis aligned with the overall scene, which is non-ideal for rotated shapes.

As we need to support orientated (rotated) bounding boxes, TBuffer3D requires the 6 vertices of the box. We also provide a convenience function, SetAABoundingBox(), for simpler case of setting an axis aligned bounding box.

Master/Local Reference Frames

If fLocalFrame is kFALSE, fLocalMaster should contain an identity matrix. This is set by default, and can be reset using SetLocalMasterIdentity() function.
Logical & Physical Objects

There are two cases of object addition:

• Add this object as a single independent entity in the world reference frame.
• Add a physical placement (copy) of this logical object (described in local reference frame).

The second case is very typical in geometry packages, GEANT4, where we have very large number repeated placements of relatively few logical (unique) shapes. Some viewers (OpenGL only at present) are able to take advantage of this by identifying unique logical shapes from the fID logical ID member of TBuffer3D. If repeated addition of the same fID is found, the shape is cached already - and the costly tessellation does not need to be sent again. The viewer can also perform internal GL specific caching with considerable performance gains in these cases.

For this to work correctly the logical object in must be described in TBuffer3D in the local reference frame, complete with the local/master translation. The viewer indicates this through the interface method

PreferLocalFrame()

If this returns kTRUE you can make repeated calls to AddObject(), with TBuffer3D containing the same fID, and different fLocalMaster placements.

For viewers supporting logical/physical objects, the TBuffer3D content refers to the properties of logical object, with the fLocalMaster transform and the fColor and fTransparency attributes, which can be varied for each physical object.

As a minimum requirement all clients must be capable of filling the raw tessellation of the object buffer, in the master reference frame. Conversely viewers must always be capable of displaying the object described by this buffer.

Scene Rebuilds

It should be understood that AddObject is not an explicit command to the viewer - it may for various reasons decide to ignore it:

• It already has the object internally cached .
• The object falls outside some 'interest' limits of the viewer camera.
• The object is too small to be worth drawing.

In all these cases AddObject() returns kNone, as it does for successful addition, simply indicating it does not require you to provide further information about this object. You should not try to make any assumptions about what the viewer did with it.

This enables the viewer to be connected to a client which sends potentially millions of objects, and only accept those that are of interest at a certain time, caching the relatively small number of CPU/memory costly logical shapes, and retaining/discarding the physical placements as required. The viewer may decide to force the client to rebuild (republish) the scene (via a TPad repaint at present), and thus collect these objects if the internal viewer state changes. It does this presently by forcing a repaint on the attached TPad object - hence the reason for putting all publishing to the viewer in the attached pad objects Paint() method. We will likely remove this requirement in the future, indicating the rebuild request via a normal ROOT signal, which the client can detect.

Physical IDs

virtual Int_t AddObject(UInt_t physicalID, const TBuffer3D & buffer, Bool_t * addChildren = 0)

If you use the first (simple) case a viewer using logical/physical pairs will generate IDs for each physical object internally. In the second you can specify a unique identifier from the client, which allows the viewer to be more efficient. It can now cache both logical and physical objects, and only discard physical objects no longer of interest as part of scene rebuilds.

Child Objects

In many geometries there is a rigid containment hierarchy, and so if the viewer is not interested in a certain object due to limits/size then it will also not be interest in any of the contained branch of descendents. Both AddObject() methods have an addChildren parameter. The viewer will complete this (if passed) indicating if children (contained within the one just sent) are worth adding.

Recyling TBuffer3D

Once add AddObject() has been called, the contents are copied to the viewer internally. You are free to destroy this object, or recycle it for the next object if suitable.

New printing facilities in batch via TASImage

Besides reading an image from a file an image can be defined by a two dimensional array of values. A palette defines the color of each value.

The image can be zoomed by defining a rectangle with the mouse. The color palette can be modified with a GUI, just select StartPaletteEditor() from the context menu.

The new class TImageDump using TASImage and derived from TVirtualPS allows to save canvas in GIF, JPEG etc, image formats in batch mode. Before this clas was intriduced it was not possible to generate bitmap files (in particular GIFfiles) in batch, such files were generated from a TCanvas. Now the method TPad::Print or TPad::SavesAs can be used in macro running in batch (root -b) to generated bitmap files (gif, jpeg, png, xpm, tiff). Example:

     $ root -b
     root [0] .x hsimple.C
     root [1] c1->Print("c1.gif");

The full description of TPad::Print options is now:

TPad::Print(const char *filename,  Option_t *option)

"ps"   - Postscript file is produced (see special cases below)
"eps"  - an Encapsulated Postscript file is produced
"pdf"  - a PDF file is produced
"svg"  - a SVG file is produced
"gif"  - a GIF file is produced
"xpm"  - a XPM file is produced
"png"  - a PNG file is produced
"jpg"  - a JPEG file is produced
"tiff" - a TIFF file is produced
"cxx"  - a C++ macro file is produced
"xml"  - a XML file
"root" - a ROOT binary file

"Portrait"  - Postscript file is produced (Portrait)
"Landscape" - Postscript file is produced (Landscape)
"Preview"   - an Encapsulated Postscript file with preview is produced.

TImageDump

    TCanvas *c1;
    TImageDump *imgdump = new TImageDump("test.png");
    c1->Paint();
    imgdump->Close();

Other new features in the graphics area

TStyle

• New data member and corresponding Getter/Setter

            Width_t   fLegendBorderSize;  //TLegend box border size
            Width_t   GetLegendBorderSize() const   {return fLegendBorderSize;}
            void      SetLegendBorderSize(Width_t size=4)
  

  The "Plain" style initializes the legend border size to 1. All other styles to 4.

  In TLegend constructor, the legend border size is set by default to the current value in gStyle.

• The line styles defined via TStyle::SetLineStyleString() are now available for all graphical interfaces: SVG, PostScript, PDF, X11, and Win32GDK. Previously they were visible only in PostScript files. They are still missing for Qt driver.
  • Line styles 5 to 10 are predefined.
  • TGedAttLineEditor shows the new line styles.
• New method SetHatchesLineWidth to set the hatches line width for hatch styles > 3100

TPaveStats

• Skewness and kurtosis can now be displayed in TPaveStats (1D and 2D histos).
• Skewness and kurtosis are available in the TPaveStats editor
• Errors can be displayed for 2D histograms statistics.

TPad

TGraph2D

• New option "Line" to paint TGraph2D. TGraph2D are connected with with a 3D polyline.
• New method SetHistogram. It allows to define the histogram to be filled. This is useful to set the range of the X and Y axis.

  Example:

  void graph2dhist()
  {
     TCanvas *c = new TCanvas("c","Graph2D example",0,0,700,600);
  
     Double_t x, y, z, P = 6.;
     Int_t np = 300;    // generate this many nodes
  
     TGraph2D *dt = new TGraph2D();
     TH2D* h2 = new TH2D("h2","h2",40,-6,6,40,-10,10);
     dt->SetHistogram(h2);
  
     TRandom *r = new TRandom();
  
     for (Int_t N=0; N<np; N++) {
        x = 2*P*(r->Rndm(N))-P;
        y = 2*P*(r->Rndm(N))-P;
        z = (sin(x)/x)*(sin(y)/y)+0.2;
        dt->SetPoint(N,x,y,z);
     }
     gStyle->SetPalette(1);
            
     dt->Draw("TRI1 p0");
  }
  

TASImage

• New method GetImageBuffer is introduced. It returns in-memory buffer compressed according to the image type. Buffer must be deallocated after usage. This method can be used for sending images over the network.
• New method SetImageBuffer introduced. It creates image from compressed buffer. Supported formats:

  PNG - by default
  XPM - two options exist:
  
  1. xpm as a single string (raw buffer). Such a string
     is returned by GetImageBuffer method.
  
     For example:
  
        char *buf;
        int sz;
        im1->GetImageBuffer(&buf, &int, TImage::kXpm); /*raw buffer*/
        TImage *im2 = TImage::Create();
        im2->SetImageBuffer(&buf, TImage::kXpm);
  
  2.  xpm as an array of strigs (preparsed)
  
      For example:
         char *xpm[] = {
         "64 28 58 1",
         "  c #0A030C",
         ". c #1C171B"
               ...
         TImage *im = TImage::Create();
         im->SetImageBuffer(xpm, TImage::kXpm);
  

• Custom Streamer was implemented. That allows to save images in ROOT files. Image's thumbnail is also saved into a file.
• galaxy_image.C tutorial is modified according to new saving schema.
• New demo file gallery.root added to tutorials. It contains thumbnailed and browsable pictures produced by some ROOT tutorials.
• Fix bug im TASImage::DrawRectangle methods. Thanks to Thomas Bretz for reporting it.
• TKey class. Possibility to save thumbnail/icon as XPM string along with object added. Currently such mechanism is used for saving thumbnailed images.
• TGPicture. Platform-dependent code was removed. Now TGPictures are created by TImage objects.
• TRootBrowser classes. Possibility to show objects with dynamically created icons added.
• New function void SetImage(ASImage * aimag)

PostScript / PDF

• Structuting directive %%Orientation added in PS files. This allows the PostScript viewers (like gv) to display automatically the PS files with the correct orientation.
• The marker size is now the same as the one on screen.
• Patterns number 1 to 25 are now available in PDF
• PostScript and PDF files can now use the CMYK color model. A new TStyle method (SetColorModelPS) allows to choose the color model (RGB or CMYK).

  TStyle::SetColorModelPS(Int_t c) Defines the color model use by TPostScript and TPDF (RGB or CMYK). CMY and CMYK models are subtractive color models unlike RGB which is an additive. They are mainly used for printing purposes. CMY means Cyan Magenta Yellow to convert RGB to CMY it is enough to do: C=1-R, M=1-G and Y=1-B. CMYK has one more component K (black). The conversion from RGB to CMYK is:

   Double_t Black   = TMath::Min(TMath::Min(1-Red,1-Green),1-Blue);
   Double_t Cyan    = (1-Red-Black)/(1-Black);
   Double_t Magenta = (1-Green-Black)/(1-Black);
   Double_t Yellow  = (1-Blue-Black)/(1-Black);
  

  CMYK add the black component which allows to have a better quality for black printing. PostScript and PDF support the CMYK model.

   c = 0 means TPostScript and TPDF will use RGB color model (default)
   c = 1 means TPostScript and TPDF will use CMYK color model
  

TArrow

TArrow, TCurlyArc,TCurlyLine

TArrow

   static Float_t  fgDefaultAngle;        //default Arrow opening angle (degrees)
   static Float_t  fgDefaultArrowSize;    //default Arrow Size
   static TString  fgDefaultOption;       //default Arrow shapes

   static Double_t fgDefaultWaveLength;   //default wavelength
   static Double_t fgDefaultAmplitude;    //default amplitude
   static Bool_t   fgDefaultIsCurly;      //default curly type

   static Double_t fgDefaultWaveLength;   //default wavelength
   static Double_t fgDefaultAmplitude;    //default amplitude
   static Bool_t   fgDefaultIsCurly;      //default curly type

Bug fixes ad Improvments in Graphics area

TMultiGraph

TStyle

  {
      for (int i=0; i<10; i++) {
         TStopwatch clock;
         clock.Start();
         gStyle->SetPalette(51, NULL);
         clock.Print();
      }
   }

TCreatePrimitives

TGraphDelaunay (TGraph2D drawing)

TH1

  TH1D h
  h.SetBins(5000000,0,1)
  h.Draw()

TArrow

1. distorted arrows' heads
2. misplaced arrow compared to a Tline at the same coordinates.

THStack

• The maximum number of histograms in a THStack plotted as lego plot was 18. Now there is no limit anymore.
• THStack colors are now stored in a dynamic arrays. Previously they were stored in a fixed length arrays of 10 entries.

2D polygons clipping

Sutherland and Hodgman's polygon-clipping algorithm uses a divide-and-conquer strategy: It solves a series of simple and identical problems that, when combined, solve the overall problem. The simple problem is to clip a polygon against a single infinite clip edge. Four clip edges, each defining one boundary of the clip rectangle, successively clip a polygon against a clip rectangle.

Steps of Sutherland-Hodgman's polygon-clipping algorithm:

• Polygons can be clipped against each edge of the window one at a time. Windows/edge intersections, if any, are easy to find since the X or Y coordinates are already known.
• Vertices which are kept after clipping against one window edge are saved for clipping against the remaining edges.
• Note that the number of vertices usually changes and will often increases.

• Case 1 : Wholly inside visible region - save endpoint
• Case 2 : Exit visible region - save the intersection
• Case 3 : Wholly outside visible region - save nothing
• Case 4 : Enter visible region - save intersection and endpoint

PostScript

• Protection added to TVirtualPS::PrinStr and TVirtualPS::PrintFast to take into account the terminating null character.
• Some modifications for the CUPS printing system.
• Remove the %%BeginSetup/%%EndSetup section as it was empty since the last CUPS modification. With that empty section tools like "psresize" didn't work anymore on PS files generated by ROOT.

SVG

• In SVG text strings:

                                                                                  
            < is now changed to &lt;
            >        "          &gt;
            &        "          &amp;
  

  < > and & are SVG's control characters and cannot be written directly.
• Tags and text always start in column 1

Bitmap output

THistPainter::PaintErrors

TCanvas

• The TCanvas size in interactive mode and batch mode were different (4 pixels horizontally and 28 vertically). Most of the time this was not a real problem. But in some cases the same macro produced a different result executed interactively or in batch. For instance the following macro executed in batch did not show the histogram title in the PostScript output. This patch make sure that batch interactive canvas sizes are the same.

  {
     TCanvas *c2 = new TCanvas("c2","",0,0,600,900);
     c2->Divide(3,3);
     TH1F *h = new TH1F("h","This is a really long title for test purposes only hopefully long enough hehehe",100,0,100);
     c2->cd(1);
     h->Draw();
     c2->Print("test.ps");
  }
  

TLegend

TTF

Axis drawing

• Always paint the axis title before painting the tick marks. This fixes a problem when setting the number of divisions to 0. In this case the axis title was not drawn.
• Label size was wrong when the text precision was equal to 3.
• In case of log scale on a vertical axis, the x-position of the extra labels (when SetMoreLogLabels is true) was not computed the same way as the x-position of the decades labels. Therefore they where not aligned.

TGraphErrors

• The fill style for boxes (option 3) was ignored.
• If a point is outside the pad limits it is set to the limit it exceed. Previously it was not initialized. This produced random drawing with the following macro:

  {
     const int n=200;
     double x[n],y[n],e[n];
     TCanvas *c1 = new TCanvas("c1", "Test",800,600);
     for (int i=0;i<n;i++) {
        x[i]=i;
        y[i]=sqrt(i);
        e[i]=y[i]/(i+1);
     }
     TH1D *Fond = new TH1D("Fond","",2,0,n);
     Fond->SetMinimum(0);
     Fond->SetMaximum(10);
     Fond->Draw();
     TGraphErrors *gr = new TGraphErrors(n,x,y,0,e);
     gr->SetFillColor(17);
     gr->Draw("    E3");
  }
  

TGraph

• A better version of the TGraph constructor creating a TGraph from an input ascii file.
• The following example produced a wrong output:

                                                                                  
  {
     hpx1 = new TH1F("hpx1","hpx1",100,-4,4);
     hpx2 = new TH1F("hpx2","hpx2",100,-4,4);
     Float_t px, py;
     for (Int_t i = 0; i < 25000; i++) {
        gRandom->Rannor(px,py);
        hpx1->Fill(px);
        hpx2->Fill(px);
        hpx2->Fill(py);
     }
     hpx1->SetFillColor(2);
     hpx1->SetFillStyle(3004);
     hpx1->Draw("LF2");
     hpx2->SetFillColor(1);
     hpx2->SetFillStyle(3005);
     hpx2->Draw("LF2 same");
  }
  

  The black histogram was not completly hatched.

GL/gl2ps

• New version of gl2ps
• New options to improve outline drawing in GL/PS files.

THistPainter

• Problems in CONT4 contour option fixed:
  • Tick marks were on the wrong axis' side.
  • It was not possible to draw axis's grid.
  • SetTickx() and SetTicky() had no effect.
  The axis for CONT4 are now drawn with THistPainter::PaintAxis(), not anymore using TPainter3dAlgorithms.
• The angular variables in POL, SPH, CYL and PSR representations are now mapped correctly.
• Protect THistPainter::PaintBoxes against a division by 0 in case of code like

     hh = new TH2F("hh","hh",100,0,1,100,0,1);
     hh->Fill(200,200); // out of range value, so that
     GetSumOfWeights()==0
     hh->Draw("box");
  

• PaintErrors: In case of log scale on a Y axis with a positive maximum value and a minimum value less or equal to 0, a new minimum is computed as a percentage of the maximum. This rule is fine but may brings back visible some bins which are out of range in linear mode. A new test has been added to prevent that. This problem is visible since revision 1.197. Previously the test modified in that revision was able to filter such wrong cases.
• In case of 1D histograms plotted as a LEGO or a SURFACE, one had to change the option LogZ to set the logarithmic scale on the Y axis. Setting the option LogY produced an error. This is now fixed.

New tutorials

• double32.C
• loopdir.C
• treefriend.C
• fitLinearRobust.C
• importCode.C
• readCode.C
• RoofitDemo.C
• assembly.C
• mathcoreVectorIO.C
• mathcoreVectorCollection.C
• mathcoreStatFunc.C
• mathcoreSpecFunc.C
• mathcoreGenVector.C
• mathcoreCDF.C
• minuit2FitBench.C
• minuit2FitBench2D.C
• minuit2GausFit.C
• glsurfaces.C
• psview.C
• copyFiles.C
• ConfidenceIntervals.C
• sqlcanvas.C
• sqltables.C
• thumbnail.C
• glViewerExercise.C
• TestSPlot.C
• regexp.C