plugins/Cuts/Cuts.hpp

#ifndef CUTS_H
#define CUTS_H
#include "../../interface/CutsAndHistos.h"
#include "../../interface/ntupleReader.hpp"
#include <TH1F.h>
#include <sstream>
#include "../../interface/samples.hpp"
#include "TKey.h"

#define CSVM 0.679
#define CSVL 0.244
#define CSVT 0.898
#define fA 0.46502
#define fB 0.53498


bool sampleCut(ntupleReader &p, Sample &sample){

    bool sampleCut = false;
    bool boost = false;
    bool isB = false;
    if(p.genZpt >= 120)
      boost = true;
    if(p.eventFlav == 5)
      isB = true;
    std::string DY("DY");
    std::string DYBOOSTED("DYBOOSTED");
    if( sample.name == DY && !boost )
      sampleCut = true;
    else if( sample.name == DYBOOSTED && boost )
      sampleCut = true;
    else if( sample.name != DY && sample.name != DYBOOSTED )
      sampleCut = true;
    else sampleCut=false;

    return sampleCut;
}


//I collect the weight and the sample information ONLY here in the SignalPreselection
class PreSelectionZee : public CutSample {
  std::string name() {return "PreSelZee";};  
  Bool_t pass(ntupleReader &p ){ return ( p.Vtype == 1 );  }
  Bool_t pass(ntupleReader &p, Sample &sample ){
    return ( sampleCut(p, sample) == true
             && p.Vtype == 1
             && p.EVENT_json == true
             && p.hbhe == true 
             && ( p.triggerFlags[5] || p.triggerFlags[6] ) );  }
  double weight(ntupleReader &p, Sample &sample){ 
    if( sample.data ) 
      return 1; 
    else 
      return ((fA*p.PUweight+fB*p.PUweight2011B)*p.weightTrig); }
};


class EmptyCut : public PCut
{
 public:
 EmptyCut():PCut(){}
  bool pass(ntupleReader &p) {
    return true;
  }
  virtual std::string name()  {return "NoCut_Gt_"+cutValueString(); }
};

class HPtCut : public PCut
{
 public:
  HPtCut(double ptMin):PCut(ptMin){}
  bool pass(ntupleReader &p) {
    return (  p.H_pt > m_cut);
  }
  virtual std::string name()  {return "Higgs_Pt_Gt_"+cutValueString(); }
};

class HMassCut : public PCut
{
 public:
 HMassCut(double massMin):PCut(massMin){}
  bool pass(ntupleReader &p) {
    return (  p.H_mass > m_cut );
  }
  virtual std::string name()  {return "Higgs_Mass_Gt_"+cutValueString(); }
};

class HMassCutMax : public PCut
{
 public:
 HMassCutMax(double maxMass ):PCut(maxMass){}
  bool pass(ntupleReader &p) {
    return ( !(p.H_mass > m_cut) );
  }
  virtual std::string name()  {return "Higgs_Mass_Gt_"+cutValueString(); }
};


class VPtCut : public PCut
{
 public:
  VPtCut(double ptMin):PCut(ptMin){}
  bool pass(ntupleReader &p) {
    return (  p.V_pt > m_cut);
  }
  virtual std::string name()  {return "V_Pt_Gt_"+cutValueString(); }
};

class VMassCutMin : public PCut
{
 public:
 VMassCutMin(double massMin):PCut(massMin){}
  bool pass(ntupleReader &p) {
    return ( p.V_mass > m_cut );
  }
  virtual std::string name()  {return "V_Mass_Gt_"+cutValueString(); }
};

class VMassCutMax : public PCut
{
 public:
 VMassCutMax(double massMax):PCut(massMax){}
  bool pass(ntupleReader &p) {
    return ( p.V_mass < m_cut );
  }
  virtual std::string name()  {return "V_Mass_Gt_"+cutValueString(); }
};


