ROOT version 3.02/06 Release Notes

The ROOT Team is pleased to announce the release of ROOT version 3.02.

Compared to the previous production release (v3.01/06) this new version
backward compatible with the previous production version has major
enhancements described below:

Binaries for all supported platforms are available at:

      http://root.cern.ch/root/Version302.html

Versions for AFS have also been updated. See the list of supported platforms:

      http://root.cern.ch/root/AFS.html

Both links are reachable via the download page.


Rene Brun, Philippe Canal, Masaharu Goto, Fons Rademakers



TStreamerInfo (I/O sub system)
==============================

Added support for type char*.

Added a new static member function TStreamerInfo::SetCanDelete().
When this option is activated (default), ReadBuffer() automatically
delete objects when a data member is a pointer to an object.
If your constructor is not pre-setting pointers to 0, you must
call this static function TStreamerInfo::SetCanDelete(kFALSE);

Added native support for a pointer to a fixed size array of pointers.

Several changes related to the introduction of the new classes TRef.

Many improvements to support the case called "fake class" in case
the shared library containing the classes is not available, or the
complex case where the shared lib is dynamically linked after opening
a file containing the classes in the shared lib.


CINT
====

Latest version of CINT with more bug fixes and more template support.


The ZIP package
===============

Minor modification by Maarten Ballintijn in the ZIP Inflate package
resulting in a gain of about 20 per cent in read time.


New class TUUID
===============

This class defines a UUID (Universally Unique IDentifier), also
known as GUIDs (Globally Unique IDentifier). A UUID is 128 bits
long, and if generated according to this algorithm, is either
guaranteed to be different from all other UUIDs/GUIDs generated
until 3400 A.D. or extremely likely to be different. UUIDs were
originally used in the Network Computing System (NCS) and
later in the Open Software Foundation's (OSF) Distributed Computing
Environment (DCE).


New class TMD5
==============

This code implements the MD5 message-digest algorithm.
To compute the message digest of a chunk of bytes, create an
TMD5 object, call Update() as needed on buffers full of bytes, and
then call Final(), which will, optinally, fill a supplied 16-byte
array with the digest.


New classes TProcessID
======================

A TProcessID identifies a ROOT job in a unique way in time and space.
The TProcessID title consists of a TUUID object which provides a globally
unique identifier (for more see TUUID.h).

A TProcessID is automatically created by the TROOT constructor.
When a TFile contains referenced objects (see TRef), the TProcessID
object is written to the file.
If a file has been written in multiple sessions (same machine or not),
a TProcessID is written for each session.
These objects are used by the class TRef to uniquely identified
any TObject pointed by a TRef.

When a referenced object is read from a file (its bit kIsReferenced is set),
this object is entered into the objects table of the corresponding TProcessID.
Each TFile has a list of TProcessIDs (see TFile::fProcessIDs) also
accessible via TProcessID::fgPIDs (for all files).
When this object is deleted, it is removed from the table via the cleanup
mechanism invoked by the TObject destructor.

Each TProcessID has a table (TObjArray *fObjects) that keeps track
of all referenced objects. If a referenced object has a fUniqueID set,
a pointer to this unique object may be found via fObjects->At(fUniqueID).
In the same way, when a TRef::GetObject is called, GetObject uses
its own fUniqueID to find the pointer to the referenced object.
See TProcessID::GetObjectWithID and PutObjectWithID.


New classes TRef, TRefArray
===========================

A TRef is a lightweight object pointing to any TObject.
This object can be used instead of normal C++ pointers in case
 - the referenced object R and the pointer P are not written to the same file
 - P is read before R
 - R and P are written to different Tree branches

When a top level object (eg Event *event) is a tree/graph of many objects,
the normal ROOT Streaming mechanism ensures that only one copy of each object
in the tree/graph is written to the output buffer to avoid circular
dependencies.
However if the object event is split into several files or into several
branches of one or more Trees, normal C++ pointers cannot be used because
each I/O operation will write the referenced objects.
When a TRef is used to point to a TObject *robj.
For example in a class with
    TRef  fRef;
one can do:
    fRef = robj;  //to set the pointer
this TRef and robj can be written with two different I/O calls
in the same or different files, in the same or different branches of a Tree.
If the TRef is read and the referenced object has not yet been read,
the TRef will return a null pointer. As soon as the referenced object
will be read, the TRef will point to it.

TRef also supports the complex situation where a TFile is updated
multiple times on the same machine or a different machine.

How does it work
----------------

A TRef is itself a TObject with an additional transient pointer fPID.
When the statement fRef = robj is executed, the following actions happen:
  - The pointer fPID is set to the current TProcessID.
  - The current ObjectNumber (see below) is incremented by one.
  - robj::fUniqueID is set to ObjectNumber.
  - In the fPID object, the element fObjects[ObjectNumber] is set to robj
  - ref::fUniqueID is also set to ObjectNumber.
