Histo1DActions/Histo1DAction/Histo1DAction.h

/*
 * Histo1DAction.h
 *
 *  Created on: 25/ago/2009
 *      Author: Nicola Mori
 */

/*! @file Histo1DAction.h The Histo1DAction class declaration file. */

#ifndef HISTO1DACTION_H_
#define HISTO1DACTION_H_

#include "../../CollectionAction/CollectionAction.h"

#include <TH1I.h>
#include <TH1F.h>
#include <TH1D.h>

/*! @brief An abstract action that fills a 1-dimensional histogram.
 *
 * This abstract class provides all the common methods needed to produce 1-dimensional histograms,
 * like reading the bins from a file, setting up the root histogram and so on. It handles histograms
 * both as a ROOT histogram and as a vector. The OnGood() method has to be implemented in children
 * classes, with the specific physical variable to fill the histogram. Eg., a rigidity histogram class
 * derived from Histo1DAction could have this OnGood() implementation:
 *
 * Fill(event->GetTrack(0)->GetTrkTrack()->GetRigidity());
 *
 * Fill() automatically fills the ROOT and the vector histogram.
 * The template argument HistoType is the type of histogram (Int_t, Double_t,...). In current
 * implementation, ROOT histograms are only supported for Int_t, Float_t and Double_t. For all the
 * other types, only the the vector histogram with text file output will be produced. If you want to
 * implement some new types of ROOT histograms, please specialize the template definitions of _CreateHisto()
 * and ~Histo1DAction() (see the specializations in the .cpp file).
 *
 * */
template<class HistoType>
class Histo1DAction: public CollectionAction {
public:

  /*! @brief Constructor.
   *
   * Binning is read from a text file.
   *
   * @param actionName The action's name.
   * @param title The ROOT histogram title.
   * @param outFileBase The file base name for the histogram output. If "", no output file will be produced.
   * @param mode The mode of ROOT file creation (see documentation of TFile constructor
   *             in ROOT's reference guide).
   * @param outRoot If true, an output ROOT file named outFileBase + ".root" will be produced.
   * @param outText If true, an output text file named outFileBase + ".txt" will be produced. It will overwrite an
   *                eventually existing file with the same name.
   */
  Histo1DAction(const char *actionName, TString title, TString outFileBase = "", TString mode = "UPDATE", bool outRoot =
      false, bool outText = false);

  /*! @brief Destructor
   *
   * This has to be specialized for each kind of ROOT histogram.
   *
   * */
  ~Histo1DAction();

  /*! @brief Sets the X axis using a binning read from a a vector.
   *
   * @param label The axis' label.
   * @param bins A vector containing the histogram binning (with sign, eventually; from lowest to highest).
   */
  void SetXAxis(TString label, vector<float> &bins);
  /*! @brief Sets the X axis reading the binning from a file.
   *
   * @param label The axis' label.
   * @param binsFile The file containing the bins (with sign, eventually; from lowest to highest).
   */
  void SetXAxis(TString label, TString binsFile);
  /*! @brief Sets the X axis specifying the binning parameters.
   *
   * @param label The axis' label.
   * @param nBins The number of bins.
   * @param min The lower limit of the axis.
   * @param max The upper limit of the axis.
   * @param logBinning If true, bins will be logarithmically spaced.
   */
  void SetXAxis(TString label, unsigned int nBins, float min, float max, bool logBinning = false);

  /*! @brief Sets up the histogram
   *
   * This routine effectively prepares the histogram, after the desired parameters has been set by #SetXAxis() and #SetYAxis().
   *
   * @param events Pointer to PamLevel2 events (unused).
   */
  void Setup(PamLevel2 *events) {
    CollectionAction::Setup(events);
    _InitHistos();

  }
  /*! @ brief Post-analysis tasks.
   *
   * This method writes the output on a ROOT file if the proper option was set in the constructor.
   */
  void Finalize();

  /*! @brief Returns the histogram.
   *
   * @return A reference to a vector containing the values of the bins of the histogram.
   */
  vector<HistoType> &GetHisto() {
    return _histo;
  }

  /*! Fills the ROOT and the vector histogram. */
  void Fill(double value, double weight = 1.);

  /*! @brief The number of events which fell below the lower histogram limit. */
  HistoType GetOverflow() {
    return _overflow;
  }

  /*! @brief The number of events which fell above the upper histogram limit. */
  HistoType GetUnderflow() {
    return _underflow;
  }

protected:

  std::vector<float> _bins;
  vector<HistoType> _histo;
  TH1 *_rootHisto;

private:

  unsigned int _underflow, _overflow;

  TString _outFileBase;
  TString _mode;
  TString _title, _xLabel;
  bool _outRoot;
  bool _outText;

