VHbb/interface/CutsAndHistos.h

#ifndef CUTSANDHISTOS_H
#define CUTSANDHISTOS_H
#include <string>
#include <sstream>
#include <vector>
#include <TROOT.h>
#include <TFile.h>
#include "ntupleReader.hpp"
#include "samples.hpp"

enum  VType{ Zmm, Zee, Wmn, Wen, Znn } iType;

class Histos {
public:
   virtual void book(TFile &f, std::string suffix) = 0;
   virtual void fill( ntupleReader &event, float w) = 0;
//   virtual Histos * clone() =0;
};

class Cut {
 public:
  virtual bool pass( ntupleReader &event ) = 0;
   virtual std::string name() = 0;
   virtual bool operator()(ntupleReader &event) {return pass(event); }
};

class CutSample : public Cut {
 public:
  virtual bool pass( ntupleReader &event ) = 0;
  virtual bool pass( ntupleReader &event, Sample &sample ) = 0;
  virtual double weight( ntupleReader &event, Sample &sample ) = 0;
   virtual std::string name() = 0;
   virtual bool operator()(ntupleReader &event) {return pass(event); }
};

class NoCut : public Cut {
 public:
  virtual bool pass( ntupleReader &event )  { return true;}
   virtual std::string name() {return "NoCut"; }
};

/// One parameter cut class
class PCut : public Cut
{
 public:
  PCut(){}
 PCut(float cut) : m_cut(cut) {}
 PCut(float minCut, float maxCut) : m_cut(minCut), M_cut(maxCut) {}
  void setCut(float cut) {m_cut=cut;}
  void setCut(float minCut, float maxCut) {m_cut=minCut; M_cut=maxCut;}
  std::string cutValueString()
    {
      std::stringstream s;
      s << m_cut;
      return s.str();
    } 
  float m_cut;
  float M_cut; 
};

class CutSet : public Cut {
 public:
 void add(Cut *c) {cuts.push_back(c);}
 void drop(Cut *c) { pastes.push_back(c);}  
 int size(){ return cuts.size(); }
 bool pass(ntupleReader &event) {
  bool result=true;
  for(size_t i=0; i< cuts.size() ; i++)
    if( ! (cuts.at(i)->pass(event)) ) 
      result=false;
  for(size_t i=0; i< pastes.size() ; i++)
    if( (pastes.at(i)->pass(event)) ) 
      result=true;
  return result;
 } 
 std::string name() {
   std::stringstream s;
   for(size_t i=0; i< cuts.size() ; i++) {
     s << "_" << cuts.at(i)->name();
   }
 return s.str();
 }

private:
 std::vector<Cut *> cuts;
 std::vector<Cut *> pastes;
 
};


///CutSet of PCut, with scanning functions
// to be implemented still
class PCutSet : public Cut {
 public:
 void add(PCut *c) {cuts.push_back(c);}
 void drop(PCut *c) { pastes.push_back(c);}  
 int size(){ return cuts.size(); }
 bool pass(ntupleReader &event) {
  bool result=true;
  for(size_t i=0; i< cuts.size(); i++)
    if( ! (cuts.at(i)->pass(event)) )
      result=false;
  for(size_t i=0; i< pastes.size() ; i++)
    if( (pastes.at(i)->pass(event)) ) 
      result=true;
  return result;
 }
 bool pass(ntupleReader &event, int n) {
  bool result=true;
  for(size_t i=0; i< n; i++){
    if( ! (cuts.at(i)->pass(event)) )
      result=false;
    for(size_t i=0; i< pastes.size() ; i++)
      if( (pastes.at(i)->pass(event)) ) 
        result=true;
  }
  return result;
 }
 std::string name() {
   std::stringstream s;
   for(size_t i=0; i< cuts.size(); i++) {
     s << "_" << cuts.at(i)->name();
   }
 return s.str();
 }
 PCut * getCut( int i ) { return cuts.at(i); }

private:
 std::vector<PCut *> cuts;
 std::vector<PCut *> pastes;

};