After having set fRef, one can immediatly return the value of robj
using fRef.GetObject(). This function returns directly fObjects[fUniqueID]
from the fPID object.

When the TRef is written, the process id number pidf of fPID is written
in addition to the TObject part of TRef (fBits,fUniqueID).
When the TRef is read, its pointer fPID is set to the value
stored in the TObjArray of TFile::fProcessIDs (fProcessIDs[pidf]).

When a referenced object robj is written, TObject::Streamer writes
in addition to the standard (fBits,fUniqueID) the pidf.
When this robj is read by TObject::Streamer, the pidf is read.
At this point, robj is entered into the table of objects of the TProcessID
corresponding to pidf.

WARNING: If MyClass is the class of the referenced object, The TObject
         part of MyClass must be Streamed. One should not
         call MyClass::Class()->IgnoreTObjectStreamer()

ObjectNumber
------------

When an object is referenced (see TRef assignement operator or TRefArray::Add)
a unique identifier is computed and stored in both the fUniqueID of the
referenced and referencing object. This uniqueID is computed by incrementing
by one the static global in TProcessID::fgNumber. fUniqueID is some sort of
serial object number in the current session. One can retrieve at any time
the current value of fgNumber by calling the static function TProcessID::GetObjectCount
or set this number via TProcessID::SetObjectCount.
To avoid a growing table of fObjects in TProcessID, in case, for example,
one processes many events in a loop, it might be necessary to reset the
ObjectNumber at the end of processing of one event. See an example
in $ROOTSYS/test/Event.cxx (look at function Build).
The value of ObjectNumber (say saveNumber=TProcessID::GetObjectCount()) may be
saved at the beginning of one event and reset to this original value
at the end of the event via TProcessID::SetObjectCount(saveNumber). These
actions may be stacked.

Action on Demand
----------------

The normal behaviour of a TRef has been described above. In addition,
TRef supports also "Actions on Demand". It may happen that the object
referenced is not yet in memory, on a separate file or not yet computed.
In this case TRef is able to automatically execute an action:
  - call to a compiled function (static function of member function)
  - call to an interpreted function
  - execution of a CINT script

How to select this option?
In the definition of the TRef data member in the original class, do:
  TRef  fRef;   //EXEC:execName. points to something
When the special keyword "EXEC:" is found in the comment field of the member,
the next string is assumed to be the name of a TExec object.
When a file is connected, the dictionary of the classes on the file
is read in memory (see TFile::ReadStreamerInfo). When the TStreamerElement
object is read, a TExec object is automatically created with the name
specified after the keywork "EXEC:" in case a TExec with a same name does
not already exist.
The action to be executed via this TExec can be specified with:
   - a call to the TExec constructor, if the constructor is called before
     opening the file.
   - a call to TExec::SetAction at any time.
     One can compute a pointer to an existing TExec with a name with:
       TExec *myExec = gROOT->GetExec(execName);
     myExec->SetAction(actionCommand); where
     - actionCommand is a string containing a CINT instruction. Examples:
         myExec->SetAction("LoadHits()");
         myExec->SetAction(".x script.C");

When a TRef is dereferenced via TRef::GetObject, its TExec will be
automatically executed. In the function/script being executed, one or more
of the following actions can be executed:
 - load a file containing the referenced object. This function typically
   looks in the file catalog (GRID).
 - compute a pointer to the referenced object and communicate this pointer
   back to the calling function TRef::GetObject via:
     TRef::SetObject(object).
As soon as an object is returned to GetObject, the fUniqueID of the TRef is set
to the fUniqueID of the referenced object. At the next call to GetObject,
the pointer stored in fPid:fObjects[fUniqueID] will be returned directly.

An example of action on demand is shown in $ROOTSYS/test/Event.h with
the member:
     TRef    fWebHistogram;   //EXEC:GetWebHistogram
When calling fWebHistogram.GetObject(), the function GetObject
will automatically invoke a script GetWebHistogram.C via the interpreter.
An example of a GetWebHistogram.C script is shown below
   void GetWebHistogram() {
      TFile *f= TFile::Open("http://root.cern.ch/files/pippa.root");
      f->cd("DM/CJ");
      TH1 *h6 = (TH1*)gDirectory->Get("h6");
      h6->SetDirectory(0);
      delete f;
      TRef::SetObject(h6);
   }

In the above example, a call to fWebHistogram.GetObject() executes the
script with the function GetWebHistogram. This script connects a file
with histograms: pippa.root on the ROOT Web site and returns the object h6
to TRef::GetObject.
Note that if the definition of the TRef fWebHistogram had been:
     TRef    fWebHistogram;   //EXEC:GetWebHistogram()
then, the compiled or interpreted function GetWebHistogram() would have
been called instead of the CINT script GetWebHistogram.C

