ROOT Version 5.16/00 Development Notes


ROOT version 5.16/00 has been released June 29, 2007.

Binaries for all supported platforms are available at:

      http://root.cern.ch/root/Version516.html
Versions for AFS have also been updated. See the list of supported platforms:
      http://root.cern.ch/Welcome.html

For more information, see:

      http://root.cern.ch

The following people have contributed to this new version:
Ilka Antcheva,
Maarten Ballintijn,
Bertrand Bellenot,
Rene Brun,
Toby Burnett,
Philippe Canal,
Federico Carminati,
Olivier Couet,
Jason Detwiler,
Valeri Fine,
Leo Franco,
Markus Frank,
Gerri Ganis,
Andrei Gheata,
Mihaela Gheata,
Jan Iwaszkiewicz,
Anna Kreshuk,
Wim Lavrijsen,
Kerry Lee,
Josef Leydold,
Sergei Linev,
Ben Lloyd,
Pere Mato,
Diego Marcos-Segura,
Lorenzo Moneta,
Axel Naumann,
Jan Fiete Grosse-Oetringhaus,
Eddy Offermann,
Valeriy Onuchin,
Timur Pocheptsov,
Fons Rademakers,
Stefan Roiser,
Paul Russo,
Scott Snyder,
Alja Tadel,
Matevz Tadel,
Jakob van Santen,
Guido Volpi


¡¡WARNINGS!! Important Changes in the dire ctories structure: ¡¡WARNINGS!!

In an effort to reduce the coupling between modules and also reduce the compi lation time, we have reorganized some important directories. The executable module r oot.exe is now linked only with -lCore -lCint -lRint, but not anymore with -lHist -lGraf -lGraf3d -lGpad -lTree -lRint -lPostscript -l Matrix -lPhysics. When a script (or command) references a class in another ROOT library, this library is autloaded by the system.

This is achieved using rootmap files. Each library comes with its own rootmap file, describing which classes are conta ined in the library and what other libraries the library depends on. This allows ROOT to load all the necessary libraries when CINT sees a class name that is mentioned in one of the rootmap files. This mechanism currently only works for classes; we plan to expand it to cover a t least typedefs, too.

You can build your own rootmap file using the rlibmap utility in $ROOT SYS/bin. Given the library libMyLib.so which is linked against libHist.so, and for which a dictionary was built using include/MyLibLinkDef.h, one would run:

rlibmap -f -o lib/libMyLib.rootmap -l lib/libMyLib.so -d libHist -c include
/MyLibLinkDef.h

From now on, libMyLib will be automatically loaded whenever CINT sees any of th e classes mentioned in include/MyLibLinkDef.h.

However, when working with compiled code, the reference d libraries must be loaded before executing the corresponding compiled script or code. This is because compiled code depends on the libraries via the operation system (the linker, to be exact) - CINT and ROOT cannot help there. Nothing was changed with respect to that, except for the number and names of lib raries that will have to be used for linking. Note that we strongly recommend to use the root-config utility to be protected against these kinds of changes. If you use it, you will not see any changes in this release. For instance to compile and link your application (with GCC) you can do somethin g like:

  g++ -o myapp.exe myapp.cxx `root-config --cflags --libs`

We have also started a major exercise aiming at a considerable reduction in size of the dictionaries (generated code and memory). The picture below shows the evolution of the virtual memory and memory heap use with the various versions of the system released since 3 years. We expect that for the next production release (December) another substantial reduction in size of the code generated for the dictionaries.

Memory footprint of different ROOT versions

New math directory

The new math directory includes the following classes previously in base. We are planning to add to this directory several classes currently in MathCore. The new library is not used by libCore. It is automatically linked when a class like TMath, TRandom is referenced in an interactive application.

A new file TMathBase.h has been created in base. It contains some frequently used functions (min,max,abs,range) for scalar or vectors that are unfortunately not provided in a standard way by all our supported platforms. TMathBase is in namespace TMath. TMathBase.h is included by TMath.h.

This separation of TMath in the new library may have some side-effects if you were assuming that TMath.h was included via a class like TNamed or TObject or TH1. Now, you may have to include explicitely TMath.h in your source file.

