interface/HistHelpers/HistogramManager.h

/*
 * HistogramManager.h
 *
 *  Created on: 4 Jul 2010
 *      Author: kreczko
 */

#ifndef HISTOGRAMMANAGER_H_
#define HISTOGRAMMANAGER_H_
#include "THCollection.h"
#include "TH1D.h"
#include "TH2D.h"
#include "../../interface/DataTypes.h"
#include <boost/shared_ptr.hpp>
#include <boost/array.hpp>
#include <boost/multi_array.hpp>
#include "TFile.h"
#include <string>

namespace BAT {

namespace JetBin {
enum value {
    NoJet,
    OneJet,
    TwoJets,
    ThreeJets,
    FourOrMoreJets,
    NUMBER_OF_JET_BINS
};

const boost::array<std::string, JetBin::NUMBER_OF_JET_BINS> names = {
        { "0jet", "1jet", "2jets", "3jets", "4orMoreJets"
        } };
}

namespace JetBinSummed {
enum value {
    allJet,
    OneOrMoreJets,
    TwoOrMoreJets,
    ThreeOrMoreJets,
    NUMBER_OF_SUMMED_JET_BINS
};

const boost::array<std::string, JetBinSummed::NUMBER_OF_SUMMED_JET_BINS> names = { {
        "0orMoreJets",
        "1orMoreJets",
        "2orMoreJets",
        "3orMoreJets" } };
}

namespace BJetBin {
enum value {
    NoBtag,
    OneBTag,
    TwoBtags,
    ThreeBtags,
    FourOrMoreBTags,
    NUMBER_OF_BJET_BINS
};

const boost::array<std::string, BJetBin::NUMBER_OF_BJET_BINS> names = { {
        "0btag",
        "1btag",
        "2btags",
        "3btags",
        "4orMoreBtags" } };
}

namespace BJetBinSummed {
enum value {
    allBtags,
    OneOrMoreBTags,
    TwoOrMoreBTags,
    ThreeOrMoreBTags,
    NUMBER_OF_SUMMED_BJET_BINS
};

const boost::array<std::string, BJetBinSummed::NUMBER_OF_SUMMED_BJET_BINS> names = { {
        "0orMoreBtag",
        "1orMoreBtag",
        "2orMoreBtags",
        "3orMoreBtags" } };
}

namespace LeptonBin {
enum value {
    Electron,
    Muon,
    NUMBER_OF_LEPTON_BINS
};

const boost::array<std::string, LeptonBin::NUMBER_OF_LEPTON_BINS> names = { {
        "elec",
        "mu" } };
}

namespace LepBinSummed {
enum value {
    lepton,
    NUMBER_OF_SUMMED_LEPTON_BINS
};

const boost::array<std::string, LepBinSummed::NUMBER_OF_SUMMED_LEPTON_BINS> names = { {
        "lepton" } };
}

typedef unsigned short ushort;
class HistogramManager {
public:
    HistogramManager();
    virtual ~HistogramManager();
    void createAllHistograms();
    void addH1D(std::string name, std::string title, unsigned int nBins, float xmin, float xmax);
    void addH1D_JetBinned(std::string name, std::string title, unsigned int nBins, float xmin, float xmax);
    void addH1D_BJetBinned(std::string name, std::string title, unsigned int nBins, float xmin, float xmax);
    void addH2D_BJetBinned(std::string name, std::string title, unsigned int nXBins, float xmin, float xmax,
            unsigned int nYBins, float ymin, float ymax);

    void addH1D_LepBinned(std::string name, std::string title, unsigned int nBins, float xmin, float xmax);

    void addH2D(std::string name, std::string title, unsigned int nXBins, float xmin, float xmax, unsigned int nYBins,
            float ymin, float ymax);

    void setCurrentDataType(DataType::value type);
    void setCurrentJetBin(unsigned int jetbin);
    void setCurrentBJetBin(unsigned int jetbin);
    void setCurrentLepBin(unsigned int jetbin);
    void setCurrentLumi(float lumi);
    void prepareForSeenDataTypes(const boost::array<bool, DataType::NUMBER_OF_DATA_TYPES>& seenDataTypes);

    boost::shared_ptr<TH1> operator[](std::string);
    boost::shared_ptr<TH1> H1D(std::string);
    boost::shared_ptr<TH1> H1D_JetBinned(std::string);
    boost::shared_ptr<TH1> H1D_BJetBinned(std::string);
    boost::shared_ptr<TH1> H1D_LepBinned(std::string);
    boost::shared_ptr<TH2> operator()(std::string);
    boost::shared_ptr<TH2> H2D(std::string);
    boost::shared_ptr<TH2> H2D_JetBinned(std::string);
    boost::shared_ptr<TH2> H2D_BJetBinned(std::string);