class JetPtCut : public PCut
{
 public:
  JetPtCut(double ptMin):PCut(ptMin){}
  bool pass(ntupleReader &p) {
    return ( p.hJet_pt[0] > m_cut
             && p.hJet_pt[1] > m_cut );
  }
  virtual std::string name()  {return "Jet_Pt_Gt_"+cutValueString(); }
};

class JetBtagCut : public PCut
{
 public:
 JetBtagCut(double btagMin, double btagMax):PCut(btagMin, btagMax){}
  bool pass(ntupleReader &p) {
    return ( p.hJet_csv[0] > m_cut
             && p.hJet_csv[1] > m_cut
             && ( p.hJet_csv[0] > M_cut
                  || p.hJet_csv[1] > M_cut )  );
  }
  virtual std::string name()  {return "Jet_Btag_Gt_"+cutValueString(); }
};

class HVdPhiCut : public PCut
{
 public:
 HVdPhiCut(double phiMin):PCut(phiMin){}
  bool pass(ntupleReader &p) {
    return (  TMath::Abs(p.HVdPhi) >  m_cut );
  }
  virtual std::string name()  {return "HV_dPhi_Gt_"+cutValueString(); }
};

class JetVeto : public PCut
{
 public:
 JetVeto(double nJetsMax):PCut(nJetsMax){}
  bool pass(ntupleReader &p) {
    return (  p.CountAddJets() < m_cut );
  }
  virtual std::string name()  {return "jetVeto_Gt_"+cutValueString(); }
};


