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 *
#	User	Rev	Content
1	dkralph	1.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	dkralph	1.2	outfile_->cd();
214	dkralph	1.1	outfile_->Write();
215			outfile_->Close();
216			}
217