class CutsAndHistos {
public:
  CutsAndHistos() {}
  CutsAndHistos(CutSample * c, std::vector<Histos *> & h):
    cutS(c),
    histos(h) {
      suffix=cutS->name(); }
  CutsAndHistos(CutSample * c, Histos * h):
    cutS(c) {
       histos.push_back(h);
       suffix=cutS->name(); }
  CutsAndHistos(Cut * c, std::vector<Histos *> & h):
    cut(c),
    histos(h) {
      suffix=cut->name(); }
  CutsAndHistos(Cut * c, Histos * h):
    cut(c) {
       histos.push_back(h);
       suffix=cut->name();
   }

  //TODO: implement destructor for all pointers received
  
  void book(TFile &f) {
    for(size_t i=0; i< histos.size(); i++) 
      histos.at(i)->book(f,suffix);
  }
  
  void process(ntupleReader &event, float w)
  {
    if(cutS->pass(event))
      for(size_t i=0; i< histos.size(); i++) 
        histos.at(i)->fill(event,w);
  }
  
  void process(ntupleReader &event, float w, Sample &s)
  {
    if(cutS->pass(event,s))
      for(size_t i=0; i< histos.size(); i++) 
        histos.at(i)->fill(event, (w * cutS->weight(event,s)) );
  }

  Cut * cut;
  CutSample * cutS;
  std::vector<Histos *> histos;

 private:
  std::string suffix;    
};

#endif