Array of TRef
-------------

The special class TRefArray should be used to store multiple references.
A TRefArray has one single pointer fPID for all objects in the array.
It has a dynamic compact table of fUniqueIDs. Use a TRefArray rather
then a collection of TRefs.

Example:
Suppose a TObjArray *mytracks containing a list of Track objects
Suppose a TRefArray *pions containing pointers to the pion tracks in mytracks.
  This list is created with statements like: pions->Add(track);
Suppose a TRefArray *muons containing pointers to the muon tracks in mytracks.
The 3 arrays mytracks,pions and muons may be written separately.


$ROOTSYS/test/Event
===================

Test program modified to illustrate the use of TRef and TRefArray


TTree: Creation of branches
===========================

Creation of branches on separate files:
when branch file names are not absolute and not an URL and the tree file
name is absolute or an URL then make the branch files relative to the path
of the tree file. In this case one can move the tree + all branch files to
a different location in the file system and still access the branch files.

Added a new branch constructor:
   Int_t TTree::Branch(TCollection *list, Int_t bufsize, Int_t splitlevel,
                       const char *name)
This function creates one branch for each element in the collection.
Each entry in the collection becomes a top level branch if the
corresponding class is not a collection. If it is a collection, the entry
in the collection becomes in turn top level branches, etc.
The splitlevel is decreased by 1 everytime a new collection is found.
For example if list is a TObjArray*
  - if splitlevel = 1, one top level branch is created for each element
    of the TObjArray.
  - if splitlevel = 2, one top level branch is created for each array element.
    if, in turn, one of the array elements is a TCollection, one top level
    branch will be created for each element of this collection.

In case a collection element is a TClonesArray, the special Tree constructor
for TClonesArray is called.
The collection itself cannot be a TClonesArray.

The function returns the total number of branches created.

If name is given, all branch names will be prefixed with name_.

IMPORTANT NOTE1: This function should not be called with splitlevel < 1.

IMPORTANT NOTE2: The branches created by this function will have names
corresponding to the collection or object names. It is important
to give names to collections to avoid misleading branch names or
identical branch names. By default collections have a name equal to
the corresponding class name, eg the default name for a TList is "TList".


TTree::GetEntry(): added the following important comments
=========================================================

By default, GetEntry() reuses the space allocated by the previous object
for each branch. You can force the previous object to be automatically
deleted if you call mybranch.SetAutoDelete(kTRUE) (default is kFALSE).
Example:
Consider the example in $ROOTSYS/test/Event.h
The top level branch in the tree T is declared with:
   Event *event = 0;  //event must be null or point to a valid object
                      //it must be initialized
   T.SetBranchAddress("event",&event);
When reading the Tree, one can choose one of these 3 options:

OPTION 1
--------

   for (Int_t i=0;i<nentries;i++) {
      T.GetEntry(i);
      the objrect event has been filled at this point
   }
The default (recommended). At the first entry an object of the
class Event will be created and pointed by event.
At the following entries, event will be overwritten by the new data.
All internal members that are TObject* are automatically deleted.
It is important that these members be in a valid state when GetEntry
is called. Pointers must be correctly initialized.
However these internal members will not be deleted if the characters "->"
are specified as the first characters in the comment field of the data
member declaration.
If "->" is specified, the pointer member is read via pointer->Streamer(buf).
In this case, it is assumed that the pointer is never null (case
of pointer TClonesArray *fTracks in the Event example).
If "->" is not specified, the pointer member is read via buf >> pointer.
In this case the pointer may be null. Note that the option with "->"
is faster to read or write and it also consumes less space in the file.

OPTION 2
--------

The option AutoDelete is set:
  TBranch *branch = T.GetBranch("event");
  branch->SetAddress(&event);
  branch->SetAutoDelete(kTRUE);
   for (Int_t i=0;i<nentries;i++) {
      T.GetEntry(i);
      the objrect event has been filled at this point
   }
In this case, at each iteration, the object event is deleted by GetEntry
and a new instance of Event is created and filled.

OPTION 3
--------

Same as option 1, but you delete yourself the event:
   for (Int_t i=0;i<nentries;i++) {
      delete event;
      event = 0;  EXTREMELY IMPORTANT
      T.GetEntry(i);
      the objrect event has been filled at this point
   }

It is strongly recommended to use the default option 1. It has the
additional advantage that functions like TTree::Draw (internally
calling TTree::GetEntry) will be functional even when the classes in the
file are not available.


TTree::MakeClass()
==================

Added support for the new branch style TBranchElement.
Several improvements in the code generator in case of C++ complex constructs.


TTree::Print()
==============

Added a new option "toponly" in TTree::Print() to print the space used
by the top branches only. A top branch is a branch that does not have
a "." in its name. The space reported includes the total of all
sub-branches of a top branch.


