rootEWKanalyzer/include/baseClass.h

#ifndef baseClass_h
#define baseClass_h

#include "rootNtupleClass.h"
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <fstream>
#include <stdio.h>
#include <iomanip>
#include <TH1F.h>
#include <math.h>
#include <stdlib.h> 

#include "TLorentzVector.h"

#define STDOUT(STRING) {                   \
        std::cout << __FILE__ <<" - Line "<<__LINE__<<" - "<<__FUNCTION__<<": "<< STRING <<std::endl;   \
}

using namespace std;

struct cut {
  string variableName;
  double minValue1;
  double maxValue1;
  double minValue2;
  double maxValue2;
  int level_int;
  string level_str;
  int histoNBins;
  double histoMin;
  double histoMax;
  // Not filled from file
  int id;
  TH1F histo1;
  TH1F histo2;
  TH1F histo3;
  TH1F histo4;
  TH1F histo5;
  // Filled event by event
  bool filled;
  double value;
  bool passed;
  int nEvtInput;
  int nEvtPassed;
};

struct preCut {
  string variableName;
  double value1;
  double value2;
  double value3;
  double value4;
  int level_int;
  string level_str;
};

// Create structure to hold
class Optimize {
 public:
  Optimize(){count=0; variableName=""; minvalue=0; maxvalue=0; testgreater=false; level_int=-10;};
  Optimize(int x0, string x1, double x2, double x3, bool x4, int x5)
    {
      count=x0;
      variableName=x1;
      minvalue=x2;
      maxvalue=x3;
      if (minvalue>maxvalue)
        {
          maxvalue=x2;
          minvalue=x3;
        }
      increment=(maxvalue-minvalue)/9.;
      if (increment<=0)
        increment=1;
      testgreater=x4;
      level_int=x5;
      value=-999999; // dummy start value
    };
  ~Optimize(){};
  int count; // store number for ordering of optimization cuts
  string variableName; // store name of variable
  double minvalue; // minimum threshold value to test
  double maxvalue; // maximum threshold to test
  double increment; // max-min, divided into 10 parts
  bool testgreater; // tests whether value should be greater or less than threshold
  int level_int; // cut level -- not used?
  double value;  // value to check against threshold

  bool Compare(int counter)
    {
      // compare value to threshold # <counter>

      // if testing that value is greater than some threshold, start with lowest threshold first
      bool passed=false;
      if (testgreater)
        {
          double thresh=minvalue+increment*counter; // convert counter # to physical threshold
          value > thresh ? passed=true: passed=false;
        }
      // if testing that value is less than threshold, start with largest threshold first.  This keep the number of \events "monotonically decreasing" over a series of 10 cuts.
      else
        {
          double thresh=maxvalue-increment*counter;
          value < thresh ? passed=true : passed = false;
        }
      return passed;
    }; // comparison function
}; // class Optimize


class myEvent {
 public :
  vector<TLorentzVector> fourvector;
  vector<double> momentum;
  vector<bool> isolation;
  vector<int> charge;
  vector<double> deltaPhi;
  vector<double> deltaEta;
  vector<double> oneOverEminusOverP;
  vector<double> transverseMass;
  vector<double> ethIso;
  vector<double> trkIso;
  vector<double> ecalIso;
  vector<double> hcalIso;
  vector<double> HoverE;
  vector<double> sigmaIetaIeta;
  vector<double> numberOfMissingInnerHits;
  vector<double> deltaPhiMet;
  double missinget;
  bool WorkingPointID(myEvent, vector<double>);
  bool WorkingPointNminus1(myEvent, vector<double>, char *);

}; // class myEvent


class baseClass : public rootNtupleClass, public myEvent {
  public :
  map<string, bool> combCutName_passed_;

  // -------------------------------------
  double multiply(double, double);
  bool triggerBitSelection(int*, int*, int*);
  bool goodPrimaryVertexSelection(int, double);
/*   bool noBeamScrapingSelection(int*, int*); */
  bool ethID(int, double, double, double, double, double);
/*   bool WorkingPointNminus1(myevent, vector<double>, char *); */
  bool ethNminus1(int, double, double, double, double, double, char *, bool);
  bool isolation(double, double);
  double deltaPhi(double, double);
  double transverseMass(double, double, double);
  // -------------------------------------

  void resetCuts();
  void fillVariableWithValue(const std::string&, const double&);
  void evaluateCuts();
  bool passedCut(const string& s);
  bool passedAllPreviousCuts(const string& s);
  bool passedAllOtherCuts(const string& s);
  bool passedAllOtherSameAndLowerLevelCuts(const string& s);
  bool variableIsFilled(const string& s);
  double getVariableValue(const string& s);
  double getPreCutValue1(const string& s);
  double getPreCutValue2(const string& s);
  double getPreCutValue3(const string& s);
  double getPreCutValue4(const string& s);
  double getCutMinValue1(const string& s);
  double getCutMaxValue1(const string& s);
  double getCutMinValue2(const string& s);
  double getCutMaxValue2(const string& s);