#endif
Revision:	1.2
Committed:	Mon Jun 11 12:32:51 2012 UTC (12 years, 11 months ago) by bortigno
Branch:	MAIN
CVS Tags:	lhcp_UnblindFix, hcp_Unblind, lhcp_11April, LHCP_PreAppFixAfterFreeze, LHCP_PreAppFreeze, workingVersionAfterHCP, hcpApproval, hcpPreApp, ICHEP8TeV, ichep8TeV, HEAD
Changes since 1.1:	+3 -3 lines
Log Message:	fixed
#	User	Rev	Content
1	bortigno	1.1	#ifndef CUTS_H
2			#define CUTS_H
3	bortigno	1.2	#include "../../interface/CutsAndHistos.h"
4			#include "../../interface/ntupleReader.hpp"
5	bortigno	1.1	#include <TH1F.h>
6			#include <sstream>
7	bortigno	1.2	#include "../../interface/samples.hpp"
8	bortigno	1.1	#include "TKey.h"
9
10			#define CSVM 0.679
11			#define CSVL 0.244
12			#define CSVT 0.898
13			#define fA 0.46502
14			#define fB 0.53498
15
16
17			bool sampleCut(ntupleReader &p, Sample &sample){
18
19			bool sampleCut = false;
20			bool boost = false;
21			bool isB = false;
22			if(p.genZpt >= 120)
23			boost = true;
24			if(p.eventFlav == 5)
25			isB = true;
26			std::string DY("DY");
27			std::string DYBOOSTED("DYBOOSTED");
28			if( sample.name == DY && !boost )
29			sampleCut = true;
30			else if( sample.name == DYBOOSTED && boost )
31			sampleCut = true;
32			else if( sample.name != DY && sample.name != DYBOOSTED )
33			sampleCut = true;
34			else sampleCut=false;
35
36			return sampleCut;
37			}
38
39
40			//I collect the weight and the sample information ONLY here in the SignalPreselection
41			class PreSelectionZee : public CutSample {
42			std::string name() {return "PreSelZee";};
43			Bool_t pass(ntupleReader &p ){ return ( p.Vtype == 1 ); }
44			Bool_t pass(ntupleReader &p, Sample &sample ){
45			return ( sampleCut(p, sample) == true
46			&& p.Vtype == 1
47			&& p.EVENT_json == true
48			&& p.hbhe == true
49			&& ( p.triggerFlags[5] \|\| p.triggerFlags[6] ) ); }
50			double weight(ntupleReader &p, Sample &sample){
51			if( sample.data )
52			return 1;
53			else
54			return ((fAp.PUweight+fBp.PUweight2011B)*p.weightTrig); }
55			};
56
57
58			class EmptyCut : public PCut
59			{
60			public:
61			EmptyCut():PCut(){}
62			bool pass(ntupleReader &p) {
63			return true;
64			}
65			virtual std::string name() {return "NoCut_Gt_"+cutValueString(); }
66			};
67
68			class HPtCut : public PCut
69			{
70			public:
71			HPtCut(double ptMin):PCut(ptMin){}
72			bool pass(ntupleReader &p) {
73			return ( p.H_pt > m_cut);
74			}
75			virtual std::string name() {return "Higgs_Pt_Gt_"+cutValueString(); }
76			};
77
78			class HMassCut : public PCut
79			{
80			public:
81			HMassCut(double massMin):PCut(massMin){}
82			bool pass(ntupleReader &p) {
83			return ( p.H_mass > m_cut );
84			}
85			virtual std::string name() {return "Higgs_Mass_Gt_"+cutValueString(); }
86			};
87
88			class HMassCutMax : public PCut
89			{
90			public:
91			HMassCutMax(double maxMass ):PCut(maxMass){}
92			bool pass(ntupleReader &p) {
93			return ( !(p.H_mass > m_cut) );
94			}
95			virtual std::string name() {return "Higgs_Mass_Gt_"+cutValueString(); }
96			};
97
98
99			class VPtCut : public PCut
100			{
101			public:
102			VPtCut(double ptMin):PCut(ptMin){}
103			bool pass(ntupleReader &p) {
104			return ( p.V_pt > m_cut);
105			}
106			virtual std::string name() {return "V_Pt_Gt_"+cutValueString(); }
107			};
108
109			class VMassCutMin : public PCut
110			{
111			public:
112			VMassCutMin(double massMin):PCut(massMin){}
113			bool pass(ntupleReader &p) {
114			return ( p.V_mass > m_cut );
115			}
116			virtual std::string name() {return "V_Mass_Gt_"+cutValueString(); }
117			};
118
119			class VMassCutMax : public PCut
120			{
121			public:
122			VMassCutMax(double massMax):PCut(massMax){}
123			bool pass(ntupleReader &p) {
124			return ( p.V_mass < m_cut );
125			}
126			virtual std::string name() {return "V_Mass_Gt_"+cutValueString(); }
127			};
128
129
130			class JetPtCut : public PCut
131			{
132			public:
133			JetPtCut(double ptMin):PCut(ptMin){}
134			bool pass(ntupleReader &p) {
135			return ( p.hJet_pt[0] > m_cut
136			&& p.hJet_pt[1] > m_cut );
137			}
138			virtual std::string name() {return "Jet_Pt_Gt_"+cutValueString(); }
139			};
140
141			class JetBtagCut : public PCut
142			{
143			public:
144			JetBtagCut(double btagMin, double btagMax):PCut(btagMin, btagMax){}
145			bool pass(ntupleReader &p) {
146			return ( p.hJet_csv[0] > m_cut
147			&& p.hJet_csv[1] > m_cut
148			&& ( p.hJet_csv[0] > M_cut
149			\|\| p.hJet_csv[1] > M_cut ) );
150			}
151			virtual std::string name() {return "Jet_Btag_Gt_"+cutValueString(); }
152			};
153
154			class HVdPhiCut : public PCut
155			{
156			public:
157			HVdPhiCut(double phiMin):PCut(phiMin){}
158			bool pass(ntupleReader &p) {
159			return ( TMath::Abs(p.HVdPhi) > m_cut );
160			}
161			virtual std::string name() {return "HV_dPhi_Gt_"+cutValueString(); }
162			};
163
164			class JetVeto : public PCut
165			{
166			public:
167			JetVeto(double nJetsMax):PCut(nJetsMax){}
168			bool pass(ntupleReader &p) {
169			return ( p.CountAddJets() < m_cut );
170			}
171			virtual std::string name() {return "jetVeto_Gt_"+cutValueString(); }
172			};
173
174
175
176			#endif