Logo ROOT  
Reference Guide
mathcoreVectorIO.C File Reference

Detailed Description

View in nbviewer Open in SWAN Example of I/O of a mathcore Lorentz Vectors in a Tree and comparison with a TLorentzVector.

A ROOT tree is written and read in both using either a XYZTVector or a TLorentzVector.

To execute the macro type in:

root[0] .x mathcoreVectorIO.C
99.8767
Time for Random gen 0.0112069 0.01
Time for new Vector 0.269083 0.26
******************************************************************************
*Tree :t1 : Tree with new LorentzVector *
*Entries : 100000 : Total = 3214176 bytes File Size = 2910669 *
* : : Tree compression factor = 1.10 *
******************************************************************************
*Branch :LV branch *
*Entries : 100000 : BranchElement (see below) *
*............................................................................*
*Br 0 :fCoordinates : *
*Entries : 100000 : Total Size= 4720 bytes One basket in memory *
*Baskets : 0 : Basket Size= 32000 bytes Compression= 1.00 *
*............................................................................*
*Br 1 :fCoordinates.fX : Double_t *
*Entries : 100000 : Total Size= 803057 bytes File Size = 733353 *
*Baskets : 26 : Basket Size= 32000 bytes Compression= 1.09 *
*............................................................................*
*Br 2 :fCoordinates.fY : Double_t *
*Entries : 100000 : Total Size= 803057 bytes File Size = 733905 *
*Baskets : 26 : Basket Size= 32000 bytes Compression= 1.09 *
*............................................................................*
*Br 3 :fCoordinates.fZ : Double_t *
*Entries : 100000 : Total Size= 803057 bytes File Size = 733645 *
*Baskets : 26 : Basket Size= 32000 bytes Compression= 1.09 *
*............................................................................*
*Br 4 :fCoordinates.fT : Double_t *
*Entries : 100000 : Total Size= 803057 bytes File Size = 708062 *
*Baskets : 26 : Basket Size= 32000 bytes Compression= 1.13 *
*............................................................................*
Time for old Vector 0.200452 0.19
******************************************************************************
*Tree :t2 : Tree with TLorentzVector *
*Entries : 100000 : Total = 4835755 bytes File Size = 3369959 *
* : : Tree compression factor = 1.43 *
******************************************************************************
*Br 0 :TLV branch : TLorentzVector *
*Entries : 100000 : Total Size= 4835322 bytes File Size = 3366724 *
*Baskets : 327 : Basket Size= 16000 bytes Compression= 1.43 *
*............................................................................*
Tree Entries 100000
Time for new Vector 0.0458519 0.05
TOT average : n = 100000 99.8767
Tree Entries 100000
Time for old Vector 0.0517001 0.05
TOT average: 99.8767
#include "TRandom2.h"
#include "TStopwatch.h"
#include "TSystem.h"
#include "TFile.h"
#include "TTree.h"
#include "TH1D.h"
#include "TCanvas.h"
#include <iostream>
#include "TLorentzVector.h"
#include "Math/Vector4D.h"
using namespace ROOT::Math;
void write(int n) {
TStopwatch timer;
R.SetSeed(1);
timer.Start();
double s = 0;
for (int i = 0; i < n; ++i) {
s += R.Gaus(0,10);
s += R.Gaus(0,10);
s += R.Gaus(0,10);
s += R.Gaus(100,10);
}
timer.Stop();
std::cout << s/double(n) << std::endl;
std::cout << " Time for Random gen " << timer.RealTime() << " " << timer.CpuTime() << std::endl;
TFile f1("mathcoreVectorIO_1.root","RECREATE");
// create tree
TTree t1("t1","Tree with new LorentzVector");
t1.Branch("LV branch","ROOT::Math::XYZTVector",&v1);
R.SetSeed(1);
timer.Start();
for (int i = 0; i < n; ++i) {
double Px = R.Gaus(0,10);
double Py = R.Gaus(0,10);
double Pz = R.Gaus(0,10);
double E = R.Gaus(100,10);
v1->SetCoordinates(Px,Py,Pz,E);
t1.Fill();
}
f1.Write();
timer.Stop();
std::cout << " Time for new Vector " << timer.RealTime() << " " << timer.CpuTime() << std::endl;
t1.Print();
// create tree with old LV
TFile f2("mathcoreVectorIO_2.root","RECREATE");
TTree t2("t2","Tree with TLorentzVector");
t2.Branch("TLV branch","TLorentzVector",&v2,16000,2);
R.SetSeed(1);
timer.Start();
for (int i = 0; i < n; ++i) {
double Px = R.Gaus(0,10);
double Py = R.Gaus(0,10);
double Pz = R.Gaus(0,10);
double E = R.Gaus(100,10);
v2->SetPxPyPzE(Px,Py,Pz,E);
t2.Fill();
}
f2.Write();
timer.Stop();
std::cout << " Time for old Vector " << timer.RealTime() << " " << timer.CpuTime() << endl;
t2.Print();
}
void read() {
TStopwatch timer;
TFile f1("mathcoreVectorIO_1.root");
// create tree
TTree *t1 = (TTree*)f1.Get("t1");
XYZTVector *v1 = 0;
t1->SetBranchAddress("LV branch",&v1);
timer.Start();
int n = (int) t1->GetEntries();
std::cout << " Tree Entries " << n << std::endl;
double etot=0;
for (int i = 0; i < n; ++i) {
t1->GetEntry(i);
etot += v1->Px();
etot += v1->Py();
etot += v1->Pz();
etot += v1->E();
}
timer.Stop();
std::cout << " Time for new Vector " << timer.RealTime() << " " << timer.CpuTime() << std::endl;
std::cout << " TOT average : n = " << n << "\t " << etot/double(n) << endl;
// create tree with old LV
TFile f2("mathcoreVectorIO_2.root");
TTree *t2 = (TTree*)f2.Get("t2");
t2->SetBranchAddress("TLV branch",&v2);
timer.Start();
n = (int) t2->GetEntries();
std::cout << " Tree Entries " << n << std::endl;
etot = 0;
for (int i = 0; i < n; ++i) {
t2->GetEntry(i);
etot += v2->Px();
etot += v2->Py();
etot += v2->Pz();
etot += v2->E();
}
timer.Stop();
std::cout << " Time for old Vector " << timer.RealTime() << " " << timer.CpuTime() << endl;
std::cout << " TOT average:\t" << etot/double(n) << endl;
}
void mathcoreVectorIO() {
int nEvents = 100000;
write(nEvents);
read();
}
#define R(a, b, c, d, e, f, g, h, i)
Definition: RSha256.hxx:110
Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system ...
Definition: LorentzVector.h:59
void IgnoreTObjectStreamer(Bool_t ignore=kTRUE)
When the class kIgnoreTObjectStreamer bit is set, the automatically generated Streamer will not call ...
Definition: TClass.cxx:4830
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition: TFile.h:54
static TClass * Class()
virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Write this object to the current directory.
Definition: TObject.cxx:798
Random number generator class based on the maximally quidistributed combined Tausworthe generator by ...
Definition: TRandom2.h:27
This is the base class for the ROOT Random number generators.
Definition: TRandom.h:27
Stopwatch class.
Definition: TStopwatch.h:28
Double_t RealTime()
Stop the stopwatch (if it is running) and return the realtime (in seconds) passed between the start a...
Definition: TStopwatch.cxx:110
void Start(Bool_t reset=kTRUE)
Start the stopwatch.
Definition: TStopwatch.cxx:58
Double_t CpuTime()
Stop the stopwatch (if it is running) and return the cputime (in seconds) passed between the start an...
Definition: TStopwatch.cxx:125
void Stop()
Stop the stopwatch.
Definition: TStopwatch.cxx:77
A TTree represents a columnar dataset.
Definition: TTree.h:79
virtual Int_t GetEntry(Long64_t entry, Int_t getall=0)
Read all branches of entry and return total number of bytes read.
Definition: TTree.cxx:5612
virtual Int_t SetBranchAddress(const char *bname, void *add, TBranch **ptr=0)
Change branch address, dealing with clone trees properly.
Definition: TTree.cxx:8354
virtual Long64_t GetEntries() const
Definition: TTree.h:459
static TClass * Class()
const Int_t n
Definition: legend1.C:16
TF1 * f1
Definition: legend1.C:11
LorentzVector< PxPyPzE4D< double > > XYZTVector
LorentzVector based on x,y,x,t (or px,py,pz,E) coordinates in double precision with metric (-,...
Definition: Vector4Dfwd.h:46
static constexpr double s
constexpr Double_t E()
Base of natural log: .
Definition: TMath.h:93
auto * t1
Definition: textangle.C:20
Author
Lorenzo Moneta

Definition in file mathcoreVectorIO.C.