Util/src/varkeepter.cc

#include "varkeepter.h"

varkeepter::varkeepter(TString varfile, TString modepar, TString treefile, int dummy, TString treename, TTree *intree):
  mode_(modepar),
  infile_(0),
  intreename_(treename),
  intree_(0),
  outfile_(0),
  outtreename_(treename),
  outtree_(0)
{
  dummy += 7; // horrible hack to make the constructor overloading not be ambiguous...
  readtext(varfile);
  init(mode_, treefile, intree);
}
//----------------------------------------------------------------------------------------
varkeepter::varkeepter(TString varfile, TString modepar, TString infilename, TString outfilename, TString treename):
  mode_(modepar),
  infile_(0),
  intreename_(treename),
  intree_(0),
  outfile_(0),
  outtreename_(treename),
  outtree_(0)
{
  // use this form to read a tree and copy it to a new file (with modifications/cuts)
  assert(modepar=="rw");
  readtext(varfile);
  init("r",infilename);
  init("w",outfilename);
}
//----------------------------------------------------------------------------------------
void varkeepter::readtext(TString varfile)
{
  // read in list of variables and types from text file
  ifstream ifs(varfile);
  assert(ifs.is_open());
  string line;
  while(getline(ifs,line)) {
    if(line[0]=='#') continue;
    stringstream ss(line);
    TString name,type;
    ss >> type >> name;
    namev_.push_back(name);
    typev_.push_back(type);
    if(type=="F")       float_map_[name] = 0;
    else if(type=="D") double_map_[name] = 0;
    else if(type=="i")   uint_map_[name] = 0;
    else if(type=="I")    int_map_[name] = 0;
    else assert(0);
  }
}
//----------------------------------------------------------------------------------------
void varkeepter::init(TString initmode, TString treefile, TTree *intree)
{
  if(initmode=="r") {
    if(intree) {
      infname_ = "";
      infile_ = 0;
      intree_ = intree;
    } else {
      infname_ = treefile;
      infile_ = TFile::Open(infname_); assert(infile_);
      infile_->GetObject(intreename_,intree_); assert(intree_);
    }
  } else if(initmode=="w") {
    outfname_ = treefile;
    outfile_ = TFile::Open(outfname_,"recreate"); assert(outfile_);
    outtree_ = new TTree(outtreename_,outtreename_); assert(outtree_);
    outtree_->SetAutoFlush(0);//????????????????????????????????????????????????????????????????????????????????????????
  } else assert(0);
  
  // set addresses or make branches for unsigned ints
  map<TString,UInt_t>::iterator it_uint;
  for(it_uint=uint_map_.begin(); it_uint!=uint_map_.end(); it_uint++) {
    if(initmode=="r")
      intree_->SetBranchAddress((*it_uint).first,&(*it_uint).second);
    else if(initmode=="w")
      outtree_->Branch((*it_uint).first,&(*it_uint).second,(*it_uint).first+"/i");
    else assert(0);
  }
  // set addresses or make branches for ints
  map<TString,Int_t>::iterator it_int;
  for(it_int=int_map_.begin(); it_int!=int_map_.end(); it_int++) {
    if(initmode=="r")
      intree_->SetBranchAddress((*it_int).first,&(*it_int).second);
    else if(initmode=="w")
      outtree_->Branch((*it_int).first,&(*it_int).second,(*it_int).first+"/I");
    else assert(0);
  }
  // set addresses or make branches for floats
  map<TString,Float_t>::iterator it_float;
  for(it_float=float_map_.begin(); it_float!=float_map_.end(); it_float++) {
    if(initmode=="r") {
      TString branchname((*it_float).first);
      intree_->SetBranchAddress(branchname,&(*it_float).second);
    } else if(initmode=="w")
      outtree_->Branch((*it_float).first,&(*it_float).second,(*it_float).first+"/F");
    else assert(0);
  }
  // set addresses or make branches for doubles
  map<TString,Double_t>::iterator it_double;
  for(it_double=double_map_.begin(); it_double!=double_map_.end(); it_double++) {
    if(initmode=="r") {
      TString branchname((*it_double).first);
      intree_->SetBranchAddress(branchname,&(*it_double).second);
    } else if(initmode=="w")
      outtree_->Branch((*it_double).first,&(*it_double).second,(*it_double).first+"/D");
    else assert(0);
  }
}
//----------------------------------------------------------------------------------------
TTree *varkeepter::gettree(TString inout)
{
  // ignores inout if mode_ is r or w
  if(mode_=="r"      || (mode_=="rw" && inout=="in"))  { assert(intree_);  return intree_;  }
  else if(mode_=="w" || (mode_=="rw" && inout=="out")) { assert(outtree_); return outtree_; }
  else assert(0);
}
//----------------------------------------------------------------------------------------
void varkeepter::getentry(UInt_t ientry)
{
  gettree("in")->GetEntry(ientry);
}
//----------------------------------------------------------------------------------------
Long64_t varkeepter::getentries()
{
  return gettree("in")->GetEntries();
}
//----------------------------------------------------------------------------------------
Float_t varkeepter::getval(TString name)
{
  if(float_map_.find(name)  != float_map_.end())  return float_map_[name];
  if(double_map_.find(name) != double_map_.end()) return double_map_[name];
  if(  int_map_.find(name)  !=   int_map_.end())  return   int_map_[name];
  if( uint_map_.find(name)  !=  uint_map_.end())  return  uint_map_[name];
  cout << "ERROR: var " << name << " not found." << endl;
  assert(0);
}  
//----------------------------------------------------------------------------------------
Float_t varkeepter::getfloatval(TString name)
{
  if(float_map_.find(name) == float_map_.end()) {
    cerr << "varkeepter: " << name << " not found!" << endl;
    assert(0);
  }
  return float_map_[name];
}
//----------------------------------------------------------------------------------------
UInt_t varkeepter::getuintval(TString name)
{
  if(uint_map_.find(name) == uint_map_.end()) {
    cerr << "varkeepter: " << name << " not found!" << endl;
    assert(0);
  }
  return uint_map_[name];
}
//----------------------------------------------------------------------------------------
Int_t varkeepter::getintval(TString name)
{
  if(int_map_.find(name) == int_map_.end()) {
    cerr << "varkeepter: " << name << " not found!" << endl;
    assert(0);
  }
  return int_map_[name];
}
//----------------------------------------------------------------------------------------
void varkeepter::setval(TString name, Float_t val)
{
  if(float_map_.find(name) == float_map_.end()) {
    cerr << "varkeepter: " << name << " not found!" << endl;
    assert(0);
  }
  float_map_[name] = val;
}
//----------------------------------------------------------------------------------------
void varkeepter::setval(TString name, Double_t val)
{
  if(double_map_.find(name) == double_map_.end()) {
    cerr << "varkeepter: " << name << " not found!" << endl;
    assert(0);
  }
  double_map_[name] = val;
}
//----------------------------------------------------------------------------------------
void varkeepter::setval(TString name, UInt_t val)
{
  if(uint_map_.find(name) == uint_map_.end()) {
    cerr << "varkeepter: " << name << " not found!" << endl;
    assert(0);
  }
  uint_map_[name] = val;
}
//----------------------------------------------------------------------------------------
void varkeepter::setval(TString name, Int_t val)
{
  if(int_map_.find(name) == int_map_.end()) {
    cerr << "varkeepter: " << name << " not found!" << endl;
    assert(0);
  }
  int_map_[name] = val;
}
//----------------------------------------------------------------------------------------
void varkeepter::fill()
{
  assert(mode_!="r");
  gettree("out")->Fill();
}
//----------------------------------------------------------------------------------------
void varkeepter::writeclose()
{
  assert(mode_!="r");
  outfile_->cd();
  outfile_->Write();
  outfile_->Close();
}