    int Section;

    void writeToDisk();
private:
    boost::multi_array<TH1CollectionRef, 2> jetBinned1DHists;
    std::vector<std::string> jetBinned1DHistNames;
    boost::multi_array<TH2CollectionRef, 2> jetBinned2DHists;
    std::vector<std::string> jetBinned2DHistNames;
    boost::multi_array<TH1CollectionRef, 2> bJetBinned1DHists;
    boost::multi_array<TH1CollectionRef, 2> lepBinned1DHists;
    std::vector<std::string> bJetBinned1DHistNames;
    std::vector<std::string> lepBinned1DHistNames;
    boost::multi_array<TH2CollectionRef, 2> bJetBinned2DHists;
    std::vector<std::string> bJetBinned2DHistNames;
    boost::array<bool, DataType::NUMBER_OF_DATA_TYPES> seenDataTypes;
    boost::array<boost::shared_ptr<TFile>, DataType::NUMBER_OF_DATA_TYPES> histFiles;
    boost::array<TH1CollectionRef, DataType::NUMBER_OF_DATA_TYPES> collection;// move to array of DataTypes
    std::vector<std::string> collection1DHistNames;
    boost::array<TH2CollectionRef, DataType::NUMBER_OF_DATA_TYPES> collection2D;
    std::vector<std::string> collection2DHistNames;
    DataType::value currentDataType;
    unsigned int currentJetbin;
    unsigned int currentBJetbin;
    unsigned int currentLepbin;
    float currentIntegratedLumi;

    const std::string assembleFilename(DataType::value) const;
    void createSummedHistograms(DataType::value);
    void createJetSummedHistograms(DataType::value);
    void createBJetSummedHistograms(DataType::value);
    void createLepSummedHistograms(DataType::value);
};

}