TBranch::SetFile()
==================

Modify the TBranch::SetFile functions such that the daughter branches are
also diverted to the specified file.


TTreeFormula
============

Several enhancements:
  - added support for TCutG which TChains
  - added several additional protections
  - fixed memory leaks.
  - added support for leaves with same name in different branches
  - one can call a method of a class in a TClonesArray
  - added support for casting implemented as a 'dynamic_cast' so that
       TTree::Draw("((TTUBE*)fShape)->GetRmin()")
    will histogram ONLY the entries containing a TTUBE (or an object
    inheriting from TTUBE).
  - functions that return an int are now histogramed in integer format
  - rationalize treatment of char arrays which are now treated as a string
    if and only if the context requires it.


TEventList upgrade (related to TTreeFormula)
============================================

TEventList object now includes ALL the entry/event that has any subparts
that match the criteria, i.e.  With fTracks a TClonesArray, the following call
   T->Draw(">>elist","fTracks.fPx>0");
will create a TEventList elist that contains ALL the entries that have one
or more tracks which have fPx greater than zero. Prior to this updates
elist would contain ONLY the entries where fTracks.A(0).fPx is greater
than zero. Another example:
   T->Draw(">>pxlist","fPx>2.7");
creates a TEventList 'pxlist' that list all events that have one or more
tracks with fPx greater than 2.7:
   T->SetEventList(pxlist);
   T->Draw("fPx");
will draw the fPx of ALL the tracks of the events that have at least
one track with a fPx greater than 2.7:
   pxlist->SetReapplyCut(kTRUE);
   T->SetEventList(pxlist);
   T->Draw("fPx");
will draw the fPx of ONLY the tracks that have a fPx greater than 2.7.


TTreeRow
========

Class has been rewritten (6 times faster and consumes less memory).
This class is used by TTree::Query().


TChain
======

Improvements in TChain::Merge(). When merging many files, it may happen
that the resulting file reaches a size > fgMaxMergeSize (default = 1.9 GBytes).
In this case the current file is automatically closed and a new file started.
If the name of the merged file was "merged.root", the subsequent files
will be named "merged_1.root", "merged_2.root", etc.
fgMaxMergeSize may be modified via the static function SetMaxMergeSize.
The function Merge returns the total number of files generated.

TChain::Merge() creates a new Tree containing ONLY the active branches.

TChain::Add() supports wildcarding (Andre Holzner).

In TChain::Addfile() remove the limitation that the file name must contain
the string ".root". ".root" is necessary only in case one wants to specify
a Tree in a subdirectory of a ROOT file with eg, the format:
   //machine/file_name.root/subdir/tree_name


TH1
===

Add new function TH1::GetQuantiles():
   Int_t TH1::GetQuantiles(Int_t nprobSum, Double_t *q,
                           const Double_t *probSum)
computes Quantiles for this histogram.
Quantile x_q of a probability distribution Function F is defined as
   F(x_q) = q with 0 <= q <= 1.
For instance the median x_0.5 of a distribution is defined as that value
of the random variable for which the distribution function equals 0.5:
   F(x_0.5) = Probability(x < x_0.5) = 0.5
(function implemented in collaboration with Eddy Offermann, Renaissance)

TH1::Rebin() function now in the TH1 context menu.

Fixed a bug in TH1::Fit() when adding a copy of teh function to the list
of functions.
Add new comments and examples in TH1::Fit() to illustrate how to set limits
for a parameter or how to fix a parameter.

Note that during the fitting process, the user may call the new static
function TF1::RejectPoint() (see TF1).

In TH1::Draw() and TGraph::Draw() a new canvas is automatically created
in case gPad points to a non-editable pad/canvas.


TH2
===

Modify the default arguments in TH2::ProfileX,Y, ProjectionX,Y.
With the new convention, the projection does not include the under/overflow
bins. When all bins are included, the number of entries in the projection
is set to the number of entries of the 2-D histogram, otherwise
the number of entries is incremented by 1 for all non empty cells.


TH3
===

Implement support for variable bin size histograms in TH3::Project3D().
Thanks to Albert Lehmann


New class THStack
=================

This new class may be used to draw a stack of histograms (1-d and 2-d)
See example in new tutorial hstack.C.


TProfile
========

TProfile::ProjectionX() supports profiles with variable bin size.


THistPainter
============

PaintErrors: use histogram attributes in case of options "e3", "e4".
Optimize size and end position of error bars around the symbol
in case of assymetric pads in THistPainter::PaintErrors.
Implement a patch from Jiri Masik to avoid drawing the horizontal lines
twice for the error bars in case the options "hist" and "e" are specified.