Revision:	1.3
Committed:	Tue Jun 5 09:10:01 2012 UTC (12 years, 11 months ago) by bortigno
Content type:	text/plain
Branch:	MAIN
CVS Tags:	lhcp_UnblindFix, hcp_Unblind, lhcp_11April, LHCP_PreAppFixAfterFreeze, LHCP_PreAppFreeze, workingVersionAfterHCP, hcpApproval, hcpPreApp, ICHEP8TeV, ichep8TeV, HEAD
Changes since 1.2:	+1 -1 lines
Log Message:	8TeV
#	Content
1	#ifndef CUTSANDHISTOS_H
2	#define CUTSANDHISTOS_H
3	#include <string>
4	#include <sstream>
5	#include <vector>
6	#include <TROOT.h>
7	#include <TFile.h>
8	#include "ntupleReader.hpp"
9	#include "samples.hpp"
10
11	enum VType{ Zmm, Zee, Wmn, Wen, Znn } iType;
12
13	class Histos {
14	public:
15	virtual void book(TFile &f, std::string suffix) = 0;
16	virtual void fill( ntupleReader &event, float w) = 0;
17	// virtual Histos * clone() =0;
18	};
19
20	class Cut {
21	public:
22	virtual bool pass( ntupleReader &event ) = 0;
23	virtual std::string name() = 0;
24	virtual bool operator()(ntupleReader &event) {return pass(event); }
25	};
26
27	class CutSample : public Cut {
28	public:
29	virtual bool pass( ntupleReader &event ) = 0;
30	virtual bool pass( ntupleReader &event, Sample &sample ) = 0;
31	virtual double weight( ntupleReader &event, Sample &sample ) = 0;
32	virtual std::string name() = 0;
33	virtual bool operator()(ntupleReader &event) {return pass(event); }
34	};
35
36	class NoCut : public Cut {
37	public:
38	virtual bool pass( ntupleReader &event ) { return true;}
39	virtual std::string name() {return "NoCut"; }
40	};
41
42	/// One parameter cut class
43	class PCut : public Cut
44	{
45	public:
46	PCut(){}
47	PCut(float cut) : m_cut(cut) {}
48	PCut(float minCut, float maxCut) : m_cut(minCut), M_cut(maxCut) {}
49	void setCut(float cut) {m_cut=cut;}
50	void setCut(float minCut, float maxCut) {m_cut=minCut; M_cut=maxCut;}
51	std::string cutValueString()
52	{
53	std::stringstream s;
54	s << m_cut;
55	return s.str();
56	}
57	float m_cut;
58	float M_cut;
59	};
60
61	class CutSet : public Cut {
62	public:
63	void add(Cut *c) {cuts.push_back(c);}
64	void drop(Cut *c) { pastes.push_back(c);}
65	int size(){ return cuts.size(); }
66	bool pass(ntupleReader &event) {
67	bool result=true;
68	for(size_t i=0; i< cuts.size() ; i++)
69	if( ! (cuts.at(i)->pass(event)) )
70	result=false;
71	for(size_t i=0; i< pastes.size() ; i++)
72	if( (pastes.at(i)->pass(event)) )
73	result=true;
74	return result;
75	}
76	std::string name() {
77	std::stringstream s;
78	for(size_t i=0; i< cuts.size() ; i++) {
79	s << "_" << cuts.at(i)->name();
80	}
81	return s.str();
82	}
83
84	private:
85	std::vector<Cut *> cuts;
86	std::vector<Cut *> pastes;
87
88	};
89
90
91	///CutSet of PCut, with scanning functions
92	// to be implemented still
93	class PCutSet : public Cut {
94	public:
95	void add(PCut *c) {cuts.push_back(c);}
96	void drop(PCut *c) { pastes.push_back(c);}
97	int size(){ return cuts.size(); }
98	bool pass(ntupleReader &event) {
99	bool result=true;
100	for(size_t i=0; i< cuts.size(); i++)
101	if( ! (cuts.at(i)->pass(event)) )
102	result=false;
103	for(size_t i=0; i< pastes.size() ; i++)
104	if( (pastes.at(i)->pass(event)) )
105	result=true;
106	return result;
107	}
108	bool pass(ntupleReader &event, int n) {
109	bool result=true;
110	for(size_t i=0; i< n; i++){
111	if( ! (cuts.at(i)->pass(event)) )
112	result=false;
113	for(size_t i=0; i< pastes.size() ; i++)
114	if( (pastes.at(i)->pass(event)) )
115	result=true;
116	}
117	return result;
118	}
119	std::string name() {
120	std::stringstream s;
121	for(size_t i=0; i< cuts.size(); i++) {
122	s << "_" << cuts.at(i)->name();
123	}
124	return s.str();
125	}
126	PCut * getCut( int i ) { return cuts.at(i); }
127
128	private:
129	std::vector<PCut *> cuts;
130	std::vector<PCut *> pastes;
131
132	};
133
134
135
136	class CutsAndHistos {
137	public:
138	CutsAndHistos() {}
139	CutsAndHistos(CutSample * c, std::vector<Histos *> & h):
140	cutS(c),
141	histos(h) {
142	suffix=cutS->name(); }
143	CutsAndHistos(CutSample * c, Histos * h):
144	cutS(c) {
145	histos.push_back(h);
146	suffix=cutS->name(); }
147	CutsAndHistos(Cut * c, std::vector<Histos *> & h):
148	cut(c),
149	histos(h) {
150	suffix=cut->name(); }
151	CutsAndHistos(Cut * c, Histos * h):
152	cut(c) {
153	histos.push_back(h);
154	suffix=cut->name();
155	}
156
157	//TODO: implement destructor for all pointers received
158
159	void book(TFile &f) {
160	for(size_t i=0; i< histos.size(); i++)
161	histos.at(i)->book(f,suffix);
162	}
163
164	void process(ntupleReader &event, float w)
165	{
166	if(cutS->pass(event))
167	for(size_t i=0; i< histos.size(); i++)
168	histos.at(i)->fill(event,w);
169	}
170
171	void process(ntupleReader &event, float w, Sample &s)
172	{
173	if(cutS->pass(event,s))
174	for(size_t i=0; i< histos.size(); i++)
175	histos.at(i)->fill(event, (w * cutS->weight(event,s)) );
176	}
177
178	Cut * cut;
179	CutSample * cutS;
180	std::vector<Histos *> histos;
181
182	private:
183	std::string suffix;
184	};
185
186	#endif
187