# Version 3.03/08 Release Notes

    The ROOT Team is pleased to announce the release of ROOT version 3.03/08.

    Compared to the previous production release (v3.02/07) this new,
    backward compatible, version has major enhancements described in the
    attachement.

    Binaries for all supported platforms are available at:

          http://root.cern.ch/root/Version303.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. Note that with this release,
    we are supporting binaries for RedHat7.2 with 3 compilers.

     For more information, see:

          http://root.cern.ch

    Rene Brun, Philippe Canal, Olivier Couet, Masaharu Goto, Fons Rademakers

    CINT
    ====

    Latest version of CINT. For the main new features see the CINT
    release notes: http://root.cern.ch/root/Cint.phtml?relnote

    rootcint
    ========

    Added the following options to run rootcint:
       -v   Display all messages
       -v0  Display no messages at all.
       -v1  Display only error messages (default).
       -v2  Display error and warning messages.
       -v3  Display error, warning and note messages.
       -v4  Display all messages

    Improvements by Victor Perevoztchikov concerning generation of
    code for STL containers and arrays of containers.
    Now arrays of containers implemented for all STL types, before was only
    for vector and deque. It works for both, pointers and objects inside of
    containers.

    Improvements by Mathieu de Naurois in case of namespaces.

    ClassDef/ClassImp changes
    =========================

    ClassDef now better supports templated classes and namespaces. The special
    ClassDefT, ClassDefT2, ClassImpT, etc macros are not needed anymore.
    Formally ClassImp is now also not needed anymore, but it is still useful
    to provide the line and file of the class implementation used by the THtml
    class.

    New class TPluginManager
    ========================

    This class implements a plug-in library manager. It keeps track of
    a list of plug-in handlers. A plug-in handler knows which plug-in
    library to load to get a specific class that is used to extend the
    functionality of a specific base class and how to create an object
    of this class. For example, to extend the base class TFile to be
    able to read RFIO files one needs to load the plug-in library
    libRFIO.so which defines the TRFIOFile class. This loading should
    be triggered when a given URI contains a regular expression defined
    by the handler. Handlers can be defined for example as resources
    in the .rootrc file, e.g.:

       Plugin.TFile:       ^rfio:   TRFIOFile    RFIO   "<constructor>"
       Plugin.TSQLServer:  ^mysql:  TMySQLServer MySQL  "<constructor>"
       +Plugin.TSQLServer: ^pgsql:  TPgSQLServer PgSQL  "<constructor>"
       Plugin.TVirtualFitter: *     TFitter      Minuit "TFitter(Int_t)"

    Where the + in front of Plugin.TSQLServer says that it extends the
    existing definition of TSQLServer, useful when there is more than
    one plug-in that can extend the same base class. The "<constructor>"
    should be the constructor or static method that generates an
    instance of the specified class. The * is a placeholder in case
    there is no need for a URI to differentiate between different
    plug-ins for the same base class. For the default plug-ins see
    $ROOTSYS/etc/system.rootrc.

    Plug-in handlers can also be registered at run time, e.g.:

      gROOT->GetPluginManager()->AddHandler("TSQLServer", "^sapdb:",
                                            "TSapDBServer", "SapDB",
               "TSapDBServer(const char*,const char*, const char*)");

    A list of currently defined handlers can be printed using:

      gROOT->GetPluginManager()->Print(); // use option="a" to see ctors

    The use of the plug-in library manager removes all textual references
    to hard-coded class and library names and the resulting dependencies
    in the base classes. The plug-in manager is used to extend a.o.
    TFile, TSQLServer, TGrid, etc. functionality.

    New class TProcessUUID
    ======================

    This class is a specialized TProcessID managing the list of UUIDs.
    In addition to TProcessID, this object has the following members:
       - fUUIDs  : a THashList of TUUIDs in string format (using a TObjString)
       - fActive : a TBits table with one bit per TUUID in the table
    When a new TUUID is entered into the list fUUIDs, it is assigned
    the first free slot in the list of bits and the TUUID UUIDNumber
    is set to this slot number.
    When a TUUID is removed from the list, the corresponding bit
    is reset in fActive.
    The object corresponding to a TUUID at slot I can be found
    via fObjects->At(I).
    One can use two mechanisms to find the object corresponding to a TUUID:
      1- the input is the TUUID.AsString. One can find the corresponding
         TObjString object objs in fUUIDs via THashList::FindObject(name).
         The slot number is then objs->GetUniqueID().
      2- The input is the UUIDNumber. The slot number is UIUIDNumber

    When a TRef points to an object having a TUUID, both the TRef and the
    referenced object have their bit kHasUUID set. In this case, the pointer
    TProcessID *fPID in TRef points to the unique object TProcessUUID.
    The TRef uniqueID is directly the UUIDNumber=slot number.

    TRef, TRefArray
    ===============

    Several changes in the handling of TRef to support the following
    use case:
      An array of objects is written to a file but the TRefs
      referencing these objects are not written to the file.
      In a next session, these objects are read in memory
      and new TRefs point to these objects and are written
      to a separate file. In a third session both files
      are connected.
    To get this scenario working, one must use a dummy TRef
    set to all objects that can be referenced in the next session.

    Add new logic to be able to reference objects with a TUUID
    (eg TDirectory, TFile). (many thanks to Bill Tanenbaum).

    Special case of a TRef pointing to an object with a TUUID
    ----------------------------------------------------------

    If the referenced object has a TUUID, its bit kHasUUID has been set.
    This case is detected by the TRef assignment operator.
    For example, TFile and TDirectory have a TUUID.
    The TRef fPID points directly to the single object TProcessUUID (deriving
    from TProcessID) and managing the list of TUUIDs for a process.
    The TRef kAsUUID bit is set and its fUniqueID is set to the fUniqueID
    of the referenced object.
    When the TRef is streamed to a buffer, the corresponding TUUID is also
    streamed with the TRef. When a TRef is read from a buffer, the corresponding
    TUUID is also read and entered into the global list of TUUIDs (if not
    already there). The TRef fUniqueID is set to the UIIDNumber.
    see TProcessUUID for more details.

    TDirectory
    ==========

    Add a new member TUUID fUUID. Each directory has now a universal
    unique id. This identifier is persistent. A TDirectory has its
    bit kHasUUID set to 1. A TDirectory/TFile is now referencable by a TRef.

    TObject
    =======

    Add new enum kHasUUID=BIT(5). The kHasUUID bit is set when an object
    has a UUID or in a TRef referencing an object with a UUID.

    TFile
    =====

    Support writing to /dev/null for benchmarking purposes. Just specify
    as file name "/dev/null", option will be forced to "CREATE".

    See also "Automatic file overflow" in TTree.

    The new Geometry package
    ========================

    The new ROOT geometry package is a tool designed for building, browsing,
    tracking and visualizing a detector geometry. The code is independent from
    other external MC for simulation, therefore it does not contain any
    constraints related to physics. However, the package defines a number of
    hooks for tracking, such as materials, magnetic field or track state flags,
    in order to allow interfacing to tracking MC's. The final goal is to be
    able to use the same geometry for several purposes, such as tracking,
    reconstruction or visualization, taking advantage of the ROOT features
    related to bookkeeping, I/O, histograming, browsing and GUI's.

    The geometrical modeler is the most important component of the package and
    it provides answers to the basic questions like "Where am I ?" or "How far
    from the next boundary ?", but also to more complex ones like "How far from
    the closest surface ?" or "Which is the next crossing along a helix ?".

    The architecture of the modeler is a combination between a GEANT-like
    containment scheme and a normal CSG binary tree at the level of shapes. An
    important common feature of all detector geometry descriptions is the
    mother-daughter concept. This is the most natural approach when tracking
    is concerned and imposes a set of constraints to the way geometry is defined.
    Constructive solid geometry composition is used only in order to create more
    complex shapes from an existing set of primitives through boolean operations.
    This feature is not implemented yet but in future full definition of boolean
    expressions will be supported.

    Practically every geometry defined in GEANT style can be mapped by the modeler.
    The basic components used for building the logical hierarchy of the geometry
    are called "volumes" and "nodes". Volumes (sometimes called "solids") are fully
    defined geometrical objects having a given shape and material and possibly
    containing a list of nodes. Nodes represent just positioned instances of volumes
    inside a container volume and they are not directly defined by user. They are
    automatically created as a result of adding one volume inside other or dividing
    a volume. The geometrical transformation hold by nodes is always defined with
    respect to their mother (relative positioning). Reflection matrices are allowed.
    All volumes have to be fully aware of their containees when the geometry is
    closed. They will build additional structures (voxels) in order to fasten-up
    the search algorithms. Finally, nodes can be regarded as bidirectional links
    between containers and containees objects.

    For more details on the package, see class TGeoManager and
    the new tutorial rootgeom.C.

    The package is developed jointly with Andrei Gheata from the ALICE
    collaboration.

    g2root
    ======

    The new version of g2root transforms an existing Geant3 geometry file
    to a C++ script creating the new ROOT geometry;
       g2root  myfile.geom  myfile.C
    for more details, see comments in g2root. This new version of g2root
    has been implemented by Mihaela Gheata.

    The old g2root has been renamed to g2rootold. (both are in $ROOTSYS/bin).

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

    The following additions to the matrix package by its maintainer
    Eddy Offermann:

    New operators:
       TMatrix  operator+(const TMatrix &source1, const TMatrix &source2);
       TMatrix  operator-(const TMatrix &source1, const TMatrix &source2);
       TMatrix  operator*(const TMatrix &source1, const TMatrix &source2);

    The next will accomplish together a[i][j]:
       const TMatrixRow operator[](Int_t rown) const;
       TMatrixRow operator[](Int_t rown);

    changes to TMatrixRow:
       const Double_t &operator[](Int_t i) const;
       Double_t &operator[](Int_t i);

    The following operations have been added to TVector,TVectorD:
       TVector  operator+(const TVector &source1, const TVector &source2);
       TVector  operator-(const TVector &source1, const TVector &source2);

    New methods:
       TMatrix &NormByDiag(const TVector &v, Option_t *option="D");
       TMatrix &NormByColumn(const TVector &v, Option_t *option="D");
       TMatrix &NormByRow(const TVector &v, Option_t *option="D");

       TMatrix &operator*=(const TMatrixDiag &diag);
       TMatrix &operator/=(const TMatrixDiag &diag);
       TMatrix &operator*=(const TMatrixRow &diag);
       TMatrix &operator/=(const TMatrixRow &diag);
       TMatrix &operator*=(const TMatrixColumn &diag);
       TMatrix &operator/=(const TMatrixColumn &diag);

    TImage and TASImage classes
    ===========================

    New set of image processing classes. The TImage class is the abstract
    image base class and TASImage is the concrete implementation using the
    libAfterImage imaging library of Sasha Vasko <sasha@aftercode.net>.

    A large part of the development was done by Reiner Rohlfs from the ISDC
    based on a set of astrophysics user requirements.

    The image class allows for the reading and writing of images in different         //
    formats, several image manipulations (scaling, tiling, merging, etc.)
    and displaying in pads. The size of the image on the screen does not
    depend on the original size of the image but on the size of the pad.
    Therefore it is very easy to resize the image on the screen by resizing
    the pad.

    Besides reading an image from a file an image can be defined by a
    two dimensional array of values (TArrayD or TVectorD). 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 libASImage.so is currently not yet pre-built in the binary
    distributions. To make it get libAfterImage.tar.gz from root.cern.ch
    (ftp://root.cern.ch/root/libAfterImage.tar.gz). Untar it and configure
    it using AACONF.linux (or the AACONF depending on you platform) and
    build it using "make; make install". Next install ROOT from source
    and specify in ./configure the location of libAfterImage.

    For its usage see the new tutorials: rose_image.C, galaxy_image.C,
    img2pad.C, imgconv.C and pad2png.C.

    This package currently only works on X11.

    HBOOK ntuple reader
    ===================

    A new set of classes THbookFile, THbookTree, THbookBranch has been added
    to a new library libHbook.so.This library provides an interface to HBOOK
    files and provides histogram and ntuple reading capability.

    THbookFile  is an interface to the Hbook objects in Hbook files.
    Any Hbook object (1-D, 2-D, Profile, RWN or CWN can be read
    NB: a THbookFile can only be used in READ mode. We have no plans to
    support writing Hbook objects from ROOT.
    Use the utility in $ROOTSYS/bin/h2root to convert Hbook to ROOT.

    With this new version, one can:
      - import automatically any 1-d, 2-d or profile histograms. The Hbook types
        are converted on the fly to ROOT types TH1F, TH2F and TProfile.

      - import ntuple headers (Row or Column-Wise).
        A new data type THbookTree (deriving from TTree) with functions like
        hbookTree.Draw("x","selection") like for a normal TTree. The ntuple data
        are read directly from the Hbook file.

      - The Tree viewer can be used directly: hbookTree.StartViewer();

      - Browse the THbookFile via TBrowser. Clicking on a Hbook ID in a file
        draws the histogram.

      - When in the browser, the context menu item "Convert2root" can be selected
        to convert a THbookFile into a normal TFile (via h2root). The converted file
        is by default connected to the browser.

    Example of use:
       gSystem->Load("libHbook");
       THbookFile f("myfile.hbook");
       f.ls();
       TH1F *h1 = (TH1F*)f.Get(1);  //import histogram ID=1 in h1
       h1->Fit("gaus");
       THbookTree *T = (THbookTree*)f.Get(111); //import ntuple header
       T->Print();  //show the Hbook ntuple variables
       T->Draw("x","y<0"); // as in normal TTree::Draw

    THbookFile can be browsed via TBrowser.

    New options in THistPainter
    ===========================

    Change THistPainter::PaintStat and PaintStat2 to implement the new logic
    with TPaveStats. The "stats" object is now added to the list of functions
    instead of being a member of THistPainter. With this change, it is easy
    to support multiple stats box in the same pad.
    With the option "same", the statistic box is not redrawn.
    With the option "sames", the statistic box is drawn. If it hides
    the previous statistics box, you can change its position
    with these lines (if h is the pointer to the histogram):
       TPaveStats *st = (TPaveStats*)h->GetListOfFunctions()->FindObject("stats")
       st->SetX1NDC(newx1); //new x start position
       st->SetX2NDC(newx2); //new x end position

    It is not necessary anymore to change the name of the stats box if one wants
    to add a new stats box. For example, the following works correctly:
       hpx.draw();
       hprof.Draw("sames"); //move the position of the stats box with the mouse

    Note that the system is backward compatible is a user calls
       TPaveStats *stats = (TPaveStats*)gpad->GetPrimitive("stats")

    Changes with option "P". New option "P0".

    Add a new entry Hoption.HighRes in Hoption_t. By default Hoption.HighRes =0.
    It is non zero when the option "High Resolution 9 is selected in TH1::Draw.
    The option low resolution is automatically selected in TGraph::PaintGrapHist
    when the number of points is greater than the number of bins in the pad.
    However, for some pathological cases (difficult to detect automatically)
    like the example below, it is necessary to force high resolution.
       {
          TH1F* h1=new TH1F("hist","hist",2048,0,2048);
          for (int i=0; i<1024;i++) {
             h1->SetBinContent(i*2,i);
             h1->SetBinContent(i*2+1,5);
          }
          h1->SetMarkerColor(2);
          h1->SetMarkerStyle(21);
          h1->Draw("p9"); //without option 9 result is not good
       }

    Implement new drawing option "LF2". When this option is specified,
    the histogram is paint with a fillarea connecting the center of the bins.

    Add argument Option_t *option to all THistPainter::Paintxxx functions.
    The new argument is used in THistPainter::PaintScatterPlot to control
    the number of dots. A new drawing option "scat=ff", eg "scat=10" means
    draw a scatter plot drawing a number of dots per cell equal to
    the cell content times 10. ff is a floating point. One can scale up/down,
    eg scat=0.1, scat=3.14, scat=1e-5. Default is "scat=1".

    New functions in TF1
    ====================

    Draw derivative of this function

       void TF1::DrawDerivative(Option_t *option)

    An intermediate TGraph object is built and drawn with option.

    The resulting graph will be drawn into the current pad.
    If this function is used via the context menu, it is recommended
    to create a new canvas/pad before invoking this function.

    Draw integral of this function

       void TF1::DrawIntegral(Option_t *option)

    An intermediate TGraph object is built and drawn with option.

    The resulting graph will be drawn into the current pad.
    If this function is used via the context menu, it is recommended
    to create a new canvas/pad before invoking this function.

    Access to these two functions is also available from the TF1
    context menu.

    Add support for zooming on Y axis of TF1.

    TF3 objects can be drawn
    ========================

    Example:
       TF3 *fun3 = new TF3("fun3","sin(x*x+y*y+z*z-36)",-2,2,-2,2,-2,2);
       fun3->Draw();

    New functions in TGraph
    =======================

    Implement two new TGraph constructors taking a TF1 as input:
       TGraph(const TF1 *f, Option_t *option="");
       TGraph(const char *fname, Option_t *option="");

    New function TGraph::PaintFit. This new function is a subset of
    THistPainter::PaintStat(). TGraph::PaintGraph() calls directly PaintFit()
    instead of TVirtualHistPainter::PaintStat().

    Like for histograms, the TPaveStats stats box is now added to the
    graph list of functions.

    Add new functions
       Bool_t   IsEditable() const;
       void     SetEditable(Bool_t editable=kTRUE); // *MENU*

    By default a TGraph can be edited with the mouse. If SetEditable(kFALSE)
    is called, the TGraph cannot be modified interactively.

    Add two optional arguments in TGraph::Fit Axis_t xmin,Axis_t xmax
    (like in TH1::Fit).
    These two arguments can be given to select a fit range.

       Fit range
       ---------
       The fit range can be specified in two ways:
         - specify rxmax > rxmin (default is rxmin=rxmax=0)
         - specify the option "R". In this case, the function will be taken
           instead of the full graph range.

    TGraph::Fit() and GraphFitChisquare(): improvements by Eddy Offermann
    to recompute the errors on parameters in case errors on the points
    are not available (case of TGraph in particular).

    TGraphErrors, TGraphAsymmErrors
    ===============================

    Add support for option "x" (draw TGraph part only) in the Paint functions.

    TAxis
    =====

    Add new options in the TAxis enum:
        kTickPlus    = BIT(9),
        kTickMinus   = BIT(10)

    Add new functions:
        virtual const char  *GetTicks() const;
        virtual void     SetTicks(Option_t *option="+"); // *MENU*
    	//  set ticks orientation
    	//  option = "+"  ticks drawn on the "positive side" (default)
    	//  option = "-"  ticks drawn on the "negative side"
    	//  option = "+-" ticks drawn on both sides

    TH2
    ===

    TH2::ProjectionX() and Y have now a new option "D" to automatically
    draw the resulting projection. This is specially convenient
    when ProjectionX,Y are used via the TH2 context menu.
    Select a drawing option, eg "d bar2" or "d hbar2" in the dialog box.

    THStack
    =======

    Add a new drawing option to THStack::Paint().
    When the option "pads" is specified,the current pad/canvas is subdivided into
    a number of pads equal to the number of histograms and each histogram
    is paint into a separate pad.

    New function Merge() in all the histogram classes
    =================================================

    Add new function
      Int_t Merge(TCollection *list)

    All classes created by TTreePlayer::DrawSelect have now a Merge function.
    This function will be called by the PROOF system currently in development
    to merge the list of objects generated by each slave processor on
    the master server.
    In case of histograms (1,2,3-D, profiles) Merge computes the min/max for
    the x, y or z axis, the new number of bins, if necessary. it add bin contents,
    errors and statistics.
    The function returns the merged number of entries if the merge is
    successfull, -1 otherwise.

    In case of polymarkers (2 or 3-d), Merge adds the list of markers in
    the collection to the current object.

    An example to merge a list of histograms with different binning, but
    having a lowest common denominator bin size is shown below:

       void atest() {
          TH1F *h1 = new TH1F("h1","h1",110,-110,0);
          TH1F *h2 = new TH1F("h2","h2",220,0,110);
          TH1F *h3 = new TH1F("h3","h3",330,-55,55);
          TRandom r;
          for (Int_t i=0;i<10000;i++) {
             h1->Fill(r.Gaus(-55,10));
             h2->Fill(r.Gaus(55,10));
             h3->Fill(r.Gaus(0,10));
          }

          TList *list = new TList;
          list->Add(h1);
          list->Add(h2);
          list->Add(h3);
          TH1F *h = (TH1F*)h1->Clone("h");
          h->Reset();
          h.Merge(list);
          h->Draw();
       }

    TPainter3dAlgorithms replaces TPainter3dAlgorithms
    ===================================

    The TPainter3dAlgorithms class has been renamed TPainter3dAlgorithms and several new
    algorithms added.

    TPad/TCanvas
    ============

    Add a new way of adding several canvases to the same Postscript file:
    if the Postscript file name finishes with "(", the file is not closed
    if the Postscript file name finishes with ")" and the file has been opened
    with "(", the file is closed. Example:
       {
          TCanvas c1("c1");
          h1.Draw();
          c1.Print("c1.ps("); //write canvas and keep the ps file open
          h2.Draw();
          c1.Print("c1.ps"); canvas is added to "c1.ps"
          h3.Draw();
          c1.Print("c1.ps)"); canvas is added to "c1.ps" and ps file is closed
       }

    Note that the following sequence writes the canvas to "c1.ps" and closes
    the ps file.:
        TCanvas c1("c1");
        h1.Draw();
        c1.Print("c1.ps");

    TPolyMarker
    ===========

    Add the following new functions:
       virtual Int_t   GetLastPoint() const { return fLastPoint;}
       virtual Int_t   Merge(TCollection *list);
       virtual Int_t   SetNextPoint(Double_t x, Double_t y); // *MENU*
       virtual Int_t   Size() const {return fLastPoint+1;}

    TPolyLine
    =========

    Add the following new functions:
       virtual Int_t   GetLastPoint() const { return fLastPoint;}
       virtual Int_t   Merge(TCollection *list);
       virtual Int_t   SetNextPoint(Double_t x, Double_t y); // *MENU*
       virtual void    SetPolyLine(Int_t n);
       virtual void    SetPolyLine(Int_t n, Float_t *x, Float_t *y,
    	                           Option_t *option="");
       virtual void    SetPolyLine(Int_t n, Double_t *x, Double_t *y3,
    	                           Option_t *option="");
       virtual Int_t   Size() const {return fLastPoint+1;}

    TPolyLine3D, TPolyMarker3D
    ==========================

    Add new function:
       Int_t Merge(TCollection *list)
       to merge all the TPolyLine3D/TPolyMarker3D in the collection.

    New class TCrown
    ================

    A crown is specified with the position of its center, its inner/outer radius,
    a minimum and maximum angle.
    The attributes of the outline line are given via TAttLine.
    The attributes of the fill area are given via TAttFill.

    See example in new tutorial crown.C

    New class TSVG
    ==============

    New class TSVG implemented by Olivier Couet. TSVG may be used
    like TPostScript to produce an SVG file instead of a postscript file.
    Viewers like Internet Explorer can view directly the SVG files.

    TBrowser
    ========

    New option to group items per 1000's behind a single icon, allowing
    easier browsing of very large collections. Of course the number of items
    per group is user definable.

    TArray classes
    ==============

    New const access operator:
       operator[]() const
    its purpose is the same as the At(Int_t i) does,
    but with it you don't have to care whether the method you
    are using is const or not: on the right hand side of an
    equation always the operator [](Int_t i) can be used for
    datamember-TArray's.

    TMath
    =====

    New fundamental mathematical and physical constants (thanks
    to Tony Colley).

    New functions:
       Double_t TMath::Voigt()
          Convolution of Gaus and Lorentz functions. (thanks to Miha D. Puc)

       Double_t TMath::BreitWigner()
          Calculate a Breit Wigner function with mean and gamma

    Add two new sorting functions:
       void BubbleHigh(Int_t Narr, Double_t *arr1, Int_t *arr2)
       void BubbleLow (Int_t Narr, Double_t *arr1, Int_t *arr2)
    Thanks to Adrian Bevan, Liverpool University

    Add new Bessel functions and the Struve function:
       Double_t BesselJ0(Double_t x);       // Bessel function J0(x) for any real x
       Double_t BesselJ1(Double_t x);       // Bessel function J1(x) for any real x
       Double_t BesselY0(Double_t x);       // Bessel function Y0(x) for positive x
       Double_t BesselY1(Double_t x);       // Bessel function Y1(x) for positive x
       Double_t Struve(Int_t n, Double_t x);// Struve functions of order 0 and 1

    TMinuit
    =======

    Change the default constructor behaviour. TMinuit is now initialized
    by default with 25 parameters.

    New class TFractionFitter
    =========================

    Add new class TFractionFitter from Frank Filthaut.

    Fits MC fractions to data histogram (a la HMCMLL, see R. Barlow and
    C. Beeston, Comp. Phys. Comm. 77 (1993) 219-228, and
    http://www.hep.man.ac.uk/~roger/hfrac.f).

    The virtue of this fit is that it takes into account both data and Monte
    Carlo statistical uncertainties. The way in which this is done is through
    a standard likelihood fit using Poisson statistics; however, the template
    (MC) predictions are also varied within statistics, leading to additional
    contributions to the overall likelihood. This leads to many more fit
    parameters (one per bin per template), but the minimization with respect to
    these additional parameters is done analytically rather than introducing
    them as formal fit parameters.

    New class TFeldmanCousins
    =========================

    Class to calculate the CL upper limit using
    the Feldman-Cousins method as described in PRD V57 #7, p3873-3889.

    The default confidence interval calculated using this method is 90%.
    This is set either by having a default the constructor, or using the
    appropriate fraction when instantiating an object of this class
    (e.g. 0.9).

    The simple extension to a Gaussian resolution function bounded at zero
    has not been addressed as yet -> `time is of the essence' as they write
    on the wall of the maze in that classic game ...

    Author: Adrian Bevan, Liverpool University

    TRandom
    =======

    Add the following new functions:

       void TRandom::RndmArray(Int_t n, Double_t *array)
          Return an array of n random numbers uniformly distributed
          between 0 and 1 not included.

       Double_t TRandom::Uniform(Double_t x1, Double_t x2)
          Returns a uniform deviate on the interval ( x1, x2 ].

       void TRandom::ReadRandom(const char *filename)
          Reads saved random generator status from filename.

       void TRandom::WriteRandom(const char *filename)
          Writes random generator status to filename.

     Note that since TRandom is the base class for all random number classes,
     the new function may be used with TRandom, TRandom2 and TRandom3.

    TTree
    =====

    Automatic file overflow when writing Trees
    ------------------------------------------

    New function TFile *TTree::ChangeFile(TFile *file)
    called by TTree::Fill when file has reached its maximum fgMaxTreeSize.
    Create a new file. If the original file is named "myfile.root",
    subsequent files are named "myfile_1.root", "myfile_2.root", etc.
    We expect to gime more control to the user at this point in
    future versions via the message handler mechanism.

    Returns pointer to new file. Currently, the automatic change of file
    is restricted to the case where the Tree is in the top level directory.
    The file should not contain sub-directories.

    Before switching to a new file, the Tree header is written
    to the current file, then the current file is closed.

    To process the multiple files created by ChangeFile(), one must use
    a TChain.

    The variable fgMaxTreeSize can be set via the static function
    TTree::SetMaxTreeSize(). The default value of fgMaxTreeSize is
    1.9 Gigabytes.

    If the current file contains other objects like TH1 and TTree,
    these objects are automatically moved to the new file.

    IMPORTANT NOTE:
       Be careful when writing the final Tree header to the file!
       Don't do:
          TFile *file = new TFile("myfile.root","recreate");
          TTree *T = new TTree("T","title");
          T->Fill(); //loop
          file->Write();  //the pointer file may not be valid
          file->Close();
       but do the following:
          TFile *file = new TFile("myfile.root","recreate");
          TTree *T = new TTree("T","title");
          T->Fill(); //loop
          file = T->GetCurrentFile(); //to get the pointer to the current file
          file->Write();
          file->Close();

    Add new functions GetWeight() and SetWeight():
       void TTree::SetWeight(Double_t w, Option_t *)
    Set tree weight. The weight is used by TTree::Draw() to automatically
    weight each selected entry in the resulting histogram.
    For example the equivalent of
       T.Draw("x","w")
    is
       T.SetWeight(w);
       T.Draw("x");

    This function is redefined by TChain::SetWeight(). In case of a TChain,
    an option "global" may be specified to set the same weight
    for all Trees in the TChain instead of the default behaviour
    using the weights of each Tree in the chain. (see TChain::SetWeight)

    TChain
    ======

    New functions GetWeight() and SetWeight() redefining the functions
    in TTree:
       void TChain::SetWeight(Double_t w, Option_t *option)
    Set chain weight. The weight is used by TTree::Draw() to automatically
    weight each selected entry in the resulting histogram.
    For example the equivalent of
       chain.Draw("x","w")
    is
       chain.SetWeight(w,"global");
       chain.Draw("x");

    By default the weight used will be the weight
    of each Tree in the TChain. However, one can force the individual
    weights to be ignored by specifying the option "global".
    In this case, the TChain global weight will be used for all Trees.

       Double_t TChain::GetWeight() const
    Return the chain weight. By default, the weight is the weight of
    the current Tree in the TChain. However, if the weight has been
    set in TChain::SetWeight() with the option "global", each Tree
    will use the same weight stored in TChain::fWeight.

    TTreePlayer/TTreeFormula
    ========================

     - Support for 2D graphical Cuts for TClonesArray members.
     - Support for 1D graphical Cuts by using their X minimum and
       maximum as ( Xmin <= Formula <= Xmax ).

     - Support for the following TTreeFormula special functions:

         Entry$   : return the current entry number (== TTree::GetReadEntry())
         Entries$ : return the total number of entries (== TTree::GetEntries())
         Length$  : return the total number of element of this formula for this
    	            entry (==TTreeFormula::GetNdata())
         Iteration$: return the current iteration over this formula for this
    	            entry (i.e. varies from 0 to LENGTH$).

     - Synchronization of the dimensions of all the formulas involved in
       a Draw call.

       For example for (with fMatrix[4][4] and fTracks[fNtrack].fVertex[3])
         T->Draw("fMatrix","fVertex>=2");

       The corrected result is histogram use something like:

         if (fTracks[0].fVertex[0]>=2) fMatrix[0][0];
         if (fTracks[0].fVertex[1]>=2) fMatrix[0][1];
         if (fTracks[0].fVertex[2]>=2) fMatrix[0][2];
         if (fTracks[1].fVertex[0]>=2) fMatrix[1][0];
         if (fTracks[1].fVertex[1]>=2) fMatrix[1][1];
         if (fTracks[1].fVertex[2]>=2) fMatrix[1][2];
         ....

       The old behavior was:

         if (fTracks[0].fVertex[0]>=2) fMatrix[0][0];
         if (fTracks[0].fVertex[1]>=2) fMatrix[0][1];
         if (fTracks[0].fVertex[2]>=2) fMatrix[0][2];
         if (fTracks[1].fVertex[0]>=2) fMatrix[0][3]; // note the extra step here.
         if (fTracks[1].fVertex[1]>=2) fMatrix[1][0];
         if (fTracks[1].fVertex[2]>=2) fMatrix[1][1];
         ....

    TThread
    =======

    Patch from Mathieu de Naurois adding Thread-safety in many ROOT classes.
    A new TVirtualMutex global is defined in TVirtualMutex.h (gCINTmutex).
    The gCINTMutes is used in TMethodCall to protect concurrent access to CINT.
    The R__LOCKGUARD macro is introduced in many classes to check for a mutex.
    The performance penalty introduced by the MUTEX logic
      -is ZERO in the application has no threads
      -about 10% in case of threads

    List of Cleanups
    ================

    In TDirectory::Append(), SetBit(kMustCleanup) for the object.
    This will force RecursiveRemove() to be called when the object
    will be deleted.
    With this change, any TObject may be added to a TDirectory.
    When the object will be deleted, it will be automatically removed
    from any TDirectory referencing it.

    PROOF
    =====

    Many new developments towards a working system by Maarten Ballintijn.
    The PROOF packetizer, which provides the work packets, has been
    implemented. The collection and merging of created objects is
    implemented. Macro caching is implemented (to avoid sending
    unchanged macros from a client to PROOF). Package handling and caching
    is implemented (to distribute additional shared libraries needed for
    the PROOF job to the PROOF cluster).

    New directory MC and library libMC.so
    =====================================

    Add a new package "mc": "The Virtual MonteCarlo".
    Virtual MC provides a virtual interface to Monte Carlo.
    It enables the user to build a virtual Monte Carlo application
    independent of any actual underlying Monte Carlo implementation itself.

    A user will have to implement a class derived from the abstract
    Monte Carlo application class, and provide functions like
    ConstructGeometry(), BeginEvent(), FinishEvent(), ... .
    The concrete Monte Carlo (Geant3, Geant4) is selected at run time -
    when processing a ROOT macro where the concrete Monte Carlo is
    instantiated.

    TDCacheFile
    ===========

    New module dcache implementing class TDCacheFile which implements a TFile
    interface to the DESY dCache mass storage system. Code by Grzegorz Mazur
    <mazur@mail.desy.de>. For more on dCache see http://www-dcache.desy.de/.

    libStar renamed to libTable
    ===========================

    To avoid confusion with pure STAR experiment framework code we renamed
    the STAR contributed library to libTable. It provides a set of classes
    for table management.

    New tutorials
    =============

    crown.C         : illustrating new class TCrown.
    rose_image.C    : showing an image (TASImage) in a ROOT canvas.
    galaxy_image.C  : illustrating the new TASImage class and an image editor.
    hsumanim.C      : illustrating how to make an animated gif file
                      and view it. The animated gif is generated using the
                      gifsicle tool. see comments in the tutorial.
    rootgeom        : example illustrating the new geometry package.
    hadd.C          : tutorial modified by Anne-Sylvie Nicollerat to automatically
                      add Trees (via a chain of trees).
    fitExclude.C    : illustrating how to exclude a range of bins from a fit.
    alien.C         : illustrating the use of the new GRID class TAlien.
    FeldmanCousins.C: illustrating the use of TFeldmanCousins class.
    spy.C, spyserv.C: demo showing how to snoop objects from a server.
                      The client "spy.C" can snoop objects from a server process
                      "spyserv.C". To run this demo do the following:
                       - open two or more windows
                       - start root in all windows
    	           - execute in the first window: .x spyserv.C (or spyserv.C++)
    	           - execute in the other window(s): .x spy.C  (or spy.C++)
    	           - in the "spy" client windows click the "Connect" button
                         and snoop the histograms by clicking on the "hpx",
                         "hpxpy" and "hprof" buttons.
    pythiaExample.C : illustrating the use of Pythia6 with ROOT.
    customContextMenu.C: illustrating how to customize a custom menu.
    customTH1Fmenu.C:    another example with TH1F.
    img2pad.C       : to show how to display an image in a pad/canvas
    imgconv.C       : save an image in various formats: .png, .gif, .xpm and tiff.
    pad2png.C       : create a canvas and save as png.
    langaus.C       : convoluted Landau and Gaussian Fitting example.
    exec3.C         : simple example showing the GUI signal/slots mechanism.
    bill.C          : benchmark comparing write/read to/from keys or trees.
    exec3.C         : show the use of signal/slots to process TCanvas events.