New io directory

The new directory io includes all the ROOT classes to do basic Input/Output. With this release, the classes in this directory are still included in libCore. The new library libRIO contains on the I/O classes. It is dynamically linked by applications referencing the I/O classes in this directory.

The class TDirectory is now a pure abstract interface. The new class TDirectoryFile derives from TDirectory and implement the real I/O functions. TFile derives from TDirectoryFile instead of TDirectory. This change may be backward incompatible if your application creates directly a TDirectory object. If this is the case, you should replace the call to TDirectory by TDirectoryFile and include TBufferFile.h instead of TBuffer.h.

The class TBuffer is also a pure abstract interface. The class TBufferFile includes all the function implementations previously in TBuffer, plus a few more functions that became necessary with the directory restructure. This change may be backward incompatible if your application creates directly a TBuffer object. If this is the case, you should replace the call to TBuffer by TBufferFile and include TBufferFile.h instead of TBuffer.h.

In case you have to maintain code using old and new versions, you can do something like:


#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,0)
#include <TBufferFile.h>
#else
#include <TBuffer.h>
#endif

...

#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,0)
    TBufferFile b(TBuffer::kWrite,10000);
#else
    TBuffer b(TBuffer::kWrite,10000);
#endif

The macros ROOT_VERSION_CODE and ROOT_VERSION are defined in RVersion.h included by all ROOT headers.

Introduce a new utility class (TCollectionProxyInfo) to allow the delaying of the creation of the CollectionProxy object until they are really needed. This also allows to remove the dependency of the dictionaries on the I/O library.

net directory changes with new library libNet

The classes in the directory net are not referenced anymore by libCore. They are dynamically linked if referenced in an interactive application. You should explicitely link with libNet if you use of the these classes in a batch application.

Changes in graf

The class TView is now an abstract interface and it has been moved to the directory gpad. All calls like
   TView *view = new TView(1);
must be replaced by
  TView *view = TView::CreateView(1);

Changes in cont

The classes in the old cont directory dealing with I/O have been moved to the new directory io. the new cont directory does not depend anymore on the I/O sub-system.

Changes in meta

The classes in the old meta directory dealing with I/O have been moved to the new directory io. the new meta directory does not depend anymore on the I/O sub-system.

Changes in base

The class TMath, TRandom, TRandom1, TRandom2 and TComplex have been moved to the new math directory.

The new directory base is not dependent on the I/O classes, the math classes or network classes

The class TView has been moved to directory gpad.

The single $ROOTSYS/etc/system.rootmap has been replaced by individual rootmap files associated to each library and stored in the $ROOTSYS/lib directory. These rootmap files are automatically build when running "make". The extra "make map" step is not needed anymore. This change should fix a large number of problems due to missing or not up-to-date rootmap file.

General cleanup with include files

We have taken advantage of this reorganization to remove unnecessary includes from many classes and to use forward references instead.

Changes in some files automatically included at startup

The main interactive class TRint was loading by default a set of frequently used includes like iostream, string, vector, pair. When the interactive ROOT starts, it can automatically load some frequently used includes. However, this introduces several overheads In your system.rootrc file, you can set the variable below to 0 to disable the loading of these includes at startup
Rint.Includes:      0
You can set the variable to 1 (default) to load only iostream , string and RTypesCint.h. You can set it to 2 to load in addition vector and pair. We strongly recommend setting the variable to 2 if your scripts include vector. and you execute your scripts multiple times.

Changes in rootcint

When generating the code for the automatic Streamer functions, rootcint generates now the following code:
	void Myclass::Streamer(TBuffer &R__b)
	{
	   // Stream an object of class Myclass.
	
	   if (R__b.IsReading()) {
	      R__b.ReadClassBuffer(Myclass::Class(),this);
	   } else {
	      R__b.WriteClassBuffer(Myclass::Class(),this);
	   }
	}
instead of
	
	void Myclass::Streamer(TBuffer &R__b)
	{
	   // Stream an object of class Myclass.
	
	   if (R__b.IsReading()) {
	      Myclass::Class()->ReadBuffer(R__b,this);
	   } else {
	      Myclass::Class()->WriteBuffer(R__b,this);
	   }
	}

