https://github.com/root-project/root
Tip revision: a6a0bcaa08667dac8b6ebd4e0c0fae2e3ce958d3 authored by Philippe Canal on 06 March 2006, 23:21:59 UTC
Backport the following patches to v4_04_02:
Backport the following patches to v4_04_02:
Tip revision: a6a0bca
TBench.cxx
// set of classes to compare the performance of STL vector versus
// native Root TClonesArray.
// See main program bench.cxx
#include "TRandom.h"
#include "TFile.h"
#include "TTree.h"
#include "TClass.h"
//the next include must be the last one on systems like Windows/NT
#include "TBench.h"
#include "Riostream.h"
THit hit;
#ifdef R__HPUX
namespace std {
using ::make_pair;
}
#endif
#ifdef R__WIN32
const char *demofile = "$TMP/bench.root";
#else
const char *demofile = "/tmp/bench.root";
#endif
const char* demofile_name(const char* tit) {
static std::string fn;
#ifdef R__WIN32
fn = "$TMP/bench.";
#else
fn = "/tmp/bench.";
#endif
fn += tit;
fn += ".root";
return fn.c_str();
}
namespace {
struct Counter {
std::string name;
int count;
Counter(const std::string& n) : name(n), count(0) {}
~Counter() {
print();
}
void print(const std::string& msg="") {
cout << msg << " --- Counter: " << name << " " << count << endl;
}
};
}
Counter hitCount("THit");
//-------------------------------------------------------------
ClassImp(THit)
//-------------------------------------------------------------
THit::THit() {
fPulses = 0;
hitCount.count++;
}
THit::THit(const THit &hit) {
hitCount.count++;
fX = hit.fX;
fY = hit.fY;
fZ = hit.fZ;
for (Int_t i=0;i<10;i++) fTime[i] = hit.fTime[i];
fPulses = 0;
fNpulses = hit.fNpulses;
if (fNpulses == 0) return;
if (hit.fPulses == 0) return;
fPulses = new int[fNpulses];
for (int j=0;j<fNpulses;j++) fPulses[j] = hit.fPulses[j];
}
THit& THit::operator=(const THit& hit) {
fX = hit.fX;
fY = hit.fY;
fZ = hit.fZ;
for (Int_t i=0;i<10;i++) fTime[i] = hit.fTime[i];
fPulses = 0;
fNpulses = hit.fNpulses;
if (fNpulses == 0) return *this;
if (hit.fPulses == 0) return *this;
if ( fPulses ) delete [] fPulses;
fPulses = new int[fNpulses];
for (int j=0;j<fNpulses;j++) fPulses[j] = hit.fPulses[j];
return *this;
}
THit::THit(int t) {
hitCount.count++;
fPulses = 0;
Set(t);
}
THit::~THit() {
hitCount.count--;
if (fPulses) delete [] fPulses;
fPulses = 0;
}
void THit::Set(int t) {
fX = gRandom->Gaus(0,1);
fY = gRandom->Gaus(0,1);
fZ = gRandom->Gaus(0,10);
if (fPulses && fNpulses > 0) delete [] fPulses;
fNpulses = t%20 + 1;
fPulses = new int[fNpulses];
for (int j=0;j<fNpulses;j++) fPulses[j] = j+1;
for (int i=0; i<10; i++) fTime[i] = t+i;
}
#if 0
#if defined(R__TEMPLATE_OVERLOAD_BUG)
template <>
#endif
TBuffer &operator>>(TBuffer &buf, THit *&obj)
{
obj = new THit();
obj->Streamer(buf);
return buf;
}
#endif
TBuffer &operator<<(TBuffer &buf, const THit *obj)
{
((THit*)obj)->Streamer(buf);
return buf;
}
//-------------------------------------------------------------
ClassImp(TObjHit)
//-------------------------------------------------------------
TObjHit::TObjHit() :THit() {}
TObjHit::TObjHit(int t) :THit(t) {}
//-------------------------------------------------------------
ClassImp(TSTLhit)
//-------------------------------------------------------------
TSTLhit::TSTLhit()
{
}
TSTLhit::TSTLhit(Int_t nmax)
{
fNhits = nmax;
fList1.reserve(nmax);
}
TSTLhit::~TSTLhit() {
Clear();
hitCount.print();
}
void TSTLhit::Clear(Option_t *)
{
fList1.erase(fList1.begin(),fList1.end());
}
void TSTLhit::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
fList1.push_back(hit);
}
}
Int_t TSTLhit::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhit *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhit"),"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhit",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhit"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhit::ReadTree()
{
TSTLhit *top = this;
TFile *f = new TFile(demofile_name("TSTLhit"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitList)
//-------------------------------------------------------------
TSTLhitList::TSTLhitList()
{
}
TSTLhitList::TSTLhitList(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitList::~TSTLhitList() {
Clear();
hitCount.print();
}
void TSTLhitList::Clear(Option_t *)
{
fList1.erase(fList1.begin(),fList1.end());
}
void TSTLhitList::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
fList1.push_back(hit);
}
}
Int_t TSTLhitList::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitList *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitList"),"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitList",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitList"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitList::ReadTree()
{
TSTLhitList *top = this;
TFile *f = new TFile(demofile_name("TSTLhitList"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitDeque)
//-------------------------------------------------------------
TSTLhitDeque::TSTLhitDeque()
{
}
TSTLhitDeque::TSTLhitDeque(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitDeque::~TSTLhitDeque() {
Clear();
hitCount.print();
}
void TSTLhitDeque::Clear(Option_t *)
{
fList1.erase(fList1.begin(),fList1.end());
}
void TSTLhitDeque::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
fList1.push_back(hit);
}
}
Int_t TSTLhitDeque::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitDeque *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitDeque"),"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitDeque",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitDeque"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitDeque::ReadTree()
{
TSTLhitDeque *top = this;
TFile *f = new TFile(demofile_name("TSTLhitDeque"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitSet)
//-------------------------------------------------------------
TSTLhitSet::TSTLhitSet()
{
}
TSTLhitSet::TSTLhitSet(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitSet::~TSTLhitSet() {
Clear();
hitCount.print();
}
void TSTLhitSet::Clear(Option_t *)
{
fList1.erase(fList1.begin(),fList1.end());
}
void TSTLhitSet::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
fList1.insert(hit);
}
}
Int_t TSTLhitSet::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitSet *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitSet"),"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitSet",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitSet"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitSet::ReadTree()
{
TSTLhitSet *top = this;
TFile *f = new TFile(demofile_name("TSTLhitSet"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitMultiset)
//-------------------------------------------------------------
TSTLhitMultiset::TSTLhitMultiset()
{
}
TSTLhitMultiset::TSTLhitMultiset(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitMultiset::~TSTLhitMultiset() {
Clear();
hitCount.print();
}
void TSTLhitMultiset::Clear(Option_t *)
{
fList1.erase(fList1.begin(),fList1.end());
}
void TSTLhitMultiset::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
fList1.insert(hit);
}
}
Int_t TSTLhitMultiset::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitMultiset *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitMultiset"),"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitMultiset",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitMultiset"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitMultiset::ReadTree()
{
TSTLhitMultiset *top = this;
TFile *f = new TFile(demofile_name("TSTLhitMultiset"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitMap)
//-------------------------------------------------------------
TSTLhitMap::TSTLhitMap()
{
}
TSTLhitMap::TSTLhitMap(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitMap::~TSTLhitMap() {
Clear();
hitCount.print();
}
void TSTLhitMap::Clear(Option_t *)
{
fList1.clear();
}
void TSTLhitMap::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
fList1.insert(std::pair<const Int_t ,THit> (j,hit));
}
}
Int_t TSTLhitMap::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitMap *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitMap"),"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitMap",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitMap"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitMap::ReadTree()
{
TSTLhitMap *top = this;
TFile *f = new TFile(demofile_name("TSTLhitMap"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitMultiMap)
//-------------------------------------------------------------
TSTLhitMultiMap::TSTLhitMultiMap()
{
}
TSTLhitMultiMap::TSTLhitMultiMap(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitMultiMap::~TSTLhitMultiMap() {
Clear();
hitCount.print();
}
void TSTLhitMultiMap::Clear(Option_t *)
{
fList1.clear();
}
void TSTLhitMultiMap::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
std::pair <const int, THit> temp(j,hit);
fList1.insert(temp);
}
}
Int_t TSTLhitMultiMap::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitMultiMap *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitMultiMap"),"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitMultiMap",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitMultiMap"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitMultiMap::ReadTree()
{
TSTLhitMultiMap *top = this;
TFile *f = new TFile(demofile_name("TSTLhitMultiMap"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
#if 0
//-------------------------------------------------------------
ClassImp(TSTLhitHashSet)
//-------------------------------------------------------------
TSTLhitHashSet::TSTLhitHashSet()
{
}
TSTLhitHashSet::TSTLhitHashSet(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitHashSet::~TSTLhitHashSet() {
Clear();
hitCount.print();
}
void TSTLhitHashSet::Clear(Option_t *)
{
fList1.erase(fList1.begin(),fList1.end());
}
void TSTLhitHashSet::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
fList1.insert(hit);
}
}
Int_t TSTLhitHashSet::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitHashSet *top = this;
if (mode > 0) {
f = new TFile(demofile,"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitHashSet",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile);
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitHashSet::ReadTree()
{
TSTLhitHashSet *top = this;
TFile *f = new TFile(demofile);
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitHashMultiSet)
//-------------------------------------------------------------
TSTLhitHashMultiSet::TSTLhitHashMultiSet()
{
}
TSTLhitHashMultiSet::TSTLhitHashMultiSet(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitHashMultiSet::~TSTLhitHashMultiSet() {
Clear();
hitCount.print();
}
void TSTLhitHashMultiSet::Clear(Option_t *)
{
fList1.erase(fList1.begin(),fList1.end());
}
void TSTLhitHashMultiSet::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
hit.Set(j);
fList1.insert(hit);
}
}
Int_t TSTLhitHashMultiSet::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitHashMultiSet *top = this;
if (mode > 0) {
f = new TFile(demofile,"recreate","STLhit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitHashMultiSet",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile);
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitHashMultiSet::ReadTree()
{
TSTLhitHashMultiSet *top = this;
TFile *f = new TFile(demofile);
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
#endif
//-------------------------------------------------------------
ClassImp(TSTLhitStar)
//-------------------------------------------------------------
TSTLhitStar::TSTLhitStar()
{
}
TSTLhitStar::TSTLhitStar(Int_t nmax)
{
fNhits = nmax;
fList2.reserve(nmax);
}
TSTLhitStar::~TSTLhitStar() {
Clear();
hitCount.print();
}
void TSTLhitStar::Clear(Option_t *)
{
for (vector<THit*>::iterator it = fList2.begin(); it<fList2.end(); it++) {
delete (*it);
}
fList2.erase(fList2.begin(),fList2.end());
//hitCount.print("Clear");
}
void TSTLhitStar::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
fList2.push_back(new THit(j));
}
}
Int_t TSTLhitStar::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitStar *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitStar"),"recreate","STLhitStar",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitStar",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitStar"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitStar::ReadTree()
{
TSTLhitStar *top = this;
TFile *f = new TFile(demofile_name("TSTLhitStar"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitStarList)
//-------------------------------------------------------------
TSTLhitStarList::TSTLhitStarList()
{
}
TSTLhitStarList::TSTLhitStarList(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitStarList::~TSTLhitStarList() {
Clear();
hitCount.print();
}
void TSTLhitStarList::Clear(Option_t *)
{
for (list<THit*>::iterator it = fList2.begin(); it!=fList2.end(); it++) {
delete (*it);
}
fList2.erase(fList2.begin(),fList2.end());
}
void TSTLhitStarList::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
fList2.push_back(new THit(j));
}
}
Int_t TSTLhitStarList::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitStarList *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitStarList"),"recreate","STLhitStar",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitStarList",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitStarList"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitStarList::ReadTree()
{
TSTLhitStarList *top = this;
TFile *f = new TFile(demofile_name("TSTLhitStarList"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitStarDeque)
//-------------------------------------------------------------
TSTLhitStarDeque::TSTLhitStarDeque()
{
}
TSTLhitStarDeque::TSTLhitStarDeque(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitStarDeque::~TSTLhitStarDeque() {
Clear();
hitCount.print();
}
void TSTLhitStarDeque::Clear(Option_t *)
{
for (deque<THit*>::iterator it = fList2.begin(); it!=fList2.end(); it++) {
delete (*it);
}
fList2.erase(fList2.begin(),fList2.end());
}
void TSTLhitStarDeque::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
fList2.push_back(new THit(j));
}
}
Int_t TSTLhitStarDeque::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitStarDeque *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitStarDeque"),"recreate","STLhitStar",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitStarDeque",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitStarDeque"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitStarDeque::ReadTree()
{
TSTLhitStarDeque *top = this;
TFile *f = new TFile(demofile_name("TSTLhitStarDeque"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitStarSet)
//-------------------------------------------------------------
TSTLhitStarSet::TSTLhitStarSet()
{
}
TSTLhitStarSet::TSTLhitStarSet(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitStarSet::~TSTLhitStarSet() {
Clear();
hitCount.print();
}
void TSTLhitStarSet::Clear(Option_t *)
{
for (set<THit*>::iterator it = fList2.begin(); it!=fList2.end(); it++) {
delete (*it);
}
fList2.erase(fList2.begin(),fList2.end());
}
void TSTLhitStarSet::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
fList2.insert(new THit(j));
}
}
Int_t TSTLhitStarSet::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitStarSet *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitStarSet"),"recreate","STLhitStar",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitStarSet",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitStarSet"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitStarSet::ReadTree()
{
TSTLhitStarSet *top = this;
TFile *f = new TFile(demofile_name("TSTLhitStarSet"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitStarMultiSet)
//-------------------------------------------------------------
TSTLhitStarMultiSet::TSTLhitStarMultiSet()
{
}
TSTLhitStarMultiSet::TSTLhitStarMultiSet(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitStarMultiSet::~TSTLhitStarMultiSet() {
Clear();
hitCount.print();
}
void TSTLhitStarMultiSet::Clear(Option_t *)
{
for (multiset<THit*>::iterator it = fList2.begin(); it!=fList2.end(); it++) {
delete (*it);
}
fList2.erase(fList2.begin(),fList2.end());
}
void TSTLhitStarMultiSet::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
fList2.insert(new THit(j));
}
}
Int_t TSTLhitStarMultiSet::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitStarMultiSet *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitStarMultiSet"),"recreate","STLhitStar",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitStarMultiSet",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitStarMultiSet"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitStarMultiSet::ReadTree()
{
TSTLhitStarMultiSet *top = this;
TFile *f = new TFile(demofile_name("TSTLhitStarMultiSet"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitStarMap)
//-------------------------------------------------------------
TSTLhitStarMap::TSTLhitStarMap()
{
}
TSTLhitStarMap::TSTLhitStarMap(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitStarMap::~TSTLhitStarMap() {
Clear();
hitCount.print();
}
void TSTLhitStarMap::Clear(Option_t *)
{
for (map<int,THit*>::iterator it = fList2.begin(); it!=fList2.end(); it++) {
delete (*it).second;
}
fList2.clear();
}
void TSTLhitStarMap::MakeEvent(int /*ievent*/)
{
// hitCount.print("1");
Clear();
// hitCount.print("1.1");
for (Int_t j=0; j<fNhits; j++) {
fList2.insert(std::pair<const Int_t, THit*> (j,new THit(j)));
}
// hitCount.print("1.2");
}
Int_t TSTLhitStarMap::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitStarMap *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitStarMap"),"recreate","STLhitStar",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitStarMap",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitStarMap"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitStarMap::ReadTree()
{
TSTLhitStarMap *top = this;
TFile *f = new TFile(demofile_name("TSTLhitStarMap"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TSTLhitStarMultiMap)
//-------------------------------------------------------------
TSTLhitStarMultiMap::TSTLhitStarMultiMap()
{
}
TSTLhitStarMultiMap::TSTLhitStarMultiMap(Int_t nmax)
{
fNhits = nmax;
}
TSTLhitStarMultiMap::~TSTLhitStarMultiMap() {
Clear();
hitCount.print();
}
void TSTLhitStarMultiMap::Clear(Option_t *)
{
for (multimap<int,THit*>::iterator it = fList2.begin(); it!=fList2.end(); it++) {
delete (*it).second;
}
fList2.clear();
}
void TSTLhitStarMultiMap::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
std::pair<const int,THit*> temp(j,new THit(j));
fList2.insert(temp);
}
}
Int_t TSTLhitStarMultiMap::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TSTLhitStarMultiMap *top = this;
if (mode > 0) {
f = new TFile(demofile_name("TSTLhitStarMultiMap"),"recreate","STLhitStar",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TSTLhitStarMultiMap",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile_name("TSTLhitStarMultiMap"));
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TSTLhitStarMultiMap::ReadTree()
{
TSTLhitStarMultiMap *top = this;
TFile *f = new TFile(demofile_name("TSTLhitStarMultiMap"));
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
Clear();
}
delete f;
return nbytes;
}
//-------------------------------------------------------------
ClassImp(TCloneshit)
//-------------------------------------------------------------
TCloneshit::TCloneshit()
{
fList3 = new TClonesArray("TObjHit");
}
TCloneshit::TCloneshit(Int_t nmax)
{
fNhits = nmax;
fList3 = new TClonesArray("TObjHit",nmax);
TObjHit::Class()->IgnoreTObjectStreamer();
}
TCloneshit::~TCloneshit() {
Clear();
hitCount.print();
}
void TCloneshit::Clear(Option_t *)
{
fList3->Delete();
//fList3->Clear();
}
void TCloneshit::MakeEvent(int /*ievent*/)
{
Clear();
for (Int_t j=0; j<fNhits; j++) {
new((*fList3)[j]) TObjHit(j);
}
}
Int_t TCloneshit::MakeTree(int mode, int nevents, int compression, int split, float &cx)
{
TFile *f=0;
TTree *T=0;
TCloneshit *top = this;
if (mode > 0) {
f = new TFile(demofile,"recreate","Cloneshit",compression);
T = new TTree("T","Demo tree");
T->Branch("event","TCloneshit",&top,64000,split);
}
for (int ievent=0; ievent<nevents; ievent++) {
MakeEvent(ievent);
if (mode > 0) T->Fill();
}
if (mode == 0) return 0;
T->Write();
delete f;
f = new TFile(demofile);
Int_t nbytes = f->GetEND();
cx = f->GetCompressionFactor();
delete f;
return nbytes;
}
Int_t TCloneshit::ReadTree()
{
TCloneshit *top = this;
TFile *f = new TFile(demofile);
TTree *T = (TTree*)f->Get("T");
T->SetBranchAddress("event",&top);
Int_t nevents = (Int_t)T->GetEntries();
Int_t nbytes = 0;
for (int ievent=0; ievent<nevents; ievent++) {
nbytes += T->GetEntry(ievent);
}
delete f;
return nbytes;
}