Skip to content

Commit

Permalink
update skimming code for new ntuples, add control region selections
Browse files Browse the repository at this point in the history
  • Loading branch information
@kpedro88
kpedro88 committed May 13, 2015
1 parent f02ba15 commit ee9fded
Show file tree
Hide file tree
Showing 7 changed files with 279 additions and 188 deletions.
88 changes: 86 additions & 2 deletions KCode/KSelectors.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -123,26 +123,106 @@ class KElectronVetoSelector : public KSelector {
//member variables
};

//------------------------------------------------------
//single muon selector
class KMuonSelector : public KSelector {
public:
//constructor
KMuonSelector() : KSelector() { }
KMuonSelector(string name_, OptionMap* localOpt_) : KSelector(name_,localOpt_) { }

//this selector doesn't add anything to tree

//used for non-dummy selectors
virtual bool Cut() {
if(sk->Muons->size()!=1) return false;
double mT = sqrt(2*sk->METPt*sk->Muons->at(0).Pt()*(1-cos(KMath::DeltaPhi(sk->Muons->at(0).Phi(),sk->METPhi))));
return mT<100;
}

//member variables
};

//------------------------------------------------------
//single electron selector
class KElectronSelector : public KSelector {
public:
//constructor
KElectronSelector() : KSelector() { }
KElectronSelector(string name_, OptionMap* localOpt_) : KSelector(name_,localOpt_) { }

//this selector doesn't add anything to tree

//used for non-dummy selectors
virtual bool Cut() {
if(sk->Electrons->size()!=1) return false;
double mT = sqrt(2*sk->METPt*sk->Electrons->at(0).Pt()*(1-cos(KMath::DeltaPhi(sk->Electrons->at(0).Phi(),sk->METPhi))));
return mT<100;
}

//member variables
};

//------------------------------------------------------
//single photon selector
class KPhotonSelector : public KSelector {
public:
//constructor
KPhotonSelector() : KSelector() { }
KPhotonSelector(string name_, OptionMap* localOpt_) : KSelector(name_,localOpt_) { }

//this selector doesn't add anything to tree

//used for non-dummy selectors
virtual bool Cut() {
return sk->NumPhotons==1;
}

//member variables
};

//------------------------------------------------------
//dimuon selector
class KDiMuonSelector : public KSelector {
public:
//constructor
KDiMuonSelector() : KSelector() { }
KDiMuonSelector(string name_, OptionMap* localOpt_) : KSelector(name_,localOpt_) { }

//this selector doesn't add anything to tree

//used for non-dummy selectors
virtual bool Cut() {
//todo: add charge, mass cuts
return sk->Muons->size() == 2;
}

//member variables
};