I/O


TWebFile

The class TWebFile has been modified to work with any web server without the need of a special plug-in as it was the case before. You can now connect to any ROOT file visible via a web server, eg
    TFile f("http://root.cern.ch/files/alice.root");
This new feature is of particular interest when used in connection with the TGHtml class described in a section later in these notes.

TTree

In TBranchElement, fix a problem when calculating the address of an base class when it happens to be a STL collection (and split). This affected ATLAS in particular.
When the master tree of a tree 'clone' relationship is deleted, we need now properly reset the address of only cloned branches in clone tree. The branch that have been added by hand by the user in the clone tree are now untouched. Also the branches of TNtuple are now properly reset to their default values (instead of a new memory area).

New Class TEntryList

TEntryList is a new class, with functionality similar to TEventList. The main differences are:

Saving the result of Draw to a TEventList or a TEntryList

TTree::Draw(const char* varexp, const char* selection, Option_t* option) can be used to fill a TEventList or a TEntryList object (list of entry numbers).

If varexp has the form >>elist , a TEventList object named "elist" is created in the current directory. elist will contain the list of entry numbers satisfying the current selection. If option "entrylist" is used, a TEntryList object is created Example:

  tree.Draw(">>yplus","y>0")
will create a TEventList object named "yplus" in the current directory.
  tree.Draw(">>yplus", "y>0", "entrylist")

will create a TEntryList object named "yplus" in the current directory.

In an interactive session, one can type (after TTree::Draw)

     yplus.Print("all")
to print the list of entry numbers in the list.
By default, the specified entry list is reset. To continue to append data to an existing list, use "+" in front of the list name;
  tree.Draw(">>+yplus","y>0")
will not reset yplus, but will enter the selected entries at the end of the existing list.

WARNING:: Future changes after this release

In this release version, when an argument of the form >>elist is passed to TTree::Draw(), by default a TEventList object is created.
After this release the default will be changed to TEntryList! This will require the following changes in the user code:
Same as before:

 tree.Draw(">>elist", "some cut"); //same as before;
but afterwards use
 TEntryList *el = (TEntryList*)gDirectory->Get("elist");
instead of
 TEventList *el = (TEventList*)gDirectory->Get("elist");

Using a TEventList or a TEntryList as Input

Once a TEventList or a TEntryList object has been generated, it can be used as input for TTree::Draw. Use TTree::SetEventList or TTree::SetEntryList to set the current event list If a TEventList object is used as input, a new TEntryList object is created inside the SetEventList function. In case of a TChain, all tree headers are loaded for this transformation. This new object is owned by the chain and is deleted with it, unless the user extracts it by calling GetEntryList() function. See also comments to SetEventList() function of TTree and TChain.

If arrays are used in the selection critera, the entry entered in the list are all the entries that have at least one element of the array that satisfy the selection.

Example:
    tree.Draw(">>pyplus","fTracks.fPy>0");
    tree->SetEventList(pyplus);
    tree->Draw("fTracks.fPy");
will draw the fPy of ALL tracks in event with at least one track with a positive fPy.

To select only the elements that did match the original selection use TEventList::SetReapplyCut or TEntryList::SetReapplyCut.

Example:
    tree.Draw(">>pyplus","fTracks.fPy>0");
    pyplus->SetReapplyCut(kTRUE);
    tree->SetEventList(pyplus);
    tree->Draw("fTracks.fPy");
will draw the fPy of only the tracks that have a positive fPy.

Note: Use tree->SetEventList(0) if you do not want use the list as input.

New Class TEntryListFromFile

This is a utility class, called by TChain::SetEntryListFile() function. Use case: suppose the user has TEntryLists, corresponding to files of the TChain, each in a separate file. This class allows to load the lists in memory one by one, in the same way that the TChain loads its TChainElements. If a file with an entry list, corresponding to a chain element, is not found, it's skipped (with a warning) and the chain processing continues on the next element. See class description and the TChain::SetEntryListFile() function comments for more details.

Base


Meta