  const TH1F& getHisto_noCuts_or_skim(const string& s);
  const TH1F& getHisto_allPreviousCuts(const string& s);
  const TH1F& getHisto_allOthrSmAndLwrLvlCuts(const string& s);
  const TH1F& getHisto_allOtherCuts(const string& s);
  const TH1F& getHisto_allCuts(const string& s);

  int    getHistoNBins(const string& s);
  double getHistoMin(const string& s);
  double getHistoMax(const string& s);


  baseClass(string * inputList, string * cutFile, string * treeName, string *outputFileName=0, string * cutEfficFile=0);
  virtual ~baseClass();

  // Optimization stuff
  void fillOptimizerWithValue(const string& s, const double& d);
  void runOptimizer();

  private :
  string * configFile_;
  string * outputFileName_; 
  TFile * output_root_;
  string * inputList_;
  string * cutFile_;
  string * treeName_; // Name of input tree objects in (.root) files
  TTree * tree_; // main tree
  TTree * tree2_; // tree for globalInfo
  string * cutEfficFile_;
  std::stringstream preCutInfo_;
  map<string, preCut> preCutName_cut_;
  map<string, cut> cutName_cut_;
  vector<string> orderedCutNames_; 
  void init();
  void readInputList();
  void readCutFile();
  bool fillCutHistos();
  bool writeCutHistos();
  bool updateCutEffic();
  bool writeCutEfficFile();
  bool sortCuts(const cut&, const cut&);
  vector<string> split(const string& s);
  double decodeCutValue(const string& s);
  bool skimWasMade_;
  int getGlobalInfoNstart( char* );
  int NBeforeSkim_;
  
  // Optimization stuff
  map<int, Optimize> optimizeName_cut_;
  TH1F* eventcuts_; // number of events passing each cut
  TH1F* h_optimizer_; // optimization histogram

};

#endif

#ifdef baseClass_cxx

#endif // #ifdef baseClass_cxx