//----------------------------------------------------
//selects events based on minDeltaPhiN value
class KMinDeltaPhiNSelector : public KSelector {
public:
//constructor
KMinDeltaPhiNSelector() : KSelector() { }
KMinDeltaPhiNSelector(string name_, OptionMap* localOpt_) : KSelector(name_,localOpt_), minDeltaPhiN(6.) {
KMinDeltaPhiNSelector(string name_, OptionMap* localOpt_) : KSelector(name_,localOpt_), minDeltaPhiN(6.), invert(false) {
//check for option
localOpt->Get("minDeltaPhiN",minDeltaPhiN);
invert = localOpt->Get("invert",false);
}

//this selector doesn't add anything to tree

//used for non-dummy selectors
virtual bool Cut() {
return sk->minDeltaPhiN > minDeltaPhiN;
if(invert) return sk->minDeltaPhiN < minDeltaPhiN;
else return sk->minDeltaPhiN > minDeltaPhiN;
}

//member variables
double minDeltaPhiN;
bool invert;
};

//-------------------------------------------------------------
Expand Down Expand Up @@ -318,6 +398,10 @@ namespace KParser {
else if(sname=="MHT") srtmp = new KMHTSelector(sname,omap);
else if(sname=="MuonVeto") srtmp = new KMuonVetoSelector(sname,omap);
else if(sname=="ElectronVeto") srtmp = new KElectronVetoSelector(sname,omap);
else if(sname=="Muon") srtmp = new KMuonSelector(sname,omap);
else if(sname=="Electron") srtmp = new KElectronSelector(sname,omap);
else if(sname=="Photon") srtmp = new KPhotonSelector(sname,omap);
else if(sname=="DiMuon") srtmp = new KDiMuonSelector(sname,omap);
else if(sname=="IsoElectronTrackVeto") srtmp = new KIsoElectronTrackVetoSelector(sname,omap);
else if(sname=="IsoMuonTrackVeto") srtmp = new KIsoMuonTrackVetoSelector(sname,omap);
else if(sname=="IsoPionTrackVeto") srtmp = new KIsoPionTrackVetoSelector(sname,omap);
Expand Down
1 change: 1 addition & 0 deletions KCode/KSkimmer.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@
#include <TROOT.h>
#include <TFile.h>
#include <TTree.h>
#include <TLorentzVector.h>

//STL headers
#include <string>
Expand Down
193 changes: 81 additions & 112 deletions KCode/KVariators.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@
#include "KSkimmer.h"

//ROOT headers
#include <TLorentzVector.h>

//STL headers
#include <string>
Expand All @@ -16,112 +17,6 @@ using namespace std;
//base class for variators is in KVariation.h

/*
//----------------------------------------------------
//variation of tau energy scale
class KTauESVariator : public KVariator {
public:
//constructor
KTauESVariator() : KVariator() { }
KTauESVariator(string name_, OptionMap* localOpt_) : KVariator(name_,localOpt_) {
//check options
up = localOpt->Get("up",true);
//set default values
HPSTauPt = 0;
}
//functions
virtual void DoVariation() {
delete HPSTauPt; HPSTauPt = new vector<double>();
HPSTauPt->reserve(sk->HPSTauPt->size());
double unc = 0.03;
for(unsigned t = 0; t < sk->HPSTauPt->size(); t++){
//store original values
HPSTauPt->push_back(sk->HPSTauPt->at(t));
//Scale tau pT by TauES uncertainty
TLorentzVector v_tau;
v_tau.SetPtEtaPhiM(sk->HPSTauPt->at(t),sk->HPSTauEta->at(t),sk->HPSTauPhi->at(t),sk->TauMass);
if(up) v_tau *= (1+unc);
else v_tau *= (1-unc);
sk->HPSTauPt->at(t) = v_tau.Pt();
}
}
virtual void UndoVariation() {
//restore original values
for(unsigned t = 0; t < sk->HPSTauPt->size(); t++){
sk->HPSTauPt->at(t) = HPSTauPt->at(t);
}
}
//member variables
bool up;
vector<double> *HPSTauPt;
};
//----------------------------------------------------
//variation of tau energy resolution
class KTauERVariator : public KVariator {
public:
//constructor
KTauERVariator() : KVariator() { }
KTauERVariator(string name_, OptionMap* localOpt_) : KVariator(name_,localOpt_) {
//check options
up = localOpt->Get("up",true);
//set default values
HPSTauPt = 0;
}
//functions
virtual void DoVariation() {
delete HPSTauPt; HPSTauPt = new vector<double>();
HPSTauPt->reserve(sk->HPSTauPt->size());
double unc = 0.1;
for(unsigned t = 0; t < sk->HPSTauPt->size(); t++){
//store original values
HPSTauPt->push_back(sk->HPSTauPt->at(t));
//Tau ER smearing
double min_dR = 1000;
bool matchedGenJetFound = false;
int index_gen = -1;
for (unsigned g = 0; g < sk->GenJetPt->size(); g++){
double dR = KMath::DeltaR(sk->HPSTauPhi->at(t),sk->HPSTauEta->at(t),sk->GenJetPhi->at(g),sk->GenJetEta->at(g));
if(dR < min_dR) {
min_dR = dR;
index_gen = g;
}
}
if (min_dR < 0.05) matchedGenJetFound = true;
if (matchedGenJetFound) {
TLorentzVector v_tau, vg;
v_tau.SetPtEtaPhiM(sk->HPSTauPt->at(t),sk->HPSTauEta->at(t),sk->HPSTauPhi->at(t),sk->TauMass);
vg.SetPtEtaPhiE(sk->GenJetPt->at(index_gen),sk->GenJetEta->at(index_gen),sk->GenJetPhi->at(index_gen),sk->GenJetEnergy->at(index_gen));
double f = 0;
if(up) f = max(vg.E() + (1+unc)*(v_tau.E()-vg.E()),0.)/v_tau.E();
else f = max(vg.E() + (1-unc)*(v_tau.E()-vg.E()),0.)/v_tau.E();
v_tau *= f;
sk->HPSTauPt->at(t) = v_tau.Pt();
}
}
}
virtual void UndoVariation() {
//restore original values
for(unsigned t = 0; t < sk->HPSTauPt->size(); t++){
sk->HPSTauPt->at(t) = HPSTauPt->at(t);
}
}
//member variables
bool up;
vector<double> *HPSTauPt;
};
//----------------------------------------------------
//variation of jet energy scale
class KJetESVariator : public KVariator {
Expand Down Expand Up @@ -249,19 +144,93 @@ class KJetERVariator : public KVariator {
};
*/

//----------------------------------------------------
//set hadronic variables to NoPhotons version
class KNoPhotonVariator : public KVariator {
public:
//constructor
KNoPhotonVariator() : KVariator() { }
KNoPhotonVariator(string name_, OptionMap* localOpt_) : KVariator(name_,localOpt_), ak4Jets(NULL) { }
//functions
virtual void DoVariation() {
//initialize
ak4Jets = new vector<TLorentzVector>();

//store original values
NJets = sk->NJets;
HT = sk->HT;
MHT = sk->MHT;
DeltaPhi1 = sk->DeltaPhi1;
DeltaPhi2 = sk->DeltaPhi2;
DeltaPhi3 = sk->DeltaPhi3;
minDeltaPhiN = sk->minDeltaPhiN;
DeltaPhiN1 = sk->DeltaPhiN1;
DeltaPhiN2 = sk->DeltaPhiN2;
DeltaPhiN3 = sk->DeltaPhiN3;
METPt = sk->METPt;
METPhi = sk->METPhi;
*ak4Jets = *(sk->ak4Jets);

//set to noPhotons vars
sk->NJets = sk->NJetsNoPhotons;
sk->HT = sk->HTnoPhotons;
sk->MHT = sk->MHTnoPhotons;
sk->DeltaPhi1 = sk->DeltaPhi1noPhotons;
sk->DeltaPhi2 = sk->DeltaPhi2noPhotons;
sk->DeltaPhi3 = sk->DeltaPhi3noPhotons;
sk->minDeltaPhiN = sk->minDeltaPhiNnoPhotons;
sk->DeltaPhiN1 = sk->DeltaPhiN1noPhotons;
sk->DeltaPhiN2 = sk->DeltaPhiN2noPhotons;
sk->DeltaPhiN3 = sk->DeltaPhiN3noPhotons;
sk->METPt = sk->METnoPhotonsPt;
sk->METPhi = sk->METnoPhotonsPhi;
*(sk->ak4Jets) = *(sk->ak4JetsNoPhotons);
}
virtual void UndoVariation() {
//restore original values
sk->NJets = NJets;
sk->HT = HT;
sk->MHT = MHT;
sk->DeltaPhi1 = DeltaPhi1;
sk->DeltaPhi2 = DeltaPhi2;
sk->DeltaPhi3 = DeltaPhi3;
sk->minDeltaPhiN = minDeltaPhiN;
sk->DeltaPhiN1 = DeltaPhiN1;
sk->DeltaPhiN2 = DeltaPhiN2;
sk->DeltaPhiN3 = DeltaPhiN3;
sk->METPt = METPt;
sk->METPhi = METPhi;
*(sk->ak4Jets) = *ak4Jets;
}

//member variables
Int_t NJets;
Float_t HT;
Float_t MHT;
Float_t DeltaPhi1;
Float_t DeltaPhi2;
Float_t DeltaPhi3;
Float_t minDeltaPhiN;
Float_t DeltaPhiN1;
Float_t DeltaPhiN2;
Float_t DeltaPhiN3;
Float_t METPt;
Float_t METPhi;
vector<TLorentzVector> *ak4Jets;
};

namespace KParser {
KVariator* processVariator(KNamed* tmp){
KVariator* vtmp = 0;
string vname = tmp->first;
OptionMap* omap = tmp->second;
/*

//check for all known variators
if(vname=="TauES") vtmp = new KTauESVariator(vname,omap);
else if(vname=="TauER") vtmp = new KTauERVariator(vname,omap);
else if(vname=="JES") vtmp = new KJetESVariator(vname,omap);
else if(vname=="JER") vtmp = new KJetERVariator(vname,omap);
if(vname=="NoPhoton") vtmp = new KNoPhotonVariator(vname,omap);
//else if(vname=="JES") vtmp = new KJetESVariator(vname,omap);
//else if(vname=="JER") vtmp = new KJetERVariator(vname,omap);
else {} //skip unknown variators
*/

if(!vtmp) cout << "Input error: unknown variator " << vname << ". This variator will be skipped." << endl;

return vtmp;
Expand Down
Loading

0 comments on commit ee9fded

Please sign in to comment.