Add a new function TClass::Move which, for now, only information the address registry of emulated object of the object move ... later this should be enhanced to really 'move' (as oppose to really on memcpy) the object from one place to the other. This new function is used by the Emulated Collection Proxy to properly handle the memory resizing.
In meta (and TRealData) increase the offset from Int_t to Long_t to properly support some use case (pyroot) on 64 bits architecture

Improvements in the documentation system class THtml

The class THtml has received a long list of improvements. They are visible in the THtml reference guide. Some of the highlights are:


Cint


class TH1

A bug has neen fixed in TH1::Rebin and its functionality extended to support the rebinning of a fixed size bin histogram into a variable bin size histogram.

Improvements in hadd

Add support for indirect files (thanks Toby Burnett). Wildcarding and indirect files are also supported
	    hadd result.root  myfil*.root
will merge all files in myfil*.root
	    hadd result.root file1.root @list.txt file2. root myfil*.root
will merge file1. root, file2. root, all files in myfil*.root and all files in the indirect text file list.txt ("@" as the first character of the file indicates an indirect file. An indirect file is a text file containing a list of other files, including other indirect files, one line per file).

TF1

Extend TF1 by adding these new possibility to construct a TF1 object:

An example of creating a TF1 from a functor is the following:

class  MyFunctionObject { 
 public: 
   // use constructor to customize your function object 
   
   double operator() (double *x, double *p) { 
      // function implementation using class data members
   } 
};
{ 
    ....
   MyFunctionObject * fobj = new MyFunctionObject(....);       // create the function object 
   TF1 * f = new TF1("f",fobj,0,1,npar,"MyFunctionObject");    // create TF1 class.  
   .....
}

Here is an example for creating a TF1 from a member function of the class :

class  MyFunction { 
 public: 
   ...
   double Evaluate() (double *x, double *p) { 
      // function implementation 
   } 
};
{ 
    ....
   MyFunction * fptr = new MyFunction(....);  // create the user function class  
   TF1 * f = new TF1("f",fptr,&MyFunction::Evaluate,0,1,npar,"MyFunction","Evaluate");   // create TF1 class. 

   .....
}

See the tutorials math/exampleFunctor.C for a running examples of creating a TF1 using these new features.

Add also in TF1 a new function, TF1::IntegralError to calculate the errors on the integral due to the uncertainties of the function parameters obtained from fitting the function to data set. The error is calculated from the covariance matrix from the last fit performed by the function.


class TMinuit

In TMinuit::Contour, the TGraph object with the contour points is now correctly closed.

MathCore

Major changes for this release are:

In addition, the following bugs have been fixed:

More detailed description of the current MathCore release can be found at this location.

SMatrix

Remove the optimized Cramer inversion for 6x6 matrices (symmetric and normal). Use now the standard method used for large matrices (Bunch-Kaufman for the symmetric and LU factorization for the general squared). The Cramer method has been found to be significantly slower on the new 64 bit machines running gcc 3.4.

Fix a bug discovered by LHCb (thanks to W. Hulsbergen) in the += and -= operators for symmetric matrices when using expressions, for examples in operations like: A += B + C;.

More detailed description of the current SMatrix release can be found at this location.

MathMore

New classes KelvinFunctions to calculate the Kelvin functions Ber(x), Bei(x), Ker(x), Kei(x), and their first derivatives. The functions in this class have been imported by Jason Detwiler (jasondet@gmail.com) from CodeCogs. See MathWorld for the definition of the Kelvin functions.


Minuit2

The following fixes have been applied :

More detailed description of the current Minuit2 release can be found at this location.


TRandom

A new algorithm for generating random numbers according to the Gaussian distribution has been introduced. The new implementation is based on the acceptance-complement ratio method from W. Hoermann and G. Derflinger from Institut f. Statistik, WU Wien and comes from the UNU.RAN package (from J. Leydold et al.).

The new algorithm is probably one of the fastest currently existing and it is a factor 2/3 times faster than the previous polar method (Box-Muller) used for TRandom::Gaus. The Box-Muller algorithm is still available in the TRandom::Rannor method for generating 2 numbers. The speed is comparable to the Ziggurat method (from Marsaglia) implemented for example in GSL and available in the MathMore library, via ROOT::Math::Random::Gaus.