  void _CreateHisto();
  void _InitHistos();
};

template<class HistoType>
void Histo1DAction<HistoType>::_CreateHisto() {

  // No ROOT histogram for generic type; see template specializations in .cpp file.
  _rootHisto = NULL;
}

template<class HistoType>
void Histo1DAction<HistoType>::_InitHistos() {

  _CreateHisto();

  if (_rootHisto) {
    Double_t *auxArray = new Double_t[_bins.size()];

    for (unsigned int i = 0; i < _bins.size(); i++) {
      auxArray[i] = _bins[i];
    }

    _rootHisto->SetBins(_bins.size() - 1, auxArray);
    _rootHisto->SetName(GetName());
    _rootHisto->SetTitle(_title);
    _rootHisto->SetXTitle(_xLabel);
    _rootHisto->SetYTitle("Events");

    delete[] auxArray;

  }

  _histo.resize(_bins.size() - 1);

}

template<class HistoType>
Histo1DAction<HistoType>::~Histo1DAction() {
}

template<class HistoType>
Histo1DAction<HistoType>::Histo1DAction(const char *actionName, TString title, TString outFileBase, TString mode,
    bool outRoot, bool outText) :
  CollectionAction(actionName), _bins(0), _histo(0), _rootHisto(NULL), _outFileBase(outFileBase), _mode(mode), _title(
      title), _xLabel(""), _outRoot(outRoot), _outText(outText) {

}

template<class HistoType>
void Histo1DAction<HistoType>::SetXAxis(TString label, vector<float> &bins) {

  _bins = bins;
  _xLabel = label;

}

template<class HistoType>
void Histo1DAction<HistoType>::SetXAxis(TString label, TString binsFile) {

  // Reading the bins from file
  ifstream binListFile;
  binListFile.open(binsFile);

  TString auxString;
  _bins.resize(0);
  while (!binListFile.eof()) {
    binListFile >> auxString;
    if (auxString != "") {
      _bins.push_back(auxString.Atof());
    }
  }
  binListFile.close();

  _xLabel = label;

}

template<class HistoType>
void Histo1DAction<HistoType>::SetXAxis(TString label, unsigned int nBins, float min, float max, bool logBinning) {

  _bins.resize(nBins + 1);

  if (!logBinning || (logBinning && min <= 0.)) {

#ifdef DEBUGPAMCUT
    if (logbinning && rigMin <= 0.)
    cout << "Warning: logarithmic binning was chosen for X axis but min <= 0. Using linear binning."
#endif

    float step = (max - min) / nBins;
    for (unsigned int i = 0; i < nBins + 1; i++) {
      _bins[i] = min + i * step;
    }

  }
  else {

    double maxExp = log10(max / min);
    for (unsigned int i = 0; i < nBins + 1; i++) {
      _bins[i] = min * pow(10., (double) i / ((double) nBins) * maxExp);
    }

  }

  _xLabel = label;
}

template<class HistoType>
inline void Histo1DAction<HistoType>::Fill(double value, double weight) {

  _rootHisto->Fill(value, weight);

  if (value < _bins[0]) {
    _underflow += (HistoType) weight;
    return;
  }

  if (value > _bins[_bins.size() - 1]) {
    _overflow += (HistoType) weight;
    return;
  }

  int xBin = 1;
  while (value >= _bins[xBin]) {
    xBin++;
  }
  xBin--;

  _histo[xBin] += (HistoType) weight;
}