Revision:	1.1
Committed:	Mon Jun 7 14:57:39 2010 UTC (14 years, 10 months ago) by jueugste
Content type:	text/plain
Branch:	MAIN
Log Message:	first commit
#	Content
1	#ifndef baseClass_h
2	#define baseClass_h
3
4	#include "rootNtupleClass.h"
5	#include <iostream>
6	#include <sstream>
7	#include <string>
8	#include <vector>
9	#include <map>
10	#include <fstream>
11	#include <stdio.h>
12	#include <iomanip>
13	#include <TH1F.h>
14	#include <math.h>
15	#include <stdlib.h>
16
17	#include "TLorentzVector.h"
18
19	#define STDOUT(STRING) { \
20	std::cout << __FILE__ <<" - Line "<<__LINE__<<" - "<<__FUNCTION__<<": "<< STRING <<std::endl; \
21	}
22
23	using namespace std;
24
25	struct cut {
26	string variableName;
27	double minValue1;
28	double maxValue1;
29	double minValue2;
30	double maxValue2;
31	int level_int;
32	string level_str;
33	int histoNBins;
34	double histoMin;
35	double histoMax;
36	// Not filled from file
37	int id;
38	TH1F histo1;
39	TH1F histo2;
40	TH1F histo3;
41	TH1F histo4;
42	TH1F histo5;
43	// Filled event by event
44	bool filled;
45	double value;
46	bool passed;
47	int nEvtInput;
48	int nEvtPassed;
49	};
50
51	struct preCut {
52	string variableName;
53	double value1;
54	double value2;
55	double value3;
56	double value4;
57	int level_int;
58	string level_str;
59	};
60
61	// Create structure to hold
62	class Optimize {
63	public:
64	Optimize(){count=0; variableName=""; minvalue=0; maxvalue=0; testgreater=false; level_int=-10;};
65	Optimize(int x0, string x1, double x2, double x3, bool x4, int x5)
66	{
67	count=x0;
68	variableName=x1;
69	minvalue=x2;
70	maxvalue=x3;
71	if (minvalue>maxvalue)
72	{
73	maxvalue=x2;
74	minvalue=x3;
75	}
76	increment=(maxvalue-minvalue)/9.;
77	if (increment<=0)
78	increment=1;
79	testgreater=x4;
80	level_int=x5;
81	value=-999999; // dummy start value
82	};
83	~Optimize(){};
84	int count; // store number for ordering of optimization cuts
85	string variableName; // store name of variable
86	double minvalue; // minimum threshold value to test
87	double maxvalue; // maximum threshold to test
88	double increment; // max-min, divided into 10 parts
89	bool testgreater; // tests whether value should be greater or less than threshold
90	int level_int; // cut level -- not used?
91	double value; // value to check against threshold
92
93	bool Compare(int counter)
94	{
95	// compare value to threshold # <counter>
96
97	// if testing that value is greater than some threshold, start with lowest threshold first
98	bool passed=false;
99	if (testgreater)
100	{
101	double thresh=minvalue+increment*counter; // convert counter # to physical threshold
102	value > thresh ? passed=true: passed=false;
103	}
104	// if testing that value is less than threshold, start with largest threshold first. This keep the number of \events "monotonically decreasing" over a series of 10 cuts.
105	else
106	{
107	double thresh=maxvalue-increment*counter;
108	value < thresh ? passed=true : passed = false;
109	}
110	return passed;
111	}; // comparison function
112	}; // class Optimize
113
114
115	class myEvent {
116	public :
117	vector<TLorentzVector> fourvector;
118	vector<double> momentum;
119	vector<bool> isolation;
120	vector<int> charge;
121	vector<double> deltaPhi;
122	vector<double> deltaEta;
123	vector<double> oneOverEminusOverP;
124	vector<double> transverseMass;
125	vector<double> ethIso;
126	vector<double> trkIso;
127	vector<double> ecalIso;
128	vector<double> hcalIso;
129	vector<double> HoverE;
130	vector<double> sigmaIetaIeta;
131	vector<double> numberOfMissingInnerHits;
132	vector<double> deltaPhiMet;
133	double missinget;
134	bool WorkingPointID(myEvent, vector<double>);
135	bool WorkingPointNminus1(myEvent, vector<double>, char *);
136
137	}; // class myEvent
138
139
140	class baseClass : public rootNtupleClass, public myEvent {
141	public :
142	map<string, bool> combCutName_passed_;
143
144	// -------------------------------------
145	double multiply(double, double);
146	bool triggerBitSelection(int, int, int*);
147	bool goodPrimaryVertexSelection(int, double);
148	/* bool noBeamScrapingSelection(int, int); */
149	bool ethID(int, double, double, double, double, double);
150	/* bool WorkingPointNminus1(myevent, vector<double>, char ); /
151	bool ethNminus1(int, double, double, double, double, double, char *, bool);
152	bool isolation(double, double);
153	double deltaPhi(double, double);
154	double transverseMass(double, double, double);
155	// -------------------------------------
156
157	void resetCuts();
158	void fillVariableWithValue(const std::string&, const double&);
159	void evaluateCuts();
160	bool passedCut(const string& s);
161	bool passedAllPreviousCuts(const string& s);
162	bool passedAllOtherCuts(const string& s);
163	bool passedAllOtherSameAndLowerLevelCuts(const string& s);
164	bool variableIsFilled(const string& s);
165	double getVariableValue(const string& s);
166	double getPreCutValue1(const string& s);
167	double getPreCutValue2(const string& s);
168	double getPreCutValue3(const string& s);
169	double getPreCutValue4(const string& s);
170	double getCutMinValue1(const string& s);
171	double getCutMaxValue1(const string& s);
172	double getCutMinValue2(const string& s);
173	double getCutMaxValue2(const string& s);
174
175	const TH1F& getHisto_noCuts_or_skim(const string& s);
176	const TH1F& getHisto_allPreviousCuts(const string& s);
177	const TH1F& getHisto_allOthrSmAndLwrLvlCuts(const string& s);
178	const TH1F& getHisto_allOtherCuts(const string& s);
179	const TH1F& getHisto_allCuts(const string& s);
180
181	int getHistoNBins(const string& s);
182	double getHistoMin(const string& s);
183	double getHistoMax(const string& s);
184
185
186	baseClass(string * inputList, string * cutFile, string * treeName, string outputFileName=0, string cutEfficFile=0);
187	virtual ~baseClass();
188
189	// Optimization stuff
190	void fillOptimizerWithValue(const string& s, const double& d);
191	void runOptimizer();
192
193	private :
194	string * configFile_;
195	string * outputFileName_;
196	TFile * output_root_;
197	string * inputList_;
198	string * cutFile_;
199	string * treeName_; // Name of input tree objects in (.root) files
200	TTree * tree_; // main tree
201	TTree * tree2_; // tree for globalInfo
202	string * cutEfficFile_;
203	std::stringstream preCutInfo_;
204	map<string, preCut> preCutName_cut_;
205	map<string, cut> cutName_cut_;
206	vector<string> orderedCutNames_;
207	void init();
208	void readInputList();
209	void readCutFile();
210	bool fillCutHistos();
211	bool writeCutHistos();
212	bool updateCutEffic();
213	bool writeCutEfficFile();
214	bool sortCuts(const cut&, const cut&);
215	vector<string> split(const string& s);
216	double decodeCutValue(const string& s);
217	bool skimWasMade_;
218	int getGlobalInfoNstart( char* );
219	int NBeforeSkim_;
220
221	// Optimization stuff
222	map<int, Optimize> optimizeName_cut_;
223	TH1F* eventcuts_; // number of events passing each cut
224	TH1F* h_optimizer_; // optimization histogram
225
226	};
227
228	#endif
229
230	#ifdef baseClass_cxx
231
232	#endif // #ifdef baseClass_cxx
233
234