For example this is obtained running the tutorial math/testrandom.C on a 2.GHz Intel Core Duo running MacOSX and compiled with gcc 4.0:

Distribution            microseconds/call
                    TRandom  TRandom1 TRandom2 TRandom3
					
Gaus (ACR method)    86.000  242.000   92.000   96.000 
Gaus (BM method)    246.000  475.000  255.000  257.000  
Rannor              141.000  258.000  148.000  147.000

In the case of Rannor, the method is the same of the previous implementation of TRandom::Gaus (BM method), but both numbers required by the polar method are used.


Unuran

The TUnuran class has been modified and extended to use now discrete and empirical distributrions. The distribution classes for continuous 1D and multi-dimensional distribution have been re-designed and renamed. In the following is the updated documentation on how to use UNURAN, via the class TUnuran in ROOT:

Functionality is also provided via the C++ classes for using a different random number generator by passing a TRandom pointer when constructing the TUnuran class (by default the ROOT gRandom is passed to UNURAN).

		  TRandom2 r; 
		  // use inside Unuran the TRandom2 (TausWorthe) generator. 
        TUnuran unr(&r);
          

The UNU.RAN documentation provides a detailed description of all the available methods and the possible options which one can pass to UNU.RAN for the various distributions.

UNU.RAN is very efficient in generating random variates when the parameter of the distributions do not vary during the generation. For example these results are obtained from running the tutorial testrandom.C on a 2.GHz Intel Core Duo running MacOSX and compiled with gcc 4.0:

 Distribution            nanoseconds/call

                     TRandom  TRandom1 TRandom2 TRandom3

 Rndm..............   24.000  137.000   29.000   30.000
 RndmArray.........   17.000  128.000   22.000   22.000
 Gaus..............   86.000  242.000   92.000   96.000
 Rannor............  141.000  258.000  148.000  147.000
 Landau............   68.000  173.000   73.000   74.000
 Binomial(5,0.5)...  152.000  695.000  171.000  179.000
 Binomial(15,0.5)..  414.000 2060.000  480.000  497.000
 Poisson(3)........  212.000  653.000  231.000  234.000
 Poisson(10).......  402.000 1618.000  456.000  460.000
 Poisson(70)....... 1225.000 1651.000 1253.000 1250.000
 Poisson(100)...... 1233.000 1664.000 1260.000 1262.000
 GausTF1...........  210.000  326.000  218.000  216.000
 LandauTF1.........  209.000  325.000  217.000  213.000
 GausUNURAN........   90.000  202.000   97.000   96.000
 PoissonUNURAN(10).  160.000  361.000  170.000  170.000
 PoissonUNURAN(100)  139.000  347.000  148.000  149.000

In this release the version 1.0.1 of UNU.RAN is used.

Geometry Package


Geometry editors

Material and mixture editors


The material editor can be invoked from the TGeoManagerEditor GUI:

TGeoManager *geom = new TGeoManager("","");
geom->Edit();

Geometry Editor Geometry Mixture Editor


The material editor reflects now the new properties added to TGeoMaterial: state, temperature and density. All material properties changes are undoable. The mixture editor currently allows adding elements one by one in the mixture composition. This can be done either by element weight fraction or by number of atoms. Once an element was added using one method the other mehod is not selectable anymore. Summing component fractions up to 1 in the final mixture is the user responsability. Adding materials as components of a mixture is not supported in this version.

The elements that were added to the mixture appear in the bottom TGCanvas of the mixture editor. The operations performed on mixture are not undoable.

PROOF


GUI


OpenGL

TGLHistPainter and TGLViewer

TRootEmbeddedCanvas

Added check for gStyle->GetCanvasPreferGL() in TRootEmbeddedCanvas constructor in a way it is done in TRootCanvas. This change enables GL rendering in TRootEmbeddedCanvas objects.

Parametric surfaces