The THistPainter and TLego classes have been extended with new functions
to draw selected regions of a 2-d histogram.
One can create one or more graphical cuts (TCutG objects) and specify
this (these) cuts in option string of the Draw function. Example, assuming
two graphical cuts with name "cut1" and "cut2", one can do:
   h1.Draw("lego");
   h2.Draw("[cut1,-cut2],surf,same");
The second Draw will superimpose on top of the first lego plot a subset of
h2 using the "surf" option with:
  -all the bins inside cut1
  -all the bins outside cut2
Up to 16 cuts may be specified in the cut string delimited by "[..]"

Currently only the following drawing options are sensitive to the cuts
option: col, box, scat, hist, lego, surf and cartesian coordinates only.

Optimize the axis layout in THistPainter::PaintLegoAxis when painting
a surface at theta=90 and phi = 0 degrees (case of option cont4).


TAxis
=====

Added new function TAxis::SetRangeUser(Axis_t ufirst, Axis_t ulast).
This function is a shortcut calling:
   TAxis::SetRange(Int_t binfirst, Int_t binlast).
The new function is visible in the context menu.

Add support for zooming on the Z axis in case of a 3-D view or zooming
on the palette axis in case of a 2-d view.

Delete the unused member fXlabels and associated member functions:
GetBinLabel, GetLabels, SetBinLabel and SetLabels.


TGaxis
======

Added a new member function TGaxis::SetNoExponent() to disable the notation
with 10^N when drawing the axis. This option is automatically selected
when drawing TAxis objects having this property.
Note that this option is implicitly selected if the number of digits
to draw a label is less than the fgMaxDigits global member.
SetNoexponent is also available from the TAxis context menu.

A few optimisations in TGaxis::PainTAxis in case a transformation function
has been specified in the constructor.
Update the example in this constructor to show a case with a log function.


TPad/TVirtualPad
================

added support for fixed aspect ratio. New methods SetFixedAspectRatio() and
HasFixedAspectRatio(). After fixing the aspect ratio the pad mouse
resize functions will maintain the current aspect ratio. SetFixedAspectRatio()
is available as toggle via the context menu.

Added signals RangeChanged() and RangeAxisChanged(). For description
of usage see Range() and RangeAxis(). Basically it allows for easy
monitoring of zoom events.


class TGraph
============

Added the following new functions:
    Double_t GetCorrelationFactor() const;
    Double_t GetCovariance() const;
    Double_t GetMean(Int_t axis=1) const;
    Double_t GetRMS(Int_t axis=1) const;

In all the TGraphX classes add a new method Apply suggested and implemented
by Miroslav Helbich <helbich@mail.desy.de>
If one has points x,y of TGraph, sometimes it is convenient to apply a
function to those points e.g y=f(x,y). There are some examples like scale
the points by some number f(x,y)=y*scale factor or if you try to fit some
complicated formula it is sometimes better to do the transformation first.

Implement new option "[]" in the TGraph::Paint() and TGraphAsymmErrors::Paint().
if option "[]" is specified only the end vertical/horizonthal lines
of the error bars are drawn. This option is interesting to superimpose
systematic errors on top of a graph with statistical errors.

Modify the Paint functions to paint the TGraph symbols after the error bars.


New class TGraphSmooth (Christian Stratowa)
===========================================

This class is a helper class to smooth TGraph, TGraphErrors or interpolate
a graph at a set of given points. See new tutorial motorcycle.C


TLegend
=======

Several cosmetic improvements.
Modify algorithm in TLegend::PaintPrimitives() when painting the fill area.
Use TPad::PaintFillArea() instead of a box. Painting via a TBox had side
effects when painting with fill styles with hatches.


TLatex
======

New symbol #tilde supported.
To be consistent with LateX, #varepsilon replaces the old #epsilon.
The new #epsilon is a new character in the Tlatex table.
varepsilon and epsilon look now identical to the LateX output.


TF1, TF2
========

When a TF1/TF2 was created with an interpreted or compiled function,
it was not possible to save the object in a file and read it in a separate
program because TF1/TF2 did not save the code of the interpreted function.
Only functions created with inline expressions could be paint in a separate
session. In TF1, we already had the logic to save an array fSave with
the function values created at fNpx points. TF2 has been modified
to provide the same functionality. One can save a TF2 and draw it
again in a new session.
To implement this feature, the signature of the function TF1::Save
has been modified to be general for 1,2 and 3-d functions.
The classes TH1 and TGraph where TF1::Save was called have been
modified accordingly.

Interpreted or compiled functions are saved at fNpx points.
Basic functions saved with the original definition.

TH1 and TGraph objects including fit functions are now fully saved
and rebuilt.

Add new function TF1::GetQuantiles() (see TH1::GetQuantiles).

Add new static global member fgRejectPoint with the new static functions:
   void TF1::RejectPoint(Bool_t reject=kTRUE)
   Bool_t TF1::RejectedPoint()