#endif /* HISTOGRAMMANAGER_H_ */
Revision:	1.1
Committed:	Thu Dec 1 16:28:48 2011 UTC (13 years, 5 months ago) by dhidas
Content type:	text/plain
Branch point for:	dhidas, MAIN
Log Message:	Initial revision
#	User	Rev	Content
1	dhidas	1.1	/*
2			* HistogramManager.h
3			*
4			* Created on: 4 Jul 2010
5			* Author: kreczko
6			*/
7
8			#ifndef HISTOGRAMMANAGER_H_
9			#define HISTOGRAMMANAGER_H_
10			#include "THCollection.h"
11			#include "TH1D.h"
12			#include "TH2D.h"
13			#include "../../interface/DataTypes.h"
14			#include <boost/shared_ptr.hpp>
15			#include <boost/array.hpp>
16			#include <boost/multi_array.hpp>
17			#include "TFile.h"
18			#include <string>
19
20			namespace BAT {
21
22			namespace JetBin {
23			enum value {
24			NoJet,
25			OneJet,
26			TwoJets,
27			ThreeJets,
28			FourOrMoreJets,
29			NUMBER_OF_JET_BINS
30			};
31
32			const boost::array<std::string, JetBin::NUMBER_OF_JET_BINS> names = {
33			{ "0jet", "1jet", "2jets", "3jets", "4orMoreJets"
34			} };
35			}
36
37			namespace JetBinSummed {
38			enum value {
39			allJet,
40			OneOrMoreJets,
41			TwoOrMoreJets,
42			ThreeOrMoreJets,
43			NUMBER_OF_SUMMED_JET_BINS
44			};
45
46			const boost::array<std::string, JetBinSummed::NUMBER_OF_SUMMED_JET_BINS> names = { {
47			"0orMoreJets",
48			"1orMoreJets",
49			"2orMoreJets",
50			"3orMoreJets" } };
51			}
52
53			namespace BJetBin {
54			enum value {
55			NoBtag,
56			OneBTag,
57			TwoBtags,
58			ThreeBtags,
59			FourOrMoreBTags,
60			NUMBER_OF_BJET_BINS
61			};
62
63			const boost::array<std::string, BJetBin::NUMBER_OF_BJET_BINS> names = { {
64			"0btag",
65			"1btag",
66			"2btags",
67			"3btags",
68			"4orMoreBtags" } };
69			}
70
71			namespace BJetBinSummed {
72			enum value {
73			allBtags,
74			OneOrMoreBTags,
75			TwoOrMoreBTags,
76			ThreeOrMoreBTags,
77			NUMBER_OF_SUMMED_BJET_BINS
78			};
79
80			const boost::array<std::string, BJetBinSummed::NUMBER_OF_SUMMED_BJET_BINS> names = { {
81			"0orMoreBtag",
82			"1orMoreBtag",
83			"2orMoreBtags",
84			"3orMoreBtags" } };
85			}
86
87			namespace LeptonBin {
88			enum value {
89			Electron,
90			Muon,
91			NUMBER_OF_LEPTON_BINS
92			};
93
94			const boost::array<std::string, LeptonBin::NUMBER_OF_LEPTON_BINS> names = { {
95			"elec",
96			"mu" } };
97			}
98
99			namespace LepBinSummed {
100			enum value {
101			lepton,
102			NUMBER_OF_SUMMED_LEPTON_BINS
103			};
104
105			const boost::array<std::string, LepBinSummed::NUMBER_OF_SUMMED_LEPTON_BINS> names = { {
106			"lepton" } };
107			}
108
109			typedef unsigned short ushort;
110			class HistogramManager {
111			public:
112			HistogramManager();
113			virtual ~HistogramManager();
114			void createAllHistograms();
115			void addH1D(std::string name, std::string title, unsigned int nBins, float xmin, float xmax);
116			void addH1D_JetBinned(std::string name, std::string title, unsigned int nBins, float xmin, float xmax);
117			void addH1D_BJetBinned(std::string name, std::string title, unsigned int nBins, float xmin, float xmax);
118			void addH2D_BJetBinned(std::string name, std::string title, unsigned int nXBins, float xmin, float xmax,
119			unsigned int nYBins, float ymin, float ymax);
120
121			void addH1D_LepBinned(std::string name, std::string title, unsigned int nBins, float xmin, float xmax);
122
123			void addH2D(std::string name, std::string title, unsigned int nXBins, float xmin, float xmax, unsigned int nYBins,
124			float ymin, float ymax);
125
126			void setCurrentDataType(DataType::value type);
127			void setCurrentJetBin(unsigned int jetbin);
128			void setCurrentBJetBin(unsigned int jetbin);
129			void setCurrentLepBin(unsigned int jetbin);
130			void setCurrentLumi(float lumi);
131			void prepareForSeenDataTypes(const boost::array<bool, DataType::NUMBER_OF_DATA_TYPES>& seenDataTypes);
132
133			boost::shared_ptr<TH1> operator[](std::string);
134			boost::shared_ptr<TH1> H1D(std::string);
135			boost::shared_ptr<TH1> H1D_JetBinned(std::string);
136			boost::shared_ptr<TH1> H1D_BJetBinned(std::string);
137			boost::shared_ptr<TH1> H1D_LepBinned(std::string);
138			boost::shared_ptr<TH2> operator()(std::string);
139			boost::shared_ptr<TH2> H2D(std::string);
140			boost::shared_ptr<TH2> H2D_JetBinned(std::string);
141			boost::shared_ptr<TH2> H2D_BJetBinned(std::string);
142
143			int Section;
144
145			void writeToDisk();
146			private:
147			boost::multi_array<TH1CollectionRef, 2> jetBinned1DHists;
148			std::vector<std::string> jetBinned1DHistNames;
149			boost::multi_array<TH2CollectionRef, 2> jetBinned2DHists;
150			std::vector<std::string> jetBinned2DHistNames;
151			boost::multi_array<TH1CollectionRef, 2> bJetBinned1DHists;
152			boost::multi_array<TH1CollectionRef, 2> lepBinned1DHists;
153			std::vector<std::string> bJetBinned1DHistNames;
154			std::vector<std::string> lepBinned1DHistNames;
155			boost::multi_array<TH2CollectionRef, 2> bJetBinned2DHists;
156			std::vector<std::string> bJetBinned2DHistNames;
157			boost::array<bool, DataType::NUMBER_OF_DATA_TYPES> seenDataTypes;
158			boost::array<boost::shared_ptr<TFile>, DataType::NUMBER_OF_DATA_TYPES> histFiles;
159			boost::array<TH1CollectionRef, DataType::NUMBER_OF_DATA_TYPES> collection;// move to array of DataTypes
160			std::vector<std::string> collection1DHistNames;
161			boost::array<TH2CollectionRef, DataType::NUMBER_OF_DATA_TYPES> collection2D;
162			std::vector<std::string> collection2DHistNames;
163			DataType::value currentDataType;
164			unsigned int currentJetbin;
165			unsigned int currentBJetbin;
166			unsigned int currentLepbin;
167			float currentIntegratedLumi;
168
169			const std::string assembleFilename(DataType::value) const;
170			void createSummedHistograms(DataType::value);
171			void createJetSummedHistograms(DataType::value);
172			void createBJetSummedHistograms(DataType::value);
173			void createLepSummedHistograms(DataType::value);
174			};
175
176			}
177
178			#endif /* HISTOGRAMMANAGER_H_ */