g4tools
is a "namespace protected" part of
inlib
and exlib
which
is of some interest for Geant4, mainly the histograms, the ntuples
and the code to write them at the ROOT, AIDA XML, CSV and HBOOK
file formats. The idea of g4tools
is to cover, with a very
light and easy to install package, what is needed to do analysis in
a "Geant4 batch program".
As g4tools
is distributed through Geant4 and
in order to avoid potential namespace clashes with other codes
that use the inlib/exlib
to do Geant4 visualization
(as for the g4view
application or some of the exlib examples),
the inlib and exlib namespaces had
been automatically changed to tools in the
g4tools
distribution. Since in principle Geant4 users
will not have to deal directly with the g4tools
classes,
but will manipulate histograms and ntuples through the
G4AnalysisManager
, we are not going
to extensively document the g4tools
classes here. Interested
people are encouraged to go at the inlib/exlib
web pages
for that (see
inlib/exlib site ).
As explained in inlib/exlib
, the code found in
g4tools
is "pure header".
This comes from the need to have an easy way to build applications, as
the ioda
one, from smartphone, passing by tablets and
up to various desktops (UNIX and Windows). For example, if building an
application targeted to the Apple AppStore and GooglePlay, the simplest way
is to pass through Xcode
and the Android make
system (or Eclipse
), and having not to build libraries simplifies a lot the handling
of all these IDEs for the same application. A fallback of that is that the
installation of g4tools
(if not using the one coming with
Geant4) is straightforward, you simply unzip the file containing the source
code! To build an application using g4tools
, as for
inlib/exlib
, you simply have to declare to your build system
the "-I" toward the unfolded directory and do "Build and Run".
Note that there is no need to have CLHEP and Geant4 installed to use
g4tools
, but you may have to install
CERNLIB (and a FORTRAN77 compiler!)
if wanting to use the classes dealing with HBOOK.
g4tools
comes with test programs of its own that may be
useful in case of problems (for example porting on a not yet covered platform).
You can build and run them with :
UNIX> <get g4tools.zip> UNIX> <unzip g4tools.zip> UNIX> cd g4tools/test/cpp UNIX> ./build UNIX> ./tools_test_histo UNIX> ./tools_test_wroot UNIX> etc...and on Windows :
DOS> <setup VisualC++ so that CL.exe is in your PATH> DOS> <get g4tools.zip> DOS> <unzip g4tools.zip> (you can use the unzip.exe of CYGWIN) DOS> cd g4tools\test\cpp DOS> .\build.bat DOS> .\tools_test_histo.exe DOS> .\tools_test_wroot.exe DOS> etc...
Note that there is no need to have CLHEP and Geant4 installed to build and run
the g4tools
test programs, but you may have to install the
CERNLIB (and a FORTRAN77 compiler!) if wanting to use the classes related to
HBOOK.
The g4tools
header files are distributed in the Geant4 source
in the source/analysis/include/tools
directory and in
the Geant4 installation, they are installed in include/tools
directory. The g4tools
test programs, included only
in Geant4 development versions, can be downloaded with the
g4tools-[version].zip
file from the inexlib
download page).
While the Geant4 analysis manager provides the methods for booking and filling the g4tools objects, it does not interface all public functions. Users can access the g4tools objects (see Section 9.2.3.4) and use the g4tools API described in the next section to get the needed informations.
h1d(const std::string& title,unsigned int Xnumber,double Xmin,double Xmax); h1d(const std::string& title,const std::vector<double>& edges); bool fill(double X,double Weight = 1);
#include <tools/histo/h1d> #include <tools/randd> ... tools::histo::h1d h("Gauss",100,-5,5); tools::rgaussd rg(1,2); for(unsigned int count=0;count<entries;count++) h.fill(rg.shoot(),1.4);
tools::histo::h1d h("Gauss",100,-5,5); ... std::cout << " mean " << h.mean() << ", rms " << h.rms() << std::endl;
bool fill(double X,double Weight = 1);
double Sx2w = h.bin_Sx2w(50);
double Sw = h.bin_Sw(50); double Sw2 = h.bin_Sw2(50); double Sxw = h.bin_Sxw(50); unsigned int n = h.bin_entries(50);
tools::histo::h1d h(...); ... const std::vector<unsigned int>& _entries = h.bins_entries(); const std::vector<double>& _bins_sum_w = h.bins_sum_w(); const std::vector<double>& _bins_sum_w2 = h.bins_sum_w2(); const std::vector< std::vector<double> >& _bins_sum_xw = h.bins_sum_xw(); const std::vector< std::vector<double> >& _bins_sum_x2w = h.bins_sum_x2w();
std::cout << "entries[50] = " << _entries[50] << std::endl; std::cout << " sum_w[50] = " << _bins_sum_w[50] << std::endl; std::cout << " sum_w2[50] = " << _bins_sum_w2[50] << std::endl; std::cout << " sum_xw[50] = " << _bins_sum_xw[50][0] << std::endl; //0 = xaxis std::cout << "sum_x2w[50] = " << _bins_sum_x2w[50][0] << std::endl; //0 = xaxis
const tools::histo::h1d::hd_t& hdata = h.dac(); //dac=data access.
const std::vector<unsigned int>& _entries = hdata.m_bin_entries; const std::vector<double>& _bins_sum_w = hdata.m_bin_Sw; const std::vector<double>& _bins_sum_w2 = hdata.m_bin_Sw2; const std::vector< std::vector<double> >& _bins_sum_xw = hdata.m_bin_Sxw; const std::vector< std::vector<double> >& _bins_sum_x2w = hdata.m_bin_Sx2w; // dump bin 50 : std::cout << "entries[50] = " << _entries[50] << std::endl; std::cout << " sum_w[50] = " << _bins_sum_w[50] << std::endl; std::cout << " sum_w2[50] = " << _bins_sum_w2[50] << std::endl; std::cout << " sum_xw[50] = " << _bins_sum_xw[50][0] << std::endl; //0 = xaxis std::cout << "sum_x2w[50] = " << _bins_sum_x2w[50][0] << std::endl; //0 = xaxis
tools::histo::h1d* projection = tools::histo::projection_x(h2d,"ProjX"); ... delete projection;
// h2d -> h1d. (User gets ownership of the returned object). h1d* slice_x(const h2d&,int y_beg_ibin,int y_end_ibin,const std::string& title); h1d* projection_x(const h2d&,const std::string& title); h1d* slice_y(const h2d&,int x_beg_ibin,int x_end_ibin,const std::string& title); h1d* projection_y(const h2d&,const std::string& title); // h2d -> p1d. (User gets ownership of the returned object). p1d* profile_x(const h2d&,int y_beg_ibin,int y_end_ibin,const std::string& title); p1d* profile_x(const h2d&,const std::string&); p1d* profile_y(const h2d&,int x_beg_ibin,int x_end_ibin,const std::string& title); p1d* profile_y(const h2d&,const std::string& title); // h3d -> h2d. (User gets ownership of the returned object). h2d* slice_xy(const h3d&,int z_beg_ibin,int z_end_ibin,const std::string& title); h2d* projection_xy(const h3d&,const std::string& title); h2d* slice_yz(const h3d&,int x_beg_ibin,int x_end_ibin,const std::string& title); h2d* projection_yz(const h3d&,const std::string& title); h2d* slice_xz(const h3d&,int y_beg_ibin,int y_end_ibin,const std::string& title); h2d* projection_xz(const h3d&,const std::string& title);