Revision:	1.2
Committed:	Mon Dec 17 17:23:07 2012 UTC (12 years, 5 months ago) by dkralph
Content type:	text/plain
Branch:	MAIN
CVS Tags:	compiled
Changes since 1.1:	+1 -0 lines
Log Message:	* empty log message *
#	Content
1	#include "varkeepter.h"
2
3	varkeepter::varkeepter(TString varfile, TString modepar, TString treefile, int dummy, TString treename, TTree *intree):
4	mode_(modepar),
5	infile_(0),
6	intreename_(treename),
7	intree_(0),
8	outfile_(0),
9	outtreename_(treename),
10	outtree_(0)
11	{
12	dummy += 7; // horrible hack to make the constructor overloading not be ambiguous...
13	readtext(varfile);
14	init(mode_, treefile, intree);
15	}
16	//----------------------------------------------------------------------------------------
17	varkeepter::varkeepter(TString varfile, TString modepar, TString infilename, TString outfilename, TString treename):
18	mode_(modepar),
19	infile_(0),
20	intreename_(treename),
21	intree_(0),
22	outfile_(0),
23	outtreename_(treename),
24	outtree_(0)
25	{
26	// use this form to read a tree and copy it to a new file (with modifications/cuts)
27	assert(modepar=="rw");
28	readtext(varfile);
29	init("r",infilename);
30	init("w",outfilename);
31	}
32	//----------------------------------------------------------------------------------------
33	void varkeepter::readtext(TString varfile)
34	{
35	// read in list of variables and types from text file
36	ifstream ifs(varfile);
37	assert(ifs.is_open());
38	string line;
39	while(getline(ifs,line)) {
40	if(line[0]=='#') continue;
41	stringstream ss(line);
42	TString name,type;
43	ss >> type >> name;
44	namev_.push_back(name);
45	typev_.push_back(type);
46	if(type=="F") float_map_[name] = 0;
47	else if(type=="D") double_map_[name] = 0;
48	else if(type=="i") uint_map_[name] = 0;
49	else if(type=="I") int_map_[name] = 0;
50	else assert(0);
51	}
52	}
53	//----------------------------------------------------------------------------------------
54	void varkeepter::init(TString initmode, TString treefile, TTree *intree)
55	{
56	if(initmode=="r") {
57	if(intree) {
58	infname_ = "";
59	infile_ = 0;
60	intree_ = intree;
61	} else {
62	infname_ = treefile;
63	infile_ = TFile::Open(infname_); assert(infile_);
64	infile_->GetObject(intreename_,intree_); assert(intree_);
65	}
66	} else if(initmode=="w") {
67	outfname_ = treefile;
68	outfile_ = TFile::Open(outfname_,"recreate"); assert(outfile_);
69	outtree_ = new TTree(outtreename_,outtreename_); assert(outtree_);
70	outtree_->SetAutoFlush(0);//????????????????????????????????????????????????????????????????????????????????????????
71	} else assert(0);
72
73	// set addresses or make branches for unsigned ints
74	map<TString,UInt_t>::iterator it_uint;
75	for(it_uint=uint_map_.begin(); it_uint!=uint_map_.end(); it_uint++) {
76	if(initmode=="r")
77	intree_->SetBranchAddress((it_uint).first,&(it_uint).second);
78	else if(initmode=="w")
79	outtree_->Branch((it_uint).first,&(it_uint).second,(*it_uint).first+"/i");
80	else assert(0);
81	}
82	// set addresses or make branches for ints
83	map<TString,Int_t>::iterator it_int;
84	for(it_int=int_map_.begin(); it_int!=int_map_.end(); it_int++) {
85	if(initmode=="r")
86	intree_->SetBranchAddress((it_int).first,&(it_int).second);
87	else if(initmode=="w")
88	outtree_->Branch((it_int).first,&(it_int).second,(*it_int).first+"/I");
89	else assert(0);
90	}
91	// set addresses or make branches for floats
92	map<TString,Float_t>::iterator it_float;
93	for(it_float=float_map_.begin(); it_float!=float_map_.end(); it_float++) {
94	if(initmode=="r") {
95	TString branchname((*it_float).first);
96	intree_->SetBranchAddress(branchname,&(*it_float).second);
97	} else if(initmode=="w")
98	outtree_->Branch((it_float).first,&(it_float).second,(*it_float).first+"/F");
99	else assert(0);
100	}
101	// set addresses or make branches for doubles
102	map<TString,Double_t>::iterator it_double;
103	for(it_double=double_map_.begin(); it_double!=double_map_.end(); it_double++) {
104	if(initmode=="r") {
105	TString branchname((*it_double).first);
106	intree_->SetBranchAddress(branchname,&(*it_double).second);
107	} else if(initmode=="w")
108	outtree_->Branch((it_double).first,&(it_double).second,(*it_double).first+"/D");
109	else assert(0);
110	}
111	}
112	//----------------------------------------------------------------------------------------
113	TTree *varkeepter::gettree(TString inout)
114	{
115	// ignores inout if mode_ is r or w
116	if(mode_=="r" \|\| (mode_=="rw" && inout=="in")) { assert(intree_); return intree_; }
117	else if(mode_=="w" \|\| (mode_=="rw" && inout=="out")) { assert(outtree_); return outtree_; }
118	else assert(0);
119	}
120	//----------------------------------------------------------------------------------------
121	void varkeepter::getentry(UInt_t ientry)
122	{
123	gettree("in")->GetEntry(ientry);
124	}
125	//----------------------------------------------------------------------------------------
126	Long64_t varkeepter::getentries()
127	{
128	return gettree("in")->GetEntries();
129	}
130	//----------------------------------------------------------------------------------------
131	Float_t varkeepter::getval(TString name)
132	{
133	if(float_map_.find(name) != float_map_.end()) return float_map_[name];
134	if(double_map_.find(name) != double_map_.end()) return double_map_[name];
135	if( int_map_.find(name) != int_map_.end()) return int_map_[name];
136	if( uint_map_.find(name) != uint_map_.end()) return uint_map_[name];
137	cout << "ERROR: var " << name << " not found." << endl;
138	assert(0);
139	}
140	//----------------------------------------------------------------------------------------
141	Float_t varkeepter::getfloatval(TString name)
142	{
143	if(float_map_.find(name) == float_map_.end()) {
144	cerr << "varkeepter: " << name << " not found!" << endl;
145	assert(0);
146	}
147	return float_map_[name];
148	}
149	//----------------------------------------------------------------------------------------
150	UInt_t varkeepter::getuintval(TString name)
151	{
152	if(uint_map_.find(name) == uint_map_.end()) {
153	cerr << "varkeepter: " << name << " not found!" << endl;
154	assert(0);
155	}
156	return uint_map_[name];
157	}
158	//----------------------------------------------------------------------------------------
159	Int_t varkeepter::getintval(TString name)
160	{
161	if(int_map_.find(name) == int_map_.end()) {
162	cerr << "varkeepter: " << name << " not found!" << endl;
163	assert(0);
164	}
165	return int_map_[name];
166	}
167	//----------------------------------------------------------------------------------------
168	void varkeepter::setval(TString name, Float_t val)
169	{
170	if(float_map_.find(name) == float_map_.end()) {
171	cerr << "varkeepter: " << name << " not found!" << endl;
172	assert(0);
173	}
174	float_map_[name] = val;
175	}
176	//----------------------------------------------------------------------------------------
177	void varkeepter::setval(TString name, Double_t val)
178	{
179	if(double_map_.find(name) == double_map_.end()) {
180	cerr << "varkeepter: " << name << " not found!" << endl;
181	assert(0);
182	}
183	double_map_[name] = val;
184	}
185	//----------------------------------------------------------------------------------------
186	void varkeepter::setval(TString name, UInt_t val)
187	{
188	if(uint_map_.find(name) == uint_map_.end()) {
189	cerr << "varkeepter: " << name << " not found!" << endl;
190	assert(0);
191	}
192	uint_map_[name] = val;
193	}
194	//----------------------------------------------------------------------------------------
195	void varkeepter::setval(TString name, Int_t val)
196	{
197	if(int_map_.find(name) == int_map_.end()) {
198	cerr << "varkeepter: " << name << " not found!" << endl;
199	assert(0);
200	}
201	int_map_[name] = val;
202	}
203	//----------------------------------------------------------------------------------------
204	void varkeepter::fill()
205	{
206	assert(mode_!="r");
207	gettree("out")->Fill();
208	}
209	//----------------------------------------------------------------------------------------
210	void varkeepter::writeclose()
211	{
212	assert(mode_!="r");
213	outfile_->cd();
214	outfile_->Write();
215	outfile_->Close();
216	}
217