The function TF1::RejectPoint() may be used in a user fitting function
to reject points. The fgRejectPoint is automatically reset.

A new member function TF1::IsInside() has been added.
Currently it returns kTRUE if the point is inside the function limits.
This function is redefined in TF2 and TF3.
The main purpose of this function is to give additional possibilities
in functions deriving from TF1. For example, if a function is only
defined in some specific non-contiguous ranges, this could be
implemented in a class deriving from TF1 and simply redefining
the function TF1::IsInside.

In TF1::DistancetoPrimitive(), evaluate the function only if the point is
inside the function range.


TColor
======

Added three new static methods:
  TColor::GetColor(Int_t r, Int_t g, Int_t b) with r,g,b in range [0,255]
  TColor::GetColor(Float_t r, Float_t g, Float_t b) with r,g,b in range [0,1]
  TColor::GetColor(const char *hexcolor) with hexcolor of form "#rrggbb"
these methods try to find the color with the specified rgb value in the
list of existing colors, if the color does not exist it will create a
new TColor with the name "#rrggbb", add it to the global list of colors
and return the color number.

Also made the methods HLStoRGB() and RGBtoHLS() static.


TPostScript
===========

Add new functions in the Postscript interface to support drawing of images
with Postscript (thanks to Olivier Couet).

Some special characters like TLatex #varphi were not correctly
interpreted by TPostScript.


TStyle
======

Add more comments to the TStyle constructor.

Add new function TStyle::SetTitlePS(const char *title) to specify
a Title in the Postscript file.

Two fixes by Jiri Masik in the TStyle ctor to avoid modifying the current
style.


TBits
=====

Improve speed of TBits::CountBits() (factor 8).
New functions: FirstNullBit() and FirstSetBit().


TMatrix, TMatrixD
=================

Interesting additions to TMatrix and TMatrixD by Eddy Offermann.
When working with the TMatrix class I was confronted again with a bit
of a limitation:

1) The current algorithm is not capable of inverting a diagional matrix
whose determinant is < 1e-300 giving a floating exception, not to speak
of more complex non-diagonal cases.

The solution is simple: first divid the element (i,j) through val, where
val = sqrt(element(i,i)*element(j,j)) and doing this again after inversion.

2) In case of a symmetric pos def matrix, a simpler/faster algorithm
can be used. I have added the kInvertedPosDef type to both classes.


TLorentzVector
==============

Add a comment about the Plus() and Minus() functions
Member functions Plus() and Minus() return the positive and negative
light-cone components:

  Double_t pcone = v.Plus();
  Double_t mcone = v.Minus();

CAVEAT: The values returned are T{+,-}Z. It is known that some authors
find it easier to define these components as (T{+,-}Z)/sqrt(2). Thus
check what definition is used in the physics you're working in and adapt
your code accordingly.


TThread
=======

Many improvements in this class: many thanks to
 - the GSI G04 group
 - Mathieu de Naurois
For more details, see the CVS history notes.

TMemberInspector
================
A BACKWARD INCOMPATIBLE change in the function Inspect.
The new signature is:
  void Inspect(TClass *cl, const char *parent, const char *name, const void *addr);


THtml
=====

Many improvements by Axel Naumann. Quoted from a mail from Axel:
"NOTE: I have changed the standard in one case. Please tell me if you want to
reversed. Due to this change all MyClass.html files will contain the "last
changed" date, even if not given in the file (if lastChanged=="", THtml
takes the current date, which in most cases should be a good approximation -
if the file weren't changed one wouldn't regenerate the documentation). See
the attached html file for an example.

To include your own files, e.g. a header, edit e.g.
$ROOTSYS/etc/system.rootrc. Add lines with:
"Root.Html.Header:    <yourfilename>"
Make sure the file ends with a new line (this is valid for all
files THtml is processing, shall we change that?)!

