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.
ROOT page - Class index - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.