template<class HistoType>
void Histo1DAction<HistoType>::Finalize() {

  if (_outFileBase != "") {
    // Write the ROOT file
    if (_rootHisto && _outRoot) {
      TFile outRootFile((_outFileBase + ".root"), _mode);
      outRootFile.cd();
      _rootHisto->Write();
      outRootFile.Close();
    }

    //Write the text file
    if (_outText) {
      ofstream outTextFile((_outFileBase + ".txt").Data(), ios_base::out);
      for (unsigned int i = 0; i < _histo.size(); i++) {
        outTextFile << _histo[i] << "\n";
      }
      outTextFile << endl;
      outTextFile.close();
    }
  }

}
#endif /* HISTO1DACTION_H_ */
1	/*
2	* Histo1DAction.h
3	*
4	* Created on: 25/ago/2009
5	* Author: Nicola Mori
6	*/
7
8	/! @file Histo1DAction.h The Histo1DAction class declaration file. /
9
10	#ifndef HISTO1DACTION_H_
11	#define HISTO1DACTION_H_
12
13	#include "../../CollectionAction/CollectionAction.h"
14
15	#include <TH1I.h>
16	#include <TH1F.h>
17	#include <TH1D.h>
18
19	/*! @brief An abstract action that fills a 1-dimensional histogram.
20	*
21	* This abstract class provides all the common methods needed to produce 1-dimensional histograms,
22	* like reading the bins from a file, setting up the root histogram and so on. It handles histograms
23	* both as a ROOT histogram and as a vector. The OnGood() method has to be implemented in children
24	* classes, with the specific physical variable to fill the histogram. Eg., a rigidity histogram class
25	* derived from Histo1DAction could have this OnGood() implementation:
26	*
27	* Fill(event->GetTrack(0)->GetTrkTrack()->GetRigidity());
28	*
29	* Fill() automatically fills the ROOT and the vector histogram.
30	* The template argument HistoType is the type of histogram (Int_t, Double_t,...). In current
31	* implementation, ROOT histograms are only supported for Int_t, Float_t and Double_t. For all the
32	* other types, only the the vector histogram with text file output will be produced. If you want to
33	* implement some new types of ROOT histograms, please specialize the template definitions of _CreateHisto()
34	* and ~Histo1DAction() (see the specializations in the .cpp file).
35	*
36	* */
37	template<class HistoType>
38	class Histo1DAction: public CollectionAction {
39	public:
40
41	/*! @brief Constructor.
42	*
43	* Binning is read from a text file.
44	*
45	* @param actionName The action's name.
46	* @param title The ROOT histogram title.
47	* @param outFileBase The file base name for the histogram output. If "", no output file will be produced.
48	* @param mode The mode of ROOT file creation (see documentation of TFile constructor
49	* in ROOT's reference guide).
50	* @param outRoot If true, an output ROOT file named outFileBase + ".root" will be produced.
51	* @param outText If true, an output text file named outFileBase + ".txt" will be produced. It will overwrite an
52	* eventually existing file with the same name.
53	*/
54	Histo1DAction(const char *actionName, TString title, TString outFileBase = "", TString mode = "UPDATE", bool outRoot =
55	false, bool outText = false);
56
57	/*! @brief Destructor
58	*
59	* This has to be specialized for each kind of ROOT histogram.
60	*
61	* */
62	~Histo1DAction();
63
64	/*! @brief Sets the X axis using a binning read from a a vector.
65	*
66	* @param label The axis' label.
67	* @param bins A vector containing the histogram binning (with sign, eventually; from lowest to highest).
68	*/
69	void SetXAxis(TString label, vector<float> &bins);
70	/*! @brief Sets the X axis reading the binning from a file.
71	*
72	* @param label The axis' label.
73	* @param binsFile The file containing the bins (with sign, eventually; from lowest to highest).
74	*/
75	void SetXAxis(TString label, TString binsFile);
76	/*! @brief Sets the X axis specifying the binning parameters.
77	*
78	* @param label The axis' label.
79	* @param nBins The number of bins.
80	* @param min The lower limit of the axis.
81	* @param max The upper limit of the axis.
82	* @param logBinning If true, bins will be logarithmically spaced.
83	*/
84	void SetXAxis(TString label, unsigned int nBins, float min, float max, bool logBinning = false);
85
86	/*! @brief Sets up the histogram
87	*
88	* This routine effectively prepares the histogram, after the desired parameters has been set by #SetXAxis() and #SetYAxis().
89	*
90	* @param events Pointer to PamLevel2 events (unused).
91	*/
92	void Setup(PamLevel2 *events) {
93	CollectionAction::Setup(events);
94	_InitHistos();
95
96	}
97	/*! @ brief Post-analysis tasks.
98	*
99	* This method writes the output on a ROOT file if the proper option was set in the constructor.
100	*/
101	void Finalize();
102
103	/*! @brief Returns the histogram.
104	*
105	* @return A reference to a vector containing the values of the bins of the histogram.
106	*/
107	vector<HistoType> &GetHisto() {
108	return _histo;
109	}
110
111	/! Fills the ROOT and the vector histogram. /
112	void Fill(double value, double weight = 1.);
113
114	/! @brief The number of events which fell below the lower histogram limit. /
115	HistoType GetOverflow() {
116	return _overflow;
117	}
118
119	/! @brief The number of events which fell above the upper histogram limit. /
120	HistoType GetUnderflow() {
121	return _underflow;
122	}
123
124	protected:
125
126	std::vector<float> _bins;
127	vector<HistoType> _histo;
128	TH1 *_rootHisto;
129
130	private:
131
132	unsigned int _underflow, _overflow;
133
134	TString _outFileBase;
135	TString _mode;
136	TString _title, _xLabel;
137	bool _outRoot;
138	bool _outText;
139
140	void _CreateHisto();
141	void _InitHistos();
142	};
143
144	template<class HistoType>
145	void Histo1DAction<HistoType>::_CreateHisto() {
146
147	// No ROOT histogram for generic type; see template specializations in .cpp file.
148	_rootHisto = NULL;
149	}
150
151	template<class HistoType>
152	void Histo1DAction<HistoType>::_InitHistos() {
153
154	_CreateHisto();
155
156	if (_rootHisto) {
157	Double_t *auxArray = new Double_t[_bins.size()];
158
159	for (unsigned int i = 0; i < _bins.size(); i++) {
160	auxArray[i] = _bins[i];
161	}
162
163	_rootHisto->SetBins(_bins.size() - 1, auxArray);
164	_rootHisto->SetName(GetName());
165	_rootHisto->SetTitle(_title);
166	_rootHisto->SetXTitle(_xLabel);
167	_rootHisto->SetYTitle("Events");
168
169	delete[] auxArray;
170
171	}
172
173	_histo.resize(_bins.size() - 1);
174
175	}
176
177	template<class HistoType>
178	Histo1DAction<HistoType>::~Histo1DAction() {
179	}
180
181	template<class HistoType>
182	Histo1DAction<HistoType>::Histo1DAction(const char *actionName, TString title, TString outFileBase, TString mode,
183	bool outRoot, bool outText) :
184	CollectionAction(actionName), _bins(0), _histo(0), _rootHisto(NULL), _outFileBase(outFileBase), _mode(mode), _title(
185	title), _xLabel(""), _outRoot(outRoot), _outText(outText) {
186
187	}
188
189	template<class HistoType>
190	void Histo1DAction<HistoType>::SetXAxis(TString label, vector<float> &bins) {
191
192	_bins = bins;
193	_xLabel = label;
194
195	}
196
197	template<class HistoType>
198	void Histo1DAction<HistoType>::SetXAxis(TString label, TString binsFile) {
199
200	// Reading the bins from file
201	ifstream binListFile;
202	binListFile.open(binsFile);
203
204	TString auxString;
205	_bins.resize(0);
206	while (!binListFile.eof()) {
207	binListFile >> auxString;
208	if (auxString != "") {
209	_bins.push_back(auxString.Atof());
210	}
211	}
212	binListFile.close();
213
214	_xLabel = label;
215
216	}
217
218	template<class HistoType>
219	void Histo1DAction<HistoType>::SetXAxis(TString label, unsigned int nBins, float min, float max, bool logBinning) {
220
221	_bins.resize(nBins + 1);
222
223	if (!logBinning \|\| (logBinning && min <= 0.)) {
224
225	#ifdef DEBUGPAMCUT
226	if (logbinning && rigMin <= 0.)
227	cout << "Warning: logarithmic binning was chosen for X axis but min <= 0. Using linear binning."
228	#endif
229
230	float step = (max - min) / nBins;
231	for (unsigned int i = 0; i < nBins + 1; i++) {
232	_bins[i] = min + i * step;
233	}
234
235	}
236	else {
237
238	double maxExp = log10(max / min);
239	for (unsigned int i = 0; i < nBins + 1; i++) {
240	_bins[i] = min * pow(10., (double) i / ((double) nBins) * maxExp);
241	}
242
243	}
244
245	_xLabel = label;
246	}
247
248	template<class HistoType>
249	inline void Histo1DAction<HistoType>::Fill(double value, double weight) {
250
251	_rootHisto->Fill(value, weight);
252
253	if (value < _bins[0]) {
254	_underflow += (HistoType) weight;
255	return;
256	}
257
258	if (value > _bins[_bins.size() - 1]) {
259	_overflow += (HistoType) weight;
260	return;
261	}
262
263	int xBin = 1;
264	while (value >= _bins[xBin]) {
265	xBin++;
266	}
267	xBin--;
268
269	_histo[xBin] += (HistoType) weight;
270	}
271
272	template<class HistoType>
273	void Histo1DAction<HistoType>::Finalize() {
274
275	if (_outFileBase != "") {
276	// Write the ROOT file
277	if (_rootHisto && _outRoot) {
278	TFile outRootFile((_outFileBase + ".root"), _mode);
279	outRootFile.cd();
280	_rootHisto->Write();
281	outRootFile.Close();
282	}
283
284	//Write the text file
285	if (_outText) {
286	ofstream outTextFile((_outFileBase + ".txt").Data(), ios_base::out);
287	for (unsigned int i = 0; i < _histo.size(); i++) {
288	outTextFile << _histo[i] << "\n";
289	}
290	outTextFile << endl;
291	outTextFile.close();
292	}
293	}
294
295	}
296	#endif /* HISTO1DACTION_H_ */