//Author: Timur Pocheptsov
void glparametric()
{
   // A parametric surface is defined by three functions:
   // S(u, v) : {x(u, v), y(u, v), z(u, v)}.
   // To create parametric surface and draw it one has to:
   //    1. Create canvas, which support OpenGL drawing (two ways):
   //       a. Call gStyle->SetCanvasPreferGL(kTRUE)
   //       b. Or create canvas with name, wich contains "gl".
   //    2. create TGLParametricEquation object.
   //       TGLParametricEquation *eq = new TGLParametricEquation
            ("name_of_object",
   //       "some FORMULA here - x(u, v)",
   //       "some FORMULA here - y(u, v)",
   //       "some FORMULA here - z(u, v)",
   //       uMin, uMax, vMin, vMax);
   //       where FORMULA is the same string (mathematical expression),
   //       as in TF2, but you should use 'u' (or 'U') instead of 'x'
   //       and 'v' (or 'V') instead of 'y'.
   //    3. Call equation->Draw();
   //       Parametric surfaces support 21 color "schemes", you can change
   //       the color:
   //       -place mouse cursor above surface (surface is selected in pad)
   //       -press 's' or 'S'.

   TCanvas *c = new TCanvas("glcanvas","Parametric surfaces with gl",
                             100, 10, 700, 700);
   c->SetFillColor(42);
   gStyle->SetFrameFillColor(42);
   c->Divide(2, 2);
   c->cd(1);
   TGLParametricEquation *p1 = new TGLParametricEquation("Conchoid",
      "1.2 ^ u * (1 + cos(v)) * cos(u)",
      "1.2 ^ u * (1 + cos(v)) * sin(u)",
      "1.2 ^ u * sin(v) - 1.5 * 1.2 ^ u",
      0., 6 * TMath::Pi(), 0., TMath::TwoPi());
   p1->Draw();
   c->cd(2);
   TGLParametricEquation *p2 = new TGLParametricEquation("Apple",
      "cos(u) * (4 + 3.8 * cos(v)) ",
      "sin(u) * (4 + 3.8 * cos(v))",
      "(cos(v)+sin(v)-1)*(1+sin(v))*log(1-pi*v/10)+7.5*sin(v)",
      0, TMath::TwoPi(), -TMath::Pi(), TMath::Pi());
   p2->Draw();
   c->cd(3);
   TGLParametricEquation *p3 = new TGLParametricEquation("Toupie",
      "(abs(u) - 1) ^ 2 * cos(v)",
      "(abs(u) - 1) ^ 2 * sin(v)",
      "u",
      -1., 1., 0, TMath::TwoPi());
   p3->Draw();
   c->cd(4);
   TGLParametricEquation *p4 = new TGLParametricEquation("Trangluoid trefoil",
      "2 * sin(3 * u) / (2 + cos(v))",
      "2 * (sin(u) + 2 * sin(2 * u)) / (2 + cos(v + 2 * pi / 3))",
      "(cos(u)-2*cos(2*u))*(2+cos(v))*(2+cos(v+2*pi/3))/4",
      -TMath::Pi(), TMath::Pi(), -TMath::Pi(), TMath::Pi());
   p4->Draw();
}
GL: a parametric function

Iso-surfaces

TH3 histograms can drawn as iso surfaces (3D iso contours).
TH3 iso surface
void gliso()
{
   const Int_t nBin = 70;
   const Double_t l = -40., r = 40.;
   Double_t w = (r-l)/nBin;
   TH3F *volume = new TH3F("V","V", nBin, l, r, nBin, l, r, nBin, l, r);
   TCanvas *canvas = new TCanvas("glC","glC",600,600);
                                                                                
   //Define and set user's palette,
   const Int_t paletteSize = 5;
   Float_t rgb[paletteSize * 3] =
      {0.9f, 0.60f, 0.f,
       0.f,  1.f,   1.f,
       1.f,  0.f,   0.f,
       0.f,  1.f,   0.f,
       1.f,  1.f,   0.f};
                                                                                
   Int_t palette[paletteSize] = {0};
                                                                                
   for (Int_t i = 0; i < paletteSize; ++i)
      palette[i] = TColor::GetColor(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);                                                                                
   gStyle->SetPalette(paletteSize, palette);
                                                                                
   Float_t x,y,z;
   for (x = l-w/2; x < r; x += w) {
      for (y = l-w/2; y < r; y += w) {
         for (z = l-w/2; z < r; z += w) {
            if ( x*x + y*y + z*z < 500) volume->Fill(x,y,z,50);
            if ( x*x + y*y + z*z < 300) volume->Fill(x,y,z,40);
            if ( x*x + y*y + z*z < 200) volume->Fill(x,y,z,30);
            if ( x*x + y*y + z*z < 80)  volume->Fill(x,y,z,20);
            if ( x*x + y*y + z*z < 30)  volume->Fill(x,y,z,10);
         }
      }
   }
                                                                                
   volume->SetContour(5);
   volume->Draw("gliso");
}
void gliso2()
{
   gStyle->SetCanvasPreferGL(true);
   TCanvas * canvas = new TCanvas("C","C",600,600);
   ntuple->Draw("px:py:pz>>h3","","Q");
   h3->SetContour(50);
   h3->Draw("gliso");
}
TH3 iso surface

Text drawing with OpenGL

The FTGL package has been imported inside the ROOT framework. This package, provided by Henry Maddocks, allows TTF font display in OpenGL. It is used by the new class TGLText which draws 3D in OpenGL scenes. TGLText being itself used by TGLAxis to draw 3D axis also in OpenGL scenes.

Major restructuring of GL viewer-scene relationship

The main idea was to generalize current GL infrustructure so that the following features can be done in the future:
  1. Full pad rendering via GL including 3D histo/func painters and 2D graphics.
  2. Implementation of GL canvas (with independent viewers serving as pads).
  3. Multi-view event-visualization front-end.
  4. Inclusion of external scenes (non-ROOT-gl) in ROOT viewer. Rendering of ROOT scenes in external GL frameworks.
Changes on the code level
  1. Extend current scene/viewer classes into a 2-level class hierarchy. New classes TGLViewerBase and TGLSceneBase.
  2. Allow scenes to be shared among viewers. View-specific scene-cache needs to be kept at the viewer side.
  3. Viewer now manages a list of scenes. It is possible to put together a combination of scenes (e.g. one showing geometry, another one tracks and yet another clusters). Each scene can define its own clipping object.
  4. Provide API for fine-grained control over rendered object removal, creation and update. This allows for efficient scene-updates.
  5. Disentangle selection, clipping and other markup objects from within viewer-scene singleton. New classes TGLClipSet, TGLManipSet.
  6. Disentangle selection management.
  7. Separate overlay rendering to allow any number of active GL-GUI elements (like manipulators are now). New classes TGLOverlayElement.
  8. Trailing white space has been removed in all files.
Restructure low-level interface to OpenGL
  1. Allow sharing GL resources among viewers.
  2. Do not bind GL-output (windowed or offscreen) to ROOT GUI.
New classes TGLContext, TGLFormat, TGLWidget. This oboletes TGLKernel and TVirtualGL classes.

Basic Graphics

TGraph

TText and TLatex

Time axis

TH2: Arrow Plots and Errors Plots

Lego Plots

TPie

TLegend

TEllipse

THStack

New class TColorWheel

TColor

PostScript and Image Dump

TASImage/TImage

In TPad::Print

TImagePalette

TPostScript

Miscellaneous

TH1

TGraph2D

Hatches painting

TGraphAsymmErrors

TGraphPolar/TPolarGram

TGaxis

TPaveStats

THistPainter::Paint2DErrors

TPolyMarker

Xft

Tutorials


Changes in Ruby

Thanks to Jakob van Santen for fixing a problem with the Ruby library. libRuby worked fine from ROOT/Cint, but did not load from within Ruby. On OS X, Ruby could only load extension libraries compiled as mach-o bundles, not those compiled as dynamiclibs. This problem is now fixed.

New tutorials

We added set of nice macros illustrating the power of the geometry package. These macros were developped at the Department of Physics, University of Seoul under the supervision of Professor Inkyu Park (icpark@physics.uos.ac.kr), for the evaluation of Computational Physics course in 2006.



ROOT page - Class index - Top of the page