ROOT Version 5.20/00 Release Notes
ROOT version 5.20/00 has been released June 25, 2008.
In case you are upgrading from version 5.14, please read the releases notes
of version 5.16 and version 5.18 in addition to these notes.
- Bindings - packages related to the interplay with other programming languages (Python, Ruby)
- Cint - the C++ interpreter
- Core - the basic ROOT functionality
- Geometry - building, representing and drawing geometrical objects
- 2D Graphics - ROOT's two dimensional graphics interface
- 3D Graphics - ROOT's three dimensional graphics interface
- Graphical User Interface - from basic GUI elements to ROOT's own, complete dialogs
- Histograming - counting values, spectra, and drawing them
- HTML - the documentation generator
- Input/Ouput - storing and reading data
- Mathemathics - everything one can use to calculate: minimizers, matrixes, FFT, and much more
- Miscellaneous - things that didn't make it into the other groups: table
- Monte Carlo - monte carlo and physics simulation interfaces
- Networking - network-related parts, e.g. protocols and authentication interfaces
- PROOF - parallel ROOT facility
- RooFit - a fitting library
- SQL - database interfaces
- TMVA - multivariate analysis tools
- Trees - ROOT's unique container class and related utilities
Binaries for all supported platforms are available at:
http://root.cern.ch/root/Version520.html
Versions for AFS have also been updated. See the list of supported
platforms:
http://root.cern.ch/Welcome.html
For more information, see:
http://root.cern.ch
The following people have contributed to this new version:
Ilka Antcheva,
Jean-François Bastien,
Bertrand Bellenot,
Rene Brun,
Philippe Canal,
Olivier Couet,
Valeri Fine,
Fabrizio Furano,
Leo Franco,
Gerri Ganis,
Andrei Gheata,
Mihaela Gheata,
David Gonzalez Maline,
Andreas Hoecker,
Jan Iwaszkiewicz,
Lukasz Janyst,
Anna Kreshuk,
Wim Lavrijsen,
Sergei Linev,
Anar Manafov,
Diego Marcos-Segura,
Lorenzo Moneta,
Axel Naumann,
Mathieu de Naurois,
Eddy Offermann,
Valeriy Onuchin,
Timur Pocheptsov,
Fons Rademakers,
Paul Russo,
Alja Tadel,
Matevz Tadel,
Wouter Verkerke,
Guido Volpi,
Hady Zalek
Core
Meta
Cont
-
Support for std algorithms and iterators for ROOT collection classes by Anar.
The background is the following. While working on the PROOF code I found
that enumerating TList is an inconvenient and a long operation, I had to
write the same code all over the place and make duplications. I tried
to use STD algorithms with it, namely std::for_each, and failed.
I therefore decided to enable std::for_each algorithm for ROOT
Containers/Iterators by making as few as possible changes, without rewriting
iterators at all. Now with only two simple lines of code one is able to
iterate through a container:
TIter iter(&list);
for_each(iter.Begin(), TIter::End(), SEnumFunctor());
or
for_each(iter.Begin(), inter_end, SEnumFunctor());
where iter_end could be an iterator to a middle of the container.
After I had changed Iterators so that they could be used with std::for_each,
I decided to go further and did some more changes. As a result,
-
I have updated CINT implementation of some algorithms (they look now
more or less better in terms of the standard),
-
All collections can be now used with std::for_each, std::find_if,
std::count_if (probably with some more algorithms. I've listed here
only what has been *checked* by me).
-
A test program has been added: $ROOTSYS/test/stressIterators.cxx
-
A tutorial macro has been added: $ROOTSYS/tutorials/cont/TListAndSTL.C
I/O
Schema Evolution
- Fix schema evolution problem in TTree::Draw by extending support in
TStreamerInfo::ReadValueAux to 'converted' numerical types, (
see issue in ROOT forum)
- When reading more than one TStreamerInfo for the same versioned
class, we now use the highest possible class version as the current
version of the class. Practically, we update the class version
when reading new (higher versioned) StreamerInfo until the Class
is actually used (i.e. TClass::GetClassVersion is call directly
or indirectly).
In particular, if a file has several StreamerInfos for the same
versioned class, we will use the highest version number as the
'current' class version (as opposed to the lowest until now).
-
For backward compatibility TStreamerInfo::BuildCheck compares the checksum of
the on-file StreamerInfo not only to the current value of the class checksum
but also to the checksum calculated using the older algorithms.
This patch extends this test to also be done when comparing 2 on-file StreamerInfos.
This removes spurrious warning message when loading 2 older files which
were written with 2 different version of the TClass CheckSum algorithm
(and the in-memory class's version is greater than both TStreamerInfos'
class version).
- Extend support of TStreamerInfo::ReadValueAux to 'converted' numerical types, hence solving TTree::Draw's schema evolution problem (see http://root.cern.ch/phpBB2/viewtopic.php?t=6225)
DirectoryAutoAdd
Use the new DirectoryAutoAdd facility for the classes:
TTree, TH1, TEventList, TEntryList, TGraph2D
(and hence their derived classes).
The instances of those classes are now added automatically
to the current directory only when Constructe'd with arguments or Clone'd
and to the directory they are read from when their are stored
directly in a TKey. [Note: the default constructor never adds
the object to the current directory]
The directory auto add can still be disabled for instance
of TH1 and TGraph2D by setting TH1::AddDirectory.
Additionally one can disable the directory auto add for
a specific class by doing:
TClass::GetClass("myclass")->SetDirectoryAutoAdd(0)
However you might want to also be able to restore the
behavior in which case you ought to do:
TClass *cl = TClass::GetClass("myclass");
ROOT::DirAutoAdd_t func = cl->GetDirectoryAutoAdd();
cl->SetDirectoryAutoAdd(0);
TROOT::ReadingObject is marked as deprecated.. It is still
set (as it was) but is no longer used by the above mention
classes.
NOTE: One side effect of this change, is that instance
of TTree, TH1, TEventList, TEntryList, TGraph2D that are
retrieved from a TMessage (i.e. from a socket) no longer
auto register themselves to the current ROOT directory.
Networking
-
TMessage now has schema evolution and TRef (i.e. ProcessID) support. To
enable
schema evolution for all messages call
TMessage::EnableSchemaEvolutionForAll(kTRUE).
To enable it only for a specific message call
mess->EnableSchemaEvolution(kTRUE).
The default for schema evolution is off. The streamer and process id
information are send only once per socket (and is supported for all
types of
sockets, TSocket, TPSocket and TXSocket). If you communicate between
two
ROOT based applications, check the version numbers on both sides. If
they
are not the same enable the schema evolution support (in case ROOT
objects
are transferred).
XROOTD
- New version 20080621-0000 containing several improvements and fixes
- Server:
- New daemon 'cmsd' supposed to replace 'olbd' with improved performances
- Improved polling strategy
- Fix problem with handling writev creating unjustified disconnections
- Fix problem with setrlimit on MacOsX Leopard
- Client:
- Fix a nasty memory leak in XrdClientCacheRead affecting
processing via TChain
- Optimized file closing recipe
- Fix
potential cache thrashing problem with big blocks requests.
- Fixes / improvements in the GSI plug-in:
- support for large (> 32 bits) certificate serial
numbers in CRL handling
- support for an external function for DN-to-username
mapping function; provide example for an LDAP based search
- fixed a few problem with return code checking.
netx
- TXNetFile:
-
Enable dynamic cache size synchronization
- Enable per-instance control of the cache parameters
also for RAW files; by
default cache is OFF for these files, but there maybe cases in which the cache can
improve performances.
- Remove call to XrdClient::Sync in SysStat
-
Correctly honor the create/recreate options coming from TFile::Open()
- Allow the size of the (written) file to be retrieved after the Close (solves several reported file size mismatches).
- TXNetSystem:
- Fix problem with GetDirEntry: the entry object was
going out-of-scope so
that the returned string was meaningless.
- Reset
the list if dir entries in FreeDirectory.
- Fix problem affecting repeated calls.
- The implementation of TFile throughput and info sending was
just sending 'regular' samples about the activity of the single TFile
instance that happened to trigger an activity in the right moment.
- Now TMonaLisaWriter keeps internally track of every
activity
and regularly sends summaries valid for all the files which had
activity in the last time interval.
- Additionally, it's now finalized the infrastructure able to
measure
and keep track of the file Open latency. A packet is sent for each
successful Open, sending the measures of the latencies for the
various phases of the open. Currently exploited fully by TAlienFile
and TXNetFile. Easy to report from other TFiles too.
- Now, the hook for the Close() func triggers sending of a
packet containing various information about the performance related to
that file only.
- Added support also for performance monitoring when writing
RGLITE: A ROOT GRID interface
RGLite plug-in - a ROOT plug-in module, which implements the ROOT Grid
interface and offers to ROOT users possibilities to perform a number of
operations using gLite middleware from within ROOT.
Supported features:
- Workload Management System operations:
- job submission – normal, DAG and parametric
jobs (gLite
WMProxy API),
- smart look-up algorithm for WMP-Endpoints,
- job status querying (gLite LB API),
- job output retrieving (Globus GridFTP).
- File Catalog operations (gLite/LCG LFC API):
- smart session manager,
- set/query the current working catalog directory,
- list files, directories and their stats,
- add/remove files in a catalog namespace,
- add/remove directories,
- add/remove replicas from a given file.
- An executive logging.
- Support of an external XML configuration file with
according XML
schema.
Usage examples:
Job operations
// loading RGLite plug-in
TGrid::Connect("glite");
// submitting Grid job
TGridJob *job = gGrid->Submit("JDLs/simple.jdl");
// getting status object
TGridJobStatus *status = job->GetJobStatus();
// getting status of the job.
TGridJobStatus::EGridJobStatus st( status->GetStatus() );
// when the st is
TGridJobStatus::kDONE you can
retrieve job's output
job->GetOutputSandbox("/tmp");
File Catalog operations
// loading RGLite plug-in
TGrid::Connect("glite");
// changing the current directory to
"/grid/dech"
gGrid->Cd("/grid/dech");
// using Mkdir to create a new
directory
Bool_t b = gGrid->Mkdir("root_test2");
// listing the current directory
TGridResult* result = gGrid->Ls();
// full file information
result->Print("all");
// removing the directory
b = gGrid->Rmdir("root_test2");
Documentation:
http://www-linux.gsi.de/%7Emanafov/D-Grid/docz/RGLite/html/
and
http://www-linux.gsi.de/~manafov/D-Grid/docz/
SQL
the new directory sql includes the following packages:
- mysql : Interface to Mysql
- odbc: Interface to ODBC
- oracle: Interface to Oracle
- pgsql: Interface to Postgress DB
- sapdb: Interface to SAPdb
Tree
Branch creation enhancement and clarifications
- Make the leaflist optional if the address points to a single numerical variable:
Int_t value;
tree->Branch(branchname, &value);
-
Introduce a way to create branch using directly
an object:
MyClass object;
TBranch *branch = tree->Branch(branchname, &object, bufsize, splitlevel)
- Clarify the ownership rules of user objects in a TTree. This clarification (and the improved auto-add-to-directory behavior
of the TH1*) allows for the TTree to now delete the memory that
its has allocated and whose ownsership was _not_ transfer back
to the user (this is happens any time the user give the TTree
the address of a pointer):
For a top-level branch the meaning of addr is as follows:
If addr is zero, then we allocate a branch object
internally and the branch is the owner of the allocated
object, not the caller. However the caller may obtain
a pointer to the branch object with GetObject().
Example:
branch->SetAddress(0);
Event* event = branch->GetObject();
... Do some work.
If addr is not zero, but the pointer addr points at is
zero, then we allocate a branch object and set the passed
pointer to point at the allocated object. The caller
owns the allocated object and is responsible for deleting
it when it is no longer needed.
Example:
Event* event = 0;
branch->SetAddress(&event);
... Do some work.
delete event;
event = 0;
If addr is not zero and the pointer addr points at is
also not zero, then the caller has allocated a branch
object and is asking us to use it. The caller owns it
and must delete it when it is no longer needed.
Example:
Event* event = new Event();
branch->SetAddress(&event);
... Do some work.
delete event;
event = 0;
These rules affect users of TTree::Branch(),
TTree::SetBranchAddress(), and TChain::SetBranchAddress()
as well because those routines call this one.
An example of a tree with branches with objects allocated
and owned by us:
TFile* f1 = new TFile("myfile_original.root");
TTree* t1 = (TTree*) f->Get("MyTree");
TFile* f2 = new TFile("myfile_copy.root", "recreate");
TTree* t2 = t1->Clone(0);
for (Int_t i = 0; i < 10; ++i) {
t1->GetEntry(i);
t2->Fill();
}
t2->Write()
delete f2;
f2 = 0;
delete f1;
f1 = 0;
An example of a branch with an object allocated by us,
but owned by the caller:
TFile* f = new TFile("myfile.root", "recreate");
TTree* t = new TTree("t", "A test tree.")
Event* event = 0;
TBranchElement* br = t->Branch("event.", &event);
for (Int_t i = 0; i < 10; ++i) {
... Fill event with meaningful data in some way.
t->Fill();
}
t->Write();
delete event;
event = 0;
delete f;
f = 0;
Notice that the only difference between this example
and the following example is that the event pointer
is zero when the branch is created.
An example of a branch with an object allocated and
owned by the caller:
TFile* f = new TFile("myfile.root", "recreate");
TTree* t = new TTree("t", "A test tree.")
Event* event = new Event();
TBranchElement* br = t->Branch("event.", &event);
for (Int_t i = 0; i < 10; ++i) {
... Fill event with meaningful data in some way.
t->Fill();
}
t->Write();
delete event;
event = 0;
delete f;
f = 0;
TTreeFormula (TTree::Draw, TTree::Scan)
- Fix CollectionTree->Scan("reco_ee_et[][2]:reco_ee_et[0][2]")
where reco_ee_et is a vector<vector<double> > See http://root.cern.ch/phpBB2/viewtopic.php?t=6536
- Insure that the formula that are used as indices or as argument to special functions have their branch(es) loaded once. This fixes http://root.cern.ch/phpBB2/viewtopic.php?p=27080#27080
- Correct the drawing of "X[1]:X[5]" when X is a vector< vector<float> >
and X[1].size()!=X[5].size(). (reported at http://root.cern.ch/phpBB2/viewtopic.php?p=27070)
- Correct the passing of NaN to function being called by TTree::Draw.
Splitting STL collections of pointers
STL collection of pointers can now be split by calling
TBranch *branch = tree->Branch( branchname, STLcollection, buffsize, splitlevel )
where STLcollection is the address of a pointer to std::vector, std::list,
std::deque, std::set or std::multiset containing pointers to objects.
and where the splitlevel is a value bigger than 100 then the collection
will be written in split mode. Ie. if it contains objects of any
types deriving from TTrack this function will sort the objects
basing on their type and store them in separate branches in split
mode.
The ROOT test example in ROOTSYS/test/bench.cxx shows many examples of collections
and storage in a TTree when using split mode or not. This program illustrates the important
gain in space and time when using this new facility.
Parallel unzipping
Introducing a parallel unzipping algorithm for pre-fetched buffers. Since we already know what buffers are going to be read, we can decompress a few of them in advance in an additional thread and give the impression that the data decompression comes for free (we gain up to 30% in reading intensive jobs).
The size of this unzipping cache is 20% the size of the TTreeCache and can be modified with TTreeCache::SetUnzipBufferSize(Long64_t bufferSize). Theoretically, we only need one buffer in advance but in practice we might fall short if the unzipping cache is too small (synchronization costs).
This experimental feature is disabled by default, to activate it use the static function
TTreeCache::SetParallelUnzip(TTreeCacheUnzip::EParUnzipMode option = TTreeCacheUnzip::kEnable).
The possible values to pass are: - TTreeCacheUnzip::kEnable to enable it
- TTreeCacheUnzip::kDisable to disable it
- TTreeCacheUnzip::kForce to force it.
The TTreeCacheUnzip is actived
only if you have more than one core. To activate it with only one core useTTreeCacheUnzip::kForce option (for example to measure the overhead).
Disk and Memory Space Gain
In ROOT older than v5.20/00, the branches' last basket, also known as the write basket, was always saved in the same "key" as the TTree object and was always present in memory when reading or writing.
When reading this write basket was always present in memory even if the branch was never accessed.
Starting in v5.20/00, TTree::Write closes out, compresses (when requested) and writes to disk in their own file record the write baskets of all the branches.
(This is implemented via the new function TTree::FlushBaskets, TBranch::FlushBaskets, TBranch::FlushOneBaskets)
TTree::AutoSave supports a new option "FlushBaskets" which will call FlushBaskets before saving the TTree object.
Benefits
Flushing the write baskets has several advantages:
- Reduce the file size of the TTree object (it not longer contains the last basket), improving read time of the TTree object
- Reduce memory footprint of the TTree object.
- In a TTree which "flushed" buffer, there is now usually only zero or one buffer in memory.
- Previously each branch always had at least one basket in memory and usually 2 (the write basket and one read basket).
- Now only the basket of the branches actually read are loaded in memory.
- allow for the basket to be compressed and stored separated, increasing the compression factor.
Note: Calling FlushBaskets too often (either directly of via AutoSave("FlushBaskets")) can lead to unnecessary fragmentation of the ROOT file,
since it write the baskets to disk (and a new basket will be started at the next fill) whether or not the content was close to filling the basket or not.
Others
- The fast tree cloning (TTreeCloner) was enhanced to support copying in-memory TTrees (that have been save as a single key on file). This issue was preventing hadd to fast clone files containing any 'in-memory' tree.
- Re-enabled the splitting of TVector3 and of any classes starting by TVector
that is not a TVectorT.
- Fix the list of StreamerInfo stored in the TFile in the case of a slow
CloneTree, previously some of the classes whose named contained '::' and any
of the STL container names was inadvertently omitted (in case of classes
that are part of the TTree but had only a base and no member or in some
cases where it had only object data members.
-
- Prevent storing a 2nd time an object non derived from TObject in the case
where the object is both the top level object of branch and has
some of it sub-object containing a pointer back to the object. (This was
actually activated in v5.18).
-
void TBranch::DeleteBaskets(Option_t* option)
new function which loops on all branch baskets. If the file where branch buffers reside is writable, free the disk space associated to the baskets of the branch, then call Reset(). If the option contains "all", delete also the baskets for the subbranches. The branch is reset.
NOTE that this function must be used with extreme care. Deleting branch baskets
fragments the file and may introduce inefficiencies when adding new entries
in the Tree or later on when reading the Tree.
- Protect TTree::GetCurrentFile in case the current directory is gROOT.
This case may happen when a TChain calls TChain::Process and no files have been
connected to the chain yet, but a TFile has been opened meanwhile.
- Remove the calls to MapObject introduce in revision 21384 when
are unnecessary hence restoring lost performance in case where
the TTree contains many simple type (double, int, etc.)
- In TBranchElement::Streamer when writing, call ForceWriteInfo
not only for the TStreamerInfo directly concerning this branch
but also (in the case of the top level branch of a split TClonesArray
or a split STL container) call ForceWriteInfo for the class of
the value.
This omission meant that slow CloneTree was (fataly) missing in
some cases the copy of the TStreamerInfo for class that are part
part of the TTree but had only a base and no member or in
some cases where it had only object data members.
- Fix the return value of the lookup in TChainIndex
when the value searched for does not exist.
PROOF
- New functionality
- Dataset management
- Interface to TProofMgr::GetSessionLogs() in the dialog
box. The graphics layout of the logbox has been re-designed, with new
buttons to grep the logs and to save them to a file. It is also
possible to choose the range of lines to be displayed and the subset of
nodes.
- Support for connection control base on the UNIX group
(new directive 'xpd.allowedgroups
<grp1>,<grp2>, ...')
- Improvements:
- In the case of mismatch between the expected and actual
number of processed events, send back to the client the list of failed
packets.
- Implement the classic strategy of the TPacketizer in
TPacketizerAdaptive; the strategy can be changed from adaptive
(default) to TPacketizer with: "PROOF_PacketizerStrategy" parameter to
PROOF
- The max workers per node can now be also set in the
xrootd config file with
xpd.putrc
Packetizer.MaxWorkersPerNode: <desired number>
-
Make fCacheDir and fPackageDir controllable via directive
- Fixes
- Two memory leaks in TProofServ affecting repeated runs
withing the same session
-
Fix a problem cleaning-up the input list on the workers
- The type of "PROOF_MaxSlavesPerNode",
"PROOF_ForceLocal" and
"PROOF_PacketAsAFraction" parameters has been changed from
Long_t to Int_t.
- TProofCondor plug-in:
- Adapt the signatures of the main constructors of
TProofCondor and TProofPEAC
(and of the related plug-in handlers) to the one of TProof.
- Add the possibility to trigger the load of a generic
TProof-derived plug-in via
a directive the xrootd config file 'xpd.proofplugin', e.g.
'xpd.proofplugin condor:'
Histogram package
The libHist library now depends on libMathCore which must be linked whenever one needs to use the histogram library.
TF1
-
The code used for implementing numerical methods like TF1::Integration or TF1::Derivation or TF1::GetX has now been now moved in MathCore and used to implement corresponding classes like GaussIntegrator or BrentRootFinder. The implementation remains however the same.
- A new method TF1::operator()(double x, double y=0, double z) which is equivalent to TF1::Eval has been added for using TF1 as a callable object.
- New templated methods TF1::SetFunction for generic C++ callable objects or for class member functions.
TH1
- Fixed a bug in the TH1::KolmogorovTest function in the case of scaled or weighted histograms. The routine has been improved and
now could also be used for comparing an histogram with a function if it is represented as an histogram with zero errors (equivalent to the case of options "F1" or "F2" in the original HDIFF routine of HBOOK). The bug has been fixed also for the TH2 and TH3 corresponding method. In addition in the case of TH3 use now all 6 axis combinations for estimating the maximum deviation. This is consistent with what is done in the 2D case.
- Improved the TH1::Chi2Test for the treatment of empty bins in the histograms. If both histograms have one empty bin, the number of degree of freedom is decreased by one but the test is performed without reporting an error. If only one histogram is having an empty bin it is considered in the comparison.
- Fixed a bug in preserving the global statistic information after scaling, adding or rebinning the histogram.
TH2
-
Improve TH2::FitFitSliceX and TH2::FitFitSliceY by adding the possibility to return the generated histograms in a TObjArray when the passed pointer is not null. Support also variable bin size histograms
- Improve histogram projections. The implementation of TH2::ProjectionX and TH2::ProjectionY has been combined in a single private method.
TH3
-
Fixed a couple of bugs in TH3::Project3DProfile.
TProfile and TProfile2D
-
Add a new option "W" in TProfile::ProjectionX and TProfile::ProjectionXY to be able to return the equivalent weighted filled histogram. Its bin content is equal to the profile bin content multiplied by the bin entries.
- Implement in the TProfile a new option, "G" for the bin error. This option can be used, bin by bin, for the combination of measurements y with known gaussian error dy. In this case the profile must be filled
with a weight = 1./dy**2 and the resulting error from the combination (1./sqrt(Sum(1./dy**2) ) ) will be calculated by the profile.
THnSparse
- Implement THnSparse::Projection and THnSparse::Merge
New Tutorials
- tutorials/hist/sparsehist.C: an example how to use the new multi dim histogram class THnSparse.
- tutorials/hist/drawsparse.C: an example how to visualize a sparse multi dim histogram.
use the new multi dim histogram class THnSparse.
CINT
CINT's directory structure has been re-arranged; the top-most cint directory now contains CINT, Reflex, and Cintex.
CINT's headers can now alternatively be included as #include "cint/header.h", i.e. from the cint/ subdirectory.
This will become the default location in a coming release.
In view of future changes and because we want to further decouple ROOT from CINT we strongly recommend to not include any CINT headers directly.
Instead please use TInterpreter as a virtual interface; it has been updated to satisfy most of ROOT's use cases of CINT.
If you still need to include CINT headers directly because functionality is missing from TInterpreter then please let us know!
CINT, Reflex, and Cintex have been ported to GCC 4.3.
- Core.
Several small fixes, e.g. for the loading of CINT vs. Cintex base dictionaries, and auto-loading of templated classes, CINT's representation of size_t, char* vs. const char* in CINT's C API, function overload resolution involving enums, increase the supported number of loaded shared libraries, remove unused long.dll, don't automatically use /tmp directory for temporary files but rely on CINTTMPDIR, TMP, or TEMP environment variables, fix the FreeBSD port, fix treatment of break in loops.
A change in CINT does not trigger a rebuild all of ROOT's dictionaries anymore; they now depend on cintdictversion.h.
An area of major new development, newly introduced in this version, concerns reduced dictionary sizes.
When calling compiled functions, CINT can use the functions' symbols instead of generating function wrappers.
The symbol-based call significantly reduces the dictionary sizes; up to 50% are possible.
It is implemented in a way that does not affect performance nor memory usage; it even fixes a few long standing issues with CINT's function overload resolution and default parameter resolution.
This is an optional feature disabled by default; see the CINT web pages for how to enable it.
As part of the directory restructuring, CINT's files have been renamed (the "v6_" prefix is removed), its dictionary files are now moved to a new subdirectory of src called "dict", and both CINT5 ( the current default) and CINT7 are available in the main cint/ subdirectory.
The previous CINT stand-alone CVS / SVN repositories are now abandoned; CINT stand-alone can be checked out as svn co http://root.cern.ch/svn/root/trunk/cint. CINT's stand-alone build system is thus now included in ROOT's cint module.
- Reflex.
Several fundamental enhancements are available for Reflex. This is a precursor to the API changes already announced for the near future.
- Allow selection.xml to select or exclude functions and exclude methods based on their prototype using the attributes proto and proto_pattern. Example: <function proto_pattern="(float*"> will select all functions taking a float as first argument.
- Reflex types are now residing in the namespace Reflex; a using namespace ROOT::Reflex; has been added to the namespace Reflex to make the transition more transparent.
- The class Reflex::Reflex has been renamed to Reflex::Instance. Its member Shutdown() is now protected; simply remove all calls: they are not needed anymore.
- Several functions now take modifier masks for certain operations, e.g. Type::IsEquivalentTo()
- From Giovanni Petrucciani: speed up gendict considerably (he reports a factor 60) by implementing a cache for e.g. the normalize functions in the python scripts.
- Fix determination of FinalType()
- PluginService does not catch exceptions thrown by the plugin's function anymore.
- Add missing dll exports / visibility declarations.
- Outline all new / delete operations, so user code does not pick up an incompatible one.
- long long is now supported (and required) as a fundamental type; MSVC <= 7.0 is thus not supported anymore.
- Cintex.
- Classes declared to CINT via Cintex now have an artificial source file set; fixes problem with CINT expecting a valid source file and Cintex not providing any.
- Fix auto-loading of Cintex itself.
- Increase the size of a local table, fixing a problem with long type names.
PyROOT
This release contains two big new features: the ability to use PROOF with
python, and the ability to pickle (python serialize) ROOT objects.
Pickling of ROOT objects is straightforward: just hand them to pickle (or
cPickle) like any other python object.
To use PROOF with python, derive your custom class from TPySelector, override
the methods that you want to specialize, and put it in a file that is shipped
to the worker nodes, e.g.:
from ROOT import TPySelector
class MyPySelector( TPySelector ):
def Begin( self ):
print 'py: beginning'
def SlaveBegin( self, tree ):
print 'py: slave beginning'
def Process( self, entry ):
self.fChain.GetEntry( entry )
print 'py: processing', self.fChain.ipi
return 1
def SlaveTerminate( self ):
print 'py: slave terminating'
def Terminate( self ):
print 'py: terminating'
The file containing the class (e.g. mymodule.py) will be treated as a
python module and should be loadable through PYTHONPATH (typically '.') at
the worker node.
Setup PROOF as normal, and call:
dataset.Process( 'TPySelector', 'mymodule' )
PROOF will instantiate a TPySelector instance, which will in turn pick up
the python class from module 'mymodule' and forward all calls.
There are several improvements in language mappings, as well as cleanup of
the code for python2.2 (Py_ssize_t handling) and MacOS 10.3. Additionally,
there are code cleanups (removing use of CINT internals) that should be
fully transparent to the end-user.
The language mapping improvements are:
- Abstract classes can no longer be instantiated (__init__ will raise an exception)
- Looping over empty STL(-like) containers will yield an immediate StopIteration
- Unknown& is favored over Unknown* in function overloading
- Implemented unary-, unary+ (__neg__ and __pos__)
- Mapped operator bool() to __nonzero__
- Support for templated member functions
- Implemented __setitem__ for unsigned int& and unsigned long& returns
The python presentation of ROOT objects (ObjectProxy) as well as the
meta-class hierarchy have undergone an internal change where individual
ObjectProxy's no longer carry a TClassRef.
Instead, this has moved to the python class level.
Although there is now an extra layer of indirection to retrieve the
class, the code is actually faster due to lower memory usage and lower
memory turnover.
Math Libraries
MathCore
MathCore includes now classes which were previously contained in libCore, like TMath, TComplex and the TRandom classes. Furthermore, some of the algorithms implemented in the TF1 class have been moved to MathCore. This implies that all other ROOT library using one of these classes, such as libHist, have a direct dependency on the Mathcore library.
Linking with libMathCore is therefore required for running any major ROOT application. It has been added to the list of libraries obtained when doing root-config --libs.
N.B.: users building ROOT applications and not using root-config MUST add libMathCore to their list of linking libraries.
Together with the libraries merge, many changes have been applied to both TMath and the other mathcore classes.
TMath
A major clean-up and re-structuring has been done for the functions present in TMath. Some functions have been implemented using the STL algorithms, which have better performances in term of CPU time and a template interface has been also added.
Some of the basic special mathematical functions of TMath, like the error function or the gamma and beta functions use now the Cephes implementation from Stephen L. Moshier, which is used as well by the ROOT::Math functions. This implementation has been found to be more accurate and in some cases more efficient in term of CPU time. More detailed information on the new mathematical functions can be found in this presentation from M. Slawinska at a ROOT team meeting.
- define the functions as template functions instead of having the same re-definition for all the various basic types. This is done for TMath::Mean,TMath::GeomMean, TMath::Median, TMath::KOrdStat
- Use STL to implement the following algorithms:
- TMath::Sort is re-implemented using std::sort.
- TMath::BinarySearch is re-implemented using the STL algorithm std::lower_bound
The STL algorithms have been found for these cases to be perform better in term of CPU time. For some other algorithms like TMath::LocMin, TMath::LocMax or TMath::Permute the original implementation is faster than STL and has been maintained.
- Add a generic iterator interface, similar to the STL algorithm interface, to the following TMath functions:
MinElement, MaxElemen, LocMin, LocMax, Mean, GeomMean, RMS,
BinarySearch. The iterator interface for sort is called
TMath::SortItr to avoid a compilation ambiguity. For example,
for finding the mean of a std::vector<double> v, one simply needs to call TMath::Mean(v.begin(), v.end() ) .
- Various changes have been applied to the mathematical functions to remove duplications in the implementation with the special and statistical functions defined in ROOT::Math. The functions which have been changed and thus they can return a sightly different result than before are:
- TMath::Erf and TMath::Erfc call ROOT::Math::erf and ROOT::math::erfc which are implemented using the Cephes algorithms, which is accurate at the required double precision level.
- TMath::Gamma(z) is implemented with ROOT::Math::tgamma, which again uses Cephes.
- The incomplete gamma function, TMath::Gamma(a,x) it is implemented using ROOT::Math::inc_gamma based on a corresponding Cephes function.
- TMath::Prob (the upper chi2 probability) is implemented also using ROOT::Math::chisquared_cdf_c which uses ROOT::Math::inc_gamma_c based on a corresponding Cephes function. Now the implementation does not suffer anymore from large numerical error present when the result of TMath::Prob was approaching zero.
- TMath::LnGamma(z) is implemented using ROOT::Math::lgamma. This affects also TMath::Beta which is implemented using the log of the gamma function.
- TMath::BetaIncomplete is implemented using ROOT::Math::beta_inc.
- TMath::GammaDist is implemented using ROOT::Math::gamma_pdf.
- TMath::LogNormal is implemented using ROOT::Math::lognormal_pdf.
- TMath::PoissonI: fixed a problem for large values and is implemented using directly TMath::Poisson with integer values.
Fit
Mathcore include now new classes for performing fits and minimization of multi-dimensional functions. The aim of these classes is to extend and improve the fitting functionality provided in ROOT via the TVirtualFitter classes and the fitting methods present in many data analysis object, such as TH1::Fit.
The fit data are decoupled from the fitter class and described by the dedicated fit data classes like the ROOT::Fit::BinData for bin data containing coordinate values of any dimensions, bin content values and optionally errors in coordinate and bin content, and ROOT::Fit::UnBinData classes for any dimension un-bin data.
The fitter class, ROOT::Fit::Fitter, provides the functionality for fitting those data with any model function implementing the parametric function interface, ROOT::Math::IParamMultiFunction. Fit methods such as least square, bin and un-bin likelihood are supported. The fit solution is then found by using the ROOT::Math::Minimizer interface class and the results are stored in the ROOT::Fit::FitResult class. Fit parameter can be configured individually using the ROOT::Fit::FitParameterSettings class.
Various implementation of the minimizer interface can be used automatically using the ROOT plug-in manager mechanism, including the linear fitter for a fast and direct solution, in case of a linear least square model, or by using Minuit, Minuit2 or GSL minimization methods provided by the MathMore library.
Functions for filling the new ROOT::Fit::BinData classes with all the histogram and graph types have been added in the histogram library (libHist) and graph library:
- ROOT::Fit::FillData( BinData & , const TH1 *, TF1 * ) for histograms (in libHist)
- ROOT::Fit::FillData( BinData & , const TGraph2D *, TF1 * ) for 2D graphs (in libHist)
- ROOT::Fit::FillData( BinData & , const TGraph *, TF1 * ) for all 1D graphs (in libGraf)
- ROOT::Fit::FillData( BinData & , const TMultiGraph *, TF1 * ) for multi-graphs (in libGraf)
MathCore Numerical Algorithms
Classes implementing numerical methods which can be used by all the other ROOT library have been added in MathCore. These originate mainly from methods present previously in the implementation of the TF1 class. Now they can be used also outside this class. In addition, in order to have a common entry point, interfaces classes for these numerical algorithms have been
included.
These interfaces are as well implemented by classes using the GSL library and located in the MathMore library. The library can be loaded automatically using the ROOT plug-in manager.
In detail, the new classes containing implementations present previously in TF1 are:
- GaussIntegrator and GaussLegendreIntegrator for numerical integration of one-dimensional functions. The first class uses Gaussian 8 and 16 point quadrature approximation, it provides the translation of the CERNLIB algorithm
DGAUSS by Sigfried Kolbig, and it is used by the TF1::Integral method. The second one uses the Gauss Legendre quadrature formula. It is used by the TF1::IntegralFast method.
These classes implement both the same virtual interface as the adaptive integration methods provided by the MathMore library. They can all be created and used easily via the common class ROOT::Math::IntegratorOneDim providing the interfaces for numerical integration.
New template methods have been also included in the common Integration class in order to be able to integrate automatically any C++ callable object.
- ROOT::Math::RichardsonDerivator implementing numerical derivation using the Richardson's extrapolation formula (use 2 derivative estimates to compute a third, more accurate estimation). This is used by the TD1::Derivative method.
- BrentRootFinder for finding the root of one-dimensional function using the Brent algorithm. The class inherits from a virtual interface, which is also implemented by the MathMore root finder methods. The user can instantiate, via the common ROOT::Math::RootFinder class, all the various root finder algorithms. The BrentRootFinder class is used by TF1::GetX .
- A similar class, BrentMinimizer1D, provides the possibility to find the minimum of one-dimensional functions using the Brent algorithm. This class is used by TF1::GetMinimum or TF1::GetMaximum
Use ROOT convention for all enumeration names defining the type of numerical algorithms (start with k, like kADAPTIVE for the integration type). This affects both MathCore and MathMore.
In addition we use now the ROOT convention for all enumeration names defining the type of numerical algorithms. The names start with k, like kADAPTIVE for the integration type. This change affects both MathCore and MathMore and it breaks backward compatibility.
MathCore Function interfaces
Mathcore provides as well interfaces for the evaluation of mathematical and parametric functions to be used in the the numerical methods. This release contains the following changes:
- The ROOT::Math::IParamFunction, ROOT::Math::IParamMultiFunction interfaces (used mainly for fitting) require now a pointer to the parameters (type const double *), when evaluating the function. The derived classes must implement now the const
method DoEvalPar (and not DoEval as before). In addition the method
operator()(const double * x, const double * p) is now const. This change makes the caching of parameter not hidden and the interface is now
thread-safe.
- A similar change in the ROOT::Math::IParamGradFunction, ROOT::Math::IParamMultiGradFunction interfaces, where the parameter values are now required for calculating the partial derivatives with respect to the parameters.
This changes the signature of the pure abstract method, DoParameterDerivative(const double *x, const double * p, , which takes also a pointer (type const double *) to the parameters.
In addition, these classes do not inherit anymore from the function gradient interface (ROOT::Math::IGradFunction and ROOT::Math::IMultiGradFunction). They define only the parameter gradient which is needed for fitting and not the coordinate gradient. A derived class, like ROOT::Math::Polynomial, implementing both functionality (coordinate and parameter gradient) inherits then from both interfaces.
-
More detailed description of the current MathCore release can be found at this location.
MathMore
This new release contains:
- Modify and rename the class ROOT::Math::RootFinder to ROOT::Math::GSLRootFinder to distinguish from the main interface class which has been put in the Mathcore library and it can create the GSLRootFinder using the plug-in manager. Furthermore, the class ROOT::Math::GSLRootFinder is not anymore a template class on the algorithm. They type of root-finder algorithm can now be selected via an enumeration
- Fixed a bug in the ROOT::Math::GSLNLSMutiFi class.
- Changes also in the class for the new enumeration names (all names start with k, like kADAPTIVE for the integration types).
More detailed description of the current MathMore release can be found at this location.
GenVector
The new physics vector classes have been moved out from the MathCore library in a new library, libGenVector. The library contains as well the CINT dictionary including main instantiations for the template classes. For this release the instantiation of some extra methods, in particular of the class ROOT::Math::TRansform3D have been added in the dictionary library.
Due to a CINT limitation, the dictionary for explicit template constructors of the Rotation classes, taking as input any other type
of rotation are missing. Therefore code like the following one will now work in CINT (or Python):
ROOT::Math::Rotation3D r;
ROOT::Math::EulerAngles eulerRot(r);
A possible solution is to use the operator=:
ROOT::Math::EulerAngles eulerRot; eulerRot = r;
In addition the setter methods for the 2D,3D and 4D vector classes have been extended following a suggestion by G. Raven. Functions like SetX instead of returning a void return now a reference to the vector class itself (*this).
Detailed description of the current GenVector release can be found at this location.
SMatrix
Fix a bug discovered by Harals Soleng in the addition of two matrix expressions. Remove also some compilation warning found on Windows when compiling matrices instantiated using float types.
Detailed description of the current SMatrix release can be found at this location.
Minuit
Two new classes have been added:
- TMinuitMinimizer: implementation of the ROOT::Math::Minimizer interface with TMinuit. This class is used for example by the new Fitter class.
- TLinearMinimizer: implementation of the ROOT::Math::Minimizer interface with the TLinearFitter.
In addition, the method TLinearFitter::SetBasisFunction(TObjArray * f) has been added to set directly the linear terms of the fit function.
Minuit2
Various fixes have been applied to different problems discovered mainly by a test program from Alfio Lazzaro. In detail:
-
Fix a bug in MnMinos which was setting wrong initial values when the parameters were limited.
This was resulting in a much larger number of function calls used inside MnMinos.
- Improve MnHesse by returning in the final state the improved gradient step values used in HessianGradientCalculator. With this change same results are obtained from using Hesse in Minuit2 or TMinuit. In addition, the interface of MnHesse (MnHesse::operator() ) has been improved to use it from the FunctionMinimum object (similar to MnMinos) in order to be called after the minimization (Migrad). The API with a MnUserParameterState should not be used after minimization, because in that case the latest state information resulting from the minimum (gradient values and step sizes) is lost.
- Add support in MnMigrad and MnMinimize for user provided analytical gradient of the FCN function. One needs to pass an instance of a function implementing the ROOT::Minuit2::FcnGradientBase interface.
- Use now std::string for storing parameter names. This removes the un-necessary limitation on the length of parameter name (10 characters) existing before. The method Name() of MinuitParameter (and of MnUserParameterState and MnUserParameters) still returns a const char * (for backward compatibility). A new method, GetName() has been added to return a std::string
-
The Minuit2Minimizer class has been improved by having an option to always run Hesse if it was not done before during the minimization. Method to retrieve the correlation coefficients have been also added.
More detailed description of the current Minuit2 release can be found at this location.
Unuran
A new version, 1.2.4, has been added to fix mainly some problems found in gcc 4.3. For the detailed changes of this new UNU.RAN version see the file $ROOTSYS/math/unuran/src/unuran-1.2.4-root/NEWS.
Last modified: Tue Jun 24 17:22:42 CEST 2008
RooFit
New tutorial macros available
A set of seventeen new tutorial macros has been added to $ROOTSYS/tutorials/roofit
- rf01_basics.C - Basic fitting, plotting and event generation
- rf02_composite.C - How to construct composite p.d.fs (sig plus bkg etc)
- rf03_multidim.C - How to construct multi-dimensional p.d.f.s
- rf04_composition.C - Using composition techniques to adjust p.d.f building blocks
- rf05_conditional.C - Construction of productions with conditional p.d.f.s
- rf06_convolution.C - Convolution of p.d.fs f(x) (X) g(x)
- rf07_bphysics.C - B physics p.d.f.s with analytical convolution
- rf08_intminuit.C - Interactive MINUIT demonstration
- rf09_constraints.C - How to specify and use parameter constraints in fits
- rf10_ranges.C - Working with sub ranges in observables in fitting and plotting
- rf11_plotbinning.C - Variable and other non-uniform binnign specifications
- rf12_mcstudy.C - Managing toy Monte Carlo studie
- rf13_wspacewrite.C - Creating and persisting workspaces
- rf14_wspaceread.C - Reading and using workspaces
- rf15_simwstool.C - Automated tools for building of simulateneous p.d.f.s
- rf16_normandint.C - Normalization, integration and cumulative distribution functions (1d)
- rf16_normandint2d.C - Normalization, integration and cumulative distribution functions (1d)
Update of class documentation
The documentation in the code itself that is extracted by THtml to construct
the online class documentation has been updated for all classes. Now all classes
have (again) a short class description, as well as a (short) description of each member function
and most data members. An update to the users manual is foreseen shortly after the 5.20
release.
RooWorkspace
A new feature has been added that allows to persist source code of RooFit classes that
are not in ROOT distribution inside a RooWorkspace to facilitate sharing
of custom code with others. To import code of custom classes call
RooWorkspace::importClassCode()
after importing the objects themselves into the workspace. For all classes
that are compiled with ACliC RooWorkspace can automatically find the source
code using the ROOT TClass interface. For custom classes that are compiled
externally and loaded into ROOT as shared library it might be necessary to
provide the location of the source files manually using the static RooWorkspace
member functions addClassDeclImportDir() and addClassImplImportDir().
When a TFile with a RooWorkspace containing source code is opened in a ROOT
session that does not have the class code already loaded for the classes
contained in the workspace, the code in the workspace is written to file,
compiled and loaded into the ROOT session on the fly.
The code repository of RooWorkspace is designed to handle classes that
have either their own implementation and header file, or are part of a group
of classes that share a common header and implementation file. More complicated
structuring of source code into files is not supported.
Also new accessors have been added for discrete-valued functions catfunc()
and stored category functions are now also printed under their own heading in Print()
Parameterized ranges
It is now possible to use RooAbsReal derived functions as range definition for variables
to construct ranges that vary as function of another variable. For example
RooRealVar x("x","x",-10,10) ; // variable with fixed range [-10,10]
RooRealVar y("y","y",0,20) ; // variable with fixed range [-10,10]
RooFormulaVar x_lo("x_lo","y-20",y) ;
RooFormulaVar x_hi("x_hi","sin(y)*5",y) ;
x.setRange(x_lo,x_hi) ; // Change x to have variable range depending on y
It is also possible to define parameterized named ranges in the same way
x.setRange("signalRegion",x_lo,x_hi) ;
There are no fundamental limits to the complexity of the parameterized ranges
that can be defined as long as the problem is uniquely defined. For example, given three observables
x, y and z, one can define a parameterized named range 'R' of x in terms of y and of y in terms of z
and ask to calculate the three dimensional integral of any function or p.d.f in terms of (x,y,z)
over that range 'R' and it will be calculated correctly, taking recursive range dependencies into
account. A definition of a range 'R' on the other hand where the bounds of x depend on y and
the bounds of y depend on x is not allowed, and an error message will be printed to complain about
the ambiguity of the problem definition. Integrals over non-rectangular regions are created the
same way as integrals over rectangular regions using the RooAbsReal::createIntegral() function, the
chosen mode of operation depends on the shape of the requestion integration range.
Note that in general integration over non (hyper)rectangular regions will be more computationally
intensive as only a subset of the observables can be integrated analytically (all of those that do not
have parameterized ranges plus those that have parameterized ranges but are not involved in the
parameterization of others (e.g. x and y in the example above)
Running integrals and Cumulative distribution functions
It is now possible to create running integrals from any RooAbsReal function and
to create cumulative distribution functions from any RooAbsPdf using the following
methods:
// Create int[xlo,x] f(x') dx' from f(x)
RooAbsReal* runInt = func.createRunningIntegral(x) ;
// Create int[xlo,x] f(x') dx' from p.d.f f(x) normalized over x
RooAbsReal* cdf = pdf.createCdf(x) ;
// Create int[xlo,x] f(x',y) dx' from p.d.f f(x,y) normalized over (x,y)
RooAbsReal* cdf = pdf.createCdf(x,y) ;
As with the similarly styled function createIntegral running integrals and c.d.f. can be created
over any number of observables, e.g createCdf(RooArgSet(x,y,z)) will create a three-dimensional
cumulative distribution function. C.d.f and running integrals that are calculated from p.d.fs that have
support for analytical integration are constructed from an appropriately reconnected RooRealIntegral.
If numeric integration is required, the c.d.f or running integral is calculated by a dedicated class
RooRunningIntegral that precalculates results for all observable values, which is more efficient
in most use cases. Cumulative distributions functions that are calculated numerically are handled slightly differently
that standard running integrals: their values is constructed to converge to exactly zero at the lower bound
and exactly 1 at the upper bound so that algorithms that make use of that property of c.d.f can do so reliably.
Constraints management
New tools have been added to simplify studies with fits involving (external) constraints on parameters.
The general philosophy is that constraints on parameters can be represented as probability density functions
and can thus be modeled by RooAbsPdf classes (e.g. a RooGaussian for a simple Gaussian constraint on a parameter).
There are two modes of operation: you can add parameter constraints to your problem definition by multiplying
the constraint p.d.f.s with your 'master' p.d.f. or you specify them externally in each operation. The
first mode of operation keeps all information in your master p.d.f and may make the logistics of non-trivial
fitting problems easier. It works as follows: first you define your regular p.d.f, then you define your
constraint p.d.f and you multiply them with RooProdPdf.
// Construct constraint
RooGaussian fconstraint("fconstraint","fconstraint",f,RooConst(0.8),RooConst(0.1)) ;
// Multiply constraint with p.d.f
RooProdPdf pdfc("pdfc","p.d.f with constraint",RooArgSet(p.d.f,fconstraint)) ;
If your top level p.d.f is already a RooProdPdf it also fine to multiply all terms together in one go.
Constraints do not need to be specified a the top-level RooProdPdf, constraint p.d.f.s in any component
RooProdPdf lower in the expression tree are used as well. Constraints are not used by default in fitting
if present in a p.d.f. To activate the use of a constraint in fitting, use the Constrain() argument in fitTo()
// Fit with internal constraint
RooFitResult* r2 = pdfc.fitTo(*d,Constrain(f)) ;
This will instruct RooAbsPdf::fitTo() to included any constraint p.d.f on parameter f in the
definition of the likelihood. It is possible to add multiple constraints on the same parameter
to the 'master' p.d.f. If so, all constraints on a given parameter will be added to the likelihood.
The RooMCStudy class has been extended to accept the Constrain() argument as well in its constructor.
If specified it will do two things: 1) it will pass the constrain argument to the fitting pass of
the toy study and 2) it will modify the generation step into a two-step procedure: for each toy
in the study it will first sample a value of each constrained parameter from the joint constraints
p.d.f and it will then generate the observables for that experiment with the thus obtained parameter values.
In this mode of operation the parameter values for each toy may thus be different. The actual parameter
for each toy can be obtained with the newly added RooMCStudy::genParDataSet() member function. The calculation
of the pull values for each parameter has been modified accordingly.
Alternatively, it is possible to specify constraints to both RooAbsPdf::fitTo() and the RooMCStudy constructor
using the ExternalConstraint() named argument to supply constraint p.d.f.s that are not part of the 'master'
p.d.f but rather an ad-hoc supplied external constraint. The argument supplied to ExternalConstraint() should
be (a set of) constraint p.d.f(s), rather than (a set of) parameters for which internal constraint p.d.f.s should
be picked up.
New operator class RooLinearMorph
A new numeric operator class RooLinearMorph has been added that provides a continuous
transformation between two p.d.f.s shapes in terms of a linear parameter alpha. The algorithm
for histograms is described in the paper by Alex Read in NUM A 425 (1999) 357-369
'Linear interpolation of histograms'. The implementation in RooLinearMorph is for
continuous functions.
// Observable and sampling binning to be used by RooLinearMorph ("cache")
RooRealVar x("x","x",-20,20) ;
x.setBins(1000,"cache") ;
// End point shapes : a gaussian on one end, a polynomial on the other
RooGaussian f1("f1","f1",x,RooConst(-10),RooConst(2)) ;
RooPolynomial f2("f2","f2",x,RooArgSet(RooConst(-0.03),RooConst(-0.001))) ;
// Interpolation parameter: rlm=f1 at alpha=0, rlm=f2 at alpha=1
RooRealVar alpha("alpha","alpha",0,1.0) ;
RooLinearMorph rlm("rlm","rlm",g1,g2,x,alpha) ;
// Plot halfway shape
alpha=0.5
RooPlot* frame = x.frame() ;
rlm.plotOn(frame) ;
In short the algorithm works as follows: for both f1(x) and f2(x), the cumulative distribution
functions F1(x) and F2(x) are calculated. One finds takes a value 'y' of both c.d.fs and
determines the corresponding x values x1,x2 at which F1(x1)=F2(x2)=y. The value of the interpolated
p.d.f fbar(x) is then calculated as fbar(alpha*x1+(1-alpha)*x2) = f1(x1)*f2(x2) / ( alpha*f2(x2) +
(1-alpha)*f1(x1) ). Given that it is not easily possible to calculate the value of RooLinearMorph
at a given value of x, the value for all values of x are calculated in one by (through a scan over y)
and stored in a cache. NB: The range of the interpolation paramater does not need to be [0,1], it can
be anything.
New workspace tool RooSimWSTool
A new tool to clone and customize p.d.f.s into a RooSimultaneous p.d.f has been added. This new
tool succeeds the original RooSimPdfBuilder tool which had a similar functionality but
has a much cleaner interface, partly thanks to its use of the RooWorkspace class for both input
of prototype p.d.fs and output of built p.d.f.s
The simplest use case to to take a workspace p.d.f as prototype and 'split' a parameter of that p.d.f
into two specialized parameters depending on a category in the dataset.
For example, given a Gaussian p.d.f G(x,m,s) we want to construct a G_a(x,m_a,s) and a G_b(x,m_b,s)
with different mean parameters to be fit to a dataset with observables
(x,c) where c is a category with states 'a' and 'b'.
Using RooSimWSTool one can create a simultaneous p.d.f from G_a and G_b
from G with the following command
RooSimWSTool wst(wspace) ;
wst.build("G_sim","G",SplitParam("m","c")) ;
From this simple example one can go to builds of arbitrary complexity
by specifying multiple SplitParam arguments on multiple parameters
involving multiple splitting categories. Splits can also be performed
in the product multiple categories, e.g.
SplitParam("m","c,d")) ;
splits parameter m in the product of states of c and d. Another possibility
is the 'constrained' split which clones the parameter for all but one state
and insert a formula specialization in a chosen state that evaluates
to 1 - sum_i(a_i) where a_i are all other specializations. For example,
given a category c with state "A","B","C","D" the specification
SplitParamConstrained("m","c","D")
will result in parameters m_A,m_B,m_C and a formula expression m_D
that evaluates to (1-(m_A+m_B+m_C)). Constrained split can also be
specified in product of categories. In that case the name of the
remainder state follows the syntax {State1;State2} where State1
and State2 are the state names of the two spitting categories. Additional
functionality exists to work with multiple prototype p.d.f.s simultaneously.
Improved infrastructure for caching p.d.f and functions
The infrastructure that exists for caching p.d.f.s, i.e. p.d.f that precalculate their value
for all observable values at one and cache those in a histogram that is returned as p.d.f shape
(with optional interpolation), has been expanded. This infrastructure comprises RooAbsCached
the base class for all caching p.d.fs, RooAbsSelfCachedPdf a base class for end-user
caching p.d.f implementations that simply cache the result of evaluate() and RooCachedPdf
that can wrap and cache any input p.d.f specified in its constructor.
By default a p.d.f is sampled and cached in all observables in any
given use context, with no need to specify what those are in advance.
The internal code has also been changed such that all cache
histograms now store pre-normalized p.d.f, which is more efficient
than 'raw' p.d.f histograms that are explicitly post-normalized
through integration. Multiple different use cases (e.g. definitions
of what are observables vs parameters) can be cached
simultaneously. Now it is also possible to specify that p.d.f.s
should be sampled and cached in one or more parameter dimensionsal
in addition to the automatically determined set of observables.
as well.
Also a complete new line of classes with similar functionality has been added inheriting from RooAbsReal.
These are RooAbsCachedReal,RooAbsSelfCachedReal and RooCachedReal. A newly
added class RooHistFunc presents these shapes and is capable of handling negative entries.
New PDF error handling structure
New infrastructure has been put into place to propagate and process p.d.f evaluation errors during fitting.
Previously evaluation errors were marked with a zero p.d.f value and propagated as a special condition
in RooAddPdf, RooProdPdf etc to result in a zero top-level p.d.f value that was caught by the RooFit minuit
interface as a special condition. Summary information on the value of the parameters and the observables
was printed for the first 10 occurrences of such conditions.
Now, each p.d.f component that generates an error
in its evaluation logs the error into a separate facility during fitting and the the RooFit minuit interface
polls this error logging facility for problems. This allows much more detailed and accurate warning messages
during the minimization phase. The level of verbosity of this new error facility can be controlled with
a new
PrintEvalErrors(Int_t code)
argument to fitTo().
- With code of -1, no errors are printed at all.
- With a
code of zero, one line is printed for each p.d.f component with problems summarizing the number of times
problems occured during the likelihood evaluation.
[#0] WARNING:Minization -- RooFitGlue: Minimized function has error status.
Returning maximum FCN so far (-1e+30) to force MIGRAD to back out of this region. Error log follows
Parameter values: m=-7.397
RooGaussian::gx[ x=x mean=m sigma=sx ] has 3 errors
- A code greater than zero will generate even more detail and
print the details of each evaluation error as provided by the p.d.f (zero value, not-a-number, normalization zero etc..)
and show the observable values at which this error occurred. At most N detailed messages per p.d.f component
are shown where N is the integral value of the 'code' argument.
[#0] WARNING:Minization -- RooFitGlue: Minimized function has error status.
Returning maximum FCN so far (-1e+30) to force MIGRAD to back out of this region. Error log follows
Parameter values: m=-7.397
RooGaussian::gx[ x=x mean=m sigma=sx ]
getLogVal() top-level p.d.f evaluates to zero or negative number @ x=x=9.09989, mean=m=-7.39713, sigma=sx=0.1
getLogVal() top-level p.d.f evaluates to zero or negative number @ x=x=6.04652, mean=m=-7.39713, sigma=sx=0.1
getLogVal() top-level p.d.f evaluates to zero or negative number @ x=x=2.48563, mean=m=-7.39713, sigma=sx=0.1
The new-style error logging is active whenever MINUIT is operating on such a p.d.f. The default value for N is 3.
Outside the MINUIT context the evaluation error each evualuation error will generate a separate message through
RooMsgService
Other new features
- The RooAddPdf constructor has been augmented with an additional boolean argument that allows to
interpret the supplied fraction parameters as recursive fractions rather than plain fractions.
If activated, an example RooAddPdf with three input p.d.f. A,B,C and two fractions fA and fB will
result in the expression
fA*A + (1-fA)(fB*B + 1-fB*C) rather than fA*A + fB*B + (1-fA-fB)*C
Recursive fraction have the advantage that all fraction can be defined to be in the range [0-1]
without resulting in configuration where the sum of all fractions exceeds 1.
- The low-level object printing interface printToStream() has been deprecated in favor of a new
printStream() method which allows much greater control over the information printed.
The printing of almost all RooFit objects has been reworked to present a more uniform look and feel.
The standard one-line result of the high-level Print() method without option now looks like
// Variable
x.Print() ;
RooRealVar::x = 0 L(-10 - 10)
// Function or p.d.f
gx.Print() ;
RooGaussian::gx[ x=x mean=m sigma=sx ] = 1
// Dataset
d.Print() ;
RooDataSet::gData[x,y] = 1000 entries
// RooPlot
frame.Print() ;
framex[x] = (RooHist::h_gData,RooCurve::g_Int[y]_Norm[x,y]_Comp[g])
Inside class RooPlot the default name of contained curves and histograms has been
reworked in something more self descriptive as is shown in the above example. A usual,
a user supplied name can always be set by supplying the Name(const char*) argument
to plotOn()
Verbose printing with "v" options is mostly unchanged except for RooPlot. In addition
printing with the "s" option will show the 'old' standard printing mode, option "t" will show
tree structure printing (only for RooAbsArg), and option "1" will invoke inline printing, i.e
a one-line description without a trailing endl.
- Data weighted projections of p.d.fs using the ProjWData() argument in RooAbsPdf::plotOn() are now calculated
with a new classes that derives from RooAbsOptTestStatistic and can thus implement the same evaluation
optimizations as are done for RooNLLVar and RooChi2Var. Specifically it is now possible to calculate projections
involving ProjWData() in parallel on multi-core hosts by adding the NumCPU(Int_t) argument to plotOn().
- A new utility function has been added to allow cloning of entire tree expressions of
RooAbsArg objects, such as a composite p.d.f including component p.d.fs and
all its variables:
RooAbsArg* clonedTree = pdf.cloneTree() ;
All cloned leaf and branch nodes are owned by the returned head node of the expression.
- Assorted minor fixes
TMVA
-
Dataset preparation:
-
Preselection: Preselection cuts now work on
arrays. Previously used TEventlists (only event wise
pass/fail) were replaced by TreeFormulas (sensitive to array
position). Thanks to Arnaud Robert (LPNHE) for his
contributions.
-
Tree assignment to signal/background: Signal and
background trees can now be assigned individually to training
and test purposes. This is achieved by setting the third
parameter of the Factory::AddSignalTree/AddBackgroundTree()
methods to "Train" or "Test" (const string). The only
restriction is that either none or all signal (background)
trees need to be specified with that option. It is possible to
mix the two modes, for instance one can assign individual
training and test trees for signal, but not for background.
-
Direct tree building: For increased flexibility,
users can also directly input signal and background,
training and test events to TMVA, instead of letting TMVA
interpret user-given trees. Note that either one of the
two approaches must be chosen (no mix). The syntax of the
new calls is described in the macros/TMVAnalysis.C test
macro. --> The User runs the event loop, copies for each
event the input variables into a std:vector, and "adds"
them to TMVA, using the dedicated calls:
factory->AddSignalTrainingEvent( vars, signalWeight );
(and replacing "Signal" by "Background", and "Training" by
"Test"). After the event loop, everything continues as in
the standard method.
-
Methods:
-
Simulated Annealing in Cuts,FDA: Entirely new
Simulated Annealing (SA) algorithm for global minimisation
in presence of local minima (optionally used in cut
optimisation (MethodCuts) and the Function Discriminant
(MethodFDA)). The SA algorithm features two approaches,
one starting at minimal temperature (ie, from within a
local minimum), slowly increasing, and another one
starting at high temperature, slowly decreasing into a
minimum. Code developed and written by Kamil Bartlomiej
Kraszewski, Maciej Kruk and Krzysztof Danielowski from IFJ
and AGH/UJ, Krakow, Poland.
-
Cuts: Added printouts, quoting the explicit cut
application for given signal efficiency. In case of
transformations of the input variables, the full expressions
are given. Added warning to Fisher in case of variable
normalisation.
-
Cuts: Added physical limits to min/max cuts if
smart option is used.
-
BDT: removed hard-coded weight file name; now,
paths and names of weight files are written as TObjStrings
into ROOT target file, and retrieved for plotting;
available weight files (corresponding to target used) can
be chosen from pop-up GUI.
-
BDT: Changes in handling negative weights in BDT
algorithm. Events with negative weights now get their
weight reduced (*= 1/boostweight) rather than increased
(*= boostweight) as the other events do. Otherwise these
events tend to receive increasingly stronger boosts,
because their effects on the separation gain are as if
background events were selected as signal and vice versa
(hence the events tend to be "wanted" in signal nodes, but
are boosted as if they were misclassified). In addition,
the separation indices are protected against negative S or
S+B returning 0.5 (no separation at all) in case that
occurs.
-
BDT: In addition there is a new BDT option to
ignore events with negative event weights for the
training. This option could be used as a cross check of a
"worst case" solution for Monte Carlo samples with
negative weights. Note that the results of the testing
phase still include these events and are hence objective.
-
BDT: Added randomised trees: similar to the
"Random Forests" technique of Leo Breiman and Adele
Cutler, it uses the "bagging" algorithm and bases the
determination of the best node-split during the training
on a random subset of variables only, which is
individually chosen for each split.
-
BDT: Move to TRandom2 for the "bagging" algorithm
and throw random weights according to Poisson
statistics. (This way the random weights are closer to a
resampling with replacement algorithm.)
-
TMlpANN: Extended options to
TMultilayerPerceptron learning methods. Added example for
reader application: TMVApplication.py
-
GUI:
-
Parallel Coordinates: New GUI button for Parallel
Coordinate plotting.
-
Application:
-
Added Python example for reader application: TMVApplication.py
-
Bug fixes:
-
TMlpANN: fixed crash with ROOT>=5.17 when using
large number of test events; also corrected bias in cross
validation: before the test events were used, which led to
an overestimated performance evaluation in case of a small
number of degrees of freedom; separate now training tree
in two parts for training and validation with configurable
ValidationFraction
-
Cuts: Corrected inconsistency in MethodCuts:
the signal efficiency written out into the weight file does
not correspond to the center of the bin within which the
background rejection is maximised (as before) but to the
lower left edge of it. This is because the cut optimisation
algorithm determines the best background rejection for all
signal efficiencies belonging into a bin. Since the best
background rejection is in general obtained for the lowest
possible signal efficiency, the reference signal efficiency
is the lowest value in the bin.
-
Cuts: Fixed Cuts (optimisaton) method -> event
with smallest value was not included in search for optimal
cut (thanks to Dimitris Varouchas, LAL-Orsay, for helping
us detecting the problem).
-
Genetic Algorithm: Corrected configurable random
seed in GeneticAlgorithm (thanks to David Gonzalez Maline,
CERN, for pointing this out)
-
GUI: Fixes in input-variable and MVA plotting:
under/over-flow numbers given on plots were not properly
normalised; the maximum histogram ranges have been
increased to avoid cut-offs. Thanks to Andreas Wenger,
Zuerich, for pointing these out.
Geom
MonteCarlo
The new montecarlo directory groups the packages
- eg: Interface to event generators
- g4root: Interface to the Geant4 system
- pythia6: Interface to pythia6
- pythia8: Interface to pythia8
- vmc: The Virtual MonteCarlo
GUI
New Classes: TGSplitFrame, TGShapedFrame, TGEventHandler
These three classes have been primarily developed to be used in EVE.
For an example of how to use them, see tutorials/eve/SplitGLView.C (this macro is used as a plugin by tutorials/eve/alice_esd_split.C).
- TGSplitFrame is a horizontally or vertically splittable composite frame. Once split, each part will contain a new TGSplitFrame, separated by a TGSplitter.
- TGShapedFrame is a TGCompositeFrame on which a custom shape is applied, starting from a picture file, by taking its transparency mask, and then applying the picture as background.
- TGEventHandler is a Base Event Handler class allowing to delegate event handling (a base class for GL event handlers).
TGListTree
- TGListTreeItem is now a base class and TGListTreeItemStd is the standard implementation (modification required by EVE).
- Switched the icon and checkbox position in TGListTreeItem.
- Added custom user control flags, with their getters and setters and three new signal methods (required by EVE). All these were implemented for better control of the TGListTree behavior.
- fUserControlled is a flag to take over the control
- fEventHandled is a flag to tell TGListTree that the current event has been processed by user.
- MouseOver(TGListTreeItem *entry)
- MouseOver(TGListTreeItem *entry, UInt_t mask)
- Clicked(TGListTreeItem *entry, Int_t btn, UInt_t mask, Int_t x, Int_t y)
- The new DrawOutline() method draws a colored outline around a list tree item following the mouse position.
- Implemented correct keyboard navigation.
- Improvements for list trees containing a large number of items (i.e. one million).
TGTab
- Added a new signal method Removed(Int_t id) to notify when a tab was removed.
TGListBox
- Fixed flickering problem on Windows.
TGDockableFrame
- Introduced the fFixedSize option, to let user choose if the undocked frame may
be resized or not. Keep the (fixed) original docked frame size when undocked
(i.e. for menus and toolbars).
TGShutter
- Two helper methods added:
- SetSelectedItem(const char *name) - switch to the shutter section 'name'.
- EnableItem(const char *name, Bool_t on) - enable/disable the shutter section 'name' according to the value of the second parameter 'on'.
TGFileDialog
- The File Open/Close dialogs show the list of all available (mounted) drives on Windows.
Modal Dialogs
- On Windows, any modal dialog now stays on top of its parent (true modal mode).
Context Menus
The context menu of ROOT classes can be created with hierarchical sub-menus, which are more convenient and offer better organization. This makes possible to access more class methods from the context menu (without having the menu becoming larger than the screen). The next is an example of the hierarchihal submenu structure shown below.
void SetLevelOne(EPaletteType palette = pal3); // *MENU={Hierarchy="Candidates/SetLevelOne"}*
void SetPalette(EPaletteType palette = pal3); // *SUBMENU={Hierarchy="Candidates/SetPalette"}*
void SetCatalog(const char * = "HESS") { } // *MENU={Hierarchy="Candidates/SetCatalog"}*
void AddCatalog(const char * = "HESS") { } // *MENU={Hierarchy="Candidates/AddCatalog"}*
void RemoveCatalog(const char * = "HESS") { } // *MENU={Hierarchy="Candidates/RemoveCatalog"}*
void AddCandidate(const char * = "NAME") { } // *MENU={Hierarchy="Candidates/AddCandidate"}*
EPaletteType fPalette; //*OPTION={GetMethod="GetPalette";SetMethod="SetPalette";Items=(PrettyPalette="PrettyPalette",SchlenkPalette="Schlenk",pal3="Pal3",pal4="Pal4")}*
GUI HTML
- Implemented controls handling (text buttons, radio buttons and check buttons)
- Implemented signals for these controls:
- ButtonClicked(const char *name, const char *val)
- SubmitClicked(const char *val)
- CheckToggled(const char *name, Bool_t on, const char *val)
- RadioChanged(const char *name, const char *val)
GUI Builder
- Robustness has been improved and several bugs fixed.
TASImage - libAfterImage library
TASImage
- Protection added in DrawCircle. Problem seen with gcc version 4.2.3.
- Fixed byte swapping issues. With that fix the pictures generated in batch
mode on Solaris and Mac are now correct (cf stressGraphics -k).
- The Alpha Blending code has been rewritten in a simpler way in order to
work on linux with gcc 4.2.3. Here also the pictures generated in batch
mode were wrong.
- In FillRectangleInternal when the rectangle to be drawn had its width or
its height equal to 0, they were set to the current image width or height.
This was not a good solution because this obscured completly the picture.
In particular, some markers being drawn with a filled rectangle, they
obscured the picture when they were really small because in that case the
rectangle drawn had width=height=0. Now, when a rectangle has its width or
height equal to 0 it is set to 1 (pixel) with makes sense because
"0" means "tiny" not "huge" ...
- New method to retrieve the last zoom position on an image:
void TASImage::GetZoomPosition(UInt_t &x, UInt_t &y, UInt_t &w, UInt_t &h) const
This is useful when the zoom has been done interactively using the mouse.
- In batch, when a picture was saved in a binary file (gif for instance) from
an image containing more than one pad, only the first pad was saved. The
following macro demonstrates the problem: ccc2.gif was wrong compared to
ccc1.gif.
{
gROOT->SetBatch();
TCanvas *c = new TCanvas;
c->Divide(1,2);
TH1F *h = new TH1F("gaus", "gaus", 100, -5, 5);
h->FillRandom("gaus", 10000);
c->cd(1); h->Draw();
c->cd(2); h->Draw("c*");
c->Print("ccc1.gif");
TImage *img = TImage::Create();
img->FromPad(c);
img->WriteImage("ccc2.gif");
}
libAfterImage
Graphical Output
PDF
- Text rotated at 270 degrees was not correct. The PDF rotation matrix
contained very small values close to 0 instead of 0. Acrobat reader
produced a wrong output and also printed result was wrong.
"gv" worked.
PostScript
- The character "@" could not be printed in PostScript files.
- Change the Page numbering to make it appear nicer in postcript viewers
like "gv". It is compliant with the Adobe Postscript Document
Structuring Conventions (easily found on the web).
- The fonts encoding has been simplified (use ISOLatin1Encoding). The new
way allows to print any character with accent etc.. like on the screen.
The new encoding was done by Pierre Juillot.
TPad
- In batch mode it was not possible to generate a bitmap file (gif,
jpeg etc..) with a filename containing ")",
"(", "]" or "[".
- The Tickx and Tixky attributes were not saved properly by SavePrimitive.
- PaintPolyLineNDC was not working in case of PS output.
- In ExecuteEvent. A problem was found Mathieu de Naurois
<denauroi@in2p3.fr>.
It can be reproduced by the following sequence:
- do TCanvas c
- do c->Divide(2,2)
- show the toolbar
- click L to enter text
- click on a pad to enter text
- move the mouse without releasing the button.
- entex text
- hit Enter.
Before this bug fix, the canvas position changed on "hit Enter".
- On a Windows dual core machine, the WaitPrimitive call returned
immediately.
Miscellaneous
TView3D
- Protection was missing in ctors in case gPad does not exits.
- Allow interactive zooming on histograms painted with option CONT4
TMultiGraph
Histograms painting
TGraph2D
- The operator "=" was not correct.
TGraph
- Protection added in PaintPolyLineHatches (division by zero in some
cases).
- All the graphical code has been moved from the TGraph classes to
TGraphPainter.
TGraphPolar
- Protection added in case a GraphPolar is plotted with option
"E" but has no errors defined.
- The markers clipping (in TGraphPainter) was wrong in case of TGraphPolar.
- The constructor's parameters naming was wrong.
- Documentation: better example (easier to understand).
- In the constructors some data members were not initialized.
TPie
- Add the TPie::GetEntries() method that return the number slices.
(Guido Volpi).
- Implement Editors for TPie and TPieSlice (Guido Volpi).
TPaletteAxis
- Attributes are now accessible in the context menu.
(requested by Mathieu de Naurois <denauroi@in2p3.fr>)
TPolyLine
- Implement the possibility to draw TPolyLine in NDC coordinates
(it was partially done but the code was not used).
Documentation
- Better comments in THelix.
- Option "FUNC" was not documented in THistPainter..
- Update the help for animated gif generation in TPad.
- Update TAttMarker documentation about the non scalable markers.
- Re-writting of the THistPainter documentation.
TCutG
- The graphical cuts applied on histograms did not work when the cut name
contained a mix of lower and upper case characters. This problem occured
because the option used to draw an histogram was always converted into
lower case before begin stored in a pad (in Draw and DrawCopy). Now in
Draw() and DrawCopy() the AppendPad() procedure is called with the option
string not converted in lower
case.
QT
Version 3 of QT is not supported anymore. If you install ROOT with the QT option
you must have QT version 4 already installed.
OpenGL
Major changes
- Reorganization of scene rendering in TGLViewer - render opaque
objects from all scenes first, then all transparent ones.
- Modularization of input event-handling in TGLViewer: all
event-handling is done by the TGLEventHandler class. One can
sub-class it now and modify behaviour of a given viewer. For
example, see TEveLegoEventHandler.
- Support highlighting of physical shapes for providing feedback and
showing selection.
Minor changes, fixes and improvements
- Improve saving of images from the GL-viewer so that the dialog
boxes and other windows do not result in black areas on the saved
image. The window must still be fully contained within the desktop.
- Improved camera controls. Three new orthographic cameras have
been added to TGLViewer, looking at the scene from another
side than the one present so far.
- Improved FTGL font management across rendering contexts and text
rendering support.
- New class TGLAxisPainter that can render 2D and 3D axes
via GL. For example see tutorials/eve/cms_calo.C.
Possible performance issues with ATI drivers (fglrx)
In late 2007 ATI switched to a new driver architecture. With these
drivers a significant degradation of GL performance in selection mode,
up to a factor of 50, was observed. Both linux and Windows drivers
were affected. The issue has been resolved in the latest driver
versions.
Eve
Major changes
- Support for multiple, parallel OpenGL views that can show different
projections of the same event.
- Provide object selection and feedback highlight across all GL-views and
list-trees.
- New classes for visualization of calorimeter data,
TEveCaloXYZ, see tutorials/eve/cms_calo.C. Available
representations: 3D-cylindrical view, projected views r-phi and rho-z,
and lego-view (with dedicated event handler allowing detailed
inspection of the data).
- Support for compound objects in view of selection, highlight and
color managament (see class TEveCompound).
- Optimize updates of GL-scenes by introducing change-stamping bits
into TEveElement. See methods AddStamp() and
StampXyzz().
- Added support for central management of visualization parameters
of objects. Instead of specifying visual attributes individually by
set-methods a single string tag can be used to retrieve all of them
with a single command, e.g.,
track->ApplyVizTag("MuonTrack"). The parameter-database can
be saved as a CINT script, edited manually and loaded. This provides more
flexibility as different users can share the same code to
instantiate visualziation objects but still override visualization
parameters independently. See TEveElement::CopyVizParams()
and TEveManager::*VizDB() methods for more information.
Minor changes, fixes and improvements
- Improved handling of projected elements.
- For fish-eye projections, allow fixing of compression scale
beyond given distance from the center.
- Add support for step-function scaling of 2D-projections. This
allows arbitrary magnification of concentric regions in r-phi and
rho-z views. See tutorial
tutorials/eve/projection_test_prescale.C.
- Path-mark type representing 2D clusters was added for
TEveTrack and TEveTrackPropagator classes.
- Add support for representing a set of arbitrary cones to
TEveBoxSet (see tutorials/eve/cone_test.C).
- TEveFrameBox now supports arbitrary 2d frame shapes -
user specifies individual points via SetQuadByPoints() function. See
tutorials/eve/quad_test.C::quad_test_circ() for an example.
- Consolidation of existing classes and code.
Misc
A new directory minicern has been introduced. This directory contains
the zebra and hbook files required to build the h2root and g2root utilities.
These small files remove dependencies on the old CERNLIB files.
h2root and g2root as well as the library libHbook are
automatically built when configuring ROOT and a Fortran compiler found in the system.
ROOT page -
Class index -
Top of the page -