You can also say "Root.Html.Header:    <your filename>+" in which case THtml
will first write its standard header and then the one provided by you (for
the footer it's the other way around, first yours, then the standard)."

Bugfixes:
- sometimes THtml wasn't able to identify a method of namespace'd classes in
  source files
- namespaced classes as return types are now correctly identified
- global enums are known as classes to CINT although they don't have the
  ClassDef macro. If such an enum showed up in a source file it resulted in a
  link to their - non-existent - documentation page (as CINT returned a class
  info), but as they don't have DeclFile / ImplFile no documentation is
  generated for them. I resolved that by only generating a link for globals
  only if the class info has a decl file specified. Thus gROOT still points to
  TROOT.html, but kChildFrame doesn't point to EFrameType. Bug found by Thomas
  Bretz.
- fXWho was set in the code. Now the env var Root.Html.XWho is read in; if
  it's not set, the old value is used.
- unused var "funcName" in ClassDescription removed (there was one with
  local scope & another one with method scope of the same name, one of them
  was unused)
- gROOT is not asked anymore if "const" is a global object each time a
  "const" shows up in the source file. Takes too much time.

Improvements:
- documentation (of the class responsible for self-documenting...).
- Authors: multiple authors can be given (comma separated list), custom HTML
  link can be specified after each author name in <...>.
- some char strings were far too short and resulted in out-of-bounds memory
  writes. Author, copyright, update and "nextLine" are changed (some from 80)
  to 1024 chars now.
- Not documented: Doc++ compatible comments outside of methods. To enable it
  the env var "Root.Html.DescriptionStyle" has to be set to "Doc++". THtml's
  new ability does not influence anything else, it's completely independent.
  Thomas Bretz and I have tested this for a while. But I'm not sure if
  allowing multiple documentation styles is a good thing. So we could just
  keep that a secret...


TPrincipal
==========

Several improvements by Christian Holm Christiansen.


TObjectTable
============

Add new option in TObjectTable::Print(), if option ="all" prints the
list of all objects with the format object number, pointer, class name,
object name.


New or modified tutorials
=========================

quantiles.C  New tutorial to illustrate teh use of TH1::GetQuantiles().
hstack.C     New tutorial to illustrate the use of the new class THStack.
motorcycle.C New tutorial to illustratre the new class TGraphSmooth.
Worldmap.C   New GUI demo by Valeriy Onuchin.
PhaseSpace.C New tutorial illustrating the use of the class TGenPhaseSpace by
             Valerio Filippini.
graphApply.C New tutorial  to demonstrate the functionality of TGraphX::Apply()
             method by Miro Helbich.
waves.C      New tutorial illustrating the use of color palettes (Otto Schaile)
greyscale.C  New tutorial showing the use of TColor::GetColor() and how to set
             a pad to the exact same color as the GUI.
DynamicSlice.C  Improved quality of graphics
FittingDemo.C   idem
first.C         idem
second.C        idem


TDatime
=======

Add boolean argument "toGMT" to Convert(). The default is false for backward
compatibility, setting it to true returns the unix time in GMT.


TMath
=====

Make the array arguments const in functions LocMin(), LocMax(), BinarySearch()
and Sort(). Add new signatures with Long_t.
New functions TMath::IsNan() and TMath::Finite().


TString
=======

Add operator+=(Float_t) and operator+=(Double_t). Both use %9.9g to
encode floating point number. If other encoding is desired do e.g.:
TString(Form("%6.2f", myfloat))


TBuffer
=======

New argument "adopt" to TBuffer ctor and to SetBuffer(). The default
value of the argument is kTRUE. When this value is kFALSE the buffer
passed will not be adopted by TBuffer and not deleted in the dtor
or in SetBuffer() when a new buffer is passed in.
*** Attention: The default value of adopt is backward incompatible for
    the SetBuffer() call. This new default behavior was introduced in v3.02/04.

TSystem
=======

Add two new getters returning the architecture and the complete built
node spec:
   TSystem::GetBuildArch()
   TSystem::GetBuildNode()


TStorage
========

New methods ReAllocChar() and ReAllocInt() to be used to reallocate
arrays of chars or ints. These methods will use new char[] and new int[]
to realloc the original arrays. Using ReAlloc() will give complaints from
memory checkers like Purify and could be a potential problem in case
for example ::operator new[]() uses a different pool then ::operator new().


Port of ROOT GUI to Win32
=========================

Bertrand Bellenot contributed to the big effort of porting the ROOT GUI
to Win32 using the Win32 version of GDK. This port is a work in progress
but already quite functional. Still missing, multiplexing between console
and graphics input. To use it do in tutorials, e.g.:
   root demos.C
   root benchmarks.C
   root guitest.C
Or in test build guitest and guiviewer which don't use the console.
To build this special Win32 version of ROOT do:
   ./configure win32gdk
   make


TGMenu
======

New methods to allow menu's to be changed after initial creation.
In TGPopupMenu:
   void            HideEntry(Int_t id);
   Bool_t          IsEntryHidden(Int_t id);
   void            DeleteEntry(Int_t id);
   void            DeleteEntry(TGMenuEntry *entry);
   TGMenuEntry    *GetEntry(Int_t id);
   TGMenuEntry    *GetEntry(const char *s);
   const TList    *GetListOfEntries() const;
in addition the AddXXXX() methods now accept a before item which allows the
addition of new menu items before the specified item.

In TGMenuBar:
   TGPopupMenu *GetPopup(const char *s);
   TGPopupMenu *RemovePopup(const char *s);
in addition the AddPopup() methods now accept a before item which allows the
addition of a new menu before the specified menu.

See the guitest programs on how these new methods should be used.


TGListBox
=========

Added method GetNumberOfEntries().


TGListView
==========

Add new signals for Clicked() and DoubleClicked() that also report
the x and y position of the mouse at time of click.

TGlient
=======

New method ProcessEventsFor(TGWindow *w). Use this method to instead
of TSystem::ProcessEvents() in case you want to allow only events for
the specified TGWindow to be processed (like when this is a progress
meter dialog).


TGNumberEntry
=============

Important new widget by Daniel Sigg that allows controlled numeric input
in many different formats (int, float, hex, time, date, etc.). An example
of usage is added to guitest.cxx and guitest.C.


TGTextEntry
===========

Support system wide clipboard (like TGTextEdit). When doing ctl-x (cut)
or ctrl-v (copy) text is put in global clipboard and can be pasted in any
other window. Mods by Daniel Sigg <sigg_d@ligo.caltech.edu>.

Add new signal "TabPressed()" (and event TE_TAB). Using this signal one
can easily implement focus changing by connecting the signal to a method
that changes the focus to the next TGTextEntry.


TQObject & Signal/Slot
======================

Very much improved detection of undefined signal and slot methods.


h2root
======

h2root modified to support remote files (rfio, castor,etc)


ACLIC
=====

Use by default the "+" option in the autoLinkDef.h file to automatically
support the new ROOT I/O format.


Memory Checker
==============

New memory checking system developed by D.Bertini and M.Ivanov.
To activate the memory checker you have to set in the .rootrc file
the resource Root.MemCheck to 1 (e.g.: Root.MemCheck: 1) and you
have to link with libNew.so (e.g. use root-config --new --libs) or
use rootn.exe. When all this is the case you will find at the end
of the program execution a file "memcheck.out" in the directory
where you started your ROOT program. Alternatively you can set
the resource Root.MemCheckFile to the name of a file to which
the leak information will be written. The contents of this
"memcheck.out" file can be analyzed and transformed into printable
text via the memprobe program (in $ROOTSYS/bin).


Template support
================

Provide ClassDef and ClassImp macros for classes with two and three
template arguments. The new macros are: ClassDef2T2, ClassDef3T2 and
ClassImp2T, ClassImp3T. ClassDefT is independent of the number of template
arguments. They are used as follows:

   // in header file MyClass.h
   template <typename T> class MyClass1 {
   private:
      T  fA;
      ...
   public:
      ...
      ClassDefT(MyClass1,1)
   };
   ClassDefT2(MyClass1,T)

   template <typename T1, typename T2> class MyClass2 {
   private:
      T1  fA;
      T2  fB;
      ...
   public:
      ...
      ClassDefT(MyClass2,1)
   };
   ClassDef2T2(MyClass2,T1,T2)

   template <typename T1, typename T2, typename T3> class MyClass3 {
   private:
      T1  fA;
      T2  fB;
      T3  fC;
      ...
   public:
      ...
      ClassDefT(MyClass3,1)
   };
   ClassDef3T2(MyClass3,T1,T2,T3)
   ClassImp3T(MyClass3,T1,T2,T3)


   // With in the LinkDef.h file all explicit template instances
   // that will be needed at link time
   #ifdef __CINT__

   #pragma link off all globals;
   #pragma link off all classes;
   #pragma link off all functions;

   #pragma link C++ class MyClass1<float>+;
   #pragma link C++ class MyClass1<double>+;
   #pragma link C++ class MyClass2<float,int>+;
   #pragma link C++ class MyClass2<float,double>+;
   #pragma link C++ class MyClass3<float,int,TObject*>+;
   #pragma link C++ class MyClass3<float,TEvent*,TObject*>+;

   #endif


SQL interface to SAP DB (http://www.sapdb.org/)
===============================================

SAP DB is an open source (GPL) RDBMS that provides full DB functionality
and can be easily used instead of Oracle. These classes are based on the
ODBC call interface and are provided by Mark Hemberger
(Marc.Hemberger@realtech.de).

SAP DB is an open, SQL-based, relational database system that provides
high availability and performance scaling from small to very large
implementations. In addition, SAP DB goes beyond relational database
technology by offering object orientation as well as support for managing
unstructured data. It supports open standards including SQL, JDBC and ODBC;
access from Perl and Python; and HTTP-based services with HTML or XML content.
SAP DB (formerly known as ADABAS) has gone Open Source. SAP DB Version
7.3.00 is available for Linux, Windows NT/Windows 2000, Solaris, HP-UX,
Tru64, AIX. For those who don't want to pay for an Oracle-like database
with comparable functionality (and better than MySQL  [;-)]


SQL interface to PostgreSQL
===========================

PostgreSQL interface provided by Gian Paolo Ciceri.


./configure script
==================

Updated ./configure script with better auxiliary package detection.


Makefiles
=========

New Makefiles and improvements in all makefiles.
New port to Sun SPARC Linux.
New MacOS X port by Keisuke Fujii
Support for gcc v3.