#define Background_cxx
#define COUT std::cout << "I'm here : " << __FILE__ << " : " << __LINE__ << std::endl;
#include "Background.h"
#include <TH2.h>
#include <TStyle.h>
#include <TCanvas.h>
#include <TTree.h>
#include <TFile.h>
#include <TChain.h>

#include "TROOT.h"
#include "TObject.h"
#include "TString.h"
#include "OffsetEtaJES/OffsetEtaJES.h"
#include "checkOQ.h"
#include "JetID_v2.0.hpp"
#include "egammaPIDdefs.h"
#include "IsEMPlusPlusDefs.h"
#include "EnergyRescaler.h"
#include "JESUncertaintyProvider.h"
#include "MultijetJESUncertaintyProvider.h"
#include "SmearingClass.h"
#include "egammaSFclass.h"
#include "JERProvider.h"
#include "AnalysisMuonEfficiencyScaleFactors.h" 
#include "CorrectCaloIso.h" 
//#include "StacoCBScaleEffFactors.h"
//#include "StacoTightScaleEffFactors.h"
//#include "MuidCBScaleEffFactors.h" 
//#include "MuidTightScaleEffFactors.h"
#include "RandomDataPeriod.h"
#include "ReweightFactorsManager.h"
#include "CaloIsoCorrection.h"
#include "METUtility.h"
#include "HSG3TrigLeptonSFTool.h"
//#include "LeptonTriggerSF.h"
//#include "electron_SF_VV.h"

#include "Top_MET.h"

#include <vector> 
#include <fstream>
#include <iostream>
#include <TEventList.h>
#include <TList.h>
#include <math.h>
#include <cmath>
#include <string> 
#include <exception>

#include "GRL_header/TGoodRunsListReader.h"
#include "GRL_header/TGoodRunsList.h"

#include "PileupReweighting/PileupReweighting/TPileupReweighting.h"

using namespace std;

using namespace Root;

//Standard Masses
const double MassW = 80398.0;
const double MassZ = 91187.6;
const double MassEl = 0.510998910;
const double MassMu = 105.658367;

//For isEM cut

const float cutReta37[11][10] = {{ 0.700, 0.700, 0.798, 0.700, 0.700, 0.690, 0.848, 0.876, 0.870, 0.894}  // < 5
				 ,{0.700, 0.700, 0.700, 0.700, 0.700, 0.715, 0.860, 0.880, 0.880, 0.880} // 5-10
				 ,{0.860, 0.860, 0.860, 0.860, 0.860, 0.730, 0.860, 0.880, 0.880, 0.880}// 10-15
				 ,{0.860, 0.860, 0.860, 0.860, 0.860, 0.740, 0.860, 0.880, 0.880, 0.880}// 15-20
				 ,{0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900}// 20-30
				 ,{0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900}// 30-40
				 ,{0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900}// 40-50
				 ,{0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900}// 50-60
				 ,{0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900}// 60-70
				 ,{0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900}// 70-80
				 ,{0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900, 0.900}};

const float cutWeta2[11][10] = {{ 0.014, 0.014, 0.014, 0.014, 0.014, 0.028, 0.017, 0.014, 0.014, 0.014}   // < 5 
				,{0.013, 0.013, 0.014, 0.014, 0.014, 0.026, 0.017, 0.014, 0.014, 0.014}  // 5-10
				,{0.013, 0.013, 0.014, 0.014, 0.014, 0.025, 0.017, 0.014, 0.014, 0.014} // 10-15
				,{0.012, 0.012, 0.013, 0.013, 0.013, 0.025, 0.017, 0.014, 0.014, 0.014} // 15-20
				,{0.012, 0.012, 0.012, 0.013, 0.015, 0.025, 0.015, 0.013, 0.013, 0.013} // 20-30
				,{0.012, 0.012, 0.012, 0.013, 0.015, 0.025, 0.015, 0.013, 0.013, 0.013} // 30-40
				,{0.012, 0.012, 0.012, 0.013, 0.015, 0.025, 0.015, 0.013, 0.013, 0.013} // 40-50
				,{0.012, 0.012, 0.012, 0.013, 0.015, 0.025, 0.015, 0.013, 0.013, 0.013} // 50-60
				,{0.012, 0.012, 0.012, 0.013, 0.015, 0.025, 0.015, 0.013, 0.013, 0.013} // 60-70
				,{0.012, 0.012, 0.012, 0.013, 0.015, 0.025, 0.015, 0.013, 0.013, 0.013} // 70-80
				,{0.012, 0.012, 0.012, 0.013, 0.015, 0.025, 0.015, 0.013, 0.013, 0.013}};// 80<;


//For histogram settings
Int_t h_nbins_el_e;
Axis_t h_min_el_e;
Axis_t h_max_el_e;
Int_t h_nbins_el_pt;
Axis_t h_min_el_pt;
Axis_t h_max_el_pt;
Int_t h_nbins_el_eta;
Axis_t h_min_el_eta;
Axis_t h_max_el_eta;
Int_t h_nbins_el_charge;
Axis_t h_min_el_charge;
Axis_t h_max_el_charge;
Int_t h_nbins_el_nBLHits;
Axis_t h_min_el_nBLHits;
Axis_t h_max_el_nBLHits;
Int_t h_nbins_el_phi;
Axis_t h_min_el_phi;
Axis_t h_max_el_phi;
Int_t h_nbins_el_quality;
Axis_t h_min_el_quality;
Axis_t h_max_el_quality;
Int_t h_nbins_mu_e;
Axis_t h_min_mu_e;
Axis_t h_max_mu_e;
Int_t h_nbins_mu_pt;
Axis_t h_min_mu_pt;
Axis_t h_max_mu_pt;
Int_t h_nbins_mu_eta;
Axis_t h_min_mu_eta;
Axis_t h_max_mu_eta;
Int_t h_nbins_mu_charge;
Axis_t h_min_mu_charge;
Axis_t h_max_mu_charge;
Int_t h_nbins_mu_phi;
Axis_t h_min_mu_phi;
Axis_t h_max_mu_phi;
Int_t h_nbins_mu_quality;
Axis_t h_min_mu_quality;
Axis_t h_max_mu_quality;
Int_t h_nbins_jet_e;
Axis_t h_min_jet_e;
Axis_t h_max_jet_e;
Int_t h_nbins_jet_pt;
Axis_t h_min_jet_pt;
Axis_t h_max_jet_pt;
Int_t h_nbins_jet_eta;
Axis_t h_min_jet_eta;
Axis_t h_max_jet_eta;
Int_t h_nbins_jet_phi;
Axis_t h_min_jet_phi;
Axis_t h_max_jet_phi;
Int_t h_nbins_met;
Axis_t h_min_met;
Axis_t h_max_met;
Int_t h_nbins_met_x;
Axis_t h_min_met_x;
Axis_t h_max_met_x;
Int_t h_nbins_met_y;
Axis_t h_min_met_y;
Axis_t h_max_met_y;
Int_t h_nbins_met_el_z_p;
Axis_t h_min_met_el_z_p;
Axis_t h_max_met_el_z_p;
Int_t h_nbins_met_el_z_n;
Axis_t h_min_met_el_z_n;
Axis_t h_max_met_el_z_n;
Int_t h_nbins_met_el_z_s;
Axis_t h_min_met_el_z_s;
Axis_t h_max_met_el_z_s;
Int_t h_nbins_met_mu_z_p;
Axis_t h_min_met_mu_z_p;
Axis_t h_max_met_mu_z_p;
Int_t h_nbins_met_mu_z_n;
Axis_t h_min_met_mu_z_n;
Axis_t h_max_met_mu_z_n;
Int_t h_nbins_met_mu_z_s;
Axis_t h_min_met_mu_z_s;
Axis_t h_max_met_mu_z_s;
Int_t h_nbins_el_number;
Axis_t h_min_el_number;
Axis_t h_max_el_number;
Int_t h_nbins_mu_number;
Axis_t h_min_mu_number;
Axis_t h_max_mu_number;
Int_t h_nbins_lep_number;
Axis_t h_min_lep_number;
Axis_t h_max_lep_number;
Int_t h_nbins_jet_number;
Axis_t h_min_jet_number;
Axis_t h_max_jet_number;

Int_t h_nbins_inv_mass;
Axis_t h_min_inv_mass;
Axis_t h_max_inv_mass;
Int_t h_nbins_w_pt;
Axis_t h_min_w_pt;
Axis_t h_max_w_pt;
Int_t h_nbins_w_trans_mass;
Axis_t h_min_w_trans_mass;
Axis_t h_max_w_trans_mass;
Int_t h_nbins_delta_r_lep_nu;
Axis_t h_min_delta_r_lep_nu;
Axis_t h_max_delta_r_lep_nu;
Int_t h_nbins_vector_sum_lnujj;
Axis_t h_min_vector_sum_lnujj;
Axis_t h_max_vector_sum_lnujj;
Int_t h_nbins_scalar_pt;
Axis_t h_min_scalar_pt;
Axis_t h_max_scalar_pt;
Int_t h_nbins_delta_r_w_jet2;
Axis_t h_min_delta_r_w_jet2;
Axis_t h_max_delta_r_w_jet2;
Int_t h_nbins_delta_phi_w_jet2;
Axis_t h_min_delta_phi_w_jet2;
Axis_t h_max_delta_phi_w_jet2;
Int_t h_nbins_delta_eta_w_jet2;
Axis_t h_min_delta_eta_w_jet2;
Axis_t h_max_delta_eta_w_jet2;
Int_t h_nbins_delta_r_jet1_jet2;
Axis_t h_min_delta_r_jet1_jet2;
Axis_t h_max_delta_r_jet1_jet2;
Int_t h_nbins_delta_phi_jet1_jet2;
Axis_t h_min_delta_phi_jet1_jet2;
Axis_t h_max_delta_phi_jet1_jet2;
Int_t h_nbins_delta_eta_jet1_jet2;
Axis_t h_min_delta_eta_jet1_jet2;
Axis_t h_max_delta_eta_jet1_jet2;

int   Level;
int   DoLESUncertainty;
int   DoJESUncertainty;
int   DoJERUncertainty;
float finalElPt_Cut;
float finalElEta_Cut_min;
float finalElEta_Cut_max;
float finalMuPt_Cut;
float finalMuEta_Cut_min;
float finalMuEta_Cut_max;
float PileUpRemoval_Cut;
float finalJetsPt_Cut;
float finalJetsEta_Cut_min;
float finalJetsEta_Cut_max;
float RemoveElEtaRange1_min;
float RemoveElEtaRange2_min;
float RemoveMuEtaRange1_min;
float RemoveMuEtaRange2_min;
float RemoveJetEtaRange1_min;
float RemoveJetEtaRange2_min;
float RemoveElEtaRange1_max;
float RemoveElEtaRange2_max;
float RemoveMuEtaRange1_max;
float RemoveMuEtaRange2_max;
float RemoveJetEtaRange1_max;
float RemoveJetEtaRange2_max;
float RemoveElPhiRange1_min;
float RemoveElPhiRange2_min;
float RemoveMuPhiRange1_min;
float RemoveMuPhiRange2_min;
float RemoveJetPhiRange1_min;
float RemoveJetPhiRange2_min;
float RemoveElPhiRange1_max;
float RemoveElPhiRange2_max;
float RemoveMuPhiRange1_max;
float RemoveMuPhiRange2_max;
float RemoveJetPhiRange1_max;
float RemoveJetPhiRange2_max; 
float NumberOfTracksPV;
float max_z_PV;
float met_Cut;
float W_Pt_Cut;
float WtransMassCut;
float Inv_Mass_2El_Cut_min;
float Inv_Mass_2El_Cut_max;
float Inv_Mass_2Mu_Cut_min;
float Inv_Mass_2Mu_Cut_max;
float JetsBTagProb_Cut;
float DeltaR_Cut_ElFakingJet;
float DeltaR_Cut_MuFakingJet;
float DeltaR_Cut_ElOverlapsEl;
float DeltaR_Cut_MuOverlapsEl;
float DeltaR_Cut_Res_El;
float DeltaR_Cut_Res_Mu;
float DeltaR_Cut_Res_Jet;
float DeltaR_El_Nu_Cut;
float DeltaR_Mu_Nu_Cut;
float DiffE_El;
float DiffE_Mu;
float VectorSum_lnujj_Cut;
float DeltaR_jet1_jet2_Cut;
float DeltaPhi_jet1_jet2_Cut;
float DeltaEta_jet1_jet2_Cut;
float DeltaR_W_jet2_Cut;
float DeltaPhi_W_jet2_Cut;
float DeltaEta_W_jet2_Cut;
float Jet2_minPt_Cut;
float Jet2_minEta_Cut;
float Jet2_maxEta_Cut;
float StrandedElectron_Cut;
float EtCone_Cut;
float Mu_nPixHits_Cut;
float Mu_nSCTHits_Cut;
float Mu_nHoles_Cut;
float Mu_z0_Cut;
float Mu_d0_Cut;
float Mu_ptcone20_over_Pt_Cut;
int z_el_quality;
int w_el_quality;
string InputStream;
string Do_Z_jets_reconstruction;
string Do_W_jets_reconstruction;
string ForceZmass;
string DoElectronSmearing;
string DoMuonSmearing;
string rel;
string MET_Ref;
string Histograms;
string OutputTruth;
string OutputResolution;
string OutputDebuggingVariables;
string InputType;
string InputYear;
string Skimming;
string WriteOutAllEvents;
string ElectronTrigger;
string TwoElectronTrigger;
string ThreeElectronTrigger;
string MuonTrigger;
string TwoMuonTrigger;
string ThreeMuonTrigger;
string ElectronMuonTrigger;
string TwoElectronMuonTrigger;
string ElectronTwoMuonTrigger;
string EtCone;
string DoPileup;
string Do1ElTrig;
string Do1MuTrig;
string Do2ElTrig;
string Do2MuTrig;
string Do3ElTrig;
string Do3MuTrig;
string Do1El1MuTrig;
string Do1El2MuTrig;
string Do2El1MuTrig;
string Do1JetTrig;
string JetTrigger;
string TriggerEfficiencies;
string NtupleType;
string BtagType;
string EgamLevelName;
Int_t  ElectronQuality;
string Alg_OA;
string TruthAlg_OA;
string MuonAlg_OA;
string JetAlg_WZ;
string TruthAlg_WZ;
string MuonAlg_WZ;
string INFO;
string Truth;

void Background::OutputHistograms(string a){
  Histograms = a; 
}
void Background::SetElEHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_el_e = a;
  h_min_el_e = b;
  h_max_el_e = c;
}
void Background::SetElPtHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_el_pt = a;
  h_min_el_pt = b;
  h_max_el_pt = c;
}
void Background::SetElEtaHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_el_eta = a;
  h_min_el_eta = b;
  h_max_el_eta = c;
}
void Background::SetElPhiHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_el_phi = a;
  h_min_el_phi = b;
  h_max_el_phi = c;
}
void Background::SetElChargeHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_el_charge = a;
  h_min_el_charge = b;
  h_max_el_charge = c;
}
void Background::SetElnBLHitsHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_el_nBLHits = a;
  h_min_el_nBLHits = b;
  h_max_el_nBLHits = c;
}
void Background::SetElQualityHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_el_quality = a;
  h_min_el_quality = b;
  h_max_el_quality = c;
}
void Background::SetWelQuality(Int_t a){
  w_el_quality = a;
}
void Background::SetWtransMassCut(Float_t a){
  WtransMassCut = a;
}
void Background::SetZelQuality(Int_t a){
  z_el_quality = a;
}

void Background::SetMuEHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_mu_e = a;
  h_min_mu_e = b;
  h_max_mu_e = c;
}
void Background::SetMuPtHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_mu_pt = a;
  h_min_mu_pt = b;
  h_max_mu_pt = c;
}
void Background::SetMuEtaHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_mu_eta = a;
  h_min_mu_eta = b;
  h_max_mu_eta = c;
}
void Background::SetMuPhiHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_mu_phi = a;
  h_min_mu_phi = b;
  h_max_mu_phi = c;
}
void Background::SetMuChargeHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_mu_charge = a;
  h_min_mu_charge = b;
  h_max_mu_charge = c;
}
void Background::SetMuQualityHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_mu_quality = a;
  h_min_mu_quality = b;
  h_max_mu_quality = c;
}
void Background::SetJetEHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_jet_e = a;
  h_min_jet_e = b;
  h_max_jet_e = c;
}
void Background::SetJetPtHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_jet_pt = a;
  h_min_jet_pt = b;
  h_max_jet_pt = c;
}
void Background::SetJetEtaHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_jet_eta = a;
  h_min_jet_eta = b;
  h_max_jet_eta = c;
}
void Background::SetJetPhiHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_jet_phi = a;
  h_min_jet_phi = b;
  h_max_jet_phi = c;
}
void Background::SetMETHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met = a;
  h_min_met = b;
  h_max_met = c;
}
void Background::SetMETxHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met_x =a;
  h_min_met_x = b;
  h_max_met_x = c;
}
void Background::SetMETyHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met_y =a;
  h_min_met_y = b;
  h_max_met_y = c;
}
void Background::SetMETzElpHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met_el_z_p =a;
  h_min_met_el_z_p = b;
  h_max_met_el_z_p = c;
}
void Background::SetMETzElnHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met_el_z_n =a;
  h_min_met_el_z_n = b;
  h_max_met_el_z_n = c;
}
void Background::SetMETzElsHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met_el_z_s =a;
  h_min_met_el_z_s = b;
  h_max_met_el_z_s = c;
}
void Background::SetMETzMupHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met_mu_z_p =a;
  h_min_met_mu_z_p = b;
  h_max_met_mu_z_p = c;
}
void Background::SetMETzMunHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met_mu_z_n =a;
  h_min_met_mu_z_n = b;
  h_max_met_mu_z_n = c;
}
void Background::SetMETzMusHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_met_mu_z_s =a;
  h_min_met_mu_z_s = b;
  h_max_met_mu_z_s = c;
}
void Background::SetElNumberHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_el_number = a;
  h_min_el_number = b;
  h_max_el_number = c;
}
void Background::SetMuNumberHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_mu_number = a;
  h_min_mu_number = b;
  h_max_mu_number = c;
}
void Background::SetJetNumberHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_jet_number = a;
  h_min_jet_number = b;
  h_max_jet_number = c;
}
void Background::SetLepNumberHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_lep_number = a;
  h_min_lep_number = b;
  h_max_lep_number = c;
}
void Background::SetInvMassHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_inv_mass = a;
  h_min_inv_mass = b;
  h_max_inv_mass = c;
}
void Background::SetWPtHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_w_pt = a;
  h_min_w_pt = b;
  h_max_w_pt = c;
}
void Background::SetWTransMassHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_w_trans_mass = a;
  h_min_w_trans_mass = b;
  h_max_w_trans_mass = c;
}
void Background::SetDeltaRLepNuHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_delta_r_lep_nu = a;
  h_min_delta_r_lep_nu = b;
  h_max_delta_r_lep_nu = c;
}
void Background::SetVectorSumlnujjHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_vector_sum_lnujj = a;
  h_min_vector_sum_lnujj = b;
  h_max_vector_sum_lnujj = c;
}
void Background::SetScalarPtHisto(Int_t a, Double_t b, Double_t c){
  h_nbins_scalar_pt = a;
  h_min_scalar_pt = b;
  h_max_scalar_pt = c;
}
void Background::SetDeltaRWJet2Histo(Int_t a, Double_t b, Double_t c){
  h_nbins_delta_r_w_jet2 = a;
  h_min_delta_r_w_jet2 = b;
  h_max_delta_r_w_jet2 = c;
}
void Background::SetDeltaPhiWJet2Histo(Int_t a, Double_t b, Double_t c){
  h_nbins_delta_phi_w_jet2 = a;
  h_min_delta_phi_w_jet2 = b;
  h_max_delta_phi_w_jet2 = c;
}
void Background::SetDeltaEtaWJet2Histo(Int_t a, Double_t b, Double_t c){
  h_nbins_delta_eta_w_jet2 = a;
  h_min_delta_eta_w_jet2 = b;
  h_max_delta_eta_w_jet2 = c;
}
void Background::SetDeltaRJet1Jet2Histo(Int_t a, Double_t b, Double_t c){
  h_nbins_delta_r_jet1_jet2 = a;
  h_min_delta_r_jet1_jet2 = b;
  h_max_delta_r_jet1_jet2 = c;
}
void Background::SetDeltaPhiJet1Jet2Histo(Int_t a, Double_t b, Double_t c){
  h_nbins_delta_phi_jet1_jet2 = a;
  h_min_delta_phi_jet1_jet2 = b;
  h_max_delta_phi_jet1_jet2 = c;
}
void Background::SetDeltaEtaJet1Jet2Histo(Int_t a, Double_t b, Double_t c){
  h_nbins_delta_eta_jet1_jet2 = a;
  h_min_delta_eta_jet1_jet2 = b;
  h_max_delta_eta_jet1_jet2 = c;
}
void Background::SetAthenaRelease(string a){
  rel = a;
}
void Background::DoForceZmass(string a){
  ForceZmass = a;
}
void Background::SetDoElectronSmearing(string a){
  DoElectronSmearing = a;
}
void Background::SetDoMuonSmearing(string a){
  DoMuonSmearing = a;
}
void Background::SetDoPileup(string a){
  DoPileup = a;
}
void Background::SetLESUncertainty(Int_t a){
  DoLESUncertainty = a;
}
void Background::SetJESUncertainty(Int_t a){
  DoJESUncertainty = a;
}
void Background::SetJERUncertainty(Int_t a){
  DoJERUncertainty = a;
}
void Background::SetMET_Ref(string a){
  MET_Ref = a;
}
void Background::DoWjetsReconstruction(string a){
  Do_W_jets_reconstruction = a;
}
void Background::DoZjetsReconstruction(string a){
  Do_Z_jets_reconstruction = a;
}
void Background::SetSkimming(string a){
  Skimming = a; 
}
void Background::SetOutputTruth(string a){
  OutputTruth = a;
}
void Background::SetOutputResolutions(string a){
  OutputResolution = a;
}
void Background::SetOutputDebuggingVariables(string a){
  OutputDebuggingVariables = a; 
}
void Background::SetInputType(string a){
  InputType = a;
}
void Background::SetInputYear(string a){
  InputYear = a;
}
void Background::SetInputStream(string a){
  InputStream = a;
}
void Background::SetVertexCuts(Float_t a, Float_t b){
  NumberOfTracksPV = a;
  max_z_PV = b; 
}
void Background::WriteAllEvents(string a){
  WriteOutAllEvents = a;
}
void Background::SetElectronTrigger(string a){
  ElectronTrigger = a;
}
void Background::DoTriggerEfficiencies(string a){
  TriggerEfficiencies = a;
}
void Background::Set2ElectronTrigger(string a){
  TwoElectronTrigger = a;
}
void Background::Set3ElectronTrigger(string a){
  ThreeElectronTrigger = a;
}
void Background::SetMuonTrigger(string a){
  MuonTrigger = a;
}
void Background::Set2MuonTrigger(string a){
  TwoMuonTrigger = a;
}
void Background::Set3MuonTrigger(string a){
  ThreeMuonTrigger = a;
}
void Background::Set1Electron1MuonTrigger(string a){
  ElectronMuonTrigger = a;
}
void Background::Set1Electron2MuonTrigger(string a){
  ElectronTwoMuonTrigger = a;
}
void Background::Set2Electron1MuonTrigger(string a){
  TwoElectronMuonTrigger = a;
}
void Background::SetJetTrigger(string a){
  JetTrigger = a;
}
void Background::SetNtupleType(string a){
  NtupleType = a;
}
void Background::SetBtagType(string a){
  BtagType = a;
}
void Background::SetElectronLevel(Int_t a){
  Level = a;
}
void Background::SetElectronQuality(Int_t a ){
  ElectronQuality = a;
}
void Background::SetEtCone20PtCorCut(Float_t a){
  EtCone_Cut = a;
}
void Background::SetMuonHitsAndVertexCuts(Float_t a, Float_t b, Float_t c, Float_t d, Float_t e){
  Mu_nPixHits_Cut = a;
  Mu_nSCTHits_Cut = b;
  Mu_nHoles_Cut = c;
  Mu_z0_Cut = d;
  Mu_d0_Cut = e;
}
void Background::SetMuPtcone20OverPtCut(Float_t a){
  Mu_ptcone20_over_Pt_Cut = a;
}
void Background::SetElectronPt_Cut(Float_t a){
  finalElPt_Cut = a;
}
void Background::SetMuonPt_Cut(Float_t a){
  finalMuPt_Cut = a;
}
void Background::SetPileUpRemovalCut(Float_t a){
  PileUpRemoval_Cut = a;
}
void Background::SetJetPt_Cut(Float_t a){
  finalJetsPt_Cut = a;
}
void Background::SetMissingEtCut(Float_t a){
  met_Cut = a;
}
void Background::RemoveElEtaRanges(Float_t a, Float_t b, Float_t c, Float_t d){
  RemoveElEtaRange1_min = a;
  RemoveElEtaRange1_max = b;
  RemoveElEtaRange2_min = c;
  RemoveElEtaRange2_max = d;
}
void Background::RemoveMuEtaRanges(Float_t a, Float_t b, Float_t c, Float_t d){
  RemoveMuEtaRange1_min = a;
  RemoveMuEtaRange1_max = b;
  RemoveMuEtaRange2_min = c;
  RemoveMuEtaRange2_max = d;
}
void Background::RemoveJetEtaRanges(Float_t a, Float_t b, Float_t c, Float_t d){
  RemoveJetEtaRange1_min = a;
  RemoveJetEtaRange1_max = b;
  RemoveJetEtaRange2_min = c;
  RemoveJetEtaRange2_max = d;
}
void Background::RemoveElPhiRanges(Float_t a, Float_t b, Float_t c, Float_t d){
  RemoveElPhiRange1_min = a;
  RemoveElPhiRange1_max = b;
  RemoveElPhiRange2_min = c;
  RemoveElPhiRange2_max = d;
}
void Background::RemoveMuPhiRanges(Float_t a, Float_t b, Float_t c, Float_t d){
  RemoveMuPhiRange1_min = a;
  RemoveMuPhiRange1_max = b;
  RemoveMuPhiRange2_min = c;
  RemoveMuPhiRange2_max = d;
}
void Background::RemoveJetPhiRanges(Float_t a, Float_t b, Float_t c, Float_t d){
  RemoveJetPhiRange1_min = a;
  RemoveJetPhiRange1_max = b;
  RemoveJetPhiRange2_min = c;
  RemoveJetPhiRange2_max = d;
}
void Background::SetElectronEta_Cut_min(Float_t a){
  finalElEta_Cut_min = a;
}
void Background::SetMuonEta_Cut_min(Float_t a){
  finalMuEta_Cut_min = a;
}
void Background::SetJetEta_Cut_min(Float_t a){
  finalJetsEta_Cut_min = a;
}
void Background::SetElectronEta_Cut_max(Float_t a){
  finalElEta_Cut_max = a;
}
void Background::SetMuonEta_Cut_max(Float_t a){
  finalMuEta_Cut_max = a;
}
void Background::SetJetEta_Cut_max(Float_t a){
  finalJetsEta_Cut_max = a;
}
void Background::Set_W_Pt_Cut(Float_t a){
  W_Pt_Cut = a;
}
void Background::SetInv_Mass_2El_Cut_min(Float_t a){
  Inv_Mass_2El_Cut_min = a;
}
void Background::SetInv_Mass_2Mu_Cut_min(Float_t a){
  Inv_Mass_2Mu_Cut_min = a;
}
void Background::SetInv_Mass_2El_Cut_max(Float_t a){
  Inv_Mass_2El_Cut_max = a;
}
void Background::SetInv_Mass_2Mu_Cut_max(Float_t a){
  Inv_Mass_2Mu_Cut_max = a;
}
void Background::SetJetsBTagProb_Cut(Float_t a){
  JetsBTagProb_Cut = a;
}
void Background::SetLeptonFakingJetDeltaR_Cut(Float_t a){
  DeltaR_Cut_ElFakingJet = a;
  DeltaR_Cut_MuFakingJet = a;
}
void Background::SetDeltaRElElAndMuElOverlap_Cut(Float_t a, Float_t b){
  DeltaR_Cut_ElOverlapsEl = a;
  DeltaR_Cut_MuOverlapsEl = b;
}
void Background::SetDeltaRElectronResCut(Float_t a){
  DeltaR_Cut_Res_El = a;
}
void Background::SetDeltaRMuonResCut(Float_t a){
  DeltaR_Cut_Res_Mu = a;
}
void Background::SetDeltaRJetResCut(Float_t a){
  DeltaR_Cut_Res_Jet = a;
}
void Background::SetDeltaRElNuCut(Float_t a){
  DeltaR_El_Nu_Cut = a;
}
void Background::SetDeltaRMuNuCut(Float_t a){
  DeltaR_Mu_Nu_Cut = a;
}
void Background::SetDeltaEMinForElTruthMatching(Float_t a){
  DiffE_El = a;
}
void Background::SetDeltaEMinForMuTruthMatching(Float_t a){
  DiffE_Mu = a;
}
void Background::SetVectorSum_lnujj_Cut(Float_t a){
  VectorSum_lnujj_Cut = a;
}
void Background::SetDeltaR_jet1_jet2_Cut(Float_t a){
  DeltaR_jet1_jet2_Cut = a;
}
void Background::SetDeltaPhi_jet1_jet2_Cut(Float_t a){
  DeltaPhi_jet1_jet2_Cut = a;
}
void Background::SetDeltaEta_jet1_jet2_Cut(Float_t a){
  DeltaEta_jet1_jet2_Cut = a;
}
void Background::SetDeltaR_W_jet2_Cut(Float_t a){
  DeltaR_W_jet2_Cut = a;
}
void Background::SetDeltaPhi_W_jet2_Cut(Float_t a){
  DeltaPhi_W_jet2_Cut = a;
}
void Background::SetDeltaEta_W_jet2_Cut(Float_t a){
  DeltaEta_W_jet2_Cut = a;
}
void Background::SetJet2_minPt_Cut(Float_t a){
  Jet2_minPt_Cut = a;
}
void Background::SetJet2_minEta_Cut(Float_t a){
  Jet2_minEta_Cut = a;
}
void Background::SetJet2_maxEta_Cut(Float_t a){
  Jet2_maxEta_Cut = a;
}
void Background::SetPtCutForStrandedElectron(Float_t a){
  StrandedElectron_Cut = a;
}
void Background::SetEgamLevelName(string a){
  EgamLevelName = a;
}
void Background::SetJetAlgorithmName_OA(string a){
  Alg_OA = a;
}
void Background::SetTruthJetAlgorithmName_OA(string a){
  TruthAlg_OA = a;
}
void Background::SetMuonAlgorithmName_OA(string a){
  MuonAlg_OA = a;
}
void Background::SetJetAlgorithmName_WZ(string a){
  JetAlg_WZ = a;
}
void Background::SetTruthJetAlgorithmName_WZ(string a){
  TruthAlg_WZ = a;
}
string EleAlg = "el_";
void Background::SetMuonAlgorithmName_WZ(string a){
  MuonAlg_WZ = a;
}
void Background::SetFunctionInfo(string a){
  INFO = a;
}
void Background::DoTruthAnalysis(string a){
  Truth = a;
}
void Background::Do1ElTrigger(string a){
  Do1ElTrig = a;
}
void Background::Do1MuTrigger(string a){
  Do1MuTrig = a;
}
void Background::Do2ElTrigger(string a){
  Do2ElTrig = a;
}
void Background::Do2MuTrigger(string a){
  Do2MuTrig = a;
}
void Background::Do3ElTrigger(string a){
  Do3ElTrig = a;
}
void Background::Do3MuTrigger(string a){
  Do3MuTrig = a;
}
void Background::Do1El1MuTrigger(string a){
  Do1El1MuTrig = a;
}
void Background::Do2El1MuTrigger(string a){
  Do2El1MuTrig = a;
}
void Background::Do1El2MuTrigger(string a){
  Do1El2MuTrig = a;
}
void Background::Do1JetTrigger(string a){
  Do1JetTrig = a;
} 


void Background::Loop()
{
  
  Long64_t nentries = fChain->GetEntriesFast();

  if(InputType == "MC"){ //For producing MC11 <mu> histograms the pileup reweighting needs 
    if(DoPileup == "Yes"){
      PileupCalcLoop(0, nentries);
    }
  }
  if(DoPileup != "Yes"){
    Loop(0, nentries);
  }
}

void Background::PileupCalcLoop(Int_t initEvent, Int_t lastEvent)
{

  if (fChain == 0) return;

  Long64_t nentries = fChain->GetEntriesFast();

  // check limits                 
  if(lastEvent > nentries) lastEvent = nentries;
  if(initEvent < 0) initEvent = 0;
  cout << "Here" << endl;
  TPileupReweighting * m_pileupTool = new Root::TPileupReweighting("MCPileUpTemplate");
  m_pileupTool->UsePeriodConfig("MC11b");
  m_pileupTool->initialize();

  //EVENT LOOP
  Long64_t nbytes = 0, nb = 0;
  for (Long64_t jentry = initEvent; jentry < lastEvent ; jentry++) {

    Long64_t ientry = LoadTree(jentry);
    if (ientry < 0) break;
    nb = fChain->GetEntry(jentry);   nbytes += nb;
  
    float weight = m_pileupTool->Fill(RunNumber, mc_channel_number, (*mcevt_weight)[0][0], averageIntPerXing);

  }
  m_pileupTool->WriteToFile("MCPileUpTemplate_MC11b.root");

}



void Background::Loop(Int_t initEvent, Int_t lastEvent)
{

  
  if (fChain == 0) return;
  
  Long64_t nentries = fChain->GetEntriesFast();
  
  // check limits
  if(lastEvent > nentries) lastEvent = nentries;
  if(initEvent < 0) initEvent = 0;

  TPileupReweighting * m_pileupTool; 
  
  TGoodRunsListReader * grlR;
  Root::TGoodRunsList grl;
  
  //float Lumi_K = 0.605529;
  //float Lumi_J = 0.233152;
  //float Lumi_L = 0.1433337;
  //float Lumi_M = 0.1053927;
  //HSG3TrigLeptonSFTool * muonTrigSF = new HSG3TrigLeptonSFTool("./", Lumi_J, Lumi_K, Lumi_L, Lumi_M);

  if(InputType == "DATA"){
    grlR = new TGoodRunsListReader();
    string sname;
    if(InputYear == "2011"){
      //sname = "data11_7TeV.periodAllYear_DetStatus-v36-pro09-03_CoolRunQuery-00-04-08_WZjets_allchannels.xml";//4.54 fb-1
      sname = "data11_7TeV.periodAllYear_DetStatus-v36-pro10_CoolRunQuery-00-04-08_WZjets_allchannels.xml";//4.71311 fb-1
      //sname = "data11_7TeV.periodAllYear_DetStatus-v35-pro09-03_CoolRunQuery-00-04-00_WZjets_allchannels.xml"; //4.3778  fb-1  
      //sname = "data11_7TeV.periodAllYear_DetStatus-v34-pro09-02_CoolRunQuery-00-04-00_WZjets_allchannels.xml"; //4.04337 fb-1 
      //sname = "data11_7TeV.periodAllYear_DetStatus-v18-pro08-04_CoolRunQuery-00-03-98_WZjets_allchannels_NOB2.xml"; //1.024 fb-1
      //      sname = "data11_7TeV.periodAllYear_DetStatus-v16-pro08-03_WZjets_allchannels.xml";
      //      sname = "data11_7TeV.periodAllYear_DetStatus-v11-pro08-01_All_Good.xml";
    }
    cout << "XML to load: " << sname.c_str() << endl;
    grlR->SetXMLFile(sname.c_str());
    grlR->Interpret();
    grl = grlR->GetMergedGoodRunsList();
    grl.Summary(false);
    cout << endl;
  } 
  else {
    
    m_pileupTool = new Root::TPileupReweighting("PileUpTool");
    m_pileupTool->AddConfigFile("./MCPileUpTemplate_MC11b.root");
    //m_pileupTool->AddMCDistribution("./MCPileUpTemplate.root");
    m_pileupTool->AddLumiCalcFile("./ilumicalc_histograms_None_178044-191933.root");
    //m_pileupTool->AddDataDistribution("./ilumicalc_histograms_None_178044-191933.root","LumiMetaData"); 
    m_pileupTool->SetUnrepresentedDataAction(2);
    m_pileupTool->initialize();

  } 
  
  //m_OutputFile = new TFile( m_Basename+".ntup.root", "RECREATE");
  m_OutputTree = new TTree("Tree", "Davies Analysis");
  
  //gFile = m_OutputFile;
  //m_OutputTree->SetDirectory(m_OutputFile);
  
  //TBranches to output
  if(initEvent == 0){
    if(InputType == "DATA" && WriteOutAllEvents == "On"){
      m_OutputTree->Branch("GRL", &m_GRL);
      m_OutputTree->Branch("larError", &m_larError);
      m_OutputTree->Branch("MET_sumEt", &m_MET_sumEt);
    }
    if(InputType == "DATA"){
      m_OutputTree->Branch("event_isQCDtemplate", &m_event_isQCDtemplate);
    }
    
    m_OutputTree->Branch("RunNumber", &m_RunNumber);
    m_OutputTree->Branch("lbn", &m_lbn);
    m_OutputTree->Branch("EventNumber", &m_EventNumber);
    m_OutputTree->Branch("mu", &m_mu);  
    m_OutputTree->Branch("vxp_n", &m_vxp_n);
    //m_OutputTree->Branch("larError", &larError);
    m_OutputTree->Branch("good_event", &m_good_event);
    m_OutputTree->Branch("LArHole_reject", &m_LArHole_reject);
    m_OutputTree->Branch("EventPassed_Trig", &m_EventPassed_Trig);
    if(InputType == "MC"){
      if (NtupleType != "Thomas") m_OutputTree->Branch("el_type", &m_el_type);
      m_OutputTree->Branch("el_ptcone20", &m_el_ptcone20);
      m_OutputTree->Branch("el_ptcone40", &m_el_ptcone40);
      if(InputYear == "2011"){
	m_OutputTree->Branch("pileup_weight", &m_pileup_weight);
	m_OutputTree->Branch("muonSFweight", &m_muonSFweight);
	m_OutputTree->Branch("elSFweight", &m_elSFweight);
	m_OutputTree->Branch("mcevt_weight",&m_mcevt_weight);
	m_OutputTree->Branch("evt_weight", &m_evt_weight);
	m_OutputTree->Branch("trig_weight", &m_trig_weight);
	m_OutputTree->Branch("OQweight",&m_OQweight);
      }
    }
    m_OutputTree->Branch("el_cl_pt", &m_el_cl_pt);
    m_OutputTree->Branch("el_cl_eta", &m_el_cl_eta);
    m_OutputTree->Branch("el_cl_phi", &m_el_cl_phi);
    m_OutputTree->Branch("el_e", &m_el_e);
    m_OutputTree->Branch("el_isEM", &m_el_isEM);
    m_OutputTree->Branch("el_pt", &m_el_pt);
    m_OutputTree->Branch("el_eta", &m_el_eta);
    m_OutputTree->Branch("el_tracketa", &m_el_tracketa);
    m_OutputTree->Branch("el_trackphi", &m_el_trackphi);
    m_OutputTree->Branch("el_tracktheta", &m_el_tracktheta);
    m_OutputTree->Branch("el_charge", &m_el_charge);
    m_OutputTree->Branch("el_blayer", &m_el_blayer);
    m_OutputTree->Branch("el_OTX_OQ", &m_el_OTX_OQ);
    m_OutputTree->Branch("el_OQ", &m_el_OQ);
    m_OutputTree->Branch("el_phi", &m_el_phi);
    m_OutputTree->Branch("el_quality", &m_el_quality);
    m_OutputTree->Branch("el_Etcone20_pt_corrected", &m_el_Etcone20_pt_corrected);
    m_OutputTree->Branch("el_Etcone30_pt_corrected", &m_el_Etcone30_pt_corrected);
    m_OutputTree->Branch("el_Etcone40_pt_corrected", &m_el_Etcone40_pt_corrected);
    m_OutputTree->Branch("el_ptcone30", &m_el_ptcone30);
    
    m_OutputTree->Branch("el_veto_pt", &m_el_veto_pt);
    m_OutputTree->Branch("el_veto_eta", &m_el_veto_eta);
    m_OutputTree->Branch("el_veto_phi", &m_el_veto_phi);
    m_OutputTree->Branch("el_veto_e", &m_el_veto_e);
    m_OutputTree->Branch("el_veto_MET_wpx", &m_el_veto_MET_wpx);
    
    m_OutputTree->Branch("mu_veto_pt", &m_mu_veto_pt);
    m_OutputTree->Branch("mu_veto_eta", &m_mu_veto_eta);
    m_OutputTree->Branch("mu_veto_phi", &m_mu_veto_phi);
    m_OutputTree->Branch("mu_veto_e", &m_mu_veto_e);
    
    m_OutputTree->Branch("mu_e", &m_mu_e);
    m_OutputTree->Branch("mu_charge", &m_mu_charge);
    m_OutputTree->Branch("mu_phi", &m_mu_phi);
    m_OutputTree->Branch("mu_pt", &m_mu_pt);
    m_OutputTree->Branch("mu_ptcone20", &m_mu_ptcone20); 
    m_OutputTree->Branch("mu_eta", &m_mu_eta);
    m_OutputTree->Branch("mu_quality", &m_mu_quality);
    
    m_OutputTree->Branch("jet_e", &m_jet_e);
    m_OutputTree->Branch("jet_m", &m_jet_m);
    m_OutputTree->Branch("jet_pt", &m_jet_pt);
    m_OutputTree->Branch("jet_eta", &m_jet_eta);
    m_OutputTree->Branch("jet_phi", &m_jet_phi);
    m_OutputTree->Branch("jet_badmedium", &m_jet_badmedium);
    m_OutputTree->Branch("jet_badtight", &m_jet_badtight);
    if(DoJESUncertainty != 0){
      m_OutputTree->Branch("jet_myDR_uncert", &m_jet_myDR_uncert);
    }
    
    m_OutputTree->Branch("MET",&m_MET);
    m_OutputTree->Branch("MET_x", &m_MET_x);
    m_OutputTree->Branch("MET_y", &m_MET_y);
    m_OutputTree->Branch("MET_bad", &m_MET_bad);
    
    m_OutputTree->Branch("el_number", &m_el_number);
    m_OutputTree->Branch("mu_number", &m_mu_number);
    m_OutputTree->Branch("lep_number", &m_lep_number);
    m_OutputTree->Branch("lep_veto_number", &m_lep_veto_number);
    m_OutputTree->Branch("jet_number", &m_jet_number);
    
    m_OutputTree->Branch("cut_good_PV", &m_cut_good_PV);
    
    //   if(WriteOutAllEvents == "On"){
    //     if(InputType == "DATA"){
    //       if(InputStream == "Egamma"){
    //m_OutputTree->Branch("EF_2g20_loose", &EF_2g20_loose);
    //m_OutputTree->Branch("EF_e20_medium", &EF_e20_medium);
    //m_OutputTree->Branch("EF_e22_medium", &EF_e22_medium);
    //	m_OutputTree->Branch("EF_2eX", &m_EF_2eX);
    //       }
    //       if(InputStream == "Muons"){
    //m_OutputTree->Branch("EF_mu18", &EF_mu18);
    //m_OutputTree->Branch("EF_mu18_MG", &EF_mu18_MG);
    //m_OutputTree->Branch("EF_mu20", &EF_mu20);
    //m_OutputTree->Branch("EF_mu20_MG", &EF_mu20_MG);
    //m_OutputTree->Branch("EF_mu40_MSonly_barrel", &EF_mu40_MSonly_barrel);
    // 	m_OutputTree->Branch("EF_2muX", &m_EF_2muX);
    //       }
    //     }
    if(InputType == "DATA"){
      m_OutputTree->Branch("EF_eX", &m_EF_eX);
      m_OutputTree->Branch("EF_muX", &m_EF_muX);
    }
    //     m_OutputTree->Branch("EF_2eX", &m_EF_2eX);
    //     m_OutputTree->Branch("EF_muX", &m_EF_muX);
    //     m_OutputTree->Branch("EF_2muX", &m_EF_2muX);
    //   }
    //   m_OutputTree->Branch("EF_jX", &m_EF_jX);
    // }
    
    if(Skimming == "Off"){
      if(m_runMode == _MODE_TR){
	m_OutputTree->Branch("w_px", &m_w_px);
	m_OutputTree->Branch("w_py", &m_w_py);
	m_OutputTree->Branch("w_pz_p", &m_w_pz_p);
	m_OutputTree->Branch("w_pz_n", &m_w_pz_n);
      }
      if(m_runMode == _MODE_HQ){
	//m_OutputTree->Branch("w_e_p", &m_w_e_p);
	//m_OutputTree->Branch("w_e_n", &m_w_e_n);
	//m_OutputTree->Branch("w_px", &m_w_px);
	//m_OutputTree->Branch("w_py", &m_w_py);
	//m_OutputTree->Branch("w_pz_p", &m_w_pz_p);
	//m_OutputTree->Branch("w_pz_n", &m_w_pz_n);
	//m_OutputTree->Branch("w_exists", &m_w_exists);
      }
      if(m_runMode == _MODE_EL){
	m_OutputTree->Branch("w_e_p", &m_w_e_p);
	m_OutputTree->Branch("w_e_n", &m_w_e_n);
	m_OutputTree->Branch("w_px", &m_w_px);
	m_OutputTree->Branch("w_py", &m_w_py);
	m_OutputTree->Branch("w_pz_p", &m_w_pz_p);
	m_OutputTree->Branch("w_pz_n", &m_w_pz_n);
	//m_OutputTree->Branch("w_m_p", &m_w_m_p);              
	//m_OutputTree->Branch("w_m_n", &m_w_m_n);              
	m_OutputTree->Branch("w_exists", &m_w_exists);
      }
      //m_OutputTree->Branch("jet_px", &m_jet_px);
      //m_OutputTree->Branch("jet_py", &m_jet_py);
      //m_OutputTree->Branch("jet_pz", &m_jet_pz);
      //m_OutputTree->Branch("jet_nclus", &m_jet_nclus);
      m_OutputTree->Branch("jet_nTrk", &m_jet_nTrk);
      //m_OutputTree->Branch("jet_emfrac", &m_jet_emfrac);
      //m_OutputTree->Branch("jet_btag_prob", &m_jet_btag_prob);
      //m_OutputTree->Branch("jet_flavor_weight_sv0", &m_jet_flavor_weight_sv0);
      //m_OutputTree->Branch("jet1_pt", &m_jet1_pt);
      //m_OutputTree->Branch("jet1_eta", &m_jet1_eta);
      //m_OutputTree->Branch("jet1_phi", &m_jet1_phi);
      //m_OutputTree->Branch("jet2_pt", &m_jet2_pt);
      //m_OutputTree->Branch("jet2_eta", &m_jet2_eta);
      //m_OutputTree->Branch("jet2_phi", &m_jet2_phi);
      
      //m_OutputTree->Branch("el_px", &m_el_px);
      //m_OutputTree->Branch("el_py", &m_el_py);
      //m_OutputTree->Branch("el_pz", &m_el_pz);
      
      //m_OutputTree->Branch("mu_px", &m_mu_px);
      //m_OutputTree->Branch("mu_py", &m_mu_py);
      //m_OutputTree->Branch("mu_pz", &m_mu_pz);
      
      
      //     if(InputType == "DATA"){
      
      //     }
      
      //m_OutputTree->Branch("event_with_BJet", &m_event_with_BJet);
      
    }
    
    //m_OutputTree->Branch("el_px_2maxpt", &m_el_px_2maxpt);
    //m_OutputTree->Branch("el_py_2maxpt", &m_el_py_2maxpt);
    //m_OutputTree->Branch("el_pz_2maxpt", &m_el_pz_2maxpt);
    //m_OutputTree->Branch("el_charge_2maxpt", &m_el_charge_2maxpt);
    //m_OutputTree->Branch("el_phi_2maxpt", &m_el_phi_2maxpt);
    //m_OutputTree->Branch("el_quality_2maxpt", &m_el_quality_2maxpt);
    //m_OutputTree->Branch("el_pt_2maxpt", &m_el_pt_2maxpt);
    //m_OutputTree->Branch("el_eta_2maxpt", &m_el_eta_2maxpt);
    //m_OutputTree->Branch("mu_e_2maxpt", &m_mu_e_2maxpt);
    //m_OutputTree->Branch("mu_px_2maxpt", &m_mu_px_2maxpt);
    //m_OutputTree->Branch("mu_py_2maxpt", &m_mu_py_2maxpt);
    //m_OutputTree->Branch("mu_pz_2maxpt", &m_mu_pz_2maxpt);
    //m_OutputTree->Branch("mu_charge_2maxpt", &m_mu_charge_2maxpt);
    //m_OutputTree->Branch("mu_phi_2maxpt", &m_mu_phi_2maxpt);
    //m_OutputTree->Branch("mu_pt_2maxpt", &m_mu_pt_2maxpt);
    //m_OutputTree->Branch("mu_eta_2maxpt", &m_mu_eta_2maxpt);
    
    if(OutputTruth == "On"){
      //m_OutputTree->Branch("el_px_truth", &m_el_px_truth);
      //m_OutputTree->Branch("el_py_truth", &m_el_py_truth);
      //m_OutputTree->Branch("el_pz_truth", &m_el_pz_truth);
      m_OutputTree->Branch("el_pt_truth", &m_el_pt_truth);
      m_OutputTree->Branch("el_e_truth", &m_el_e_truth);
      m_OutputTree->Branch("el_m_truth", &m_el_m_truth);
      m_OutputTree->Branch("el_eta_truth", &m_el_eta_truth);
      m_OutputTree->Branch("el_phi_truth", &m_el_phi_truth);
      //m_OutputTree->Branch("el_charge_truth", &m_el_charge_truth);
      //m_OutputTree->Branch("mu_px_truth", &m_mu_px_truth);
      //m_OutputTree->Branch("mu_py_truth", &m_mu_py_truth);
      //m_OutputTree->Branch("mu_pz_truth", &m_mu_pz_truth);
      m_OutputTree->Branch("mu_pt_truth", &m_mu_pt_truth);
      m_OutputTree->Branch("mu_e_truth", &m_mu_e_truth);
      m_OutputTree->Branch("mu_m_truth", &m_mu_m_truth);
      m_OutputTree->Branch("mu_eta_truth", &m_mu_eta_truth);
      m_OutputTree->Branch("mu_phi_truth", &m_mu_phi_truth);
      //m_OutputTree->Branch("mu_charge_truth", &m_mu_charge_truth);
      
      if(m_runMode == _MODE_TR){
	m_OutputTree->Branch("tau_n_truth", &m_tau_n_truth);
	m_OutputTree->Branch("WZ_mass_truth", &m_WZ_mass_truth);
      }
      //m_OutputTree->Branch("jet_e_truth", &m_jet_e_truth);
      //m_OutputTree->Branch("jet_px_truth", &m_jet_px_truth);
      //m_OutputTree->Branch("jet_py_truth", &m_jet_py_truth);
      //m_OutputTree->Branch("jet_pz_truth", &m_jet_pz_truth);
      //m_OutputTree->Branch("jet_pt_truth", &m_jet_pt_truth);
      //m_OutputTree->Branch("jet_eta_truth", &m_jet_eta_truth);
      //m_OutputTree->Branch("jet_phi_truth", &m_jet_phi_truth);
      
      //m_OutputTree->Branch("el_px_truth_matched", &m_el_px_truth_matched);
      //m_OutputTree->Branch("el_py_truth_matched", &m_el_py_truth_matched);
      //m_OutputTree->Branch("el_pz_truth_matched", &m_el_pz_truth_matched);
      //m_OutputTree->Branch("el_pt_truth_matched", &m_el_pt_truth_matched);
      //m_OutputTree->Branch("el_eta_truth_matched", &m_el_eta_truth_matched);
      //m_OutputTree->Branch("el_phi_truth_matched", &m_el_phi_truth_matched);
      
      //m_OutputTree->Branch("mu_px_truth_matched", &m_mu_px_truth_matched);
      //m_OutputTree->Branch("mu_py_truth_matched", &m_mu_py_truth_matched);
      //m_OutputTree->Branch("mu_pz_truth_matched", &m_mu_pz_truth_matched);
      //m_OutputTree->Branch("mu_pt_truth_matched", &m_mu_pt_truth_matched);
      //m_OutputTree->Branch("mu_eta_truth_matched", &m_mu_eta_truth_matched);
      //m_OutputTree->Branch("mu_phi_truth_matched", &m_mu_phi_truth_matched);
      
      //m_OutputTree->Branch("jet_px_truth_matched", &m_jet_px_truth_matched);
      //m_OutputTree->Branch("jet_py_truth_matched", &m_jet_py_truth_matched);
      //m_OutputTree->Branch("jet_pz_truth_matched", &m_jet_pz_truth_matched);
      //m_OutputTree->Branch("jet_pt_truth_matched", &m_jet_pt_truth_matched);
      //m_OutputTree->Branch("jet_eta_truth_matched", &m_jet_eta_truth_matched);
      //m_OutputTree->Branch("jet_phi_truth_matched", &m_jet_phi_truth_matched);
      
      //m_OutputTree->Branch("DeltaR_ElMatched_ElTruth", &m_DeltaR_ElMatched_ElTruth);
      //m_OutputTree->Branch("DeltaR_MuMatched_MuTruth", &m_DeltaR_MuMatched_MuTruth);
      //m_OutputTree->Branch("DeltaR_JetsMatched_JetsTruth", &m_DeltaR_JetsMatched_JetsTruth);
      
      //m_OutputTree->Branch("RecoEl_is_Matched", &m_RecoEl_is_Matched);
      //m_OutputTree->Branch("RecoMu_is_Matched", &m_RecoMu_is_Matched);
      //m_OutputTree->Branch("RecoMatchedEl_withCorrectCharge", &m_RecoMatchedEl_withCorrectCharge);
      //m_OutputTree->Branch("RecoMatchedMu_withCorrectCharge", &m_RecoMatchedMu_withCorrectCharge);
      
      m_OutputTree->Branch("MET_truth_x", &m_MET_truth_x);
      m_OutputTree->Branch("MET_truth_y", &m_MET_truth_y);
      m_OutputTree->Branch("MET_truth", &m_MET_truth);
      
      m_OutputTree->Branch("w_e_truth", &m_w_e_truth);
      m_OutputTree->Branch("w_pt_truth", &m_w_pt_truth);
      m_OutputTree->Branch("w_phi_truth", &m_w_phi_truth);
      m_OutputTree->Branch("w_eta_truth", &m_w_eta_truth);
      m_OutputTree->Branch("w_charge_truth", &m_w_charge_truth);
      
      //     m_OutputTree->Branch("w_trans_mass_truth", &m_w_trans_mass_truth);
      
      m_OutputTree->Branch("z_e_truth", &m_z_e_truth);
      m_OutputTree->Branch("z_pt_truth", &m_z_pt_truth);
      m_OutputTree->Branch("z_phi_truth", &m_z_phi_truth);
      m_OutputTree->Branch("z_eta_truth", &m_z_eta_truth);
      
      //     m_OutputTree->Branch("z_trans_mass_truth", &m_z_trans_mass_truth);
      
      //     m_OutputTree->Branch("el_number_truth", &m_el_number_truth);
      //     m_OutputTree->Branch("mu_number_truth", &m_mu_number_truth);
      //     m_OutputTree->Branch("lep_number_truth", &m_lep_number_truth);
      //     m_OutputTree->Branch("jet_number_truth", &m_jet_number_truth);
      
    }
    //   if(OutputResolution == "On"){
    //     m_OutputTree->Branch("Resolution_ElPt", &m_Resolution_ElPt);
    //     m_OutputTree->Branch("Resolution_MuPt", &m_Resolution_MuPt);
    //     m_OutputTree->Branch("Resolution_JetsPt", &m_Resolution_JetsPt);
    //     m_OutputTree->Branch("Resolution_JetsPt_min_20GeV", &m_Resolution_JetsPt_min_20GeV);
    //     m_OutputTree->Branch("Resolution_JetsPt_20GeV_40GeV", &m_Resolution_JetsPt_20GeV_40GeV);
    //     m_OutputTree->Branch("Resolution_JetsPt_40GeV_70GeV", &m_Resolution_JetsPt_40GeV_70GeV);
    //     m_OutputTree->Branch("Resolution_JetsPt_70GeV_110GeV", &m_Resolution_JetsPt_70GeV_110GeV);
    //     m_OutputTree->Branch("Resolution_JetsPt_110GeV_150GeV", &m_Resolution_JetsPt_110GeV_150GeV);
    //     m_OutputTree->Branch("Resolution_JetsPt_150GeV_max", &m_Resolution_JetsPt_150GeV_max);
    //   }
    //   if(OutputDebuggingVariables == "On"){
    //     m_OutputTree->Branch("Det_El", &m_Det_El);
    //     m_OutputTree->Branch("Det_Mu", &m_Det_Mu);
    //     m_OutputTree->Branch("checkMassW_El", &m_checkMassW_El);
    //     m_OutputTree->Branch("checkMassW_Mu", &m_checkMassW_Mu);
    
    //   }
    
      
    if(m_runMode == _MODE_TR){
      //m_OutputTree->Branch("TR_CL_inv_mass_2El_all", &m_inv_mass_2El_all);
      //m_OutputTree->Branch("TR_CL_inv_mass_2El_Z", &m_inv_mass_2El_Z);
      //m_OutputTree->Branch("TR_CL_inv_mass_2Mu_all", &m_inv_mass_2Mu_all);
      //m_OutputTree->Branch("TR_CL_inv_mass_2Mu_Z", &m_inv_mass_2Mu_Z);
      m_OutputTree->Branch("w_enu_chosen_exists", &m_w_enu_chosen_exists);
      m_OutputTree->Branch("w_munu_chosen_exists", &m_w_munu_chosen_exists);
      m_OutputTree->Branch("TR_WZ_inv_mass", &m_TR_WZ_inv_mass);
      m_OutputTree->Branch("TR_WZ_inv_mass_p", &m_TR_WZ_inv_mass_p);
      m_OutputTree->Branch("TR_WZ_inv_mass_n", &m_TR_WZ_inv_mass_n);
      m_OutputTree->Branch("TR_WZ_inv_mass_eee", &m_TR_WZ_inv_mass_eee);
      m_OutputTree->Branch("TR_WZ_inv_mass_eee_p", &m_TR_WZ_inv_mass_eee_p);
      m_OutputTree->Branch("TR_WZ_inv_mass_eee_n", &m_TR_WZ_inv_mass_eee_n);
      m_OutputTree->Branch("TR_WZ_inv_mass_eemu", &m_TR_WZ_inv_mass_eemu);
      m_OutputTree->Branch("TR_WZ_inv_mass_eemu_p", &m_TR_WZ_inv_mass_eemu_p);
      m_OutputTree->Branch("TR_WZ_inv_mass_eemu_n", &m_TR_WZ_inv_mass_eemu_n);
      m_OutputTree->Branch("TR_WZ_inv_mass_mumue", &m_TR_WZ_inv_mass_mumue);
      m_OutputTree->Branch("TR_WZ_inv_mass_mumue_p", &m_TR_WZ_inv_mass_mumue_p);
      m_OutputTree->Branch("TR_WZ_inv_mass_mumue_n", &m_TR_WZ_inv_mass_mumue_n);
      m_OutputTree->Branch("TR_WZ_inv_mass_mumumu", &m_TR_WZ_inv_mass_mumumu);
      m_OutputTree->Branch("TR_WZ_inv_mass_mumumu_p", &m_TR_WZ_inv_mass_mumumu_p);
      m_OutputTree->Branch("TR_WZ_inv_mass_mumumu_n", &m_TR_WZ_inv_mass_mumumu_n);
      m_OutputTree->Branch("TR_WZ_trans_mass_mumumu", &m_TR_WZ_trans_mass_mumumu);
      m_OutputTree->Branch("TR_WZ_trans_mass_mumue", &m_TR_WZ_trans_mass_mumue);
      m_OutputTree->Branch("TR_WZ_trans_mass_eemu", &m_TR_WZ_trans_mass_eemu);
      m_OutputTree->Branch("TR_WZ_trans_mass_eee", &m_TR_WZ_trans_mass_eee);
      m_OutputTree->Branch("TR_WZ_trans_mass", &m_TR_WZ_trans_mass);
    }
    
    if(m_runMode == _MODE_HQ || m_runMode == _MODE_TR){
      m_OutputTree->Branch("MET_el_z_p", &m_MET_el_z_p);
      m_OutputTree->Branch("MET_el_z_n", &m_MET_el_z_n);
      m_OutputTree->Branch("MET_el_z_s", &m_MET_el_z_s);
      m_OutputTree->Branch("MET_mu_z_p", &m_MET_mu_z_p);
      m_OutputTree->Branch("MET_mu_z_n", &m_MET_mu_z_n);
      m_OutputTree->Branch("MET_mu_z_s", &m_MET_mu_z_s);
      m_OutputTree->Branch("w_enu_trans_mass", &m_w_enu_trans_mass);
      m_OutputTree->Branch("w_enu_pt", &m_w_enu_pt);
      m_OutputTree->Branch("w_enu_phi", &m_w_enu_phi);
      m_OutputTree->Branch("w_enu_eta_p", &m_w_enu_eta_p);
      m_OutputTree->Branch("w_enu_eta_n", &m_w_enu_eta_n);
      m_OutputTree->Branch("w_enu_charge", &m_w_enu_charge);
      m_OutputTree->Branch("w_enu_m_p", &m_w_enu_m_p);              
      m_OutputTree->Branch("w_enu_m_n", &m_w_enu_m_n);  
      m_OutputTree->Branch("w_munu_trans_mass", &m_w_munu_trans_mass);
      m_OutputTree->Branch("w_munu_pt", &m_w_munu_pt);
      m_OutputTree->Branch("w_munu_phi", &m_w_munu_phi);
      m_OutputTree->Branch("w_munu_eta_p", &m_w_munu_eta_p);
      m_OutputTree->Branch("w_munu_eta_n", &m_w_munu_eta_n);
      m_OutputTree->Branch("w_munu_charge", &m_w_munu_charge);
      m_OutputTree->Branch("w_munu_m_p", &m_w_munu_m_p);              
      m_OutputTree->Branch("w_munu_m_n", &m_w_munu_m_n);  
      m_OutputTree->Branch("w_enu_exists", &m_w_enu_exists);
      m_OutputTree->Branch("w_munu_exists", &m_w_munu_exists);
      m_OutputTree->Branch("z_ee_e", &m_z_ee_e);
      //m_OutputTree->Branch("z_ee_px", &m_z_ee_px);
      //m_OutputTree->Branch("z_ee_py", &m_z_ee_py);
      //m_OutputTree->Branch("z_ee_pz", &m_z_ee_pz);
      m_OutputTree->Branch("z_ee_pt", &m_z_ee_pt);
      m_OutputTree->Branch("z_ee_phi", &m_z_ee_phi);
      m_OutputTree->Branch("z_ee_eta", &m_z_ee_eta);
      m_OutputTree->Branch("z_ee_m", &m_z_ee_m);
      m_OutputTree->Branch("z_ee_chosen1", &m_z_ee_chosen1);
      m_OutputTree->Branch("z_ee_chosen2", &m_z_ee_chosen2);
      m_OutputTree->Branch("z_ee_trans_mass", &m_z_ee_trans_mass);
      m_OutputTree->Branch("z_mumu_e", &m_z_mumu_e);
      //m_OutputTree->Branch("z_mumu_px", &m_z_mumu_px);
      //m_OutputTree->Branch("z_mumu_py", &m_z_mumu_py);
      //m_OutputTree->Branch("z_mumu_pz", &m_z_mumu_pz);
      m_OutputTree->Branch("z_mumu_pt", &m_z_mumu_pt);
      m_OutputTree->Branch("z_mumu_phi", &m_z_mumu_phi);
      m_OutputTree->Branch("z_mumu_eta", &m_z_mumu_eta);
      m_OutputTree->Branch("z_mumu_m", &m_z_mumu_m);
      m_OutputTree->Branch("z_mumu_chosen1", &m_z_mumu_chosen1);
      m_OutputTree->Branch("z_mumu_chosen2", &m_z_mumu_chosen2);
      m_OutputTree->Branch("z_mumu_trans_mass", &m_z_mumu_trans_mass);
    }
    
    if(m_runMode == _MODE_HQ){
      m_OutputTree->Branch("cut_delta_eta_j1_j2", &m_cut_delta_eta_j1_j2);
      m_OutputTree->Branch("cut_delta_phi_j1_j2", &m_cut_delta_phi_j1_j2);
      
      if(Do_W_jets_reconstruction == "On"){
	//m_OutputTree->Branch("w_trans_mass", &m_w_trans_mass);
	//m_OutputTree->Branch("w_pt", &m_w_pt);
	//m_OutputTree->Branch("w_phi", &m_w_phi);
	//m_OutputTree->Branch("w_eta_p", &m_w_eta_p);
	//m_OutputTree->Branch("w_eta_n", &m_w_eta_n);
	//m_OutputTree->Branch("w_charge", &m_w_charge);
	//m_OutputTree->Branch("w_m_p", &m_w_m_p);              
	//m_OutputTree->Branch("w_m_n", &m_w_m_n);  
	m_OutputTree->Branch("best_solution_deta_w_fjet", &m_best_solution_deta_w_fjet);
	m_OutputTree->Branch("HQ_inv_mass_p_n", &m_HQ_inv_mass_p_n);
	m_OutputTree->Branch("HQ_inv_mass_w_enu_p_n", &m_HQ_inv_mass_w_enu_p_n);
	m_OutputTree->Branch("HQ_inv_mass_w_munu_p_n", &m_HQ_inv_mass_w_munu_p_n);
	m_OutputTree->Branch("HQ_inv_mass_p", &m_HQ_inv_mass_p);
	m_OutputTree->Branch("HQ_inv_mass_n", &m_HQ_inv_mass_n);
	m_OutputTree->Branch("HQ_inv_mass_w_enu_p", &m_HQ_inv_mass_w_enu_p);
	m_OutputTree->Branch("HQ_inv_mass_w_enu_n", &m_HQ_inv_mass_w_enu_n);
	//m_OutputTree->Branch("HQ_inv_mass_w_enu_sdr", &m_HQ_inv_mass_w_enu_sdr);
	m_OutputTree->Branch("HQ_inv_mass_w_munu_p", &m_HQ_inv_mass_w_munu_p);
	m_OutputTree->Branch("HQ_inv_mass_w_munu_n", &m_HQ_inv_mass_w_munu_n);
	//m_OutputTree->Branch("HQ_inv_mass_w_munu_sdr", &m_HQ_inv_mass_w_munu_sdr);
	m_OutputTree->Branch("HQ_trans_mass", &m_HQ_trans_mass);
	m_OutputTree->Branch("HQ_trans_mass_w_enu", &m_HQ_trans_mass_w_enu);
	m_OutputTree->Branch("HQ_trans_mass_w_munu", &m_HQ_trans_mass_w_munu);
	
	m_OutputTree->Branch("cut_scalar_pt", &m_cut_scalar_pt);
	m_OutputTree->Branch("cut_scalar_pt_no_met", &m_cut_scalar_pt_no_met);
	
	m_OutputTree->Branch("cut_vector_sum_lnujj_p", &m_cut_vector_sum_lnujj_p);
	m_OutputTree->Branch("cut_vector_sum_lnujj_n", &m_cut_vector_sum_lnujj_n);
	m_OutputTree->Branch("cut_vector_sum_lnujj_p_n", &m_cut_vector_sum_lnujj_p_n);
	
	m_OutputTree->Branch("cut_delta_eta_w_j2_p", &m_cut_delta_eta_w_j2_p);
	m_OutputTree->Branch("cut_delta_eta_w_j2_n", &m_cut_delta_eta_w_j2_n);
	m_OutputTree->Branch("cut_delta_eta_w_j2_p_n", &m_cut_delta_eta_w_j2_p_n);
	m_OutputTree->Branch("cut_delta_phi_w_j2", &m_cut_delta_phi_w_j2);
	m_OutputTree->Branch("cut_delta_eta_w_j1_p", &m_cut_delta_eta_w_j1_p);
	m_OutputTree->Branch("cut_delta_eta_w_j1_n", &m_cut_delta_eta_w_j1_n);
	m_OutputTree->Branch("cut_delta_eta_w_j1_p_n", &m_cut_delta_eta_w_j1_p_n);
	m_OutputTree->Branch("cut_delta_phi_w_j1", &m_cut_delta_phi_w_j1);
	
	m_OutputTree->Branch("cut_delta_eta_lep_nu_p", &m_cut_delta_eta_lep_nu_p);
	m_OutputTree->Branch("cut_delta_eta_lep_nu_n", &m_cut_delta_eta_lep_nu_n);
	m_OutputTree->Branch("cut_delta_eta_lep_nu_p_n", &m_cut_delta_eta_lep_nu_p_n);
	m_OutputTree->Branch("cut_delta_phi_lep_nu", &m_cut_delta_phi_lep_nu);
	m_OutputTree->Branch("cut_delta_eta_lep_j1", &m_cut_delta_eta_lep_j1);
	m_OutputTree->Branch("cut_delta_phi_lep_j1", &m_cut_delta_phi_lep_j1);
	m_OutputTree->Branch("cut_delta_eta_lep_j2", &m_cut_delta_eta_lep_j2);
	m_OutputTree->Branch("cut_delta_phi_lep_j2", &m_cut_delta_phi_lep_j2);
	m_OutputTree->Branch("cut_delta_eta_nu_j2_p", &m_cut_delta_eta_nu_j2_p);
	m_OutputTree->Branch("cut_delta_eta_nu_j2_n", &m_cut_delta_eta_nu_j2_n);
	m_OutputTree->Branch("cut_delta_eta_nu_j2_p_n", &m_cut_delta_eta_nu_j2_p_n);
	m_OutputTree->Branch("cut_delta_phi_nu_j2", &m_cut_delta_phi_nu_j2);
	
      }
      if(Do_Z_jets_reconstruction == "On"){
	m_OutputTree->Branch("HQ_inv_mass_Z_jet", &m_HQ_inv_mass_Z_jet);
	m_OutputTree->Branch("HQ_inv_mass_Zee_jet", &m_HQ_inv_mass_Zee_jet);
	m_OutputTree->Branch("HQ_inv_mass_Zmumu_jet", &m_HQ_inv_mass_Zmumu_jet);
	
	m_OutputTree->Branch("cut_delta_eta_z_j2", &m_cut_delta_eta_z_j2);
	m_OutputTree->Branch("cut_delta_phi_z_j2", &m_cut_delta_phi_z_j2);
	m_OutputTree->Branch("cut_delta_eta_z_j1", &m_cut_delta_eta_z_j1);
	m_OutputTree->Branch("cut_delta_phi_z_j1", &m_cut_delta_phi_z_j1);
	m_OutputTree->Branch("cut_delta_eta_e_e", &m_cut_delta_eta_e_e);
	m_OutputTree->Branch("cut_delta_eta_mu_mu", &m_cut_delta_eta_mu_mu);
	m_OutputTree->Branch("cut_delta_phi_e_e", &m_cut_delta_phi_e_e);
	m_OutputTree->Branch("cut_delta_phi_mu_mu", &m_cut_delta_phi_mu_mu);
	m_OutputTree->Branch("cut_delta_eta_lep_lep", &m_cut_delta_eta_lep_lep);
	m_OutputTree->Branch("cut_delta_phi_lep_lep", &m_cut_delta_phi_lep_lep);
	//m_OutputTree->Branch("z_pt", &m_z_pt);
	//m_OutputTree->Branch("z_phi", &m_z_phi);
	//m_OutputTree->Branch("z_eta", &m_z_eta);
	//m_OutputTree->Branch("z_trans_mass", &m_z_trans_mass);
      }
    }
    
    if(m_runMode == _MODE_EL){
      m_OutputTree->Branch("w_pt", &m_w_pt);
      
      m_OutputTree->Branch("CL_ElE", &m_CL_ElE);
      m_OutputTree->Branch("CL_ElPx", &m_CL_ElPx);
      m_OutputTree->Branch("CL_ElPy", &m_CL_ElPy);
      m_OutputTree->Branch("CL_ElPz", &m_CL_ElPz);
      m_OutputTree->Branch("CL_ElPt", &m_CL_ElPt);
      m_OutputTree->Branch("CL_ElEta", &m_CL_ElEta);
      m_OutputTree->Branch("CL_ElPhi", &m_CL_ElPhi);
      
      m_OutputTree->Branch("CL_Z_plus_ele_inv_mass", &m_CL_Z_plus_ele_inv_mass);
      m_OutputTree->Branch("CL_Z_plus_nu_trans_mass", &m_CL_Z_plus_nu_trans_mass);
      m_OutputTree->Branch("CL_W_ele_inv_mass_p",&m_CL_W_ele_inv_mass_p);
      m_OutputTree->Branch("CL_W_ele_inv_mass_n",&m_CL_W_ele_inv_mass_n);
      m_OutputTree->Branch("CL_W_ele_inv_mass",&m_CL_W_ele_inv_mass);
    }
  }//End of Branch Outputs

  
  m_pileup_events = 0;
  double totalLumi = 0.;
  
  //MAIN EVENT LOOP
  Long64_t nbytes = 0, nb = 0;
  for (Long64_t jentry = initEvent; jentry < lastEvent ; jentry++) {
    
    //clear ntuple vectors
    RewindNtupleVars();
    
    Long64_t ientry = LoadTree(jentry);
    if (ientry < 0) break;
    nb = fChain->GetEntry(jentry);   nbytes += nb;
    // if (Cut(ientry) < 0) continue;
    
    /////////////////////////////////////////////////////////////////
    //Set input year for Data
    if(InputType == "DATA"){
      if(RunNumber > 167884){
	InputYear = "2011";
      }
      else {InputYear = "2010";}
    }
    
    /////////////////////////////////////////////////////////////////
    //Executing GoodRunsLists
    if(InputType == "DATA"){
      if(grl.HasRunLumiBlock(RunNumber,lbn)){
	m_GRL = 1;
      }
      if(!grl.HasRunLumiBlock(RunNumber,lbn)){
	m_GRL = 0;
      }
    }

    /////////////////////////////////////////////////////////////////
    //Computing pileup weight for MC with respect to 2011 Data
    if(InputType == "MC") {
      m_pileup_weight = 1.;
      if (InputYear == "2011"){
	cout << "RunNumber " << RunNumber << endl;  
	m_pileup_weight = m_pileupTool->GetCombinedWeight(RunNumber,mc_channel_number,averageIntPerXing);
	//Generate RandomDataPeriod for MC if needed
	RandomDataPeriod = m_pileupTool->GetRandomRunNumber(RunNumber);
	int_lum = m_pileupTool->getIntegratedLumiVector();
	totalLumi = m_pileupTool->GetIntegratedLumi();
	cout << "RandomDataPeriod " << RandomDataPeriod << endl;
      }
      
      m_mcevt_weight = (*mcevt_weight)[0][0];//mc_event_weight;

    }

    /////////////////////////////////////////////////////////////////
    // event cut flow
    event_cut_passed[0] += 1.;
    if ((InputType == "DATA" && m_GRL == 1) || InputType =="MC"){
      event_cut_passed[1] += 1.;
      
      //if ( InputType == "MC" ) {
      //event_cut_passed[3] += m_mcevt_weight * m_pileup_weight;
      //}
    }
    /////////////////////////////////////////////////////////////////
    //Function chain required for TechniRho Events
    //
    /////////////////////////////////////////////////////////////////
    if(m_runMode == _MODE_TR){
      ProcessVertex();
      ProcessEventInfo();
      //ProcessIsTau();
      ProcessMuons(); //Processing Muons before Electrons
      //TruthMuons();
      //Muon_Eff_Reso();
      ProcessElectrons();
      //TruthElectrons();
      //Electron_Eff_Reso();
      //TruthJets();
      ProcessTriggers();    
      ProcessJets();      
      CombinedInvariantMassElectrons();
      Select2ElForZRecons();
      CombinedInvariantMassMuons();
      Select2MuForZRecons();
      GetMissingEt();
      TruthMET();
      ProcessEventQuality();
      ScalarPT();
      ReconstructW_TechniRho();
      ReconsWZMass();
      Truth_W_and_Z();
      if(InputType == "MC"){
	m_evt_weight = (m_mcevt_weight*m_pileup_weight*m_muonSFweight*m_elSFweight*m_trig_weight/*m_trig_sf*/); 
	CountPileUpReweightedEvents();
	int aT = IS_techniA(); //Truth study
      }
    }
    /////////////////////////////////////////////////////////////////
    
    /////////////////////////////////////////////////////////////////
    //Function chain required for tprime Events 
    //
    /////////////////////////////////////////////////////////////////
    if(m_runMode == _MODE_HQ){
      ProcessVertex();
      ProcessEventInfo();
      ProcessMuons();
      //Muon_Eff_Reso();
      ProcessElectrons();
      ProcessTriggers();
      //Electron_Eff_Reso();
      //CalculateQCDTemplate();
      ProcessJets();
      if (NtupleType == "MC") {
	//TruthElectrons(); 
	//TruthMuons();
	TruthJets();
	Truth_W_and_Z();
      }
      GetMissingEt();
      TruthMET();
      ScalarPT();
      if(Do_W_jets_reconstruction == "On"){
	ReconstructW_HVLquark_CompLepton();
	ReconsWjetMass();
	ReconsWjetMass_ifbJets();
      }
      if(Do_Z_jets_reconstruction == "On"){
	CombinedInvariantMassElectrons();
	Select2ElForZRecons();
	CombinedInvariantMassMuons();
	Select2MuForZRecons();
	ReconsZjetMass();
      }
      ProcessEventQuality();
      if(InputType == "MC"){
	m_evt_weight = (m_mcevt_weight*m_pileup_weight*m_muonSFweight*m_elSFweight*m_trig_weight/*m_trig_sf*/); 
	CountPileUpReweightedEvents();
      }
      Truth_W_and_Z();
    }
    /////////////////////////////////////////////////////////////////
      
    /////////////////////////////////////////////////////////////////////////////
    //Function chain required for excited (composite)  electron/neutrino Events 
    //
    /////////////////////////////////////////////////////////////////////////////
    if(m_runMode == _MODE_EL){
      ProcessVertex();
      ProcessEventInfo();
      ProcessElectrons();
      //TruthElectrons();
      Electron_Eff_Reso();
      ProcessMuons();
      TruthMuons();
      Muon_Eff_Reso();
      ProcessTriggers();
      ProcessJets();
      TruthJets();
      CombinedInvariantMassElectrons();
      Select2ElForZRecons();
      CombinedInvariantMassMuons();
      Select2MuForZRecons();
      GetMissingEt();
      TruthMET();
      ScalarPT();
      ReconstructW_HVLquark_CompLepton();
      Truth_W_and_Z();
      Reconstruct_Z_plus_electron();
      Reconstruct_Z_plus_neutrino();
      ReconstructW_ele_CompLepton();
      ProcessEventQuality();
      if(InputType == "MC"){
	m_evt_weight = (m_mcevt_weight*m_pileup_weight*m_muonSFweight*m_elSFweight*m_trig_sf); 
	CountPileUpReweightedEvents();
      }
    }
    /////////////////////////////////////////////////////////////////
    
    //gFile = m_OutputFile;
    
    cout << "-----------------------------------------------------" << endl;
    
    if(InputType == "DATA"){
      cout << "el_pt.size() " << (int) m_el_pt.size() << endl;
      if((m_runMode == _MODE_TR && ((int) m_el_pt.size() >=2 || (int) m_mu_pt.size()>= 2)) || 
	 (m_runMode == _MODE_HQ && ((int) m_el_pt.size() >=1 || (int) m_mu_pt.size()>=1)) ){
	m_OutputTree->Fill();
      }
    }
    if(InputType == "MC"){
      if((m_runMode == _MODE_TR && ((int) m_el_pt.size() >=2 || (int) m_mu_pt.size()>=2)) ||
	 (m_runMode == _MODE_HQ && ((int) m_el_pt.size() >=1 || (int) m_mu_pt.size()>=1)) ){ 
	m_OutputTree->Fill();
      }
    }
  } //EVENT LOOP ENDS

  if(InputType == "MC"){
    cout << "Total Lumi Used : " << totalLumi << endl;
    cout << "Pile-up number of events: " << m_pileup_events << endl;   
  }
  
  //h_EventWeight->Write();
  //h_SumWeight->Write();
  //gFile = m_OutputFile;
  m_OutputFile->cd();
  m_OutputTree->SetDirectory(m_OutputFile);
  cout << "write... " << endl;
  m_OutputTree->Write();
  cout << "close... " << endl; 
  m_OutputFile->Close();
  //COUT;

  ofstream cutflow_file;
  cutflow_file.open ( m_Basename+".csv");
  
  //COUT;
  cutflow_file << "CUTFLOW: "<< endl;
  cutflow_file << "EVENT: "<< endl;
  for (int cut = 0; cut < (int) event_cut_n ; cut++){
    cutflow_file << setw(20) << event_cut_name[cut] << " " << event_cut_passed[cut] << endl;
  }
  //COUT;
  cutflow_file << "VERTEX: "<< endl;
  for (int cut = 0; cut < (int) vxp_cut_n ; cut++){
    cutflow_file << setw(20) << vxp_cut_name[cut] << " " << vxp_cut_passed[cut] << endl;
  }
  //COUT;
  cutflow_file << "ELECTRONS: "<< endl;
  for (int cut = 0; cut < (int) el_cut_n ; cut++){
    cutflow_file << setw(20) << el_cut_name[cut] << " " << el_cut_passed[cut] << endl;
  }
  //COUT;
  cutflow_file << "MUONS: "<< endl;
  for (int cut = 0; cut < (int) mu_cut_n ; cut++){
    cutflow_file << setw(20) << mu_cut_name[cut] << " " << mu_cut_passed[cut] << endl;
  }
  cutflow_file << "JETS: "<< endl;
  for (int cut = 0; cut < (int) jet_cut_n ; cut++){
    cutflow_file << setw(20) << jet_cut_name[cut] << " " << jet_cut_passed[cut] << endl;
  }
  cutflow_file << endl;
  cutflow_file << "Z: " << endl;
  for (int cut = 0; cut < (int) z_ee_cut_n ; cut++){
    cutflow_file << setw(20) << z_ee_cut_name[cut] << " " << z_ee_cut_passed[cut] << endl;
  }
  //COUT;
  for (int cut = 0; cut < (int) z_mumu_cut_n ; cut++){
    cutflow_file << setw(20) << z_mumu_cut_name[cut] << " " << z_mumu_cut_passed[cut] << endl;
  }
  //COUT;
  cutflow_file << endl;
  cutflow_file << "W: " << endl;
  for (int cut = 0; cut < (int) w_cut_n ; cut++){
    cutflow_file << setw(20) << w_cut_name[cut] << " " << w_cut_passed[cut] << endl;
  }
  //COUT;
  cutflow_file << endl;
  cutflow_file << "3 LEPTON EVENTS: " << endl;
  //COUT;
  for (int cut = 0; cut < (int) lep3_cut_n ; cut++){
    cutflow_file << setw(20) << lep3_cut_name[cut] << " " << lep3_cut_passed[cut] << endl;
  }
  
  //COUT;
  
  cutflow_file.close();
  //COUT;

}

void Background::ProcessVertex(){
  
  m_vxp_n = vxp_n;
  
  int good_vertex = 0;
  m_nPV = 0;
  for (int itr = 0; itr < (int) (*vxp_nTracks).size() ; itr++){
    if(m_GRL == 1 || InputType == "MC"){
      vxp_cut_passed[0] += 1.;
      if(itr == 0){
	if((*vxp_nTracks)[0] >= 3){
	  vxp_cut_passed[1] += 1.;
	  m_cut_good_PV.push_back(1);
	  good_vertex = 1; 
	}
      }
      if((*vxp_nTracks)[itr] >= 3){ //Counting number of vertexes with 3 or more tracks 
	//if(fabs((*vxp_z)[itr]) < max_z_PV){
	vxp_cut_passed[2] += 1.;
	m_nPV++;
	//}
      }
    }
  }
  if(good_vertex == 0){
    m_cut_good_PV.push_back(0);
  }
}

void Background::ProcessEventInfo(){
  m_RunNumber = RunNumber;
  m_lbn = lbn;
  m_EventNumber = EventNumber;
  m_mu = averageIntPerXing;
}

void Background::ProcessTriggers(){
  
  int EventPassed = 0;  
  float muon_trigWeight = 0.; //Actual Trigger Weight 
  float elec_trigWeight = 0.; //Actual Trigger Weight
  
  if(InputYear == "2011"){
    // VLQ
    if(m_runMode == _MODE_HQ || m_runMode == _MODE_TR){
      if(InputType == "DATA"){
	if(RunNumber <= 186493){ //All periods up to I. 
	  if(InputStream == "Egamma"){
	    if(EF_e20_medium == 1 && (EF_mu18_MG == 1 || EF_mu18 == 1 || EF_mu40_MSonly_barrel == 1)){
	      EventPassed = 1;
	    }
	    if(EF_e20_medium == 1 && (EF_mu18_MG == 0 && EF_mu18 == 0 && EF_mu40_MSonly_barrel == 0)){
	      EventPassed = 1;
	    }
 	  }
	  if(InputStream == "Muons"){
	    if(EF_e20_medium == 0 && (EF_mu18_MG == 1 || EF_mu18 == 1 || EF_mu40_MSonly_barrel == 1)){
	      EventPassed = 1;
	    }
	  }
	  m_EF_eX.push_back(EF_e20_medium);
	  if(EF_mu18_MG == 1 || EF_mu18 == 1 || EF_mu40_MSonly_barrel == 1){
	    m_EF_muX.push_back(1);
	  }
	  if(EF_mu18_MG == 0 && EF_mu18 == 0 && EF_mu40_MSonly_barrel == 0){
	    m_EF_muX.push_back(0);
	  }
	}
	if(RunNumber > 186493 && RunNumber <= 186755){ //Period J
	  if(InputStream == "Egamma"){
	    if(EF_e20_medium == 1 && (EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1)){
	      EventPassed = 1;
	    }
	    if(EF_e20_medium == 1 && (EF_mu18_MG_medium == 0 && EF_mu18_medium == 0 && EF_mu40_MSonly_barrel_medium == 0)){
	      EventPassed = 1;
	    }
	  }
	  if(InputStream == "Muons"){
	    if(EF_e20_medium == 0 && (EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1)){
	      EventPassed = 1;
	    }
	  }
	  m_EF_eX.push_back(EF_e20_medium);
	  if(EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1){
	    m_EF_muX.push_back(1);
	  }
	  if(EF_mu18_MG_medium == 0 && EF_mu18_medium == 0 && EF_mu40_MSonly_barrel_medium == 0){
	    m_EF_muX.push_back(0);
	  }
	}
	if(RunNumber > 186755 && RunNumber <= 187815){ //Period K
	  if(InputStream == "Egamma"){
	    if(EF_e22_medium == 1 && (EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1)){
	      EventPassed = 1;
	    }
	    if(EF_e22_medium == 1 && (EF_mu18_MG_medium == 0 && EF_mu18_medium == 0 && EF_mu40_MSonly_barrel_medium == 0)){
	      EventPassed = 1;
	    }
	  }
	  if(InputStream == "Muons"){
	    if(EF_e22_medium == 0 && (EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1)){
	      EventPassed = 1;
	    }
	  }
	  m_EF_eX.push_back(EF_e22_medium);
	  if(EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1){
	    m_EF_muX.push_back(1);
	  }
	  if(EF_mu18_MG_medium == 0 && EF_mu18_medium == 0 && EF_mu40_MSonly_barrel_medium == 0){
	    m_EF_muX.push_back(0);
	  }
	} 
	if(RunNumber > 187815){ //Periods L-M
	  if(InputStream == "Egamma"){
	    if((EF_e22vh_medium1 == 1 || EF_e45_medium1 == 1) && (EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1)){
	      EventPassed = 1;
	    }
	    if((EF_e22vh_medium1 == 1 || EF_e45_medium1 == 1) && (EF_mu18_MG_medium == 0 && EF_mu18_medium == 0 && EF_mu40_MSonly_barrel_medium == 0)){
	      EventPassed = 1;
	    }
	  }
	  if(InputStream == "Muons"){
	    if(EF_e22vh_medium1 == 0 && EF_e45_medium1 == 0 && (EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1)){
	      EventPassed = 1;
	    }
	  }
	  if(EF_e22vh_medium1 == 1 || EF_e45_medium1 == 1){
	    m_EF_eX.push_back(1);
	  }
	  if(EF_e22vh_medium1 == 0 && EF_e45_medium1 == 0){
	    m_EF_eX.push_back(0);
	  }
	  if(EF_mu18_MG_medium == 1 || EF_mu18_medium == 1 || EF_mu40_MSonly_barrel_medium == 1){
	    m_EF_muX.push_back(1);
	  }
	  if(EF_mu18_MG_medium == 0 && EF_mu18_medium == 0 && EF_mu40_MSonly_barrel_medium == 0){
	    m_EF_muX.push_back(0);
	  }
	}
      }
      if(InputType == "MC"){
	bool pass_elec_trig_BtoJ = EF_e20_medium;
	bool pass_elec_trig_K    = EF_e22_medium;
	bool pass_elec_trig_LtoM = EF_e22vh_medium1||EF_e45_medium1;
	bool pass_muon_trig_BtoI = (EF_mu18_MG || EF_mu18 || EF_mu40_MSonly_barrel); //B-I
	bool pass_muon_trig_JtoM = (EF_mu18_MG_medium || EF_mu18_medium || EF_mu40_MSonly_barrel_medium);
	//Lumi calculated with data11_7TeV.periodAllYear_DetStatus-v36-pro10_CoolRunQuery-00-04-08_WZjets_allchannels.xml
	float Lumi_BtoI = 1.501848;
	float Lumi_BtoJ = 1.735;
	float Lumi_LtoM = 2.487264;
	float Lumi_JtoM = 3.325945;
	float Lumi_K    = 0.605529;
	float Lumi_J = 0.233152;
	float Lumi_L = 0.1433337;
	float Lumi_M = 0.1053927;
	float Lumi_Total = Lumi_BtoI + 3.325945;

	float muon_rate_not_fired_data_lumi_BtoI = 1.;
	float muon_rate_not_fired_mc_lumi_BtoI = 1.;
	float muon_rate_not_fired_data_lumi_JtoM = 1.;
	float muon_rate_not_fired_mc_lumi_JtoM = 1.;

	//Trigger scale factors must initialization
	float elec_eventTrigSF = 1.;
	float elec_eventTrigSF_lumi_BtoJ = 1.;
	float elec_eventTrigSF_lumi_K = 1.;
	float elec_eventTrigSF_lumi_LtoM = 1.;
	float muon_eventTrigSF = 1.;
	float muon_eventTrigSF_lumi_BtoI = 1.;
	float muon_eventTrigSF_lumi_JtoM = 1.;

	if(pass_muon_trig_BtoI && pass_muon_trig_JtoM) muon_trigWeight = 1.;
        else if (pass_muon_trig_BtoI && !pass_muon_trig_JtoM) muon_trigWeight = Lumi_BtoI/(Lumi_Total);
        else if (!pass_muon_trig_BtoI && pass_muon_trig_JtoM) muon_trigWeight = Lumi_JtoM/(Lumi_Total);
        else muon_trigWeight = 0.;

	if(pass_elec_trig_BtoJ && pass_elec_trig_K && pass_elec_trig_LtoM) elec_trigWeight = 1.;
	else if( pass_elec_trig_BtoJ &&  pass_elec_trig_K && !pass_elec_trig_LtoM) elec_trigWeight = (Lumi_BtoJ + Lumi_K)/(Lumi_Total);
	else if( pass_elec_trig_BtoJ && !pass_elec_trig_K && !pass_elec_trig_LtoM) elec_trigWeight = (Lumi_BtoJ)/(Lumi_Total);
	else if(!pass_elec_trig_BtoJ && !pass_elec_trig_K && pass_elec_trig_LtoM) elec_trigWeight = (Lumi_LtoM)/(Lumi_Total);
	else if(!pass_elec_trig_BtoJ &&  pass_elec_trig_K && pass_elec_trig_LtoM) elec_trigWeight = (Lumi_K + Lumi_LtoM)/(Lumi_Total);
	else elec_trigWeight = 0.; 

	//Muons Trigger Efficiency Scale Factors 
	HSG3TrigLeptonSFTool * muonTrigSF = new HSG3TrigLeptonSFTool("./", Lumi_J, Lumi_K, Lumi_L, Lumi_M);
	//HSG3TrigLeptonSFTool muonTrigSF("./", Lumi_J, Lumi_K, Lumi_L, Lumi_M);
	for(int itr_muon = 0; itr_muon < (int) m_mu_pt.size() ; itr_muon++){
	  TLorentzVector tlv_muon; 
	  tlv_muon.SetPtEtaPhiE(m_mu_pt[itr_muon], m_mu_eta[itr_muon], m_mu_phi[itr_muon], m_mu_e[itr_muon]);
	  if(pass_muon_trig_BtoI){ 
	    EventPassed = 1;
	    std::pair<double,double> muon_trig_eff_data_lumi_BtoI = muonTrigSF->MuEffErr_CB_HSG3("per2011B2_I",true,tlv_muon);
	    std::pair<double,double> muon_trig_eff_mc_lumi_BtoI = muonTrigSF->MuEffErr_CB_HSG3("per2011B2_I",false,tlv_muon);
	    float cur_muon_eff_mc_lumi_BtoI = muon_trig_eff_mc_lumi_BtoI.first;   
	    float cur_muon_eff_data_lumi_BtoI = muon_trig_eff_data_lumi_BtoI.first;                                                         
	    muon_rate_not_fired_data_lumi_BtoI = (1-cur_muon_eff_data_lumi_BtoI);  
	    muon_rate_not_fired_mc_lumi_BtoI = (1-cur_muon_eff_mc_lumi_BtoI); 
	    //float cur_muon_eff_mc_err = muon_trig_eff_mc_lumi_BtoI.second;
	    //float cur_muon_eff_data_err = muon_trig_eff_data_lumi_BtoI.second;
	    //float cur_muon_sf_err = sqrt(pow(cur_muon_eff_mc_err,2.)+pow(cur_muon_eff_data_err,2.)); 
	  }
	  if(pass_muon_trig_JtoM){
	    EventPassed = 1;
	    std::pair<double,double> muon_trig_eff_data_lumi_JtoM = muonTrigSF->MuEffErr_CB_HSG3("per2011J_M",true,tlv_muon);
	    std::pair<double,double> muon_trig_eff_mc_lumi_JtoM = muonTrigSF->MuEffErr_CB_HSG3("per2011J_M",false,tlv_muon);
	    float cur_muon_eff_mc_lumi_JtoM = muon_trig_eff_mc_lumi_JtoM.first;   
	    float cur_muon_eff_data_lumi_JtoM = muon_trig_eff_data_lumi_JtoM.first;                                                         
	    muon_rate_not_fired_data_lumi_JtoM = (1-cur_muon_eff_data_lumi_JtoM);  
	    muon_rate_not_fired_mc_lumi_JtoM = (1-cur_muon_eff_mc_lumi_JtoM); 
	    //float cur_muon_eff_mc_err = muon_trig_eff_mc_lumi_JtoM.second;
	    //float cur_muon_eff_data_err = muon_trig_eff_data_lumi_JtoM.second;
	    //float cur_muon_sf_err = sqrt(pow(cur_muon_eff_mc_err,2.)+pow(cur_muon_eff_data_err,2.)); 
	  }
	  muon_eventTrigSF_lumi_BtoI = ((1-muon_rate_not_fired_mc_lumi_BtoI)) ? ((1-muon_rate_not_fired_data_lumi_BtoI)/(1-muon_rate_not_fired_mc_lumi_BtoI))*Lumi_BtoI : Lumi_BtoI; 
	  muon_eventTrigSF_lumi_JtoM = ((1-muon_rate_not_fired_mc_lumi_JtoM)) ? ((1-muon_rate_not_fired_data_lumi_JtoM)/(1-muon_rate_not_fired_mc_lumi_JtoM))*Lumi_JtoM : Lumi_JtoM;     
	
	  //Total muon trig weight:
	  muon_eventTrigSF *= (muon_eventTrigSF_lumi_BtoI + muon_eventTrigSF_lumi_JtoM) ? (muon_eventTrigSF_lumi_BtoI + muon_eventTrigSF_lumi_JtoM) / (Lumi_BtoI + Lumi_LtoM) : 1.;
	
	}//end of muon loop
	delete muonTrigSF;
	
	//Electrons Trigger Efficiency Scale Factors 
	for(int itr_elec = 0 ; itr_elec < (int) m_el_pt.size() ; itr_elec++){
	  TLorentzVector Ele;
	  Ele.SetPtEtaPhiE(m_el_pt[itr_elec], m_el_eta[itr_elec], m_el_phi[itr_elec], m_el_e[itr_elec]);
	  if(pass_elec_trig_BtoJ){ 
	    EventPassed = 1;
	    std::pair<double,double> elec_trig_SF_mc_lumi_BtoJ;
	    if(m_el_quality[itr_elec] == 2 || m_el_quality[itr_elec] == 3){
	      elec_trig_SF_mc_lumi_BtoJ = mySFclass.scaleFactor(m_el_cl_eta[itr_elec], Ele.Pt(), 9, 0, 5, true);
	    }
	    if(m_el_quality[itr_elec] == 4 || m_el_quality[itr_elec] == 5){
	      elec_trig_SF_mc_lumi_BtoJ = mySFclass.scaleFactor(m_el_cl_eta[itr_elec], Ele.Pt(), 11, 0, 5, true);
	    }
	    elec_eventTrigSF_lumi_BtoJ = elec_trig_SF_mc_lumi_BtoJ.first;   
	  }
	  if(pass_elec_trig_K) { 
	    EventPassed = 1;
	    std::pair<double,double> elec_trig_SF_mc_lumi_K;
	    if(m_el_quality[itr_elec] == 2 || m_el_quality[itr_elec] == 3){
	      elec_trig_SF_mc_lumi_K = mySFclass.scaleFactor(m_el_cl_eta[itr_elec], Ele.Pt(), 13, 0, 5, true);
	    }
	    if(m_el_quality[itr_elec] == 4 || m_el_quality[itr_elec] == 5){
	      elec_trig_SF_mc_lumi_K = mySFclass.scaleFactor(m_el_cl_eta[itr_elec], Ele.Pt(), 15, 0, 5, true);
	    }
	    elec_eventTrigSF_lumi_K = elec_trig_SF_mc_lumi_K.first;   
	  }
	  if(pass_elec_trig_LtoM) { 
	    EventPassed = 1;
	    std::pair<double,double> elec_trig_SF_mc_lumi_LtoM;
	    if(m_el_quality[itr_elec] == 2 || m_el_quality[itr_elec] == 3){
	      elec_trig_SF_mc_lumi_LtoM = mySFclass.scaleFactor(m_el_cl_eta[itr_elec], Ele.Pt(), 17, 0, 5, true);
	    }
	    if(m_el_quality[itr_elec] == 4 || m_el_quality[itr_elec] == 5){
	      elec_trig_SF_mc_lumi_LtoM = mySFclass.scaleFactor(m_el_cl_eta[itr_elec], Ele.Pt(), 19, 0, 5, true);
	    }
	    elec_eventTrigSF_lumi_LtoM = elec_trig_SF_mc_lumi_LtoM.first;   
	  }
	  elec_eventTrigSF_lumi_BtoJ *= elec_eventTrigSF_lumi_BtoJ ? elec_eventTrigSF_lumi_BtoJ*Lumi_BtoJ : Lumi_BtoJ;
	  elec_eventTrigSF_lumi_K    *= elec_eventTrigSF_lumi_K    ? elec_eventTrigSF_lumi_K*Lumi_K       : Lumi_K;
	  elec_eventTrigSF_lumi_LtoM *= elec_eventTrigSF_lumi_LtoM ? elec_eventTrigSF_lumi_LtoM*Lumi_LtoM : Lumi_LtoM;

	  elec_eventTrigSF *= ((elec_eventTrigSF_lumi_BtoJ + elec_eventTrigSF_lumi_K + elec_eventTrigSF_lumi_LtoM)) ? (elec_eventTrigSF_lumi_BtoJ + elec_eventTrigSF_lumi_K + elec_eventTrigSF_lumi_LtoM) / (Lumi_BtoJ + Lumi_K + Lumi_LtoM) : 1.;
	  
	}//end of electron loop 
	
	//Calculating total trigger weight -- Includes trigger decision : *_trigWeight	
	if(elec_trigWeight > 0. && muon_trigWeight > 0.){
	  m_trig_weight = elec_trigWeight*elec_eventTrigSF*muon_trigWeight*muon_eventTrigSF;
	}	
	if(elec_trigWeight > 0. && muon_trigWeight <= 0.){
	  m_trig_weight = elec_trigWeight*elec_eventTrigSF;
	}	
	if(elec_trigWeight <= 0. && muon_trigWeight > 0.){
	  m_trig_weight = muon_trigWeight*muon_eventTrigSF;
	}	
	if(elec_trigWeight <= 0. && muon_trigWeight <= 0.){
	  m_trig_weight = 0.;
	}	

      }
    }
  }
  if(elec_trigWeight > 0. || muon_trigWeight > 0.){
    m_EventPassed_Trig = 1;    
  }
  if(elec_trigWeight <= 0. && muon_trigWeight <= 0.){
    m_EventPassed_Trig = 0;
  }

}

void Background::ProcessIsTau(){

  int CountNumberOfTruthTaus = 0; 
  for(int itr = 0 ; itr < (int) (*mc_pdgId).size() ; itr++){
    if( fabs((*mc_pdgId)[itr]) == 15){
      CountNumberOfTruthTaus += 1;
    }
  }
  cout << "CountNumberOfTruthTaus  Final " << CountNumberOfTruthTaus << endl;
  m_tau_n_truth.push_back(CountNumberOfTruthTaus);

}

void Background::ProcessElectrons(){

  egammaOQ myOQ;
  //egammaSFclass mySFclass;
  
  //  string EleAlg = "el_";
  vector<int>   m_all_el_type;
  if(InputType == "MC" && NtupleType != "Thomas") m_all_el_type = *mapVarsVectorInt[EleAlg+"type"];
  vector<int>   m_all_el_author(*mapVarsVectorInt[EleAlg+"author"]);
  vector<float> m_all_el_cl_E(*mapVarsVectorFloat[EleAlg+"cl_E"]);
  vector<float> m_all_el_cl_pt(*mapVarsVectorFloat[EleAlg+"cl_pt"]);
  vector<float> m_all_el_cl_eta(*mapVarsVectorFloat[EleAlg+"cl_eta"]);
  vector<float> m_all_el_cl_phi(*mapVarsVectorFloat[EleAlg+"cl_phi"]);
  vector<float> m_all_el_E(*mapVarsVectorFloat[EleAlg+"E"]);
  vector<float> m_all_el_charge(*mapVarsVectorFloat[EleAlg+"charge"]);
  vector<float> m_all_el_phi(*mapVarsVectorFloat[EleAlg+"phi"]);
  vector<float> m_all_el_eta(*mapVarsVectorFloat[EleAlg+"eta"]);
  vector<float> m_all_el_etap(*mapVarsVectorFloat[EleAlg+"etap"]);
  vector<float> m_all_el_etas2(*mapVarsVectorFloat[EleAlg+"etas2"]);
  vector<float> m_all_el_weta2(*mapVarsVectorFloat[EleAlg+"weta2"]);
  vector<float> m_all_el_reta(*mapVarsVectorFloat[EleAlg+"reta"]);
  vector<int> m_all_el_nSCTHits(*mapVarsVectorInt[EleAlg+"nSCTHits"]);
  vector<int> m_all_el_nPixHits(*mapVarsVectorInt[EleAlg+"nPixHits"]);
  vector<float> m_all_el_tracketa(*mapVarsVectorFloat[EleAlg+"tracketa"]);
  vector<float> m_all_el_trackphi(*mapVarsVectorFloat[EleAlg+"trackphi"]);
  vector<float> m_all_el_tracktheta(*mapVarsVectorFloat[EleAlg+"tracktheta"]);
  vector<float> m_all_el_trackz0pv(*mapVarsVectorFloat[EleAlg+"trackz0pv"]);
  vector<float> m_all_el_trackd0pv(*mapVarsVectorFloat[EleAlg+"trackd0pv"]);
  vector<float> m_all_el_tracksigd0pv(*mapVarsVectorFloat[EleAlg+"tracksigd0pv"]);
  vector<unsigned int>   m_all_el_isEM(*mapVarsVectorUnsignedInt[EleAlg+"isEM"]);
  vector<unsigned int>   m_all_el_OQ(*mapVarsVectorUnsignedInt[EleAlg+"OQ"]);
  vector<float> m_all_el_Etcone20_pt_corrected(*mapVarsVectorFloat[EleAlg+"Etcone20_pt_corrected"]);
  vector<float> m_all_el_Etcone30_pt_corrected(*mapVarsVectorFloat[EleAlg+"Etcone30_pt_corrected"]);
  vector<float> m_all_el_Etcone40_pt_corrected(*mapVarsVectorFloat[EleAlg+"Etcone40_pt_corrected"]);
  vector<float> m_all_el_ptcone20(*mapVarsVectorFloat[EleAlg+"ptcone20"]);
  vector<float> m_all_el_ptcone30(*mapVarsVectorFloat[EleAlg+"ptcone30"]);
  vector<float> m_all_el_ptcone40(*mapVarsVectorFloat[EleAlg+"ptcone40"]);
  vector<float> m_all_el_Etcone20(*mapVarsVectorFloat[EleAlg+"Etcone20"]);
  vector<float> m_all_el_Etcone30(*mapVarsVectorFloat[EleAlg+"Etcone30"]);
  vector<float> m_all_el_Etcone40(*mapVarsVectorFloat[EleAlg+"Etcone40"]);
  vector<float> m_all_el_pt(*mapVarsVectorFloat[EleAlg+"pt"]);
  vector<vector<float> > m_all_el_MET_wpx(*mapVarsVectorVectorFloat[EleAlg+"MET_wpx"]);
  vector<vector<float> > m_all_el_MET_wpy(*mapVarsVectorVectorFloat[EleAlg+"MET_wpy"]);

  //For Truth
  TLorentzVector Ele_truth;

  //vector<int>   m_all_el_blayer;
  //vector<int>   m_all_el_OTX;
  //vector<int>   m_all_el_quality;
  vector<float> m_all_el_px;
  vector<float> m_all_el_py;
  vector<float> m_all_el_pz;
  //COUT;
  if(NtupleType == "WZ" || NtupleType == "Thomas"){
    
    //define tempory loose, medium, mediumIso, tight, and tightIso   
    const unsigned int Loose =     egammaPID::ElectronLoosePP;
    const unsigned int Medium =    egammaPID::ElectronMediumPP;
    const unsigned int MediumIso = egammaPID::ElectronMediumPPIso;  
    const unsigned int Tight =     egammaPID::ElectronTightPP;      
    const unsigned int TightIso =  egammaPID::ElectronTightPPIso;   
    //COUT;    
    for(int itr = 0 ; itr < (int) (*el_E).size() ; itr++){
      if(((*el_isEM)[itr] & TightIso) == 0) m_all_el_quality.push_back(5);
      else if(((*el_isEM)[itr] & Tight) == 0) m_all_el_quality.push_back(4);
      else if(((*el_isEM)[itr] & MediumIso) == 0) m_all_el_quality.push_back(3);
      else if(((*el_isEM)[itr] & Medium) == 0) m_all_el_quality.push_back(2);
      else if(((*el_isEM)[itr] & Loose) == 0) m_all_el_quality.push_back(1);
      else m_all_el_quality.push_back(0);
      
      //COUT;
      //For OTX cleaning
      
      if(InputType == "DATA"){
	if( ((*el_OQ)[itr] & 1446) == 0 /*&& myOQ.checkOQClusterElectron(RunNumber, el_cl_eta->at(itr), el_cl_phi->at(itr)) != 3*/){ //No checkOQ for Data
	  m_all_el_OTX.push_back(1);
	}
	if( ((*el_OQ)[itr] & 1446) != 0 /*|| myOQ.checkOQClusterElectron(RunNumber, el_cl_eta->at(itr), el_cl_phi->at(itr)) == 3*/){ //No checkOQ for Data
	  m_all_el_OTX.push_back(3);
	}
      }
      if(InputType == "MC"){
	if(RandomDataPeriod >= 180614 && RandomDataPeriod <= 185352){
	  if(((*el_OQ)[itr] & 1446) == 0 && myOQ.checkOQClusterElectron( RandomDataPeriod , el_cl_eta->at(itr), el_cl_phi->at(itr)) != 3){
	    m_all_el_OTX.push_back(1);
	  }
	  if(((*el_OQ)[itr] & 1446) == 0 && myOQ.checkOQClusterElectron( RandomDataPeriod , el_cl_eta->at(itr), el_cl_phi->at(itr)) == 3){
	    m_all_el_OTX.push_back(2); //Passes OQ but fails checkOQ --> Could be LAr Hole
	  }
	}
	if(RandomDataPeriod < 180614 || RandomDataPeriod > 185352){
	  if(((*el_OQ)[itr] & 1446) == 0){
	    m_all_el_OTX.push_back(1);
	  }
	}
	if(((*el_OQ)[itr] & 1446) != 0){
	  m_all_el_OTX.push_back(3);
	}
      }
      
      if((*el_nBLHits)[itr] >= 1){
	m_all_el_blayer.push_back((*el_nBLHits)[itr]);
      }
      if((*el_nBLHits)[itr] < 1 && (*el_expectHitInBLayer)[itr] != 1){
	m_all_el_blayer.push_back(-1);
      }
      if((*el_nBLHits)[itr] < 1 && (*el_expectHitInBLayer)[itr] == 1){
	m_all_el_blayer.push_back(0);
      }
    }
    
    // cout << "DEBUG " << (int) (*el_E).size() << endl;            
    // cout << "DEBUG " << (int) m_all_el_px.size() << endl << endl;
    //Int_t STOP = 0;
    eg2011::EnergyRescaler eRescale;
    eRescale.useDefaultCalibConstants("2011");
    bool is_mc;
    
    for(int itr = 0 ; itr < (int) m_all_el_quality.size() ; itr++){  
      //For truth studies
      if(InputType == "MC"){
	vector<float> m_all_el_truth_pt(*mapVarsVectorFloat[EleAlg+"truth_pt"]);
	vector<float> m_all_el_truth_eta(*mapVarsVectorFloat[EleAlg+"truth_eta"]);
	vector<float> m_all_el_truth_phi(*mapVarsVectorFloat[EleAlg+"truth_phi"]);
	vector<float> m_all_el_truth_E(*mapVarsVectorFloat[EleAlg+"truth_E"]);
	Ele_truth.SetPtEtaPhiE(m_all_el_truth_pt[itr], m_all_el_truth_eta[itr], m_all_el_truth_phi[itr], m_all_el_truth_E[itr]);
      }
      if(m_GRL == 1 || (InputType == "MC" /*&& m_good_event == 1*/)){ 
	el_cut_passed[0] += 1.;
	float finalElE = m_all_el_cl_E[itr]; //always
	float finalElPt = -999.;
	float finalElPx;
	float finalElPy;
	float finalElPz;
	float finalElEta;
	float finalElPhi;
	if((m_all_el_nSCTHits[itr] + m_all_el_nPixHits[itr]) < 4){
	  finalElPt = m_all_el_cl_pt[itr]; //Corrected el_cl_pt                                                                                                     
	  finalElPx = finalElPt*cos(m_all_el_cl_phi[itr]);
	  finalElPy = finalElPt*sin(m_all_el_cl_phi[itr]);
	  finalElPz = finalElPt*sinh(m_all_el_cl_eta[itr]);
	  finalElEta = m_all_el_cl_eta[itr];
	  finalElPhi = m_all_el_cl_phi[itr];
	}
	if((m_all_el_nSCTHits[itr] + m_all_el_nPixHits[itr]) >= 4){ //always the case for medium and tight electrons 
	  finalElPt = m_all_el_cl_E[itr]/cosh(m_all_el_tracketa[itr]); //With corrected el_cl_pt 
	  finalElPx = finalElPt*cos(m_all_el_trackphi[itr]);
	  finalElPy = finalElPt*sin(m_all_el_trackphi[itr]);
	  finalElPz = finalElPt*sinh(m_all_el_tracketa[itr]);
	  finalElEta = m_all_el_tracketa[itr];
	  finalElPhi = m_all_el_trackphi[itr];
	}
	//COUT;
	TLorentzVector Ele;
	Ele.SetPtEtaPhiE(finalElPt, finalElEta, finalElPhi, finalElE); 
	float Smearing_Factor = 1.;
	float Cluster_E_El = 1; 
	float El_Px = Ele.Px();
	float El_Py = Ele.Py();
	float El_Px_smear = Ele.Px();
	float El_Py_smear = Ele.Py();
	float El_Px_energyCor = Ele.Px();
	float El_Py_energyCor = Ele.Py();
	if(InputType == "MC" && DoElectronSmearing == "Yes"){
	  double mcWithConstantTerm=true;// if you use a MC without constant term,
	  Smearing_Factor = eRescale.getSmearingCorrectionMeV(m_all_el_cl_eta[itr], m_all_el_cl_E[itr], DoLESUncertainty, mcWithConstantTerm, "2011");
	  Ele.SetPtEtaPhiM(Smearing_Factor*Ele.Pt(), Ele.Eta(), Ele.Phi(), Ele.M()); //Smear energy 
	  El_Px_smear = Ele.Px();
	  El_Py_smear = Ele.Py();
	}
	if(InputType == "DATA"){ 
	  Cluster_E_El = eRescale.applyEnergyCorrectionMeV(m_all_el_cl_eta[itr], m_all_el_cl_phi[itr], m_all_el_cl_E[itr], finalElPt, 0, "ELECTRON" );
	  cout << "Cluster_E_El       " << Cluster_E_El << endl;
          cout << "m_all_el_cl_E[itr] " << m_all_el_cl_E[itr] << endl;  
	  if((m_all_el_nSCTHits[itr] + m_all_el_nPixHits[itr]) < 4){
	    Ele.SetPtEtaPhiM(m_all_el_cl_pt[itr]*Cluster_E_El/m_all_el_cl_E[itr], Ele.Eta(), Ele.Phi(), Ele.M()); 
	  }
	  if((m_all_el_nSCTHits[itr] + m_all_el_nPixHits[itr]) >= 4){
	    Ele.SetPtEtaPhiM(Cluster_E_El/cosh(m_all_el_tracketa[itr]), Ele.Eta(), Ele.Phi(), Ele.M()); 
	  }
	  El_Px_energyCor = Ele.Px();
	  El_Py_energyCor = Ele.Py();
	}
	//COUT;
	//Pt Cuts, Eta cuts and possibly removed Eta or Phi ranges.  
	if((m_all_el_author[itr] == 1 || m_all_el_author[itr] == 3) ) {
	  el_cut_passed[1] += 1.;
	  ////////////////////////////////////////////////
	  if(m_all_el_OTX[itr] == 2){ //For MET correction
	    if(Ele.Pt() > 20000.0){
	      m_el_all_itr.push_back(itr);
	      m_el_all_MET_wpx.push_back(m_all_el_MET_wpx[itr][0]);
	      m_el_all_MET_wpy.push_back(m_all_el_MET_wpy[itr][0]);
	      m_dx_ele_all_lar.push_back(-Ele.Px());
	      m_dy_ele_all_lar.push_back(-Ele.Py());
	    }
	  } 
	  ////////////////////////////////////////////////
	  if(m_all_el_OTX[itr] != 3){ //This contains OQ cuts... see above  
	    el_cut_passed[2] += 1.;
	    if(m_all_el_OTX[itr] != 2 || InputType == "DATA"){
	      el_cut_passed[3] += 1.;
	      if ( m_all_el_cl_eta[itr] == 2.47 || m_all_el_cl_eta[itr] == -2.47 ) 
		cout << "DEBUG " << "el eta amiguity" << endl;
	      if ( m_all_el_cl_eta[itr] >= finalElEta_Cut_min &&
		   m_all_el_cl_eta[itr] <= finalElEta_Cut_max &&
		   (fabs(m_all_el_cl_eta[itr]) < RemoveElEtaRange1_min || fabs(m_all_el_cl_eta[itr]) > RemoveElEtaRange1_max) && 
		   (fabs(m_all_el_cl_eta[itr]) < RemoveElEtaRange2_min || fabs(m_all_el_cl_eta[itr]) > RemoveElEtaRange2_max) && 
		   (m_all_el_cl_phi[itr] < RemoveElPhiRange1_min || m_all_el_cl_phi[itr] > RemoveElPhiRange1_max) && 
		   (m_all_el_cl_phi[itr] < RemoveElPhiRange2_min || m_all_el_cl_phi[itr] > RemoveElPhiRange2_max) ){
		el_cut_passed[4] += 1.;
		//Electron Reconstruction Efficiency
		pair <float,float> ElRecoSFeta; 
		pair <float,float> ElIdenSFeta;
		pair <float,float> ElTrigSFeta; 
		if(Ele.Pt() > 20000.0){
		  //COUT;
		  int set;
		  //--- Identification Efficiency
		  COUT;
		  if(InputType == "MC"){
		    if(m_all_el_quality[itr] == 2 || m_all_el_quality[itr] == 3){
		      set = 6; //For medium
		      ElIdenSFeta = mySFclass.scaleFactor(m_all_el_cl_eta[itr], Ele.Pt(), set, 0, 5, true);
		    }
		    COUT;
		    if(m_all_el_quality[itr] == 4 || m_all_el_quality[itr] == 5){
		      set = 7; //For tight
		      cout << "m_all_el_cl_eta[itr]  " << m_all_el_cl_eta[itr] << endl;
		      ElIdenSFeta = mySFclass.scaleFactor(m_all_el_cl_eta[itr], Ele.Pt(), set, 0, 5, true);
		    }
		    COUT;
		    //--- Above may not be ready yet
		    
		    //--- Reconstruction Efficiency 
		    ElRecoSFeta = mySFclass.scaleFactor(m_all_el_cl_eta[itr], Ele.Pt(), 4, 0, 5, true);
		 		    cout << "ElIdenSFeta.first " << ElIdenSFeta.first << endl;  
		    cout << "ElRecoSFeta.first " << ElRecoSFeta.first << endl; 
		    cout << "ElTrigSFeta.first " << ElTrigSFeta.first << endl;  
		    if(ElIdenSFeta.first <= 0. ){
		      ElIdenSFeta.first = 1.0;
		    }
		    if(ElRecoSFeta.first <= 0. ){
		      ElRecoSFeta.first = 1.0;
		    }
		    if(ElTrigSFeta.first <= 0. ){
		      ElTrigSFeta.first = 1.0;
		    }
		  }
		}
		if ( m_all_el_quality[itr] >= ElectronQuality ) {
		  el_cut_passed[5] += 1.;
		  //COUT;
		  //cout << " finalElPt_Cut " << finalElPt_Cut << endl;
		  if(Ele.Pt() > 20000.0){ //Use this for analysis
		    //if ( Ele.Pt()  > finalElPt_Cut ) { //Use this for cut flow
		    el_cut_passed[6] +=1.;
		    //COUT;
		    if(m_all_el_quality[itr] >= 2  ) {
		      el_cut_passed[7] += 1.;
		      if ( fabs(m_all_el_trackd0pv[itr]/m_all_el_tracksigd0pv[itr]) < 10. ) {
			el_cut_passed[8] += 1.;
			if ( fabs(m_all_el_trackz0pv[itr]) < 10. ) {
			  el_cut_passed[9] += 1.;
			  if(m_all_el_blayer[itr] != 0 || m_runMode == _MODE_HQ){
			    el_cut_passed[10] += 1.;
			    //COUT;
			    //e/mu overlap removal
			    float DeltaPhi = 0.0;
			    float DeltaEta = 0.0;
			    float DeltaR   = 0.0;
			    int ElectronOverlapElectron = 0;
			    int MuonOverlapElectron = 0; 
			    if(m_runMode == _MODE_TR){
			      for(int itrMu = 0 ; itrMu < (int) m_mu_veto_e.size() ; itrMu++){
				//COUT;
				DeltaPhi = fabs( m_mu_veto_id_phi[itrMu] - m_all_el_trackphi[itr] );
				if(DeltaPhi > 3.141592654){
				  DeltaPhi = (2*3.141592654 - DeltaPhi);
				}
				//COUT;
				DeltaEta = fabs( m_mu_veto_id_eta[itrMu] - m_all_el_tracketa[itr] );
				DeltaR = sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta);
				//COUT;
				if(DeltaR < DeltaR_Cut_MuOverlapsEl){
				  MuonOverlapElectron = 1;
				  break;
				}
			      }
			    }
			    //COUT;
			    if(MuonOverlapElectron == 0){
			      //COUT;
			      el_cut_passed[11] += 1.;
			      for(int itrEl = 0 ; itrEl < itr ; itrEl++){ //Iterates over electrons with higher Pt -- Use cluster eta phi 
				//COUT;
				if(m_all_el_pt[itrEl] > finalElPt_Cut){
				  DeltaPhi = fabs( m_all_el_cl_phi[itrEl] - m_all_el_cl_phi[itr] );
				  if(DeltaPhi > 3.141592654){
				    DeltaPhi = (2*3.141592654 - DeltaPhi);
				  }
				  DeltaEta = fabs( m_all_el_cl_eta[itrEl] - m_all_el_cl_eta[itr] );
				  //COUT;
				  DeltaR = sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta);
				  if(DeltaR < DeltaR_Cut_ElOverlapsEl){
				    ElectronOverlapElectron = 1;
				    break;
				  }
				}
			      }
			      //COUT;
			      if(ElectronOverlapElectron == 0){
				el_cut_passed[12] += 1.;
				
				cout << "m_all_el_Etcone30[itr]   " << m_all_el_Etcone30[itr] << endl;
				float EtconeXX_pt_corrected = 0; 
				cout << "m_nPV " << m_nPV << endl;  
				if(InputType == "MC"){
				  is_mc = true;
				  EtconeXX_pt_corrected = CaloIsoCorrection::GetPtCorrectedIsolation(m_all_el_cl_E[itr], m_all_el_etas2[itr], m_all_el_etap[itr], m_all_el_cl_eta[itr], 30 /*dR radius*/, is_mc, m_all_el_Etcone30[itr], true, CaloIsoCorrection::ELECTRON);
				}
				if(InputType == "DATA"){
				  is_mc = false;
				  EtconeXX_pt_corrected = CaloIsoCorrection::GetPtCorrectedIsolation(m_all_el_cl_E[itr], m_all_el_etas2[itr], m_all_el_etap[itr], m_all_el_cl_eta[itr], 30 /*dR radius*/, is_mc, m_all_el_Etcone30[itr], false, CaloIsoCorrection::ELECTRON);
				}
				cout << "EtconeXX_pt_corrected                 " << EtconeXX_pt_corrected << endl; 
				int passed_iso = 0;
				if(EtconeXX_pt_corrected/Ele.Pt() < EtCone_Cut){ //Now a relative cut < 0.14
				  passed_iso = 1;
				  el_cut_passed[13] += 1.; 
				}
				if(Ele.Pt() > finalElPt_Cut && passed_iso == 1){ 
				  //Fill variables
				  if(InputType == "MC"){
				    if(NtupleType != "Top"){
				      if(InputType == "MC" && NtupleType != "Thomas") m_el_type.push_back(m_all_el_type[itr]);
				    }
				    m_el_ptcone20.push_back(m_all_el_ptcone20[itr]);
				    m_el_ptcone40.push_back(m_all_el_ptcone40[itr]);
				  }
				  //COUT;
				  m_all_elSFweight.push_back((ElIdenSFeta.first)*(ElRecoSFeta.first)*(ElTrigSFeta.first));
				  //COUT;
				  m_el_cl_pt.push_back(m_all_el_cl_pt[itr]);
				  m_el_e.push_back(Ele.E());
				  m_el_isEM.push_back(m_all_el_isEM[itr]);
				  m_el_OQ.push_back(m_all_el_OQ[itr]);
				  m_el_OTX_OQ.push_back(m_all_el_OTX[itr]);
				  m_el_cl_eta.push_back(m_all_el_cl_eta[itr]);
				  m_el_cl_phi.push_back(m_all_el_cl_phi[itr]);
				  m_el_px.push_back(Ele.Px());
				  m_el_py.push_back(Ele.Py());                                
				  m_el_pz.push_back(Ele.Pz());
				  m_el_charge.push_back(m_all_el_charge[itr]);
				  m_el_blayer.push_back(m_all_el_blayer[itr]);
				  m_el_pt.push_back(Ele.Pt());
				  m_el_eta.push_back(Ele.Eta());
				  m_el_phi.push_back(Ele.Phi());
				  m_el_tracketa.push_back(m_all_el_tracketa[itr]);
				  m_el_trackphi.push_back(m_all_el_trackphi[itr]);
				  m_el_tracktheta.push_back(m_all_el_tracktheta[itr]);
				  m_el_MET_wpx.push_back(m_all_el_MET_wpx[itr][0]);
				  m_el_MET_wpy.push_back(m_all_el_MET_wpy[itr][0]);
				  m_dx_ele_energyCor.push_back(El_Px_energyCor - El_Px);
				  m_dy_ele_energyCor.push_back(El_Py_energyCor - El_Py);
				  // 	      m_el_trackz0pv.push_back(m_all_el_trackz0pv[itr]);
				  // 	      m_el_trackd0pv.push_back(m_all_el_trackd0pv[itr]);
				  // 	      m_el_tracksigd0pv.push_back(m_all_el_tracksigd0pv[itr]);
				  m_el_quality.push_back(m_all_el_quality[itr]);
				  //		      h_el_quality->Fill(m_all_el_quality[itr]);
				  m_el_Etcone20_pt_corrected.push_back(m_all_el_Etcone20_pt_corrected[itr]);
				  m_el_Etcone30_pt_corrected.push_back(m_all_el_Etcone30_pt_corrected[itr]);
				  m_el_Etcone40_pt_corrected.push_back(m_all_el_Etcone40_pt_corrected[itr]);
				  m_el_ptcone30.push_back(m_all_el_ptcone30[itr]);
				  if(OutputTruth == "On" && InputType == "MC"){
				    if(Ele_truth.E() > 0.){
				      m_el_pt_truth.push_back(Ele_truth.Pt());
				      m_el_eta_truth.push_back(Ele_truth.Eta());
				      m_el_phi_truth.push_back(Ele_truth.Phi());
				      m_el_e_truth.push_back(Ele_truth.E());
				      m_el_m_truth.push_back(Ele_truth.M());
				    }
				    else if(Ele_truth.E() <= 0.){
				      m_el_pt_truth.push_back(0);
				      m_el_eta_truth.push_back(0);
				      m_el_phi_truth.push_back(0);
				      m_el_e_truth.push_back(0);
				      m_el_m_truth.push_back(0);
				    }
				  }
				}
				//Otherwise Fill those that pass Pt > 20000.0 : check Pt if statement  
				m_el_veto_pt.push_back(Ele.Pt());
				m_el_veto_eta.push_back(Ele.Eta());
				m_el_veto_phi.push_back(Ele.Phi());
				m_el_veto_cl_eta.push_back(m_all_el_cl_eta[itr]);
				m_el_veto_cl_phi.push_back(m_all_el_cl_phi[itr]);
				m_el_veto_e.push_back(Ele.E());
				m_el_veto_px.push_back(Ele.Px()); 
				m_el_veto_py.push_back(Ele.Py());
				m_el_veto_pz.push_back(Ele.Pz());
				m_el_veto_smearing_factor.push_back(Smearing_Factor);
				m_el_veto_MET_wpx.push_back(m_all_el_MET_wpx[itr][0]);
				m_el_veto_MET_wpy.push_back(m_all_el_MET_wpy[itr][0]);
				m_dx_ele_smear.push_back(El_Px_smear - El_Px);
				m_dy_ele_smear.push_back(El_Py_smear - El_Py);
				
				// 		      //For trigger efficiencies
				// 		      if(TriggerEfficiencies == "On" && Do1ElTrig == "On" && *mapVarsBool[ElectronTrigger] == 1){
				// 			m_el_pt_num1ElTrig.push_back(finalElPt);  //numerator of 1ElTrig efficiency
				// 			m_el_quality_num1ElTrig.push_back(m_all_el_quality[itr]);
				// 		      }
				// 		      if(TriggerEfficiencies == "On" && Do2ElTrig == "On" && *mapVarsBool[TwoElectronTrigger] == 1){
				// 			m_el_pt_num2ElTrig.push_back(finalElPt); //numerator of 2ElTrig efficiency
				// 			m_el_quality_num2ElTrig.push_back(m_all_el_quality[itr]);
				// 		      }
				// 		      if(TriggerEfficiencies == "On" && Do3ElTrig == "On" && *mapVarsBool[ThreeElectronTrigger] == 1){
				// 			m_el_pt_num3ElTrig.push_back(finalElPt); //numerator of 3ElTrig efficiency
				// 			m_el_quality_num3ElTrig.push_back(m_all_el_quality[itr]);
				// 		      }
				// 		      if(TriggerEfficiencies == "On" && Do1El1MuTrig == "On" && *mapVarsBool[ElectronMuonTrigger] == 1){
				// 			m_el_pt_num1El1MuTrig.push_back(finalElPt); //numerator of 1El1MuTrig efficiency 
				// 			m_el_quality_num1El1MuTrig.push_back(m_all_el_quality[itr]);
				// 		      }
				// 		      if(TriggerEfficiencies == "On" && Do1El2MuTrig == "On" && *mapVarsBool[ElectronTwoMuonTrigger] == 1){
				// 			m_el_pt_num1El2MuTrig.push_back(finalElPt); //numerator of 1El2MuTrig efficiency                
				// 			m_el_quality_num1El2MuTrig.push_back(m_all_el_quality[itr]);
				// 		      }
				// 		      if(TriggerEfficiencies == "On" && Do2El1MuTrig == "On" && *mapVarsBool[TwoElectronMuonTrigger] == 1){
				// 			m_el_pt_num2El1MuTrig.push_back(finalElPt); //numerator of 2El1MuTrig efficiency             
				// 			m_el_quality_num2El1MuTrig.push_back(m_all_el_quality[itr]);
				// 		      }
				//		    }
				// 		  }
				// 		}
			      }
			    }
			  }
			}
		      }
		    }
		  }
		}
	      }
	    }
	  }
	}
      }
    }
  }
  //   for(int itr = 0 ; ( itr < 2 && itr < (int) m_all_el_E.size() )/*only want 2 first ones*/ ; itr ++){
  //     m_el_e_2maxpt.push_back(m_all_el_E[itr]);
  //     m_el_px_2maxpt.push_back(m_all_el_px[itr]);
  //     m_el_py_2maxpt.push_back(m_all_el_py[itr]);
  //     m_el_pz_2maxpt.push_back(m_all_el_pz[itr]);
  //     m_el_charge_2maxpt.push_back(m_all_el_charge[itr]);
  //     m_el_pt_2maxpt.push_back(m_all_el_pt[itr]);
  //     m_el_eta_2maxpt.push_back(m_all_el_eta[itr]);
  //     m_el_phi_2maxpt.push_back(m_all_el_phi[itr]);
  //     m_el_quality_2maxpt.push_back(m_all_el_quality[itr]);
  //   }
  
  //Final number of Electrons 
  m_el_number.push_back((int) m_el_pt.size()); 
  if(m_runMode == _MODE_TR || m_runMode == _MODE_HQ){
    m_lep_number.push_back(m_el_number[0] + m_mu_number[0]);
    m_lep_veto_number.push_back(((int) m_el_veto_e.size()) + ((int) m_mu_veto_e.size()));
    
  }
  //Total efficiency weight
  m_elSFweight = 1.0;
  for(int itr = 0 ; itr < (int) m_all_elSFweight.size() ; itr++){
    m_elSFweight = m_elSFweight*m_all_elSFweight[itr];
  }
  
  //delete mySFclass;
  
  if(INFO == "On"){
    cout << "ProcessElectrons() completed successfully" << endl;
  }
  
}

void Background::TruthDecayQuarks(){
  
}

void Background::TruthElectrons(){
  
  vector<float> m_all_el_E(*mapVarsVectorFloat[EleAlg+"E"]);
  vector<float> m_all_el_charge(*mapVarsVectorFloat[EleAlg+"charge"]);
  vector<float> m_all_el_phi(*mapVarsVectorFloat[EleAlg+"phi"]);
  vector<float> m_all_el_eta(*mapVarsVectorFloat[EleAlg+"eta"]);
    
  //     if(NtupleType == "WZ" || NtupleType == "Thomas"){
  for( int itr = 0 ; itr < (int) (*mc_pdgId).size() ; itr++){
    //cout << "(*mc_pdgId)[itr]  " << (*mc_pdgId)[itr] << endl; 
    //cout << "(*mc_pt)[itr]     " << (*mc_pt)[itr]  << endl;
    if( fabs((*mc_pdgId)[itr]) == 11 && (*mc_status)[itr] == 1 && (*mc_barcode)[itr] < 200000 && (*mc_pt)[itr] >= finalElPt_Cut && (*mc_eta)[itr] >= finalElEta_Cut_min && (*mc_eta)[itr] <= finalElEta_Cut_max && ( fabs((*mc_eta)[itr]) < RemoveElEtaRange1_min || fabs((*mc_eta)[itr]) > RemoveElEtaRange1_max) && ( fabs((*mc_eta)[itr]) < RemoveElEtaRange2_min || fabs((*mc_eta)[itr]) > RemoveElEtaRange2_max ) && ( (*mc_phi)[itr] < RemoveElPhiRange1_min || (*mc_phi)[itr] > RemoveElPhiRange1_max) && ( (*mc_phi)[itr] < RemoveElPhiRange2_min || (*mc_phi)[itr] > RemoveElPhiRange2_max) && ((*mc_charge)[itr] == 1 || (*mc_charge)[itr] == -1) ){
      m_el_px_truth.push_back(cos((*mc_phi)[itr])*(*mc_pt)[itr]);
      m_el_py_truth.push_back(sin((*mc_phi)[itr])*(*mc_pt)[itr]);
      float TruthParticle_Pz;
      //TruthParticle_Pz = (*mc_pt)[itr]/(tan(2*atan(exp(-(*mc_eta)[itr]))));  //To check
      TruthParticle_Pz = (*mc_pt)[itr]*sinh((*mc_eta)[itr]);
      m_el_pz_truth.push_back(TruthParticle_Pz);
      m_el_e_truth.push_back(sqrt(((*mc_pt)[itr])*((*mc_pt)[itr]) + TruthParticle_Pz*TruthParticle_Pz));
      m_el_pt_truth.push_back((*mc_pt)[itr]);
      m_el_eta_truth.push_back((*mc_eta)[itr]);
      m_el_m_truth.push_back((*mc_m)[itr]);
      m_el_phi_truth.push_back((*mc_phi)[itr]);
      m_el_charge_truth.push_back((int) (*mc_charge)[itr]);
    }
  }
  //    }
  
  //The number of truth electrons
  m_el_number_truth.push_back((int) m_el_pt_truth.size());
  
  if(INFO == "On"){
    cout << "TruthElectrons() completed succesfully" << endl;
  }
}
	    
void Background::Electron_Eff_Reso(){
  
  if(Truth == "On"){
    if(m_el_number[0] > 0){
      if((int) m_el_pt_truth.size() == 0){
	for(int i = 0 ; i < m_el_number[0] ; i++){
	  m_RecoEl_is_Matched.push_back(0);
	}
      }	
      if((int) m_el_pt_truth.size() > 0){
	for(int itr1 = 0 ; itr1 < m_el_number[0] ; itr1++){
	  float DeltaEta = 0.;
	  float DeltaPhi = 0.;
	  float RatioE = 1000000.0;
	  float DeltaR = 1000.0;
	  float DeltaR_Match = 1000.0;
	  int El_Matched = -999;
	  int DeltaCharge = -999;
	  for(int itr2 = 0 ; itr2 < m_el_number_truth[0] ; itr2++){
	    DeltaEta = fabs(m_el_eta[itr1] - m_el_eta_truth[itr2]);
	    DeltaPhi = fabs(m_el_phi[itr1] - m_el_phi_truth[itr2]);
	    if(DeltaPhi > 3.141592654){
	      DeltaPhi = (2*3.141592654 - DeltaPhi);
	    }
	    DeltaR = sqrt(DeltaEta*DeltaEta + DeltaPhi*DeltaPhi);
	    DeltaCharge = (int) (m_el_charge[itr1] - m_el_charge_truth[itr2]);
	    RatioE = fabs(m_el_e[itr1]/m_el_e_truth[itr2]); 
	    if(DeltaR < DeltaR_Cut_Res_El && DeltaR < DeltaR_Match && RatioE > DiffE_El && RatioE < (DiffE_El + 1) ){
	      El_Matched = itr2;
	      DeltaR_Match = DeltaR; 
	    }
	  }
	  if(El_Matched == -999){
	    m_RecoEl_is_Matched.push_back(0);
	  }
	  if(El_Matched >= 0 && DeltaR_Match < DeltaR_Cut_Res_El){
	    m_RecoEl_is_Matched.push_back(1);
	    float ElPtResolution;
	    float ElEtaResolution;
	    ElPtResolution = ((m_el_pt[itr1]/m_el_pt_truth[El_Matched]) - 1);
	    ElEtaResolution = ((m_el_eta[itr1]/m_el_eta_truth[El_Matched]) - 1);
	    m_DeltaR_ElMatched_ElTruth.push_back(DeltaR_Match);
	    m_Resolution_ElPt.push_back(ElPtResolution);
	    m_el_px_truth_matched.push_back(m_el_px_truth[El_Matched]);
	    m_el_py_truth_matched.push_back(m_el_py_truth[El_Matched]);
	    m_el_pz_truth_matched.push_back(m_el_pz_truth[El_Matched]);
	    m_el_pt_truth_matched.push_back(m_el_pt_truth[El_Matched]);
	    m_el_eta_truth_matched.push_back(m_el_eta_truth[El_Matched]);
	    m_el_phi_truth_matched.push_back(m_el_phi_truth[El_Matched]);
	    if(DeltaCharge == 0){
	      m_RecoMatchedEl_withCorrectCharge.push_back(1);
	    }
	    if(DeltaCharge != 0){
	      m_RecoMatchedEl_withCorrectCharge.push_back(0);
	    }
	  }
	}
      }
    }
    if(INFO == "On"){
      cout << "Electron_Eff_Reso() completed succesfully" << endl;
    }
  }
}  

void Background::ProcessMuons(){
  
  //Muon Smearing and scale correction
  MuonSmear::SmearingClass myMuonSmear("Data11","staco","pT","Rel17","./");  
  myMuonSmear.UseScale(1);
  myMuonSmear.RestrictCurvatureCorrections(2.5);
  myMuonSmear.FillScales("KC");
    
  //For MET correction
  const unsigned int UNKNOWN = 0x0000;
  const unsigned int DEFAULT = 0x0001;
  const unsigned int SPECTRO = 0x0002;
  const unsigned int TRACK = 0x0004;
  const unsigned int REFMUON = 0x0008;
  const unsigned int MUID = 0x0010;

  vector<int> m_all_mu_author(*mapVarsVectorInt[MuonAlg_WZ+"author"]);
  vector<int> m_all_mu_loose(*mapVarsVectorInt[MuonAlg_WZ+"loose"]);
  vector<int> m_all_mu_medium(*mapVarsVectorInt[MuonAlg_WZ+"medium"]);
  vector<int> m_all_mu_tight(*mapVarsVectorInt[MuonAlg_WZ+"tight"]);
  vector<int> m_all_mu_isCombinedMuon(*mapVarsVectorInt[MuonAlg_WZ+"isCombinedMuon"]);
  vector<int> m_all_mu_nBLHits(*mapVarsVectorInt[MuonAlg_WZ+"nBLHits"]);
  vector<int> m_all_mu_expectBLayerHit(*mapVarsVectorInt[MuonAlg_WZ+"expectBLayerHit"]);
  vector<int> m_all_mu_nPixHits(*mapVarsVectorInt[MuonAlg_WZ+"nPixHits"]);
  vector<int> m_all_mu_nSCTHits(*mapVarsVectorInt[MuonAlg_WZ+"nSCTHits"]);
  vector<int> m_all_mu_nPixelDeadSensors(*mapVarsVectorInt[MuonAlg_WZ+"nPixelDeadSensors"]);
  vector<int> m_all_mu_nSCTDeadSensors(*mapVarsVectorInt[MuonAlg_WZ+"nSCTDeadSensors"]);
  vector<int> m_all_mu_nPixHoles(*mapVarsVectorInt[MuonAlg_WZ+"nPixHoles"]);
  vector<int> m_all_mu_nSCTHoles(*mapVarsVectorInt[MuonAlg_WZ+"nSCTHoles"]);
  vector<int> m_all_mu_nTRTHits(*mapVarsVectorInt[MuonAlg_WZ+"nTRTHits"]);
  vector<int> m_all_mu_nTRTOutliers(*mapVarsVectorInt[MuonAlg_WZ+"nTRTOutliers"]);
  vector<float> m_all_mu_z0_exPV(*mapVarsVectorFloat[MuonAlg_WZ+"z0_exPV"]);
  vector<float> m_all_mu_d0_exPV(*mapVarsVectorFloat[MuonAlg_WZ+"d0_exPV"]);
  vector<float> m_all_mu_ptcone20(*mapVarsVectorFloat[MuonAlg_WZ+"ptcone20"]);
  vector<float> m_all_mu_ptcone30(*mapVarsVectorFloat[MuonAlg_WZ+"ptcone30"]);
  vector<float> m_all_mu_etcone20(*mapVarsVectorFloat[MuonAlg_WZ+"etcone20"]);
  vector<float> m_all_mu_etcone30(*mapVarsVectorFloat[MuonAlg_WZ+"etcone30"]);
  vector<float> m_all_mu_ie_theta(*mapVarsVectorFloat[MuonAlg_WZ+"ie_theta"]);
  vector<float> m_all_mu_id_theta(*mapVarsVectorFloat[MuonAlg_WZ+"id_theta"]);
  vector<float> m_all_mu_me_theta(*mapVarsVectorFloat[MuonAlg_WZ+"me_theta"]);
  vector<float> m_all_mu_ie_qoverp(*mapVarsVectorFloat[MuonAlg_WZ+"ie_qoverp"]);
  vector<float> m_all_mu_id_qoverp(*mapVarsVectorFloat[MuonAlg_WZ+"id_qoverp"]);
  vector<float> m_all_mu_id_d0_exPV(*mapVarsVectorFloat[MuonAlg_WZ+"id_d0_exPV"]);
  vector<float> m_all_mu_id_z0_exPV(*mapVarsVectorFloat[MuonAlg_WZ+"id_z0_exPV"]);
  vector<float> m_all_mu_id_cov_d0_exPV(*mapVarsVectorFloat[MuonAlg_WZ+"id_cov_d0_exPV"]);
  //COUT;
  vector<float> m_all_mu_id_phi(*mapVarsVectorFloat[MuonAlg_WZ+"id_phi"]);
  vector<float> m_all_mu_me_phi(*mapVarsVectorFloat[MuonAlg_WZ+"me_phi"]);
  vector<float> m_all_mu_me_qoverp(*mapVarsVectorFloat[MuonAlg_WZ+"me_qoverp"]);
  vector<float> m_all_mu_E(*mapVarsVectorFloat[MuonAlg_WZ+"E"]);
  vector<float> m_all_mu_px(*mapVarsVectorFloat[MuonAlg_WZ+"px"]);
  vector<float> m_all_mu_py(*mapVarsVectorFloat[MuonAlg_WZ+"py"]);
  vector<float> m_all_mu_pz(*mapVarsVectorFloat[MuonAlg_WZ+"pz"]);
  vector<float> m_all_mu_charge(*mapVarsVectorFloat[MuonAlg_WZ+"charge"]);
  vector<float> m_all_mu_phi(*mapVarsVectorFloat[MuonAlg_WZ+"phi"]);	
  vector<float> m_all_mu_pt(*mapVarsVectorFloat[MuonAlg_WZ+"pt"]);
  vector<float> m_all_mu_eta(*mapVarsVectorFloat[MuonAlg_WZ+"eta"]);
  //COUT;
  //vector<float> m_all_mu_id_theta(*mapVarsVectorFloat[MuonAlg_WZ+"id_theta"]);
  vector<vector<float> > m_all_mu_MET_wpx(*mapVarsVectorVectorFloat[MuonAlg_WZ+"MET_wpx"]);
  vector<vector<float> > m_all_mu_MET_wpy(*mapVarsVectorVectorFloat[MuonAlg_WZ+"MET_wpy"]);
  vector<vector<unsigned int> > m_all_mu_MET_statusWord(*mapVarsVectorVectorUnsignedInt[MuonAlg_WZ+"MET_statusWord"]);

  //For truth
  TLorentzVector Mu_truth;

  vector<int> m_all_mu_quality;
  for(int itr = 0 ; itr < (int) m_all_mu_E.size() ; itr++){
    if(m_all_mu_tight[itr]) m_all_mu_quality.push_back(3);
    else if(m_all_mu_medium[itr]) m_all_mu_quality.push_back(2);
    else if(m_all_mu_loose[itr]) m_all_mu_quality.push_back(1);
    else m_all_mu_quality.push_back(0);
  }
  //COUT;

  for(int itr = 0 ; itr < (int) m_all_mu_E.size() ; itr++){  
    if(m_GRL == 1 || (InputType == "MC" /*&& m_good_event == 1*/)){
      
      //For truth
      if(InputType == "MC"){
	vector<float> m_all_mu_truth_pt(*mapVarsVectorFloat[MuonAlg_WZ+"truth_pt"]);
	vector<float> m_all_mu_truth_eta(*mapVarsVectorFloat[MuonAlg_WZ+"truth_eta"]);
	vector<float> m_all_mu_truth_phi(*mapVarsVectorFloat[MuonAlg_WZ+"truth_phi"]);
	vector<float> m_all_mu_truth_E(*mapVarsVectorFloat[MuonAlg_WZ+"truth_E"]);
	Mu_truth.SetPtEtaPhiE(m_all_mu_truth_pt[itr], m_all_mu_truth_eta[itr], m_all_mu_truth_phi[itr], m_all_mu_truth_E[itr]);
      }

      //COUT;
      mu_cut_passed[0] += 1.;
      float finalMuPt  = m_all_mu_pt[itr];
      float finalMuEta = m_all_mu_eta[itr];
      float finalMuPhi = m_all_mu_phi[itr];
      float finalMuE = m_all_mu_E[itr];
      TLorentzVector Muon;
      Muon.SetPtEtaPhiE(finalMuPt, finalMuEta, finalMuPhi, finalMuE);
      float Mu_Px = 0;
      float Mu_Py = 0;
      float Mu_Px_smear = 0;
      float Mu_Py_smear = 0;
      Mu_Px = Muon.Px();
      Mu_Py = Muon.Py(); 
      //For MC smearing 
      double eta  = finalMuEta;
      double ptcb = finalMuPt;
      double ptms = fabs (1.0/(m_all_mu_me_qoverp[itr]) *sin((m_all_mu_me_theta[itr])));
      double ptid = fabs (1.0/(m_all_mu_id_qoverp[itr]) *sin((m_all_mu_id_theta[itr]))); 
      float MuonCorrectionFactor = 1.0; 
      if(InputType == "MC" && DoMuonSmearing == "Yes"){
	myMuonSmear.SetSeed(EventNumber, itr);
	myMuonSmear.Event(ptms,ptid,ptcb,eta,m_all_mu_charge[itr]); 
	finalMuPt = myMuonSmear.pTCB();
	//finalMuPtMS = myMuonSmear.pTMS();
	//finalMuPtID = myMuonSmear.pTID();
	MuonCorrectionFactor = finalMuPt/m_all_mu_pt[itr];
      }
      //final muon 4-vector
      Muon.SetPtEtaPhiM(MuonCorrectionFactor*Muon.Pt(), Muon.Eta(), Muon.Phi(), Muon.M());
      Mu_Px_smear = Muon.Px();
      Mu_Py_smear = Muon.Py();
      if ( (m_all_mu_author[itr] == 12 &&(MuonAlg_WZ=="mu_muid_")) || ((m_all_mu_author[itr] == 6 || m_all_mu_author[itr] == 7)&&(MuonAlg_WZ=="mu_staco_")) ) {
	if(m_all_mu_isCombinedMuon[itr] == 1){
	  mu_cut_passed[1] += 1.;
	  if(m_all_mu_quality[itr] == 3){
	    //--- For Muon Efficiency Tool ---
	    /*vector<double> int_lum(11);
	    int_lum[0] = 11.991;
	    int_lum[1] = 166.467;
	    int_lum[2] = 50.418;
	    int_lum[3] = 136.759;
	    int_lum[4] = 517.988;
	    int_lum[5] = 264.752;
	    int_lum[6] = 333.797;
	    int_lum[7] = 233.152;
	    int_lum[8] = 576.290;
	    int_lum[9] = 1415.898;
	    int_lum[10] = 1031.540;*/
	    //---
	    if(MuonAlg_WZ == "mu_muid_" && InputType == "MC"){
	      Analysis::AnalysisMuonEfficiencyScaleFactors sf("Muid_CB", int_lum, "MeV", "./MuonEfficiencyCorrections/"); 
	      if(Muon.Pt() > 15000.0){
		m_all_muonSFweight.push_back(sf.scaleFactor(Muon));
	      }
	      else {
		m_all_muonSFweight.push_back(1.);
	      }
	    }
	    if(MuonAlg_WZ == "mu_staco_" && InputType == "MC"){
	      Analysis::AnalysisMuonEfficiencyScaleFactors sf("STACO_CB", int_lum, "MeV", "./MuonEfficiencyCorrections/"); 
	      if(Muon.Pt() > 15000.0){
		m_all_muonSFweight.push_back(sf.scaleFactor(Muon)); 
	      }
	      else {
		m_all_muonSFweight.push_back(1.);
	      }
	    }
	    mu_cut_passed[2] += 1.;
	    //COUT;
	    if ( Muon.Eta() >= finalMuEta_Cut_min && Muon.Eta() <= finalMuEta_Cut_max ) {
	      if ( (fabs(Muon.Eta()) < RemoveMuEtaRange1_min || fabs(finalMuEta) > RemoveMuEtaRange1_max) && (fabs(Muon.Eta()) < RemoveMuEtaRange2_min || fabs(Muon.Eta()) > RemoveMuEtaRange2_max) && (finalMuPhi < RemoveMuPhiRange1_min || finalMuPhi > RemoveMuPhiRange1_max) && (finalMuPhi < RemoveMuPhiRange2_min || finalMuPhi > RemoveMuPhiRange2_max) ) {
		mu_cut_passed[3] += 1.;
		if(Muon.Pt() > 20000.0){ //Use this for analysis
		  //if(Muon.Pt() > finalMuPt_Cut){ //Use this for cut flow 
		  mu_cut_passed[4] += 1.;
		  if( m_all_mu_nBLHits[itr] >= 1 || (m_all_mu_expectBLayerHit[itr] == 0) ){
		    mu_cut_passed[5] += 1.;
		    if ( ((m_all_mu_nPixHits[itr] + m_all_mu_nPixelDeadSensors[itr]) > Mu_nPixHits_Cut || 
			  (m_all_mu_nPixHits[itr] + m_all_mu_nPixelDeadSensors[itr]) < 0) ) {// > 1 in rel16 recommendation
		      mu_cut_passed[6] += 1.;
		      //COUT;
		      if ( ((m_all_mu_nSCTHits[itr] + m_all_mu_nSCTDeadSensors[itr]) >= Mu_nSCTHits_Cut || 
			    (m_all_mu_nSCTHits[itr] + m_all_mu_nSCTDeadSensors[itr]) < 0) ) {//>= 6 in rel16 recommendation 
			mu_cut_passed[7] += 1.;
			//cout << "Mu_nHoles_Cut " << Mu_nHoles_Cut << endl;  
			if ( (m_all_mu_nPixHoles[itr] + m_all_mu_nSCTHoles[itr]) < Mu_nHoles_Cut){
			  mu_cut_passed[8] += 1.;
			  //TRT
			  bool good=false;
			  int m_all_mu_nSumHits = m_all_mu_nTRTHits[itr]+m_all_mu_nTRTOutliers[itr];
			  if(fabs(Muon.Eta()) < 1.9 && m_all_mu_nSumHits > 5 && m_all_mu_nTRTOutliers[itr] < 0.9*m_all_mu_nSumHits){
			    good=true;
			  }
			  if(fabs(Muon.Eta()) >= 1.9){
			    if(m_all_mu_nSumHits > 5){
			      if(m_all_mu_nTRTOutliers[itr] < 0.9*m_all_mu_nSumHits){
				good=true;
			      }
			    }
			    if(m_all_mu_nSumHits <= 5){
			      good=true;
			    }
			  }
			  if (good) {
			    mu_cut_passed[9] += 1.;	    
			    if ( fabs(m_all_mu_z0_exPV[itr]) < Mu_z0_Cut ) {
			      mu_cut_passed[10] += 1.;	    
			      if ( fabs(m_all_mu_id_d0_exPV[itr]/sqrt(m_all_mu_id_cov_d0_exPV[itr])) < Mu_d0_Cut){
				mu_cut_passed[11] += 1.;	    
				float IsoCone = 0.; 
				if(InputType == "MC"){
				  //  CorrectCaloIso Iso; 
				  //IsoCone = Iso.CorrectEtCone30Rel(Muon.Pt(), m_all_mu_etcone30[itr], m_nPV, Muon.Eta());
				  IsoCone = m_all_mu_etcone30[itr];   
				}
				if(InputType == "DATA"){
				  IsoCone = m_all_mu_etcone30[itr];
				}
				if ( IsoCone/Muon.Pt() < Mu_ptcone20_over_Pt_Cut ) { //now using etcone30/pt < 0.14 
				  mu_cut_passed[12] += 1.;
				  //Fill Variables
				  if(Muon.Pt() > finalMuPt_Cut){
				    //COUT;
				    m_mu_ptcone20.push_back(m_all_mu_ptcone20[itr]);
				    m_mu_e.push_back(Muon.E());
				    m_mu_px.push_back(Muon.Px());
				    m_mu_py.push_back(Muon.Py());                              
				    m_mu_pz.push_back(Muon.Pz());
				    m_mu_charge.push_back((int) m_all_mu_charge[itr]);
				    m_mu_pt.push_back(Muon.Pt());
				    m_mu_eta.push_back(Muon.Eta());
				    m_mu_phi.push_back(Muon.Phi());
				    m_mu_quality.push_back(m_all_mu_quality[itr]);
				    if(OutputTruth == "On" && InputType == "MC"){
				      m_mu_pt_truth.push_back(Mu_truth.Pt());
				      m_mu_eta_truth.push_back(Mu_truth.Eta());
				      m_mu_phi_truth.push_back(Mu_truth.Phi());
				      m_mu_e_truth.push_back(Mu_truth.E());
				      m_mu_m_truth.push_back(Mu_truth.M());
				    }
				  }
				  if(Muon.Pt() > 20000.0){
				    m_mu_veto_pt.push_back(Muon.Pt());
				    m_mu_veto_eta.push_back(Muon.Eta());
				    m_mu_veto_phi.push_back(Muon.Phi());
				    m_mu_veto_id_eta.push_back(-log(tan(m_all_mu_id_theta[itr]/2.)));
				    m_mu_veto_id_phi.push_back(m_all_mu_id_phi[itr]);
				    m_mu_veto_e.push_back(Muon.E());
				    m_mu_veto_smearing_factor.push_back(MuonCorrectionFactor);
				    if(InputType == "MC"){ //TO Fix
				      //COUT; 
				      m_mu_veto_MET_wpx.push_back(m_all_mu_MET_wpx[itr][0]);
				      m_mu_veto_MET_wpy.push_back(m_all_mu_MET_wpy[itr][0]);
				      //COUT;
				      if( m_all_mu_MET_statusWord[itr][0] &DEFAULT){ //combined muon
					m_dx_mu_smear.push_back(Mu_Px_smear - Mu_Px);
					m_dy_mu_smear.push_back(Mu_Py_smear - Mu_Py);
				      }
				      //COUT;
				      if( m_all_mu_MET_statusWord[itr][0] &SPECTRO){ //ms only
					m_dx_mu_smear.push_back(Mu_Px_smear - ptms*cos(m_all_mu_me_phi[itr]));
					m_dy_mu_smear.push_back(Mu_Py_smear - ptms*sin(m_all_mu_me_phi[itr]));
				      }
				      //COUT;
				      if( m_all_mu_MET_statusWord[itr][0] &TRACK){ //id only
					m_dx_mu_smear.push_back(Mu_Px_smear - ptid*cos(m_all_mu_id_phi[itr]));
					m_dy_mu_smear.push_back(Mu_Py_smear - ptid*sin(m_all_mu_id_phi[itr]));
				      }
				      else {
					m_dx_mu_smear.push_back(0);
					m_dy_mu_smear.push_back(0);
				      }
				      //COUT;
				    }
				  }
				  //For trigger efficiencies
				  if(TriggerEfficiencies == "On" && Do1MuTrig == "On" && *mapVarsBool[MuonTrigger] == 1){
				    m_mu_pt_num1MuTrig.push_back(Muon.Pt()); //numerator of 1MuTrig efficiency 
				    m_mu_quality_num1MuTrig.push_back(m_all_mu_quality[itr]);
				  }
				  if(TriggerEfficiencies == "On" && Do2MuTrig == "On" && *mapVarsBool[TwoMuonTrigger] == 1){
				    m_mu_pt_num2MuTrig.push_back(Muon.Pt()); // numerator of 2MuTrig efficiency
				    m_mu_quality_num2MuTrig.push_back(m_all_mu_quality[itr]);
				  }
				  if(TriggerEfficiencies == "On" && Do3MuTrig == "On" && *mapVarsBool[ThreeMuonTrigger] == 1){
				    m_mu_pt_num3MuTrig.push_back(Muon.Pt()); // numerator of 3MuTrig efficiency         
				    m_mu_quality_num3MuTrig.push_back(m_all_mu_quality[itr]);
				  }
				  if(TriggerEfficiencies == "On" && Do1El1MuTrig == "On" && *mapVarsBool[ElectronMuonTrigger] == 1){
				    m_mu_pt_num1El1MuTrig.push_back(Muon.Pt()); // numerator of 1El1MuTrig efficiency 
				    m_mu_quality_num1El1MuTrig.push_back(m_all_mu_quality[itr]);
				  }
				  if(TriggerEfficiencies == "On" && Do1El2MuTrig == "On" && *mapVarsBool[ElectronTwoMuonTrigger] == 1){
				    m_mu_pt_num1El2MuTrig.push_back(Muon.Pt()); // numerator of 1El2MuTrig efficiency      
				    m_mu_quality_num1El2MuTrig.push_back(m_all_mu_quality[itr]);
				  }
				  if(TriggerEfficiencies == "On" && Do2El1MuTrig == "On" && *mapVarsBool[TwoElectronMuonTrigger] == 1){
				    m_mu_pt_num2El1MuTrig.push_back(Muon.Pt()); // numerator of 2El1MuTrig efficiency        
				    m_mu_quality_num2El1MuTrig.push_back(m_all_mu_quality[itr]);
				  }
				}
			      }
			    }
			  }
			}
		      }
		    }
		  }
		}
	      }
	    }
	  }
	}
      }
    }
  }
  
  //Still for trigger efficiencies - The two electron trigger.
  for(int itr_trig = 0 ; itr_trig < (int) m_mu_pt.size() ; itr_trig++){
    if(TriggerEfficiencies == "On" && (int) m_mu_pt.size() >= 2){
      m_mu_pt_den2MuTrig.push_back(m_mu_pt[itr_trig]);  //denominator of 2MuTrig efficiency
      m_mu_quality_den2MuTrig.push_back(m_mu_quality[itr_trig]); //denominator of 2MuTrig efficiency
    }
    if(TriggerEfficiencies == "On" && (int) m_mu_pt.size() >= 3){
      m_mu_pt_den3MuTrig.push_back(m_mu_pt[itr_trig]);  //denominator of 3MuTrig efficiency  
      m_mu_quality_den3MuTrig.push_back(m_mu_quality[itr_trig]); //denominator of 3MuTrig efficiency
    }
    if(m_runMode != _MODE_TR){
      if(TriggerEfficiencies == "On" && (int) m_mu_pt.size() >= 1 && (int) m_el_pt.size() >= 1){
	m_el_pt_den1El1MuTrig.push_back(m_el_pt[itr_trig]); //denominator of 1El1MuTrig efficiency 
	m_el_quality_den1El1MuTrig.push_back(m_el_quality[itr_trig]);
	m_mu_pt_den1El1MuTrig.push_back(m_mu_pt[itr_trig]);
	m_mu_quality_den1El1MuTrig.push_back(m_mu_quality[itr_trig]);
      }
      if(TriggerEfficiencies == "On" && (int) m_mu_pt.size() >= 2 && (int) m_el_pt.size() >= 1){
	m_el_pt_den1El2MuTrig.push_back(m_el_pt[itr_trig]); //denominator of 1El2MuTrig efficiency
	m_el_quality_den1El2MuTrig.push_back(m_el_quality[itr_trig]);
	m_mu_pt_den1El2MuTrig.push_back(m_mu_pt[itr_trig]);
	m_mu_quality_den1El2MuTrig.push_back(m_mu_quality[itr_trig]);
      }
      if(TriggerEfficiencies == "On" && (int) m_mu_pt.size() >= 1 && (int) m_el_pt.size() >= 2){
	m_el_pt_den2El1MuTrig.push_back(m_el_pt[itr_trig]); //denominator of 2El1MuTrig efficiency
	m_el_quality_den2El1MuTrig.push_back(m_el_quality[itr_trig]);
	m_mu_pt_den2El1MuTrig.push_back(m_mu_pt[itr_trig]);
	m_mu_quality_den2El1MuTrig.push_back(m_mu_quality[itr_trig]);
      }
    }
  }
  //COUT;
  //   for(int itr = 0 ; ( itr < 2 && itr < (int) m_all_mu_e.size() )/*only want 2 first ones*/ ; itr ++){
  //         m_mu_e_2maxpt.push_back(m_all_mu_e[itr]);
  //     m_mu_px_2maxpt.push_back(m_all_mu_px[itr]);
  //     m_mu_py_2maxpt.push_back(m_all_mu_py[itr]);
  //     m_mu_pz_2maxpt.push_back(m_all_mu_pz[itr]);
  //     m_mu_charge_2maxpt.push_back(m_all_mu_charge[itr]);
  //     m_mu_pt_2maxpt.push_back(m_all_mu_pt[itr]);
  //     m_mu_eta_2maxpt.push_back(m_all_mu_eta[itr]);
  //     m_mu_phi_2maxpt.push_back(m_all_mu_phi[itr]);
  //   }
      
  //Set Number of Final Muons and Leptons
  m_mu_number.push_back((int) m_mu_e.size());  
  //  h_mu_number->Fill((int) m_mu_e.size());
  
  //Total muon efficiency weight
  if(InputType == "MC"){
    float MuonTotalSFweight = 1.0;
    for(int itr = 0 ; itr < (int) m_all_muonSFweight.size() ; itr++){
      MuonTotalSFweight = MuonTotalSFweight*m_all_muonSFweight[itr];
    }
    m_muonSFweight = MuonTotalSFweight;
  }
  if(InputType == "DATA"){
    m_muonSFweight = 1.0;
  }
   
  if(INFO == "On"){
    cout << "ProcessMuons() completed succesfully   " << endl;
  }

}

void Background::TruthMuons(){

  if(Truth == "On"){

    //Counting the number of Truth Muons above electron Pt cut
    if(NtupleType == "OA"){
      //Obsolete
    }
    if(NtupleType == "WZ" || NtupleType == "Thomas"){
      for( int itr = 0 ; itr < (int) (*mc_pdgId).size() ; itr++){
	if(fabs((*mc_pdgId)[itr]) == 13){
	  //cout << "(*mc_status)[itr]  " << (*mc_status)[itr]  << endl;
	  //cout << "(*mc_barcode)[itr]  " << (*mc_barcode)[itr] << endl;
	  //cout << "(*mc_pt)[itr]  " << (*mc_pt)[itr] << endl;
	  //cout << "(*mc_eta)[itr]  " << (*mc_eta)[itr] << endl;
	}
	//cout << "(*mc_pt)[itr]    "<< (*mc_pt)[itr] << endl;
	//cout << "(*mc_pdgId)[itr]  " << (*mc_pdgId)[itr] << endl;
	if( (*mc_status)[itr] == 1 && (*mc_barcode)[itr] < 200000 && (*mc_pt)[itr] >= finalMuPt_Cut && (*mc_eta)[itr] >= finalMuEta_Cut_min && (*mc_eta)[itr] <= finalMuEta_Cut_max && ( fabs((*mc_eta)[itr]) < RemoveMuEtaRange1_min || fabs((*mc_eta)[itr]) > RemoveMuEtaRange1_max) && ( fabs((*mc_eta)[itr]) < RemoveMuEtaRange2_min || fabs((*mc_eta)[itr]) > RemoveMuEtaRange2_max ) && ( (*mc_phi)[itr] < RemoveMuPhiRange1_min || (*mc_phi)[itr] > RemoveMuPhiRange1_max ) && ( (*mc_phi)[itr] < RemoveMuPhiRange2_min || (*mc_phi)[itr] > RemoveMuPhiRange2_max ) && ((*mc_charge)[itr] == 1 || (*mc_charge)[itr] == -1)  ){
	  m_mu_px_truth.push_back(cos((*mc_phi)[itr])*(*mc_pt)[itr]);
	  m_mu_py_truth.push_back(sin((*mc_phi)[itr])*(*mc_pt)[itr]);
	  float TruthParticle_Pz;
	  //TruthParticle_Pz = (*mc_pt)[itr]/(tan(2*atan(exp(-(*mc_eta)[itr]))));  //To check
	  TruthParticle_Pz = (*mc_pt)[itr]*sinh((*mc_eta)[itr]);
	  m_mu_pz_truth.push_back(TruthParticle_Pz);
	  m_mu_pt_truth.push_back((*mc_pt)[itr]);
	  m_mu_e_truth.push_back(sqrt(((*mc_pt)[itr])*((*mc_pt)[itr]) + TruthParticle_Pz*TruthParticle_Pz));
	  m_mu_eta_truth.push_back((*mc_eta)[itr]);
	  m_mu_m_truth.push_back((*mc_m)[itr]);
	  m_mu_phi_truth.push_back((*mc_phi)[itr]);
	  m_mu_charge_truth.push_back((int) (*mc_charge)[itr]);
	}
      }
    }
    //The number of truth muons
    m_mu_number_truth.push_back((int) m_mu_pt_truth.size());
        
    //Number of true leptons
    m_lep_number_truth.push_back(m_el_number_truth[0] + m_mu_number_truth[0]);
    
    if(INFO == "On"){
      cout << "TruthMuons() completed succesfully   " << endl;
    }
  }
}

void Background::Muon_Eff_Reso(){
  
  if(Truth == "On"){
    if(m_mu_number[0] > 0){
      if((int) m_mu_pt_truth.size() == 0){
	for(int i = 0 ; i < m_mu_number[0] ; i++){
	  m_RecoMu_is_Matched.push_back(0);
	}
      }	
      if((int) m_mu_pt_truth.size() > 0){
	for(int itr1 = 0 ; itr1 < m_mu_number[0] ; itr1++){
	  float DeltaEta = 0.;
	  float DeltaPhi = 0.;
	  float RatioE = 1000000.0;
	  float DeltaR = 1000000.0;
	  float DeltaR_Match = 1000.0;
	  int DeltaCharge = -999;
	  int Mu_Matched = -999;
	  for(int itr2 = 0 ; itr2 < m_mu_number_truth[0] ; itr2++){
	    DeltaEta = fabs(m_mu_eta[itr1] - m_mu_eta_truth[itr2]);
	    DeltaPhi = fabs(m_mu_phi[itr1] - m_mu_phi_truth[itr2]);
	    if(DeltaPhi > 3.141592654){
	      DeltaPhi = (2*3.141592654 - DeltaPhi);
	    }
	    DeltaR = sqrt(DeltaEta*DeltaEta + DeltaPhi*DeltaPhi);
	    DeltaCharge = m_mu_charge[itr1] - m_mu_charge_truth[itr2];
	    RatioE = fabs(m_mu_e[itr1]/m_mu_e_truth[itr2]); 
	    if(DeltaR < DeltaR_Cut_Res_Mu && DeltaR < DeltaR_Match && RatioE > DiffE_Mu && RatioE < (DiffE_Mu + 1) ){
	      Mu_Matched = itr2;
	      DeltaR_Match = DeltaR; 
	    }
	  }
	  if(Mu_Matched == -999){
	    m_RecoMu_is_Matched.push_back(0);
	  }
	  if(Mu_Matched >= 0 && DeltaR_Match < DeltaR){
	    m_RecoMu_is_Matched.push_back(1);
	    float MuEtaResolution;
	    float MuPtResolution;
	    MuPtResolution = ((m_mu_pt[itr1]/m_mu_pt_truth[Mu_Matched]) - 1);
	    MuEtaResolution = ((m_mu_eta[itr1]/m_mu_eta_truth[Mu_Matched]) - 1);
	    m_DeltaR_MuMatched_MuTruth.push_back(DeltaR_Match);
	    m_Resolution_MuPt.push_back(MuPtResolution);
	    m_mu_px_truth_matched.push_back(m_mu_px_truth[Mu_Matched]);
	    m_mu_py_truth_matched.push_back(m_mu_py_truth[Mu_Matched]);
	    m_mu_pz_truth_matched.push_back(m_mu_pz_truth[Mu_Matched]);
	    m_mu_pt_truth_matched.push_back(m_mu_pt_truth[Mu_Matched]);
	    m_mu_eta_truth_matched.push_back(m_mu_eta_truth[Mu_Matched]);
	    m_mu_phi_truth_matched.push_back(m_mu_phi_truth[Mu_Matched]);
	    if(DeltaCharge == 0){
	      m_RecoMatchedMu_withCorrectCharge.push_back(1);
	    }
	    if(DeltaCharge != 0){
	      m_RecoMatchedMu_withCorrectCharge.push_back(0);
	    }
	  }
	}
      }
    }
    if(INFO == "On"){
      cout << "Muon_Eff_Reso() completed succesfully" << endl;
    }
  }
}

void Background::ProcessJets(){
  
 
  vector<float> m_all_jet_jvtxf(*mapVarsVectorFloat[JetAlg_WZ+"jvtxf"]);
  vector<float> m_all_jet_emscale_pt(*mapVarsVectorFloat[JetAlg_WZ+"emscale_pt"]);
  vector<float> m_all_jet_E(*mapVarsVectorFloat[JetAlg_WZ+"E"]);
  vector<float> m_all_jet_m(*mapVarsVectorFloat[JetAlg_WZ+"m"]);
  vector<float> m_all_jet_pt(*mapVarsVectorFloat[JetAlg_WZ+"pt"]);
  vector<float> m_all_jet_eta(*mapVarsVectorFloat[JetAlg_WZ+"eta"]);
  vector<float> m_all_jet_emscale_eta(*mapVarsVectorFloat[JetAlg_WZ+"emscale_eta"]);
  vector<float> m_all_jet_phi(*mapVarsVectorFloat[JetAlg_WZ+"phi"]);
  vector<float> m_all_jet_nTrk(*mapVarsVectorFloat[JetAlg_WZ+"nTrk"]);
  vector<float> m_all_jet_emfrac(*mapVarsVectorFloat[JetAlg_WZ+"emfrac"]);
  vector<float> m_all_jet_BCH_CORR_CELL(*mapVarsVectorFloat[JetAlg_WZ+"BCH_CORR_CELL"]); 
  vector<float> m_all_jet_BCH_CORR_JET(*mapVarsVectorFloat[JetAlg_WZ+"BCH_CORR_JET"]); 
  //if(InputType == "MC"){
  //  vector<vector<float> > m_all_jet_MET_wpx(*mapVarsVectorVectorFloat[JetAlg_WZ+"_MET_wpx"]); 
  //  vector<vector<float> > m_all_jet_MET_wpy(*mapVarsVectorVectorFloat[JetAlg_WZ+"_MET_wpy"]); 
  //}
  //COUT;
  vector<int>   m_all_jet_ugly;
  vector<int>   m_all_jet_badloose;
  vector<int>   m_all_jet_badmedium;
  vector<int>   m_all_jet_badtight;
  
  string jet_JES;
  string jet_JER;
  //AntiKt4EMJESTopoJets and AntiKt4TopoJES 
  if(m_runMode == _MODE_HQ){ //To switch back!!!!!!
    jet_JES = "AntiKt4EMJESTopoJets";
    jet_JER = "AntiKt4TopoJES";
  }
  if(m_runMode == _MODE_TR){
    jet_JES = "AntiKt6GSWJESTopoJets"; 
    jet_JER = "AntiKt6TopoJES";
  }
  //COUT;
  MultijetJESUncertaintyProvider myJES(jet_JES, "JESUncertainty.root");
  JERProvider myJER(jet_JER,"Truth","JERProviderPlots.root");                                                                                                        
  if(DoJESUncertainty != 0 || DoJERUncertainty != 0){
    //myJES.includeFlavorComposition(false); //if jet_JES = "AntiKt6LCTopoJets" 
    myJES.init();
    myJER.init();  
  }                                                                                                                                    
  
  //Define Bad/Ugly/Good Jets
  for(int itr = 0 ; itr < (int) m_all_jet_E.size() ; itr++){
    float emf  = (*mapVarsVectorFloat[JetAlg_WZ+"emfrac"])[itr];
    float fmax = (*mapVarsVectorFloat[JetAlg_WZ+"fracSamplingMax"])[itr];
    float HECf = (*mapVarsVectorFloat[JetAlg_WZ+"hecf"])[itr];
    float HECq = (*mapVarsVectorFloat[JetAlg_WZ+"HECQuality"])[itr];
    float LArQ = (*mapVarsVectorFloat[JetAlg_WZ+"LArQuality"])[itr];
    float negE = (*mapVarsVectorFloat[JetAlg_WZ+"NegativeE"])[itr];
    float SumPtTrk = (*mapVarsVectorFloat[JetAlg_WZ+"sumPtTrk"])[itr];
    float time = (*mapVarsVectorFloat[JetAlg_WZ+"Timing"])[itr];
    float AverageLArQF = (*mapVarsVectorFloat[JetAlg_WZ+"AverageLArQF"])[itr]; 
    float pt = m_all_jet_pt[itr];
    float eta = m_all_jet_eta[itr];

    //    int BadLooser = 
    int BadLoose = JetID::isBadJet(JetID::LooseBad,emf,HECf,LArQ,HECq,time,SumPtTrk,eta,pt,fmax,negE);
    int BadMedium = JetID::isBadJet(JetID::MediumBad,emf,HECf,LArQ,HECq,time,SumPtTrk,eta,pt,fmax,negE);
    int BadTight = JetID::isBadJet(JetID::TightBad,emf,HECf,LArQ,HECq,time,SumPtTrk,eta,pt,fmax,negE);

    m_all_jet_badloose.push_back(BadLoose);
    m_all_jet_badmedium.push_back(BadMedium);
    m_all_jet_badtight.push_back(BadTight);

    float tgap3f = (*mapVarsVectorFloat[JetAlg_WZ+"tgap3f"])[itr];
    float BCH_CORR_CELL = (*mapVarsVectorFloat[JetAlg_WZ+"BCH_CORR_CELL"])[itr];
    int Ugly = 0;
    if ( tgap3f > 0.5 || BCH_CORR_CELL > 0.5 ) Ugly = 1;
    m_all_jet_ugly.push_back(Ugly);

  }

  float DeltaPhi;
  float DeltaEta;
  float DeltaR;
  int ElectronFakingJet;
  int MuonFakingJet;
  int MET_bad = 0;
    
  //Calculating DeltaR between Jets and electrons to remove jets that are actually electrons 
  //and removing Ugly and Bad jets

  if(NtupleType == "WZ" || NtupleType == "Thomas"){
    //COUT;
    //     cout << "DEBUG " << (int) mapVarsVectorFloat[JetAlg_WZ+"emscaleE"]->size()  << endl;    
    //     cout << "DEBUG " << (int) m_all_jet_emscale_E.size() << endl << endl;        
    m_LArHole_reject = 0;
    for(int itrJ = 0; itrJ < (int) m_all_jet_E.size() ; itrJ++){
      if(m_GRL == 1 || (InputType == "MC" /*&& m_good_event == 1*/)){
	jet_cut_passed[0] += 1.;
	if( m_all_jet_E[itrJ] >= 0){  //The jet must have jet_atk4topoem_E > 0
	  jet_cut_passed[1] += 1.;
	  if ( m_all_jet_pt[itrJ] >= finalJetsPt_Cut || (DoJESUncertainty != 0 && m_all_jet_pt[itrJ] > 15000.0) || (DoJERUncertainty != 0 && m_all_jet_pt[itrJ] > 15000.0)){
	    jet_cut_passed[2] += 1.;
	    if ( m_all_jet_emscale_eta[itrJ] >= finalJetsEta_Cut_min &&
		 m_all_jet_emscale_eta[itrJ] <= finalJetsEta_Cut_max &&
		 ( m_all_jet_emscale_eta[itrJ] < RemoveJetEtaRange1_min || m_all_jet_emscale_eta[itrJ] > RemoveJetEtaRange1_max) &&
		 ( m_all_jet_emscale_eta[itrJ] < RemoveJetEtaRange2_min || m_all_jet_emscale_eta[itrJ] > RemoveJetEtaRange2_max) ) {
	      jet_cut_passed[3] += 1.;
	      if ( m_all_jet_ugly[itrJ] == 0 && m_all_jet_badloose[itrJ] == 0 ) {
		jet_cut_passed[4] += 1.;
		if ( (fabs(m_all_jet_jvtxf[itrJ]) >= PileUpRemoval_Cut || m_all_jet_jvtxf[itrJ] < 0) ) {
		  if ( ( m_all_jet_phi[itrJ] < RemoveJetPhiRange1_min || m_all_jet_phi[itrJ] > RemoveJetPhiRange1_max ) &&
		       ( m_all_jet_phi[itrJ] < RemoveJetPhiRange2_min || m_all_jet_phi[itrJ] > RemoveJetPhiRange2_max )  ){
		    ElectronFakingJet = 0;
		    //COUT;
		    for(int itrEl = 0 ; itrEl < (int) m_el_veto_e.size() ; itrEl++){
		      //COUT;
		      DeltaPhi = fabs( m_el_veto_cl_phi[itrEl] - m_all_jet_phi[itrJ] );
		      if(DeltaPhi > 3.141592654){
			DeltaPhi = (2*3.141592654 - DeltaPhi);
		      }
		      //COUT;
		      DeltaEta = fabs( m_el_veto_cl_eta[itrEl] - m_all_jet_eta[itrJ] );  
		      DeltaR = sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta);
		      if(DeltaR < DeltaR_Cut_ElFakingJet){
			ElectronFakingJet = 1;
			break;
		      }
		      //COUT;
		    }
		    //COUT;
		    MuonFakingJet = 0;
		    /*for(int itrMu = 0 ; itrMu < (int) m_mu_e.size() ; itrMu++){
		      DeltaPhi = fabs( atan2(m_mu_py[itrMu],m_mu_px[itrMu]) - atan2(m_all_jet_pt[itrJ]*cos(m_all_jet_phi[itrJ]),m_all_jet_pt[itrJ])*sin(m_all_jet_phi[itrJ]));
		      if(DeltaPhi > 3.141592654){
		      DeltaPhi = 2*3.141592654 - DeltaPhi;
		      }
		      DeltaEta = -log(tan((acos(m_mu_pz[itrMu]/m_mu_e[itrMu]))/2)) + log(tan((acos(m_all_jet_pz[itrJ]/m_all_jet_E[itrJ]))/2));
		      DeltaR = sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta);
		      if(DeltaR < DeltaR_Cut_MuFakingJet){
		      MuonFakingJet = 1;
		      break;
		      }
		      }*/
		    
		    bool flag;
		    if(InputType == "DATA"){
		      flag = IsLArHoleVeto(m_all_jet_pt[itrJ], m_all_jet_eta[itrJ], m_all_jet_phi[itrJ], m_all_jet_BCH_CORR_JET[itrJ], m_all_jet_BCH_CORR_CELL[itrJ], 1 /*isData*/, 40000.0 /*jet threshold*/);
		    }
		    if(InputType == "MC"){
		      flag = IsLArHoleVeto(m_all_jet_pt[itrJ], m_all_jet_eta[itrJ], m_all_jet_phi[itrJ], m_all_jet_BCH_CORR_JET[itrJ], m_all_jet_BCH_CORR_CELL[itrJ], 0 /*isData*/, 40000.0 /*jet threshold*/);
		    }
		    if(flag == true){
		      m_LArHole_reject = 1;
		    }
		    if(ElectronFakingJet == 0 && MuonFakingJet == 0) {
		      //COUT;
		      jet_cut_passed[5] += 1.;
		      m_jet_pt_uncert.push_back(m_all_jet_pt[itrJ]);
		      m_jet_eta_uncert.push_back(m_all_jet_eta[itrJ]);
		      m_jet_phi_uncert.push_back(m_all_jet_phi[itrJ]);
		      m_jet_m_uncert.push_back(m_all_jet_m[itrJ]);
		      m_jet_nTrk_uncert.push_back(m_all_jet_nTrk[itrJ]);
		      m_jet_emfrac_uncert.push_back(m_all_jet_emfrac[itrJ]);
		      m_jet_badmedium_uncert.push_back(m_all_jet_badmedium[itrJ]);
		      m_jet_badtight_uncert.push_back(m_all_jet_badtight[itrJ]);
		      m_jet_e_uncert.push_back(m_all_jet_E[itrJ]);
		      //COUT;
		      //if(m_runMode == _MODE_TR){
		      //  m_jet_MET_wpx_uncert.push_back((*jet_antikt6LCtopo_MET_wpx)[itrJ][0]);
		      //  m_jet_MET_wpy_uncert.push_back((*jet_antikt6LCtopo_MET_wpy)[itrJ][0]);
		      // }
		      //COUT;
		      if(DoJESUncertainty == 0 && DoJERUncertainty == 0){
			m_jet_pt.push_back(m_all_jet_pt[itrJ]);
			m_jet_eta.push_back(m_all_jet_eta[itrJ]);
			m_jet_phi.push_back(m_all_jet_phi[itrJ]);
			m_jet_m.push_back(m_all_jet_m[itrJ]);
			m_jet_nTrk.push_back(m_all_jet_nTrk[itrJ]);
			m_jet_emfrac.push_back(m_all_jet_emfrac[itrJ]);
			m_jet_badmedium.push_back(m_all_jet_badmedium[itrJ]);
			m_jet_badtight.push_back(m_all_jet_badtight[itrJ]);
			m_jet_e.push_back(m_all_jet_E[itrJ]);
		      }
		    }
		    //}
		  }
		}
	      }
	    }
	  }
	}
	//For MET cleaning:
	if((m_all_jet_badloose[itrJ] == 1 && m_all_jet_pt[itrJ] > 20000.0)){
	  MET_bad = 1;
	}
      }
    }
    m_MET_bad.push_back(MET_bad);
    
    ///////////////////////////
    //JES UNCERTAINTIES
    ///////////////////////////
    
    if(DoJESUncertainty != 0){
      //COUT;
      if((int) m_jet_pt_uncert.size() >= 2){
	for(int itrJ = 0; itrJ < (int) m_jet_pt_uncert.size() ; itrJ++){
	  float myDR = 10.;
	  for(int itrJ2 = 0 ; itrJ2 < (int) m_jet_pt_uncert.size(); itrJ2++){ //Find smallest DeltaR with closest jet
	    if(itrJ != itrJ2){
	      float DeltaEta = fabs(m_jet_eta_uncert[itrJ] - m_jet_eta_uncert[itrJ2]);
	      float DeltaPhi = fabs(m_jet_phi_uncert[itrJ] - m_jet_phi_uncert[itrJ2]);
	      if(DeltaPhi > 3.141592654){                                        
		DeltaPhi = (2*3.141592654 - DeltaPhi); 
	      }
	      float DeltaR = sqrt(DeltaEta*DeltaEta + DeltaPhi*DeltaPhi);
	      if(DeltaR < myDR){
		myDR = DeltaR;
	      }
	    }
	  }
	  m_jet_myDR_uncert.push_back(myDR);
	}
      }
      if((int) m_jet_pt_uncert.size() == 1){
	m_jet_myDR_uncert.push_back(0);
      }
      //COUT;
      TLorentzVector jet_with_uncert;
      TLorentzVector jet_without_uncert;
      for(int itr = 0 ; itr < (int) m_jet_pt_uncert.size() ; itr++){ 
	//JES without pile-up to be added to uncertainty with pile-up below  
	double total_jet_pt_uncertainty = 0.0;
	jet_without_uncert.SetPtEtaPhiM(m_jet_pt_uncert[itr], m_jet_eta_uncert[itr],m_jet_phi_uncert[itr], m_jet_m_uncert[itr]);
	if(DoJESUncertainty == 2){ //+1 sigma 
	  //COUT;
	  cout << "m_jet_pt_uncert[itr]    " << m_jet_pt_uncert[itr] << endl;
	  cout << "m_jet_eta_uncert[itr]   " << m_jet_eta_uncert[itr] << endl;
	  cout << "m_jet_myDR_uncert[itr]  " << m_jet_myDR_uncert[itr] << endl; 
 	  total_jet_pt_uncertainty = myJES.getRelPosUncert(m_jet_pt_uncert[itr], m_jet_eta_uncert[itr], m_jet_myDR_uncert[itr]); // for the relative positive uncertainty
	  //COUT;
	}
	if(DoJESUncertainty == 1){ //-1 sigma
	  total_jet_pt_uncertainty = myJES.getRelNegUncert(m_jet_pt_uncert[itr], m_jet_eta_uncert[itr], m_jet_myDR_uncert[itr]); // for the relative negative uncertainty
	}
	
	//Pile-up uncertainty
	if(fabs(m_jet_eta_uncert[itr]) <= 2.1){
	  if(m_jet_pt_uncert[itr] > 20000.0 && m_jet_pt_uncert[itr] <= 50000.0){
	    total_jet_pt_uncertainty = sqrt(total_jet_pt_uncertainty*total_jet_pt_uncertainty + 0.05*0.05); //Add 5% due to pileup
	  }
	  if(m_jet_pt_uncert[itr] > 50000.0){
	    total_jet_pt_uncertainty = sqrt(total_jet_pt_uncertainty*total_jet_pt_uncertainty + 0.02*0.02); //Add 2% due to pileup
	  }
	}
	if(fabs(m_jet_eta_uncert[itr]) > 2.1 && fabs(m_jet_eta_uncert[itr]) < 4.5){
	  if(m_jet_pt_uncert[itr] > 20000. && m_jet_pt_uncert[itr] <= 50000.0){
	    total_jet_pt_uncertainty = sqrt(total_jet_pt_uncertainty*total_jet_pt_uncertainty + 0.07*0.07); //Add 7% due to pileup
	  }
	  if(m_jet_pt_uncert[itr] > 50000.0){
	    total_jet_pt_uncertainty = sqrt(total_jet_pt_uncertainty*total_jet_pt_uncertainty + 0.03*0.03); //Add 3% due to pileup
	  }
	}
	if(DoJESUncertainty == 1){
	  jet_with_uncert.SetPtEtaPhiM(m_jet_pt_uncert[itr]*(1 - total_jet_pt_uncertainty), m_jet_eta_uncert[itr], m_jet_phi_uncert[itr], m_jet_m_uncert[itr]); 
	}
	if(DoJESUncertainty == 2){
	  jet_with_uncert.SetPtEtaPhiM(m_jet_pt_uncert[itr]*(1 + total_jet_pt_uncertainty), m_jet_eta_uncert[itr], m_jet_phi_uncert[itr], m_jet_m_uncert[itr]); 
	}
	if(jet_with_uncert.Pt() > finalJetsPt_Cut){
	  m_jet_pt.push_back(jet_with_uncert.Pt());
	  m_jet_eta.push_back(jet_with_uncert.Eta());
	  m_jet_phi.push_back(jet_with_uncert.Phi());
	  m_jet_m.push_back(jet_with_uncert.M());
	  m_jet_nTrk.push_back(m_jet_nTrk_uncert[itr]);
	  m_jet_emfrac.push_back(m_jet_emfrac_uncert[itr]);
	  m_jet_badmedium.push_back(m_jet_badmedium_uncert[itr]);
	  m_jet_badtight.push_back(m_jet_badtight_uncert[itr]);
	  m_jet_e.push_back(jet_with_uncert.E());
	  m_dx_jet.push_back(jet_with_uncert.Px() - jet_without_uncert.Px());
	  m_dy_jet.push_back(jet_with_uncert.Py() - jet_without_uncert.Py());
	  //if(m_runMode == _MODE_TR){
	  //  m_jet_MET_wpx.push_back(m_jet_MET_wpx_uncert[itr]);
	  //  m_jet_MET_wpy.push_back(m_jet_MET_wpy_uncert[itr]);
	  // }
	}
      }
    }
    
    /////////////////////////
    //JER UNCERTAINTIES
    /////////////////////////
    if(DoJERUncertainty != 0){
      TLorentzVector jet_without_uncert;
      TLorentzVector jet_with_uncert;
      //COUT;
      for(int itr = 0 ; itr < (int) m_jet_pt_uncert.size() ; itr++){
	jet_without_uncert.SetPtEtaPhiM(m_jet_pt_uncert[itr], m_jet_eta_uncert[itr], m_jet_phi_uncert[itr], m_jet_m_uncert[itr]); 
	float S = myJER.getSigma( jet_without_uncert.Pt()/1000., jet_without_uncert.PseudoRapidity());//  to get the resolution (pt in GeV)             
	float U	= myJER.getUncert(jet_without_uncert.Pt()/1000., jet_without_uncert.PseudoRapidity());  //to get its uncertainty (pt in GeV)
	float D = sqrt((S+U)*(S+U) - S*S);  //Smearing factor
	TRandom * m_Random = new TRandom();
	float jet_smeared_pt = jet_without_uncert.Pt()*(1 + m_Random->Gaus(0, D));
	jet_with_uncert.SetPtEtaPhiM(jet_smeared_pt, m_jet_eta_uncert[itr], m_jet_phi_uncert[itr], m_jet_m_uncert[itr]);
	if(jet_with_uncert.Pt() > finalJetsPt_Cut){
	  m_jet_pt.push_back(jet_with_uncert.Pt());
	  m_jet_eta.push_back(jet_with_uncert.Eta());
	  m_jet_phi.push_back(jet_with_uncert.Phi());
	  m_jet_m.push_back(jet_with_uncert.M());
	  m_jet_nTrk.push_back(m_jet_nTrk_uncert[itr]);
	  m_jet_emfrac.push_back(m_jet_emfrac_uncert[itr]);
	  m_jet_badmedium.push_back(m_jet_badmedium_uncert[itr]);
	  m_jet_badtight.push_back(m_jet_badtight_uncert[itr]);
	  m_jet_e.push_back(jet_with_uncert.E());
	  m_dx_jet.push_back(jet_with_uncert.Px() - jet_without_uncert.Px());
	  m_dy_jet.push_back(jet_with_uncert.Py() - jet_without_uncert.Py());
	  //if(m_runMode == _MODE_TR){
	  //  m_jet_MET_wpx.push_back(m_jet_MET_wpx_uncert[itr]);
	  //  m_jet_MET_wpy.push_back(m_jet_MET_wpy_uncert[itr]);
	  // }
	  delete m_Random; 
	}
      }
    }

  }
  m_jet_number.push_back((int) m_jet_e.size());
  
  if(m_jet_number[0] > 0){
    m_jet1_pt.push_back(m_jet_pt[0]);
    m_jet1_eta.push_back(m_jet_eta[0]);
    m_jet1_phi.push_back(m_jet_phi[0]);
  }
  if(m_jet_number[0] > 1){
    m_jet2_pt.push_back(m_jet_pt[1]);
    m_jet2_eta.push_back(m_jet_eta[1]);
    m_jet2_phi.push_back(m_jet_phi[1]);
  }
  int CountEvent = 0;
  for(int itrJ = 0; itrJ < (int) m_jet_e.size() ; itrJ++){
    //     if(m_jet_btag_prob[itrJ] > 0.9 && CountEvent == 0){    // m_jet_btag_prob is either 0 or 1. 
    //       CountEvent = 1;
    //     }
    if(CountEvent == 1){
      m_event_with_BJet.push_back(1);
      break;
    }
  }
  if(CountEvent == 0){
    m_event_with_BJet.push_back(0);
  }
  
  if(INFO == "On"){
    cout << "ProcessJets() completed succesfully   " << endl;
  }
  
}
  
void Background::TruthJets(){
    
  //   if(Truth == "On"){
    
  //     string Jet = "jet_";
  //     string Temp = Jet.append(TruthAlg_WZ);
  //     string JetAlgTempE = Temp;
  //     string JetAlgTempPx = Temp;
  //     string JetAlgTempPy = Temp;
  //     string JetAlgTempPz = Temp;
  //     string JetAlgE = JetAlgTempE.append("_E");
  //     string JetAlgPhi = JetAlgTempPx.append("_phi");
  //     string JetAlgEta = JetAlgTempPy.append("_eta");
  //     string JetAlgPt = JetAlgTempPz.append("_pt");
    
  //     if(!mapVarsVectorFloat[JetAlgE]){
  //       cout << "Truth Jet Algorithm branches do not exist!! Aborting" << endl;  //Error message
  //       return;
  //     } 
    
  //     vector<float>::iterator itr_E = mapVarsVectorFloat[JetAlgE]->begin();
  //     vector<float>::iterator itr_phi = mapVarsVectorFloat[JetAlgPhi]->begin();
  //     vector<float>::iterator itr_eta = mapVarsVectorFloat[JetAlgEta]->begin();
  //     vector<float>::iterator itr_pt = mapVarsVectorFloat[JetAlgPt]->begin();
    
  //     for( ; itr_E != mapVarsVectorFloat[JetAlgE]->end() ; itr_E++){
  //       m_all_jet_e_truth.push_back(*itr_E); 
  //     }
  //     for( ; itr_phi != mapVarsVectorFloat[JetAlgPhi]->end() ; itr_phi++){
  //       m_all_jet_phi_truth.push_back(*itr_phi); 
  //     }
  //     for( ; itr_eta != mapVarsVectorFloat[JetAlgEta]->end() ; itr_eta++){
  //       m_all_jet_eta_truth.push_back(*itr_eta);
  //     }
  //     for( ; itr_pt != mapVarsVectorFloat[JetAlgPt]->end() ; itr_pt++){
  //       m_all_jet_pt_truth.push_back(*itr_pt);
  //     }
    
    
  //     //Counting the number of Truth Jets above electron Pt cut
  //     float TruthParticle_Px ;
  //     float TruthParticle_Py;
  //     float TruthParticle_Pz;
  //     for(int itr = 0 ; itr < (int) m_all_jet_e_truth.size() ; itr++){
  //       TruthParticle_Px = cos(m_all_jet_phi_truth[itr])*m_all_jet_pt_truth[itr]; 
  //       TruthParticle_Py = sin(m_all_jet_phi_truth[itr])*m_all_jet_pt_truth[itr];
  //       //TruthParticle_Pz = m_all_jet_pt_truth[itr]/(tan(2*atan(exp(-m_all_jet_eta_truth[itr]))));
  //       TruthParticle_Pz = m_all_jet_pt_truth[itr]*sinh(m_all_jet_eta_truth[itr]);
  //       if(m_all_jet_pt_truth[itr] >= finalJetsPt_Cut && m_all_jet_eta_truth[itr] >= finalJetsEta_Cut_min && m_all_jet_eta_truth[itr] <= finalJetsEta_Cut_max && ( m_all_jet_eta_truth[itr] < RemoveJetEtaRange1_min || m_all_jet_eta_truth[itr] > RemoveJetEtaRange1_max) && (m_all_jet_eta_truth[itr] < RemoveJetEtaRange2_min || m_all_jet_eta_truth[itr] > RemoveJetEtaRange2_max ) && ( m_all_jet_phi_truth[itr] < RemoveJetPhiRange1_min || m_all_jet_phi_truth[itr] > RemoveJetPhiRange1_max) && ( m_all_jet_phi_truth[itr] < RemoveJetPhiRange2_min || m_all_jet_phi_truth[itr] > RemoveJetPhiRange2_max)  ){
  // 	m_jet_e_truth.push_back(m_all_jet_e_truth[itr]);
  // 	m_jet_px_truth.push_back(TruthParticle_Px);
  // 	m_jet_py_truth.push_back(TruthParticle_Py);
  // 	m_jet_pz_truth.push_back(TruthParticle_Pz);
  // 	m_jet_pt_truth.push_back(m_all_jet_pt_truth[itr]);
  // 	m_jet_eta_truth.push_back(m_all_jet_eta_truth[itr]);
  // 	m_jet_phi_truth.push_back(m_all_jet_phi_truth[itr]);
  //       }
  //     }
    
  //     //The number of truth jets
  //     m_jet_number_truth.push_back((int) m_jet_pt_truth.size());
    
  //     //Resolutions
  //     int STOP;
  //     if(m_jet_number[0] > 0 && m_jet_number_truth[0] > 0){
  //       for(int itr1 = 0 ; itr1 < m_jet_number_truth[0] ; itr1++){
  // 	STOP = 0;
  // 	float DeltaPt;
  // 	for(int itr2 = 0 ; itr2 < m_jet_number[0] ; itr2++){
  // 	  //float DeltaPt_min = 10000000.;
  // 	  float DeltaEta = 0.;
  // 	  float DeltaPhi = 0.;
  // 	  float DeltaR = 0.;
  // 	  DeltaPt = fabs(m_jet_pt[itr2] - m_jet_pt_truth[itr1]);  
  // 	  DeltaEta = m_jet_eta[itr2] - m_jet_eta_truth[itr1];
  // 	  DeltaPhi = fabs(m_jet_phi[itr2] - m_jet_phi_truth[itr1]); 
  // 	  if(DeltaPhi > 3.141592654){
  // 	    DeltaPhi = (2*3.141592654 - DeltaPhi);
  // 	  }
  // 	  DeltaR = sqrt(DeltaEta*DeltaEta + DeltaPhi*DeltaPhi);
  // 	  if(DeltaR < DeltaR_Cut_Res_Jet && STOP == 0 /*&& DeltaPt < DeltaPt_min */){
  // 	    //DeltaPt_min = DeltaPt;
  // 	    float JetsPtResolution;
  // 	    STOP = 1;
  // 	    JetsPtResolution = (m_jet_pt[itr2]/m_jet_pt_truth[itr1]) - 1;
  // 	    m_DeltaR_JetsMatched_JetsTruth.push_back(DeltaR);
  // 	    m_Resolution_JetsPt.push_back(JetsPtResolution);
  // 	    //Binned Jet Resolutions:
  // 	    if(m_jet_pt_truth[itr1] > finalJetsPt_Cut && m_jet_pt_truth[itr1] < 20000){
  // 	      float JetsPtResolution_min_20GeV = (m_jet_pt[itr2]/m_jet_pt_truth[itr1]) - 1;
  // 	      m_Resolution_JetsPt_min_20GeV.push_back(JetsPtResolution_min_20GeV);
  // 	    }
  // 	    if(m_jet_pt_truth[itr1] > 20000 && m_jet_pt_truth[itr1] < 40000){
  // 	      float JetsPtResolution_20GeV_40GeV = (m_jet_pt[itr2]/m_jet_pt_truth[itr1]) - 1;
  // 	      m_Resolution_JetsPt_20GeV_40GeV.push_back(JetsPtResolution_20GeV_40GeV);
  // 	    }
  // 	    if(m_jet_pt_truth[itr1] > 40000 && m_jet_pt_truth[itr1] < 70000){
  // 	      float JetsPtResolution_40GeV_70GeV = (m_jet_pt[itr2]/m_jet_pt_truth[itr1]) - 1;
  // 	      m_Resolution_JetsPt_40GeV_70GeV.push_back(JetsPtResolution_40GeV_70GeV);
  // 	    }
  // 	    if(m_jet_pt_truth[itr1] > 70000 && m_jet_pt_truth[itr1] < 110000){
  // 	      float JetsPtResolution_70GeV_110GeV = (m_jet_pt[itr2]/m_jet_pt_truth[itr1]) - 1;
  // 	      m_Resolution_JetsPt_70GeV_110GeV.push_back(JetsPtResolution_70GeV_110GeV);
  // 	    }
  // 	    if(m_jet_pt_truth[itr1] > 110000 && m_jet_pt_truth[itr1] < 150000){
  // 	      float JetsPtResolution_110GeV_150GeV = (m_jet_pt[itr2]/m_jet_pt_truth[itr1]) - 1;
  // 	      m_Resolution_JetsPt_110GeV_150GeV.push_back(JetsPtResolution_110GeV_150GeV);
  // 	    }
  // 	    if(m_jet_pt_truth[itr1] > 150000 ){
  // 	      float JetsPtResolution_150GeV_max = (m_jet_pt[itr2]/m_jet_pt_truth[itr1]) - 1;
  // 	      m_Resolution_JetsPt_150GeV_max.push_back(JetsPtResolution_150GeV_max);
  // 	    }
  // 	    m_jet_px_truth_matched.push_back(m_jet_px_truth[itr1]);
  // 	    m_jet_py_truth_matched.push_back(m_jet_py_truth[itr1]);
  // 	    m_jet_pz_truth_matched.push_back(m_jet_pz_truth[itr1]);
  // 	    m_jet_pt_truth_matched.push_back(m_jet_pt_truth[itr1]);
  // 	    m_jet_eta_truth_matched.push_back(m_jet_eta_truth[itr1]);
  // 	    m_jet_phi_truth_matched.push_back(m_jet_phi_truth[itr1]);
  // 	  }
  // 	  if(STOP == 1){
  // 	    break;
  // 	  }
  // 	}
  //       }
  //     } 
    
  
  //     if(INFO == "On"){
  //       cout << "TruthJets() completed succesfully   " << endl;
  //     }
  //   }
  
}


void Background::CombinedInvariantMassElectrons(){
  
  int ChargeMatch2El = -1;
  TLorentzVector El1;
  TLorentzVector El2;
  TLorentzVector Z;
  //COUT;
  cout << "m_el_pt.size() " << m_el_pt.size() << endl;
  if((int) m_el_pt.size() > 1){
    //COUT;    
    for(int itr1 = 0 ; itr1 < (int) m_el_pt.size() ; itr1++){
      if(m_el_quality[itr1] >= z_el_quality){
	int temp = (itr1 + 1);
	for(int itr2 = temp ; itr2 < (int) m_el_pt.size() ; itr2++){
	  if(m_el_quality[itr2] >= z_el_quality){
	    El1.SetPtEtaPhiE(m_el_pt[itr1], m_el_eta[itr1], m_el_phi[itr1], m_el_e[itr1]);
	    El2.SetPtEtaPhiE(m_el_pt[itr2], m_el_eta[itr2], m_el_phi[itr2], m_el_e[itr2]);
	    Z = El1 + El2;
	    if(ForceZmass == "Yes"){
	      Float_t Scale = MassZ/(Z.M());
	      Z.SetPxPyPzE(Z.Px()*Scale, Z.Py()*Scale, Z.Pz()*Scale, Z.E()*Scale);
	      El1.SetPxPyPzE(El1.Px()*Scale, El1.Py()*Scale, El1.Pz()*Scale, El1.E()*Scale);
	      El2.SetPxPyPzE(El2.Px()*Scale, El2.Py()*Scale, El2.Pz()*Scale, El2.E()*Scale);
	      cout << "New Z mass: " << Z.M() << endl;
	    }
	    ChargeMatch2El = m_el_charge[itr1] + m_el_charge[itr2];
	    m_inv_mass_2El_all.push_back(Z.M());
	    m_Z_ee_E.push_back(Z.E());
	    m_Z_ee_Px.push_back(Z.Px());
	    m_Z_ee_Py.push_back(Z.Py());
	    m_Z_ee_Pz.push_back(Z.Pz());
	    m_ChargeMatch2El.push_back(ChargeMatch2El);
	    m_z_trans_mass_el_all.push_back(sqrt((El1.Pt() + El2.Pt())*(El1.Pt() + El2.Pt()) - Z.Px()*Z.Px() - Z.Py()*Z.Py()));
	    m_cut_delta_eta_e_e_all.push_back(fabs(El1.Eta() - El2.Eta()));
	    m_Z_ee_chosen1.push_back(itr1);
	    m_Z_ee_chosen2.push_back(itr2);
	    //COUT;
	    float DPhiE1E2 = fabs(El1.Phi() - El2.Phi());
	    if(DPhiE1E2 > 3.141595426){
	      DPhiE1E2 = 2*3.141592654 - DPhiE1E2;
	    }
	    m_cut_delta_phi_e_e_all.push_back(DPhiE1E2);
	  }
	}
      }
    }
  }
  
  if(INFO == "On"){
    cout << "CombinedInvariantMassElectrons() completed succesfully   " << endl;
  }
  
}

void Background::Select2ElForZRecons(){
    
  float DiffMassZ = MassZ;
  int Best_Combo = -1;
  if((int) m_inv_mass_2El_all.size() == 0){
    m_El_ComboZ.push_back(-1);
  }
  if((int) m_inv_mass_2El_all.size() >= 1){
    //COUT;
    for (int itr3 = 0 ; itr3 < (int) m_inv_mass_2El_all.size() ; itr3++){    
      cout << " fabs(MassZ - m_inv_mass_2El_all[itr3])  " << fabs(MassZ - m_inv_mass_2El_all[itr3]) << endl;
      cout << " m_ChargeMatch2El[itr3] " << m_ChargeMatch2El[itr3] << endl;
      if(fabs(MassZ - m_inv_mass_2El_all[itr3]) < DiffMassZ && m_ChargeMatch2El[itr3] == 0){
  	DiffMassZ = fabs(MassZ - m_inv_mass_2El_all[itr3]);
  	Best_Combo = itr3;
	//COUT;
      }
    }
    if(Best_Combo != -1){
      //COUT;
      if(m_inv_mass_2El_all[Best_Combo] >= (MassZ - Inv_Mass_2El_Cut_min) &&  m_inv_mass_2El_all[Best_Combo] <= (MassZ + Inv_Mass_2El_Cut_max)){
	m_inv_mass_2El_Z.push_back(m_inv_mass_2El_all[Best_Combo]);
	m_El_ComboZ.push_back(Best_Combo); 
	m_z_ee_e.push_back(m_Z_ee_E[Best_Combo]);
	m_z_ee_px.push_back(m_Z_ee_Px[Best_Combo]);
	m_z_ee_py.push_back(m_Z_ee_Py[Best_Combo]);
	m_z_ee_pz.push_back(m_Z_ee_Pz[Best_Combo]);
	m_z_ee_trans_mass.push_back(m_z_trans_mass_el_all[Best_Combo]);
	m_cut_delta_eta_e_e.push_back(m_cut_delta_eta_e_e_all[Best_Combo]);
	m_cut_delta_phi_e_e.push_back(m_cut_delta_phi_e_e_all[Best_Combo]);
	TLorentzVector Zee;
	Zee.SetPxPyPzE(m_z_ee_px[0],m_z_ee_py[0],m_z_ee_pz[0],m_z_ee_e[0]);
	m_z_ee_pt.push_back(Zee.Pt());
	m_z_ee_phi.push_back(Zee.Phi());
	m_z_ee_eta.push_back(Zee.Eta());
	m_z_ee_m.push_back(Zee.M());
	//int el1 = (2*Best_Combo);
	//int el2 = (2*Best_Combo + 1);  
	m_z_ee_chosen1.push_back(m_Z_ee_chosen1[Best_Combo]);
	m_z_ee_chosen2.push_back(m_Z_ee_chosen2[Best_Combo]);
	z_ee_cut_passed[0] += +1.; 
      }
      if(m_inv_mass_2El_all[Best_Combo] < (MassZ - Inv_Mass_2El_Cut_min) ||  m_inv_mass_2El_all[Best_Combo] > (MassZ + Inv_Mass_2El_Cut_max)){
	m_El_ComboZ.push_back(-1);
      }
    }
    else{
      m_El_ComboZ.push_back(-1);
    }
  }
   
  if(INFO == "On"){
    cout << "Select2ElForZRecons() completed succesfully   " << endl;
  }
}

void Background::CombinedInvariantMassMuons(){
 
  TLorentzVector Mu1;
  TLorentzVector Mu2;
  TLorentzVector Z;
  float ChargeMatch2Mu = -1.0;
  if((int) m_mu_e.size() > 1){
    for(int itr1 = 0 ; itr1 < (int) m_mu_e.size() ; itr1++){
      if(m_mu_quality[itr1]>2){
  	int temp = (itr1 + 1);
  	for(int itr2 = temp ; itr2 < (int) m_mu_e.size() ; itr2++){
  	  if(m_mu_quality[itr2]>2){
	    Mu1.SetPtEtaPhiE(m_mu_pt[itr1], m_mu_eta[itr1], m_mu_phi[itr1], m_mu_e[itr1]);
	    Mu2.SetPtEtaPhiE(m_mu_pt[itr2], m_mu_eta[itr2], m_mu_phi[itr2], m_mu_e[itr2]);
	    Z = Mu1 + Mu2; 
	    if(ForceZmass == "Yes"){
	      Float_t Scale = MassZ/(Z.M());
	      Z.SetPxPyPzE(Z.Px()*Scale, Z.Py()*Scale, Z.Pz()*Scale, Z.E()*Scale);
	      Mu1.SetPxPyPzE(Mu1.Px()*Scale, Mu1.Py()*Scale, Mu1.Pz()*Scale, Mu1.E()*Scale);
	      Mu2.SetPxPyPzE(Mu2.Px()*Scale, Mu2.Py()*Scale, Mu2.Pz()*Scale, Mu2.E()*Scale);
	      cout << "New Z mass: " << Z.M() << endl;
	    }
	    ChargeMatch2Mu = m_mu_charge[itr1] +  m_mu_charge[itr2];
	    m_inv_mass_2Mu_all.push_back(Z.M());
  	    m_Z_mumu_E.push_back(Z.E());
  	    m_Z_mumu_Px.push_back(Z.Px());
  	    m_Z_mumu_Py.push_back(Z.Py());
  	    m_Z_mumu_Pz.push_back(Z.Pz());
	    m_Z_mumu_chosen1.push_back(itr1);
	    m_Z_mumu_chosen2.push_back(itr2);
  	    m_ChargeMatch2Mu.push_back(ChargeMatch2Mu);
  	    m_z_trans_mass_mu_all.push_back(sqrt((Mu1.Pt() + Mu2.Pt())*(Mu1.Pt() + Mu2.Pt()) - Z.Px()*Z.Px() - Z.Py()*Z.Py()));
	    m_cut_delta_eta_mu_mu_all.push_back(fabs(Mu1.Eta() - Mu2.Eta()));
	    float DPhiMu1Mu2 = fabs(Mu1.Phi() - Mu2.Phi());
	    if(DPhiMu1Mu2 > 3.141595426){
	      DPhiMu1Mu2 = 2*3.141592654 - DPhiMu1Mu2;
	    }
	    m_cut_delta_phi_mu_mu_all.push_back(DPhiMu1Mu2);
  	  }
  	}
      }
    }
  }

  if(INFO == "On"){
    cout << "CombinedInvariantMassMuons() completed succesfully   " << endl;
  }
  
}

void Background::Select2MuForZRecons(){

  float DiffMassZ = MassZ;
  int Best_Combo = -1;
  if((int) m_inv_mass_2Mu_all.size() == 0){
    m_Mu_ComboZ.push_back(-1);
  }
  if((int) m_inv_mass_2Mu_all.size() >= 1){
    for (int itr3 = 0 ; itr3 < (int) m_inv_mass_2Mu_all.size() ; itr3++){    
      if(fabs(MassZ - m_inv_mass_2Mu_all[itr3]) < DiffMassZ && m_ChargeMatch2Mu[itr3] == 0){
	DiffMassZ = fabs(MassZ - m_inv_mass_2Mu_all[itr3]);
	Best_Combo = itr3;
      }
    }
    ////COUT;
    if(Best_Combo != -1){
      if(m_inv_mass_2Mu_all[Best_Combo] >= (MassZ - Inv_Mass_2Mu_Cut_min) &&  m_inv_mass_2Mu_all[Best_Combo] <= (MassZ + Inv_Mass_2Mu_Cut_max)){
	m_inv_mass_2Mu_Z.push_back(m_inv_mass_2Mu_all[Best_Combo]);
	m_Mu_ComboZ.push_back(Best_Combo);  
	m_z_mumu_e.push_back(m_Z_mumu_E[Best_Combo]);
	m_z_mumu_px.push_back(m_Z_mumu_Px[Best_Combo]);
	m_z_mumu_py.push_back(m_Z_mumu_Py[Best_Combo]);
	m_z_mumu_pz.push_back(m_Z_mumu_Pz[Best_Combo]);
	m_z_mumu_trans_mass.push_back(m_z_trans_mass_mu_all[Best_Combo]);
	m_cut_delta_eta_mu_mu.push_back(m_cut_delta_eta_mu_mu_all[Best_Combo]);
	m_cut_delta_phi_mu_mu.push_back(m_cut_delta_phi_mu_mu_all[Best_Combo]);
	TLorentzVector Zmumu;
	Zmumu.SetPxPyPzE(m_z_mumu_px[0],m_z_mumu_py[0],m_z_mumu_pz[0],m_z_mumu_e[0]);
	m_z_mumu_pt.push_back(Zmumu.Pt());
	m_z_mumu_phi.push_back(Zmumu.Phi());
	m_z_mumu_eta.push_back(Zmumu.Eta());
	m_z_mumu_m.push_back(Zmumu.M());
	//int mu1 = (2*Best_Combo);
	//int mu2 = (2*Best_Combo + 1);
	m_z_mumu_chosen1.push_back(m_Z_mumu_chosen1[Best_Combo]);
	m_z_mumu_chosen2.push_back(m_Z_mumu_chosen2[Best_Combo]);
	z_mumu_cut_passed[0] += 1.;
      }
      if(m_inv_mass_2Mu_all[Best_Combo] < (MassZ - Inv_Mass_2Mu_Cut_min) ||  m_inv_mass_2Mu_all[Best_Combo] > (MassZ + Inv_Mass_2Mu_Cut_max)){
	m_Mu_ComboZ.push_back(-1);
      }
    }
    else{
      m_Mu_ComboZ.push_back(-1);
    }
  }
  
  if((int) m_cut_delta_phi_mu_mu.size() > 0 ){
    m_cut_delta_phi_lep_lep.push_back(m_cut_delta_phi_mu_mu[0]);
    m_cut_delta_eta_lep_lep.push_back(m_cut_delta_eta_mu_mu[0]);
  }
  if((int) m_cut_delta_phi_e_e.size() > 0 ){
    m_cut_delta_phi_lep_lep.push_back(m_cut_delta_phi_e_e[0]);
    m_cut_delta_eta_lep_lep.push_back(m_cut_delta_eta_e_e[0]);
  }

  if(INFO == "On"){
    cout << "Select2MuForZRecons() completed succesfully   " << endl;
  }

}

void Background::GetMissingEt(){

  float KEl;
  float HEl;
  float Det_El;
  float KMu;
  float HMu;
  float Det_Mu;
  float metz_El_p = 4000000.;
  float metz_El_n = 4000000.;
  float metz_Mu_p = 4000000.;
  float metz_Mu_n = 4000000.;
  
  TVector2 MET;
  float MET_px;
  float MET_py;

  //MET 
  //Top_MET::Set_METWeights(Electron_MissingEt_wpx, &Electron_MissingEt_wpy, &Electron_MissingEt_wet, 0, 0, 0, &Jet_MissingEt_wpx, &Jet_MissingEt_wpy, &Jet_MissingEt_wet, &Muon_MissingEt_statusWord, &Muon_MissingEt_wpx, &Muon_MissingEt_wpy, &Muon_MissingEt_wet);
  //Top_MET::Set_Electrons(Electrons_tlv_scaled, Electrons_tlv);
  //Top_MET::Set_Jets(Jets_tlv_scaled, Jets_tlv, Jets_emscale_tlv);
  //Top_MET::Set_Muons(Muon_tlv_scaled, Muon_tlv, Muon_ms_tlv_scaled, Muon_ms_tlv, Muon_track_tlv_scaled, Muon_track_tlv); 




  //MET Correction for all electrons and muons   
  TLorentzVector All_El;
  TLorentzVector All_Mu;
  float dx_el = 0; //For Electron Smearing  
  float dy_el = 0; //For Electron Smearing
  float dx_mu = 0; //For Muon Smearing 
  float dy_mu = 0; //For Muon Smearing 
  float dx_jet = 0; //For Jets JES/JER calculation  
  float dy_jet = 0; //For Jets JES/JER calculation
  float dx_lar_el = 0; //For Electrons falling in LAr Hole
  float dy_lar_el = 0; //For Electrons falling in LAr Hole
  float dx_el_energyCor = 0;
  float dy_el_energyCor = 0;

  if(InputType == "MC"){
    //Electron Smearing Correction
    for(int itr = 0 ; itr < (int) m_el_veto_e.size(); itr++){
      //Add all dx from smeared electrons
      dx_el += m_dx_ele_smear[itr]*m_el_veto_MET_wpx[itr];
      dy_el += m_dy_ele_smear[itr]*m_el_veto_MET_wpy[itr];
    }
    //Muon Smearing Correction
    for(int itr = 0 ; itr < (int) m_mu_veto_e.size(); itr++){
      cout << "m_dx_mu_smear.size() " << (int) m_dx_mu_smear.size() << endl;
      cout << "m_mu_veto_MET_wpx.size() " << (int) m_mu_veto_MET_wpx.size() << endl;
      if(m_mu_veto_pt[itr] > finalMuPt_Cut){
	dx_mu += m_dx_mu_smear[itr]*m_mu_veto_MET_wpx[itr];
	dy_mu += m_dy_mu_smear[itr]*m_mu_veto_MET_wpy[itr];
      }
    }
    //COUT;
    //Electron falling in LAr Hole Correction
    for(int itr = 0 ; itr < (int) m_el_all_itr.size(); itr++){
      dx_lar_el += m_dx_ele_all_lar[itr]*m_el_all_MET_wpx[itr];
      dy_lar_el += m_dy_ele_all_lar[itr]*m_el_all_MET_wpy[itr];
    }
    //COUT;
    //for JES/JER uncertainties --> Must use AntiKt6LCTopo 
    if(DoJESUncertainty != 0 || DoJERUncertainty != 0){
      //METUtility *metSys = new METUtility;
      //metSys->setCellFix(true);
      //metSys->doForwardEtaCut(true);
      //metSys->setPileUpUncertainty(0.10);
      //metSys->setObjects("jets", jet_AntiKt6LCTopo_pt, jet_AntiKt6LCTopo_eta, jet_AntiKt6LCTopo_phi, jet_AntiKt6LCTopo_E, jet_AntiKt6LCTopo_MET_wet, jet_AntiKt6LCTopo_MET_wpx, jet_AntiKt6LCTopo_MET_wpy, jet_AntiKt6LCTopo_MET_statusWord);
      //metSys->setExtraJetParameters(jet_AntiKt6LCTopo_GCWJES, jet_AntiKt6LCTopo_m, jet_AntiKt6LCTopo_eta, jet_AntiKt6LCTopo_phi);
      for(int itr = 0 ; itr < (int) m_jet_pt.size(); itr++){
	dx_jet += m_dx_jet[itr];
	dy_jet += m_dy_jet[itr];
      }
    }
    //COUT;
  }
  if(InputType == "DATA"){
    for(int itr = 0; itr < (int) m_el_pt.size() ; itr++){
      dx_el_energyCor += m_dx_ele_energyCor[itr];
      dy_el_energyCor += m_dy_ele_energyCor[itr];
    }
  }

  //Following SM WZ group's MET definition
  float MuonboyX = MET_MuonBoy_et*cos(MET_MuonBoy_phi);
  float RefMuonX = MET_RefMuon_Track_et*cos(MET_RefMuon_Track_phi);
  float MuonboyY = MET_MuonBoy_et*sin(MET_MuonBoy_phi);
  float RefMuonY = MET_RefMuon_Track_et*sin(MET_RefMuon_Track_phi);

  float MET_x = 0.;
  float MET_y = 0.;
  float MET_sumet = 0.0001;
    
  //Subtract Electron contributions to MET : 
  if(MET_Ref == "No"){ //SM WZ group definition
    MET_x = MET_LocHadTopo_etx_ForwardReg + MET_LocHadTopo_etx_EndcapRegion + MET_LocHadTopo_etx_CentralReg + MuonboyX - RefMuonX;
    MET_y = MET_LocHadTopo_ety_ForwardReg + MET_LocHadTopo_ety_EndcapRegion + MET_LocHadTopo_ety_CentralReg + MuonboyY - RefMuonY;
    MET_px = MET_x - dx_el_energyCor - dx_el - dx_lar_el - dx_mu - dx_jet;
    MET_py = MET_y - dy_el_energyCor - dy_el - dy_lar_el - dy_mu - dy_jet;
    MET_sumet = MET_LocHadTopo_sumet_ForwardReg+MET_LocHadTopo_sumet_EndcapRegion+MET_LocHadTopo_sumet_CentralReg+ MET_MuonBoy_sumet_ForwardReg+ MET_MuonBoy_sumet_EndcapRegion+ MET_MuonBoy_sumet_CentralReg;
  }
  if(MET_Ref == "Yes"){ //With MET RefFinal
    MET_x = MET_RefFinal_etx_ForwardReg + MET_RefFinal_etx_EndcapRegion + MET_RefFinal_etx_CentralReg + MuonboyX - RefMuonX;
    MET_y = MET_RefFinal_ety_ForwardReg + MET_RefFinal_ety_EndcapRegion + MET_RefFinal_ety_CentralReg + MuonboyY - RefMuonY;
    MET_px = MET_RefFinal_em_et*cos(MET_RefFinal_em_phi) - dx_el_energyCor - dx_el - dx_lar_el - dx_mu - dx_jet;
    MET_py = MET_RefFinal_em_et*sin(MET_RefFinal_em_phi) - dy_el_energyCor - dy_el - dy_lar_el - dy_mu - dy_jet;
    MET_sumet = MET_RefFinal_sumet_ForwardReg+MET_RefFinal_sumet_EndcapRegion+MET_RefFinal_sumet_CentralReg+ MET_MuonBoy_sumet_ForwardReg+ MET_MuonBoy_sumet_EndcapRegion+ MET_MuonBoy_sumet_CentralReg;
  }
  
  //MET_px -= (All_El.Px());
  //MET_px -= (All_Mu.Px());
  //MET_py -= (All_El.Py());
  //MET_py -= (All_Mu.Py());
  
  MET.Set(MET_px, MET_py);
  
  if(NtupleType == "WZ" || NtupleType == "Thomas"){
    m_MET_x.push_back(MET.Px());
    m_MET_y.push_back(MET.Py());
    m_MET.push_back(MET.Mod());
    m_MET_sumEt.push_back(MET_sumet);
    if(InputType == "DATA"){
      m_larError.push_back(larError);
    }
    if(OutputTruth == "On"){
      m_MET_truth_x.push_back(MET_Truth_NonInt_et*cos(MET_Truth_NonInt_phi));
      m_MET_truth_y.push_back(MET_Truth_NonInt_et*sin(MET_Truth_NonInt_phi));
      m_MET_truth.push_back(sqrt(m_MET_truth_x[0]*m_MET_truth_x[0] + m_MET_truth_y[0]*m_MET_truth_y[0]));
    }
  }
      
  //electrons
  //cout << "m_el_pt.size()   " << (int) m_el_pt.size() << endl;
  if((int) m_el_pt.size() > 0){
    for(int itr = 0 ; itr < (int) m_el_pt.size() ; itr++){
      if(m_el_quality[itr] >= w_el_quality /*medium*/ ){
	KEl = (MassW*MassW - MassEl*MassEl)/2.0 + m_el_px[itr]*m_MET_x[0] + m_el_py[itr]*m_MET_y[0];
	HEl = m_el_e[itr]*m_el_e[itr] - m_el_pz[itr]*m_el_pz[itr];
	Det_El = KEl*KEl*m_el_pz[itr]*m_el_pz[itr] - HEl*(m_el_e[itr]*m_el_e[itr]*(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]) - KEl*KEl);
	m_Det_El.push_back(Det_El);
	if(Det_El >= 0.0){ 
	  metz_El_p = (KEl*m_el_pz[itr] + sqrt(Det_El))/HEl;
	  metz_El_n = (KEl*m_el_pz[itr] - sqrt(Det_El))/HEl;
	  if(fabs(metz_El_p) < 3500000.0 && fabs(metz_El_n) < 3500000.0){
	    m_MET_el_z_p.push_back(metz_El_p);
	    m_MET_el_z_n.push_back(metz_El_n);
	    m_MET_el_z_s.push_back(1);
	  }
	  else if(fabs(metz_El_p) > 3500000.0 || fabs(metz_El_n) > 3500000.0){
	    m_MET_el_z_p.push_back(0);
	    m_MET_el_z_n.push_back(0);
	    m_MET_el_z_s.push_back(-1);
	  }
	}
	if(Det_El < 0.0){
	  metz_El_p = KEl*m_el_pz[itr];
	  metz_El_n = KEl*m_el_pz[itr];
	  if(fabs(metz_El_p) < 3500000.0 && fabs(metz_El_n) < 3500000.0){
	    m_MET_el_z_p.push_back(metz_El_p);
	    m_MET_el_z_n.push_back(metz_El_n);
	    m_MET_el_z_s.push_back(0);
	  }
	  else if(fabs(metz_El_p) > 3500000.0 || fabs(metz_El_n) > 3500000.0){
	    m_MET_el_z_p.push_back(0);
	    m_MET_el_z_n.push_back(0);
	    m_MET_el_z_s.push_back(-1);
	  }
	}
      }
      else if(m_el_quality[itr] < w_el_quality ){
	m_MET_el_z_s.push_back(0);
	//h_MET_el_z_s->Fill(0);
	m_Det_El.push_back(-1.0);
      }
    }
  }
  if((int) m_el_pt.size() == 0){
    m_MET_el_z_s.push_back(0);
    //h_MET_el_z_s->Fill(0);
  }
  //muons
  if((int) m_mu_e.size() > 0){
    for(int itr = 0 ; itr < (int) m_mu_e.size() ; itr++){
      if(m_mu_quality[itr] > 2 /*tight muons*/){
	KMu = (MassW*MassW - MassMu*MassMu)/2.0 + m_mu_px[itr]*m_MET_x[0] + m_mu_py[itr]*m_MET_y[0];
	HMu = m_mu_e[itr]*m_mu_e[itr] - m_mu_pz[itr]*m_mu_pz[itr];
	Det_Mu = KMu*KMu*m_mu_pz[itr]*m_mu_pz[itr] - HMu*(m_mu_e[itr]*m_mu_e[itr]*(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]) - KMu*KMu);
	m_Det_Mu.push_back(Det_Mu);
	if(Det_Mu >= 0.0){
	  metz_Mu_p = (KMu*m_mu_pz[itr] + sqrt(Det_Mu))/HMu;
	  metz_Mu_n = (KMu*m_mu_pz[itr] - sqrt(Det_Mu))/HMu;
	  if(fabs(metz_Mu_p) < 3500000.0 && fabs(metz_Mu_n) < 3500000.0){
	    m_MET_mu_z_p.push_back(metz_Mu_p);
	    m_MET_mu_z_n.push_back(metz_Mu_n);
	    m_MET_mu_z_s.push_back(1);
	  }
	  else if(fabs(metz_Mu_p) > 3500000.0 || fabs(metz_Mu_n) > 3500000.0){
	    m_MET_mu_z_p.push_back(0);
	    m_MET_mu_z_n.push_back(0);
	    m_MET_mu_z_s.push_back(-1);
	  }
	}
	if(Det_Mu < 0.0){
	  metz_Mu_p = KMu*m_mu_pz[itr];
	  metz_Mu_n = KMu*m_mu_pz[itr];
	  if(fabs(metz_Mu_p) < 3500000.0 && fabs(metz_Mu_n) < 3500000.0){
	    m_MET_mu_z_p.push_back(metz_Mu_p);
	    m_MET_mu_z_n.push_back(metz_Mu_n);
	    m_MET_mu_z_s.push_back(0);
	  }
	  else if(fabs(metz_Mu_p) > 3500000.0 || fabs(metz_Mu_n) > 3500000.0){
	    m_MET_mu_z_p.push_back(0);
	    m_MET_mu_z_n.push_back(0);
	    m_MET_mu_z_s.push_back(-1);
	  }
	}
      }
      else if(m_mu_quality[itr] <= 2){
	m_MET_mu_z_s.push_back(0);
      }
    }
  }
  if((int) m_mu_e.size() == 0){        
    m_MET_mu_z_s.push_back(0);
    //h_MET_mu_z_s->Fill(0);
  }

  //Electron and Muon Trigger Efficiency
  vector<TLorentzVector> Elec;
  vector<TLorentzVector> Muon;
  
  for(int itr = 0 ; itr < (int) m_el_pt.size() ; itr++){
    TLorentzVector El_temp;
    El_temp.SetPtEtaPhiE(m_el_pt[itr], m_el_eta[itr], m_el_phi[itr], m_el_e[itr]);
    Elec.push_back(El_temp);
  }
  if((int) m_el_pt.size() == 0){
    Elec.clear();
  }
  
  for(int itr = 0 ; itr < (int) m_mu_pt.size() ; itr++){
    TLorentzVector Mu_temp;
    Mu_temp.SetPtEtaPhiE(m_mu_pt[itr], m_mu_eta[itr], m_mu_phi[itr], m_mu_e[itr]);
    Muon.push_back(Mu_temp);
  }
  if((int) m_mu_pt.size() == 0){
    Muon.clear();
  }

  m_trig_sf = 1.;
  if(ReweightFactorsManager::get_instance() && ((int) m_el_pt.size() > 0 || (int) m_mu_pt.size() > 0) ){
    m_trig_sf = ReweightFactorsManager::get_instance()->getEventTrigSF(true, Elec, Muon);
    cout << "Elec.size() " << (int) Elec.size() << endl; 
    cout << "Muon.size() " << (int) Muon.size() << endl; 
    cout << " SF = " << m_trig_sf << endl;
  }
      
  if(INFO == "On"){
    cout << "GetMissingEt() completed succesfully   " << endl;
  }
  
}

void Background::CalculateQCDTemplate(){

  if(InputType == "DATA"){
    egammaOQ myOQ; 
    egammaSFclass mySFclass;
    //RandomDataPeriod mc_dataperiod;                                                                                                                              
    //int dataperiodformc = mc_dataperiod.GetDataPeriod();

    vector<int>   m_qcd_el_author(*mapVarsVectorInt[EleAlg+"author"]);
    vector<float> m_qcd_el_cl_E(*mapVarsVectorFloat[EleAlg+"cl_E"]);
    vector<float> m_qcd_el_cl_pt(*mapVarsVectorFloat[EleAlg+"cl_pt"]);
    vector<float> m_qcd_el_cl_eta(*mapVarsVectorFloat[EleAlg+"cl_eta"]);
    vector<float> m_qcd_el_cl_phi(*mapVarsVectorFloat[EleAlg+"cl_phi"]);
    vector<float> m_qcd_el_E(*mapVarsVectorFloat[EleAlg+"E"]);
    vector<float> m_qcd_el_charge(*mapVarsVectorFloat[EleAlg+"charge"]);
    vector<float> m_qcd_el_phi(*mapVarsVectorFloat[EleAlg+"phi"]);
    vector<float> m_qcd_el_eta(*mapVarsVectorFloat[EleAlg+"eta"]);
    vector<float> m_qcd_el_weta2(*mapVarsVectorFloat[EleAlg+"weta2"]);
    vector<float> m_qcd_el_reta(*mapVarsVectorFloat[EleAlg+"reta"]);
    vector<int> m_qcd_el_nSCTHits(*mapVarsVectorInt[EleAlg+"nSCTHits"]);
    vector<int> m_qcd_el_nPixHits(*mapVarsVectorInt[EleAlg+"nPixHits"]);
    vector<float> m_qcd_el_tracketa(*mapVarsVectorFloat[EleAlg+"tracketa"]);
    vector<float> m_qcd_el_trackphi(*mapVarsVectorFloat[EleAlg+"trackphi"]);
    vector<float> m_qcd_el_tracktheta(*mapVarsVectorFloat[EleAlg+"tracktheta"]);
    vector<float> m_qcd_el_trackz0pv(*mapVarsVectorFloat[EleAlg+"trackz0pv"]);
    vector<float> m_qcd_el_trackd0pv(*mapVarsVectorFloat[EleAlg+"trackd0pv"]);
    vector<float> m_qcd_el_tracksigd0pv(*mapVarsVectorFloat[EleAlg+"tracksigd0pv"]);
    vector<unsigned int>   m_qcd_el_isEM(*mapVarsVectorUnsignedInt[EleAlg+"isEM"]);
    vector<unsigned int>   m_qcd_el_OQ(*mapVarsVectorUnsignedInt[EleAlg+"OQ"]);
    vector<float> m_qcd_el_Etcone20_pt_corrected(*mapVarsVectorFloat[EleAlg+"Etcone20_pt_corrected"]);
    vector<float> m_qcd_el_Etcone30_pt_corrected(*mapVarsVectorFloat[EleAlg+"Etcone30_pt_corrected"]);
    vector<float> m_qcd_el_Etcone40_pt_corrected(*mapVarsVectorFloat[EleAlg+"Etcone40_pt_corrected"]);
    vector<float> m_qcd_el_ptcone20(*mapVarsVectorFloat[EleAlg+"ptcone20"]);
    vector<float> m_qcd_el_ptcone30(*mapVarsVectorFloat[EleAlg+"ptcone30"]);
    vector<float> m_qcd_el_ptcone40(*mapVarsVectorFloat[EleAlg+"ptcone40"]);
    vector<float> m_qcd_el_pt(*mapVarsVectorFloat[EleAlg+"pt"]);
  
    if(NtupleType == "WZ" || NtupleType == "Thomas"){
    
      //define tempory loose, medium, mediumIso, tight, and tightIso   
      const unsigned int Loose =     egammaPID::ElectronLoose;
      const unsigned int Medium =    egammaPID::ElectronMedium_WithTrackMatch;
      const unsigned int MediumIso = egammaPID::ElectronMediumIso_WithTrackMatch;  
      const unsigned int Tight =     egammaPID::ElectronTight_WithTrackMatch;      
      const unsigned int TightIso =  egammaPID::ElectronTightIso_WithTrackMatch;   

      for(int itr = 0 ; itr < (int) (*el_E).size() ; itr++){
	if(((*el_isEM)[itr] & TightIso) == 0) m_qcd_el_quality.push_back(5);
	else if(((*el_isEM)[itr] & Tight) == 0) m_qcd_el_quality.push_back(4);
	else if(((*el_isEM)[itr] & MediumIso) == 0) m_qcd_el_quality.push_back(3);
	else if(((*el_isEM)[itr] & Medium) == 0) m_qcd_el_quality.push_back(2);
	else if(((*el_isEM)[itr] & Loose) == 0) m_qcd_el_quality.push_back(1);
	else m_qcd_el_quality.push_back(0);
      
	////COUT;
	//For OTX cleaning
      
	if(InputYear == "2011"){
	  if(InputType == "DATA"){
	    if( ((*el_OQ)[itr] & 1446) == 0 && myOQ.checkOQClusterElectron(RunNumber, el_cl_eta->at(itr), el_cl_phi->at(itr)) != 3){ 
	      m_qcd_el_OTX.push_back(1);
	    }
	    if( ((*el_OQ)[itr] & 1446) != 0 || myOQ.checkOQClusterElectron(RunNumber, el_cl_eta->at(itr), el_cl_phi->at(itr)) == 3){
	      m_qcd_el_OTX.push_back(3);
	    }
	  }
	  if(InputType == "MC"){
	    if(((*el_OQ)[itr] & 1446) == 0 /*&& myOQ.checkOQClusterElectron( dataperiodformc , el_cl_eta->at(itr), el_cl_phi->at(itr)) != 3*/){
	      m_qcd_el_OTX.push_back(1);
	    }
	    if(((*el_OQ)[itr] & 1446) == 0 /*&& myOQ.checkOQClusterElectron( dataperiodformc , el_cl_eta->at(itr), el_cl_phi->at(itr)) == 3*/){
	      m_qcd_el_OTX.push_back(2); //Passes OQ but fails OTX
	    }
	    if(((*el_OQ)[itr] & 1446) != 0){
	      m_qcd_el_OTX.push_back(3);
	    }
	  }
	} 
      
	if((*el_nBLHits)[itr] >= 1){
	  m_qcd_el_blayer.push_back((*el_nBLHits)[itr]);
	}
	if((*el_nBLHits)[itr] < 1 && (*el_expectHitInBLayer)[itr] != 1){
	  m_qcd_el_blayer.push_back(-1);
	}
	if((*el_nBLHits)[itr] < 1 && (*el_expectHitInBLayer)[itr] == 1){
	  m_qcd_el_blayer.push_back(0);
	}
      }

      // cout << "DEBUG " << (int) (*el_E).size() << endl;            
      // cout << "DEBUG " << (int) m_qcd_el_px.size() << endl << endl;
      //Int_t STOP = 0;
      eg2011::EnergyRescaler eRescale;
      eRescale.useDefaultCalibConstants("2011");
    
      int count_good_el = 0;
      for(int itr = 0 ; itr < (int) m_qcd_el_quality.size() ; itr++){  
	if(m_GRL == 1 || (InputType == "MC" /*&& m_good_event == 1*/)){
	  float finalElE = m_qcd_el_cl_E[itr]; //always
	  float finalElPt = -999.;
	  float finalElPx;
	  float finalElPy;
	  float finalElPz;
	  float finalElEta;
	  float finalElPhi;
	  if((m_qcd_el_nSCTHits[itr] + m_qcd_el_nPixHits[itr]) < 4){
	    finalElPt = m_qcd_el_cl_pt[itr]; //Corrected el_cl_pt                                                                                                     
	    finalElPx = finalElPt*cos(m_qcd_el_cl_phi[itr]);
	    finalElPy = finalElPt*sin(m_qcd_el_cl_phi[itr]);
	    finalElPz = finalElPt*sinh(m_qcd_el_cl_eta[itr]);
	    finalElEta = m_qcd_el_cl_eta[itr];
	    finalElPhi = m_qcd_el_cl_phi[itr];
	  }
	  if((m_qcd_el_nSCTHits[itr] + m_qcd_el_nPixHits[itr]) >= 4){ //always the case for medium and tight electrons 
	    finalElPt = m_qcd_el_cl_E[itr]/cosh(m_qcd_el_tracketa[itr]); //With corrected el_cl_pt 
	    finalElPx = finalElPt*cos(m_qcd_el_trackphi[itr]);
	    finalElPy = finalElPt*sin(m_qcd_el_trackphi[itr]);
	    finalElPz = finalElPt*sinh(m_qcd_el_tracketa[itr]);
	    finalElEta = m_qcd_el_tracketa[itr];
	    finalElPhi = m_qcd_el_trackphi[itr];
	  }
	  ////COUT;
	  TLorentzVector Ele;
	  Ele.SetPtEtaPhiE(finalElPt, finalElEta, finalElPhi, finalElE); 
	  float Smearing_Factor = 1.;
	  if(InputType == "MC" && DoElectronSmearing == "Yes"){
	    double mcWithConstantTerm=true;// if you use a MC without constant term,                                                                                            
	    Smearing_Factor = eRescale.getSmearingCorrectionMeV(m_qcd_el_cl_eta[itr], m_qcd_el_cl_E[itr], DoLESUncertainty, mcWithConstantTerm);
	    Ele.SetPtEtaPhiE(finalElPt, finalElEta, finalElPhi, Smearing_Factor*finalElE); //Smear Pt 
	  }
	  //Pt Cuts, Eta cuts and possibly removed Eta or Phi ranges.  
	  if((m_qcd_el_author[itr] == 1 || m_qcd_el_author[itr] == 3) ) {
	    if(m_qcd_el_OTX[itr] != 3){ //This contains OQ cuts... see above  
	      if ( m_qcd_el_cl_eta[itr] == 2.47 || m_qcd_el_cl_eta[itr] == -2.47 ) 
		cout << "DEBUG " << "el eta amiguity" << endl;
	      if ( m_qcd_el_cl_eta[itr] >= finalElEta_Cut_min &&
		   m_qcd_el_cl_eta[itr] <= finalElEta_Cut_max &&
		   (fabs(m_qcd_el_cl_eta[itr]) < RemoveElEtaRange1_min || fabs(m_qcd_el_cl_eta[itr]) > RemoveElEtaRange1_max) && 
		   (fabs(m_qcd_el_cl_eta[itr]) < RemoveElEtaRange2_min || fabs(m_qcd_el_cl_eta[itr]) > RemoveElEtaRange2_max) && 
		   (m_qcd_el_cl_phi[itr] < RemoveElPhiRange1_min || m_qcd_el_cl_phi[itr] > RemoveElPhiRange1_max) && 
		   (m_qcd_el_cl_phi[itr] < RemoveElPhiRange2_min || m_qcd_el_cl_phi[itr] > RemoveElPhiRange2_max) ){
		if ( (m_runMode == _MODE_HQ && ((m_qcd_el_quality[itr] == 2 || m_qcd_el_quality[itr] == 3) && m_qcd_el_quality[itr] != 4 && m_qcd_el_quality[itr] != 5)) 
		     || (m_runMode == _MODE_TR && m_qcd_el_quality[itr] >= 2) ){
		  if ( Ele.Pt()  > finalElPt_Cut ) { //Use this for cut flow
		    if ( fabs(m_qcd_el_trackd0pv[itr]/m_qcd_el_tracksigd0pv[itr]) < 10. ) {
		      if ( fabs(m_qcd_el_trackz0pv[itr]) < 10. ) {
			if(m_qcd_el_blayer[itr] != 0 || m_runMode == _MODE_HQ){
			  //e/mu overlap removal
			  float DeltaPhi = 0.0;
			  float DeltaEta = 0.0;
			  float DeltaR   = 0.0;
			  int ElectronOverlapElectron = 0;
			  int MuonOverlapElectron = 0; 
			  if(m_runMode == _MODE_TR){
			    for(int itrMu = 0 ; itrMu < (int) m_mu_e.size() ; itrMu++){
			      //COUT;
			      DeltaPhi = fabs( m_mu_phi[itrMu] - m_qcd_el_trackphi[itr] );
			      if(DeltaPhi > 3.141592654){
				DeltaPhi = (2*3.141592654 - DeltaPhi);
			      }
			      //COUT;
			      DeltaEta = fabs( m_mu_eta[itrMu] - m_qcd_el_tracketa[itr] );
			      DeltaR = sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta);
			      //COUT;
			      if(DeltaR < DeltaR_Cut_MuOverlapsEl){
				MuonOverlapElectron = 1;
				break;
			      }
			    }
			  }
			  //COUT;
			  if(MuonOverlapElectron == 0){
			    for(int itrEl = 0 ; itrEl < itr ; itrEl++){ //Iterates over electrons with higher Pt
			      //COUT;
			      if(m_qcd_el_pt[itrEl] > finalElPt_Cut){
				DeltaPhi = fabs( m_qcd_el_trackphi[itrEl] - m_qcd_el_trackphi[itr] );
				if(DeltaPhi > 3.141592654){
				  DeltaPhi = (2*3.141592654 - DeltaPhi);
				}
				DeltaEta = fabs( m_qcd_el_tracketa[itrEl] - m_qcd_el_tracketa[itr] );
				//COUT;
				DeltaR = sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta);
				if(DeltaR < DeltaR_Cut_ElOverlapsEl){
				  ElectronOverlapElectron = 1;
				  break;
				}
			      }
			    }
			    if(ElectronOverlapElectron == 0){
			      if(m_qcd_el_Etcone20_pt_corrected[itr] < EtCone_Cut || m_runMode == _MODE_TR){
				count_good_el += 1;
				if(m_runMode == _MODE_HQ){
				  m_event_isQCDtemplate.push_back(1.0);
				}
			      }
			    }
			  }
			}
		      }
		    }
		  }
		}
	      }
	    }
	  }
	}
      }
    
    
      if(m_runMode == _MODE_TR && count_good_el == 2){
	for(int itr = 0 ; itr < (int) m_qcd_el_quality.size() ; itr++){  
	  if(m_GRL == 1 || (InputType == "MC" /*&& m_good_event == 1*/)){
	    float finalElE = m_qcd_el_cl_E[itr]; //always
	    float finalElPt = -999.;
	    float finalElPx;
	    float finalElPy;
	    float finalElPz;
	    float finalElEta;
	    float finalElPhi;
	    if((m_qcd_el_nSCTHits[itr] + m_qcd_el_nPixHits[itr]) < 4){
	      finalElPt = m_qcd_el_cl_pt[itr]; //Corrected el_cl_pt                                                                                                     
	      finalElPx = finalElPt*cos(m_qcd_el_cl_phi[itr]);
	      finalElPy = finalElPt*sin(m_qcd_el_cl_phi[itr]);
	      finalElPz = finalElPt*sinh(m_qcd_el_cl_eta[itr]);
	      finalElEta = m_qcd_el_cl_eta[itr];
	      finalElPhi = m_qcd_el_cl_phi[itr];
	    }
	    if((m_qcd_el_nSCTHits[itr] + m_qcd_el_nPixHits[itr]) >= 4){ //always the case for medium and tight electrons 
	      finalElPt = m_qcd_el_cl_E[itr]/cosh(m_qcd_el_tracketa[itr]); //With corrected el_cl_pt 
	      finalElPx = finalElPt*cos(m_qcd_el_trackphi[itr]);
	      finalElPy = finalElPt*sin(m_qcd_el_trackphi[itr]);
	      finalElPz = finalElPt*sinh(m_qcd_el_tracketa[itr]);
	      finalElEta = m_qcd_el_tracketa[itr];
	      finalElPhi = m_qcd_el_trackphi[itr];
	    }
	    //COUT;
	    TLorentzVector Ele;
	    Ele.SetPtEtaPhiE(finalElPt, finalElEta, finalElPhi, finalElE); 
	    float Smearing_Factor = 1.;
	    if(InputType == "MC" && DoElectronSmearing == "Yes"){
	      double mcWithConstantTerm=true;// if you use a MC without constant term,                                                                                            
	      Smearing_Factor = eRescale.getSmearingCorrectionMeV(m_qcd_el_cl_eta[itr], m_qcd_el_cl_E[itr], DoLESUncertainty, mcWithConstantTerm);
	      Ele.SetPtEtaPhiE(finalElPt, finalElEta, finalElPhi, Smearing_Factor*finalElE); //Smear Pt 
	    }
	    //Pt Cuts, Eta cuts and possibly removed Eta or Phi ranges.  
	    if((m_qcd_el_author[itr] == 1 || m_qcd_el_author[itr] == 3) ) {
	      //if ( ((m_qcd_el_OQ[itr] != 3)) {
	      if(m_qcd_el_OTX[itr] != 3){ //This contains OQ cuts... see above  
		//if(m_qcd_el_OTX[itr] != 2 || InputType == "DATA"){
		if ( m_qcd_el_cl_eta[itr] == 2.47 || m_qcd_el_cl_eta[itr] == -2.47 ) 
		  cout << "DEBUG " << "el eta amiguity" << endl;
		if ( m_qcd_el_cl_eta[itr] >= finalElEta_Cut_min &&
		     m_qcd_el_cl_eta[itr] <= finalElEta_Cut_max &&
		     (fabs(m_qcd_el_cl_eta[itr]) < RemoveElEtaRange1_min || fabs(m_qcd_el_cl_eta[itr]) > RemoveElEtaRange1_max) && 
		     (fabs(m_qcd_el_cl_eta[itr]) < RemoveElEtaRange2_min || fabs(m_qcd_el_cl_eta[itr]) > RemoveElEtaRange2_max) && 
		     (m_qcd_el_cl_phi[itr] < RemoveElPhiRange1_min || m_qcd_el_cl_phi[itr] > RemoveElPhiRange1_max) && 
		     (m_qcd_el_cl_phi[itr] < RemoveElPhiRange2_min || m_qcd_el_cl_phi[itr] > RemoveElPhiRange2_max) ){
		  if ( m_qcd_el_quality[itr] == 1 && m_qcd_el_quality[itr] != 2 ){
		    if ( Ele.Pt()  > finalElPt_Cut ) { //Use this for cut flow
		      if ( fabs(m_qcd_el_trackd0pv[itr]/m_qcd_el_tracksigd0pv[itr]) < 10. ) {
			if ( fabs(m_qcd_el_trackz0pv[itr]) < 10. ) {
			  if(m_qcd_el_blayer[itr] != 0 || m_runMode == _MODE_HQ){
			    //e/mu overlap removal
			    float DeltaPhi = 0.0;
			    float DeltaEta = 0.0;
			    float DeltaR   = 0.0;
			    int ElectronOverlapElectron = 0;
			    int MuonOverlapElectron = 0; 
			    if(m_runMode == _MODE_TR){
			      for(int itrMu = 0 ; itrMu < (int) m_mu_e.size() ; itrMu++){
				DeltaPhi = fabs( m_mu_phi[itrMu] - m_qcd_el_trackphi[itr] );
				if(DeltaPhi > 3.141592654){
				  DeltaPhi = (2*3.141592654 - DeltaPhi);
				}
				//COUT;
				DeltaEta = fabs( m_mu_eta[itrMu] - m_qcd_el_tracketa[itr] );
				DeltaR = sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta);
				//COUT;
				if(DeltaR < DeltaR_Cut_MuOverlapsEl){
				  MuonOverlapElectron = 1;
				  break;
				}
			      }
			    }
			    if(MuonOverlapElectron == 0){
			      for(int itrEl = 0 ; itrEl < itr ; itrEl++){ //Iterates over electrons with higher Pt
				//COUT;
				if(m_qcd_el_pt[itrEl] > finalElPt_Cut){
				  DeltaPhi = fabs( m_qcd_el_trackphi[itrEl] - m_qcd_el_trackphi[itr] );
				  if(DeltaPhi > 3.141592654){
				    DeltaPhi = (2*3.141592654 - DeltaPhi);
				  }
				  DeltaEta = fabs( m_qcd_el_tracketa[itrEl] - m_qcd_el_tracketa[itr] );
				  //COUT;
				  DeltaR = sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta);
				  if(DeltaR < DeltaR_Cut_ElOverlapsEl){
				    ElectronOverlapElectron = 1;
				    break;
				  }
				}
			      }
			      if(ElectronOverlapElectron == 0){
				if(m_qcd_el_Etcone20_pt_corrected[itr] < EtCone_Cut || m_runMode == _MODE_TR){
				  m_event_isQCDtemplate.push_back(1.0);
				}
			      }
			    }
			  }
			}
		      }
		    }
		  }
		}
	      }
	    }
	  }
	}
      }
    }
  
    if((int) m_event_isQCDtemplate.size() == 0){
      m_event_isQCDtemplate.push_back(0.);
    }
  
  }
  if(INFO == "On"){
    cout << "CalculateQCDTemplate() completed succesfully   " << endl;
  }
}


void Background::TruthMET(){
 
  // //   //Not completed
  // //   if(Truth == "On"){
  // //     if(NtupleType == "WZ" || NtupleType == "Thomas"){
  // //       m_MET_x_truth.push_back(MET_Truth_Int_et*cos(MET_Truth_Int_phi));
  // //       m_MET_diff_x_truth.push_back((MET_Truth_Int_et*cos(MET_Truth_Int_phi)) - (MET_Truth_NonInt_etx));
  // //       m_MET_y_truth.push_back((MET_Truth_Int_et*sin(MET_Truth_Int_phi)));
  // //       m_MET_diff_y_truth.push_back((MET_Truth_Int_et*sin(MET_Truth_Int_phi)) - (MET_Truth_NonInt_ety));
  // //       m_MET_et_truth.push_back(sqrt(MET_Truth_Int_et*cos(MET_Truth_Int_phi)*MET_Truth_Int_et*cos(MET_Truth_Int_phi) + MET_Truth_Int_et*sin(MET_Truth_Int_phi)*MET_Truth_Int_et*sin(MET_Truth_Int_phi)));
  // //       //m_MET_et_truth.push_back(sqrt(m_MET_x_truth[0]*m_MET_x_truth[0] + m_MET_y_truth[0]*m_MET_y_truth[0]));
  // //       //Resolution
  // //     }
  // //     if(INFO == "On"){
  // //       cout << "TruthMET() completed succesfully   " << endl;
  // //     }
  // //   }
  
}

void Background::ScalarPT(){
  
  if(NtupleType == "WZ" || NtupleType == "Thomas"){
    float scalar_sum_el = 0.;
    float scalar_sum_mu = 0.;
    float scalar_sum_jet = 0.;
    
    for(Int_t i = 0; i < (int) m_el_pt.size() ; i++){
      scalar_sum_el += m_el_pt[i];
    }
    for(Int_t i = 0; i < (int) m_mu_pt.size() ; i++){
      scalar_sum_mu += m_mu_pt[i];
    }
    for(Int_t i = 0; i < (int) m_jet_pt.size() ; i++){
      scalar_sum_jet += m_jet_pt[i];
    }
    
    if(m_MET[0] > met_Cut){
      m_cut_scalar_pt.push_back(scalar_sum_el + scalar_sum_mu + scalar_sum_jet + m_MET[0]);
      //h_cut_scalar_pt->Fill(scalar_sum_el + scalar_sum_mu + scalar_sum_jet + m_MET[0]);
    }

    m_cut_scalar_pt_no_met.push_back(scalar_sum_el + scalar_sum_mu + scalar_sum_jet);
    //h_cut_scalar_pt_no_met->Fill(scalar_sum_el + scalar_sum_mu + scalar_sum_jet);
  
  }
  
  if(INFO == "On"){
    cout << "ScalarPT() completed succesfully   " << endl;
  }
}

void Background::ReconstructW_TechniRho(){
  
  
  //COUT;
  //Find highest Pt electron or muon to reconstruct the W.
  float E_lep_E_nu_trans = 0.0;
      
  //Z --> ee
  //COUT;
  if((int) m_z_ee_pt.size() == 1){
    float ElPt = 0.0;
    float MuPt = 0.0;
    int itrEl = -1;
    int itrMu = -1; 
    for(int itr = 0 ; itr < (int) m_el_pt.size() ; itr++){
      if(itr != m_z_ee_chosen1[0] && itr != m_z_ee_chosen2[0] && m_el_number[0] >= 3){
	ElPt = m_el_pt[itr];
	itrEl = itr; 
	break;
      }
    }
    //COUT;
    //cout << "itrEl " << itrEl << endl;
    if(m_mu_number[0] > 0){
      MuPt = m_mu_pt[0];
      itrMu = 0;
    }
    //COUT;
    if(ElPt > MuPt && itrEl != -1){
      m_TR_El_E_notZ.push_back(m_el_e[itrEl]);
      m_TR_El_Px_notZ.push_back(m_el_px[itrEl]);
      m_TR_El_Py_notZ.push_back(m_el_py[itrEl]);
      m_TR_El_Pz_notZ.push_back(m_el_pz[itrEl]);
      m_TR_El_Pt_notZ.push_back(m_el_pt[itrEl]);  
      m_TR_El_Charge_notZ.push_back(m_el_charge[itrEl]);
      m_TR_El_Itr_notZ.push_back(itrEl);
    }
    //COUT;
    if(MuPt > ElPt && itrMu != -1){
      m_TR_Mu_E_notZ.push_back(m_mu_e[itrMu]);
      m_TR_Mu_Px_notZ.push_back(m_mu_px[itrMu]);
      m_TR_Mu_Py_notZ.push_back(m_mu_py[itrMu]);
      m_TR_Mu_Pz_notZ.push_back(m_mu_pz[itrMu]);
      m_TR_Mu_Pt_notZ.push_back(m_mu_pt[itrMu]);  
      m_TR_Mu_Charge_notZ.push_back(m_mu_charge[itrMu]);
      m_TR_Mu_Itr_notZ.push_back(itrMu);
    }
  }
  //COUT;
  //Z --> mumu
  if((int) m_z_mumu_pt.size() == 1){
    float ElPt = 0.0;
    float MuPt = 0.0;
    int itrEl = -1;
    int itrMu = -1; 
    for(int itr = 0 ; itr < (int) m_mu_pt.size() ; itr++){
      if(itr != m_z_mumu_chosen1[0] && itr != m_z_mumu_chosen2[0] && m_mu_number[0] >= 3){
	MuPt = m_mu_pt[itr];
	itrMu = itr;
	break;
      }
    }
    //COUT;
    if(m_el_number[0] > 0){
      ElPt = m_el_pt[0];
      itrEl = 0;
    }
    //COUT;
    if(ElPt > MuPt && itrEl != -1){
      m_TR_El_E_notZ.push_back(m_el_e[itrEl]);
      m_TR_El_Px_notZ.push_back(m_el_px[itrEl]);
      m_TR_El_Py_notZ.push_back(m_el_py[itrEl]);
      m_TR_El_Pz_notZ.push_back(m_el_pz[itrEl]);
      m_TR_El_Pt_notZ.push_back(m_el_pt[itrEl]);  
      m_TR_El_Charge_notZ.push_back(m_el_charge[itrEl]);
      m_TR_El_Itr_notZ.push_back(itrEl);
    }
    //COUT;
    if(MuPt > ElPt && itrMu != -1){
      m_TR_Mu_E_notZ.push_back(m_mu_e[itrMu]);
      m_TR_Mu_Px_notZ.push_back(m_mu_px[itrMu]);
      m_TR_Mu_Py_notZ.push_back(m_mu_py[itrMu]);
      m_TR_Mu_Pz_notZ.push_back(m_mu_pz[itrMu]);
      m_TR_Mu_Pt_notZ.push_back(m_mu_pt[itrMu]);  
      m_TR_Mu_Charge_notZ.push_back(m_mu_charge[itrMu]);
      m_TR_Mu_Itr_notZ.push_back(itrMu);
    }
    //COUT;
  }
  
  //COUT;
  //Calculate the W's 4-vector:
  //4+ Lepton case
  int W_exists = 0;
  
  if((int) m_TR_El_Pt_notZ.size() > 0){
    if(m_MET_el_z_s[m_TR_El_Itr_notZ[0]] != -1){
      float Temp_WE_p = m_TR_El_E_notZ[0] + sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] 
						 + m_MET_el_z_p[m_TR_El_Itr_notZ[0]]*m_MET_el_z_p[m_TR_El_Itr_notZ[0]]);
      float Temp_WE_n = m_TR_El_E_notZ[0] + sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] 
						 + m_MET_el_z_n[m_TR_El_Itr_notZ[0]]*m_MET_el_z_n[m_TR_El_Itr_notZ[0]]);
      float Temp_WPx = m_TR_El_Px_notZ[0] + m_MET_x[0];
      float Temp_WPy = m_TR_El_Py_notZ[0] + m_MET_y[0];
      float Temp_WPz_p = m_TR_El_Pz_notZ[0] + m_MET_el_z_p[m_TR_El_Itr_notZ[0]];
      float Temp_WPz_n = m_TR_El_Pz_notZ[0] + m_MET_el_z_n[m_TR_El_Itr_notZ[0]];
      int   Temp_WCharge = m_TR_El_Charge_notZ[0]; 

      TLorentzVector W_p;
      TLorentzVector W_n;
      W_p.SetPxPyPzE(Temp_WPx, Temp_WPy, Temp_WPz_p, Temp_WE_p);
      W_n.SetPxPyPzE(Temp_WPx, Temp_WPy, Temp_WPz_n, Temp_WE_n);
      E_lep_E_nu_trans = sqrt(m_TR_El_Px_notZ[0]*m_TR_El_Px_notZ[0] + m_TR_El_Py_notZ[0]*m_TR_El_Py_notZ[0]) 
	+ sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]); 
      float WtransMass = sqrt( E_lep_E_nu_trans*E_lep_E_nu_trans - Temp_WPx*Temp_WPx - Temp_WPy*Temp_WPy);
      if(W_p.M() > 0.0 && W_n.M() > 0.0 && WtransMass > WtransMassCut){  //May need to add fabs(W_p.Eta()) < 10.0 ...
	m_w_enu_e_p.push_back(Temp_WE_p);
	m_w_enu_e_n.push_back(Temp_WE_n);
	m_w_enu_px.push_back(Temp_WPx);
	m_w_enu_py.push_back(Temp_WPy);
	m_w_enu_pz_p.push_back(Temp_WPz_p);
	m_w_enu_pz_n.push_back(Temp_WPz_n);
	m_w_enu_pt.push_back(W_p.Pt());
	m_w_enu_phi.push_back(W_p.Phi());
	m_w_enu_eta_p.push_back(W_p.Eta());
	m_w_enu_eta_n.push_back(W_n.Eta());
	m_w_enu_charge.push_back(Temp_WCharge);
	m_w_enu_m_p.push_back(W_p.M());
	m_w_enu_m_n.push_back(W_n.M());
	m_w_enu_trans_mass.push_back(WtransMass); 
	m_w_enu_exists.push_back(m_MET_el_z_s[m_TR_El_Itr_notZ[0]]);
	W_exists = 1;
      }
    }
  }
  if((int) m_TR_Mu_Pt_notZ.size() > 0){
    if(m_MET_mu_z_s[m_TR_Mu_Itr_notZ[0]] != -1){
      float Temp_WE_p = m_TR_Mu_E_notZ[0] + sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] 
						 + m_MET_mu_z_p[m_TR_Mu_Itr_notZ[0]]*m_MET_mu_z_p[m_TR_Mu_Itr_notZ[0]]);
      float Temp_WE_n = m_TR_Mu_E_notZ[0] + sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] 
						 + m_MET_mu_z_n[m_TR_Mu_Itr_notZ[0]]*m_MET_mu_z_n[m_TR_Mu_Itr_notZ[0]]);
      float Temp_WPx = m_TR_Mu_Px_notZ[0] + m_MET_x[0];
      float Temp_WPy = m_TR_Mu_Py_notZ[0] + m_MET_y[0];
      float Temp_WPz_p = m_TR_Mu_Pz_notZ[0] + m_MET_mu_z_p[m_TR_Mu_Itr_notZ[0]];
      float Temp_WPz_n = m_TR_Mu_Pz_notZ[0] + m_MET_mu_z_n[m_TR_Mu_Itr_notZ[0]];
      int   Temp_WCharge = m_TR_Mu_Charge_notZ[0]; 
      
      TLorentzVector W_p;
      TLorentzVector W_n;
      //COUT;
      W_p.SetPxPyPzE(Temp_WPx, Temp_WPy, Temp_WPz_p, Temp_WE_p);
      W_n.SetPxPyPzE(Temp_WPx, Temp_WPy, Temp_WPz_n, Temp_WE_n);
      E_lep_E_nu_trans = sqrt(m_TR_Mu_Px_notZ[0]*m_TR_Mu_Px_notZ[0] + m_TR_Mu_Py_notZ[0]*m_TR_Mu_Py_notZ[0]) 
	+ sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]); 
      float WtransMass = sqrt( E_lep_E_nu_trans*E_lep_E_nu_trans - Temp_WPx*Temp_WPx - Temp_WPy*Temp_WPy);
      //COUT;
      if(W_p.M() > 0.0 && W_n.M() > 0.0 && WtransMass > WtransMassCut){ //May need to add fabs(W_p.Eta()) < 10.0 ...
	m_w_munu_e_p.push_back(Temp_WE_p);
	m_w_munu_e_n.push_back(Temp_WE_n);
	m_w_munu_px.push_back(Temp_WPx);
	m_w_munu_py.push_back(Temp_WPy);
	m_w_munu_pz_p.push_back(Temp_WPz_p);
	m_w_munu_pz_n.push_back(Temp_WPz_n);
	m_w_munu_pt.push_back(W_p.Pt());
	m_w_munu_phi.push_back(W_p.Phi());
	//cout << "m_w_munu_pz_p[0] " << m_w_munu_pz_p[0] << endl;
	//cout << "m_w_munu_pz_n[0] " << m_w_munu_pz_n[0] << endl;
	m_w_munu_eta_p.push_back(W_p.Eta());
	m_w_munu_eta_n.push_back(W_n.Eta());
	//COUT;
	m_w_munu_charge.push_back(Temp_WCharge);
	m_w_munu_m_p.push_back(W_p.M());
	m_w_munu_m_n.push_back(W_n.M());
	m_w_munu_trans_mass.push_back(WtransMass); 
	m_w_munu_exists.push_back(m_MET_mu_z_s[m_TR_Mu_Itr_notZ[0]]);
	W_exists = 1;
      }
    }
  }
  
  if((int) m_TR_El_Pt_notZ.size() > 0 && m_w_enu_exists.size() == 0){
    if(m_MET_el_z_s[m_TR_El_Itr_notZ[0]] == -1){
      float Temp_WE  = m_TR_El_E_notZ[0] + sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]); 
      float Temp_WPx = m_TR_El_Px_notZ[0] + m_MET_x[0];
      float Temp_WPy = m_TR_El_Py_notZ[0] + m_MET_y[0];
      float Temp_WPz = m_TR_El_Pz_notZ[0]; //No Missing pz solution
      TLorentzVector W;
      W.SetPxPyPzE(Temp_WPx, Temp_WPy, Temp_WPz, Temp_WE);
      E_lep_E_nu_trans = sqrt(m_TR_El_Px_notZ[0]*m_TR_El_Px_notZ[0] + m_TR_El_Py_notZ[0]*m_TR_El_Py_notZ[0]) 
	+ sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]); 
      float WtransMass = sqrt( E_lep_E_nu_trans*E_lep_E_nu_trans - Temp_WPx*Temp_WPx - Temp_WPy*Temp_WPy);
      int   Temp_WCharge = m_TR_El_Charge_notZ[0]; 
      if(W.M() > 0.0 && WtransMass > WtransMassCut){ //May need to add fabs(W_p.Eta()) < 10.0 ...
	m_w_enu_e_n.push_back(Temp_WE);
	m_w_enu_px.push_back(Temp_WPx);
	m_w_enu_py.push_back(Temp_WPy);
	m_w_enu_pz_n.push_back(Temp_WPz);
	m_w_enu_pt.push_back(W.Pt());
	m_w_enu_phi.push_back(W.Phi());
	m_w_enu_eta_n.push_back(W.Eta());
	m_w_enu_charge.push_back(Temp_WCharge);
	m_w_enu_m_n.push_back(W.M());
	m_w_enu_trans_mass.push_back(WtransMass); 
	m_w_enu_exists.push_back(-1);
      }
    }
  }
  if((int) m_TR_Mu_Pt_notZ.size() > 0 && m_w_munu_exists.size() == 0){
    if(m_MET_mu_z_s[m_TR_Mu_Itr_notZ[0]] == -1){
      float Temp_WE  = m_TR_Mu_E_notZ[0] + sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]); 
      float Temp_WPx = m_TR_Mu_Px_notZ[0] + m_MET_x[0];
      float Temp_WPy = m_TR_Mu_Py_notZ[0] + m_MET_y[0];
      float Temp_WPz = m_TR_Mu_Pz_notZ[0]; //No Missing pz solution
      TLorentzVector W;
      W.SetPxPyPzE(Temp_WPx, Temp_WPy, Temp_WPz, Temp_WE);
      E_lep_E_nu_trans = sqrt(m_TR_Mu_Px_notZ[0]*m_TR_Mu_Px_notZ[0] + m_TR_Mu_Py_notZ[0]*m_TR_Mu_Py_notZ[0]) 
	+ sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]); 
      float WtransMass = sqrt( E_lep_E_nu_trans*E_lep_E_nu_trans - Temp_WPx*Temp_WPx - Temp_WPy*Temp_WPy);
      int   Temp_WCharge = m_TR_Mu_Charge_notZ[0]; 
      if(W.M() > 0.0 && WtransMass > WtransMassCut){ //May need to add fabs(W_p.Eta()) < 10.0 ...
	m_w_munu_e_n.push_back(Temp_WE);
	m_w_munu_px.push_back(Temp_WPx);
	m_w_munu_py.push_back(Temp_WPy);
	m_w_munu_pz_n.push_back(Temp_WPz);
	m_w_munu_pt.push_back(W.Pt());
	m_w_munu_phi.push_back(W.Phi());
	m_w_munu_eta_n.push_back(W.Eta());
	m_w_munu_charge.push_back(Temp_WCharge);
	m_w_munu_m_n.push_back(W.M());
	m_w_munu_trans_mass.push_back(WtransMass); 
	m_w_munu_exists.push_back(-1);
      }
    }
  }

  //COUT;
  //TR W transverse mass
  if(W_exists == 1){
    //COUT;
    w_cut_passed[0] += 1.;
    //W cut flow
    if((int) m_w_enu_pt.size() != 0){
      if(m_w_enu_trans_mass[0] >= WtransMassCut){
	w_cut_passed[1] += 1.;
      }
      if((int) m_z_ee_e.size() > 0 || (int) m_z_mumu_e.size() > 0){
	w_cut_passed[2] += 1.;
      }
    }
    if((int) m_w_munu_pt.size() != 0){
      if(m_w_munu_trans_mass[0] >= WtransMassCut){
	w_cut_passed[1] += 1.;
      }
      if((int) m_z_ee_e.size() > 0 || (int) m_z_mumu_e.size() > 0){
	w_cut_passed[2] += 1.;
      }
    }
    //COUT;
  }

  
  /*  if(El_chosenW > -1 && m_TR_El_Pt_notZ[0] > m_TR_Mu_Pt_notZ[0] && m_Det_El[El_chosenW] >= 0.0 && (int) m_el_charge[El_chosenW] != 0 ){
      UnderSqrt_El_p = MassEl*MassEl + 2*( m_TR_El_E_notZ[0]*(sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_el_z_p[El_chosenW]*m_MET_el_z_p[El_chosenW])) 
      - m_TR_El_Px_notZ[0]*m_MET_x[0] - m_TR_El_Py_notZ[0]*m_MET_y[0] - m_TR_El_Pz_notZ[0]*m_MET_el_z_p[El_chosenW] );
      UnderSqrt_El_n = MassEl*MassEl + 2*( m_TR_El_E_notZ[0]*(sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_el_z_n[El_chosenW]*m_MET_el_z_n[El_chosenW])) 
      - m_TR_El_Px_notZ[0]*m_MET_x[0] - m_TR_El_Py_notZ[0]*m_MET_y[0] - m_TR_El_Pz_notZ[0]*m_MET_el_z_n[El_chosenW] );
      if(UnderSqrt_El_p >= 0.0){
      checkMW_El_p = sqrt(UnderSqrt_El_p);
      }
      if(UnderSqrt_El_n){
      checkMW_El_n = sqrt(UnderSqrt_El_n);
      }
      if(checkMW_El_p >= 0.0){
      m_checkMassW_El.push_back(checkMW_El_p);
      }
      if(checkMW_El_n >= 0.0){
      m_checkMassW_El.push_back(checkMW_El_n);
      }
      }
      if(Mu_chosenW > -1 && m_TR_El_Pt_notZ[0] < m_TR_Mu_Pt_notZ[0] && m_Det_Mu[Mu_chosenW] >= 0.0 && (int) m_mu_charge[Mu_chosenW] != 0 ){
      UnderSqrt_Mu_p = MassMu*MassMu + 2*( m_TR_Mu_E_notZ[0]*(sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_mu_z_p[Mu_chosenW]*m_MET_mu_z_p[Mu_chosenW]))
      - m_TR_Mu_Px_notZ[0]*m_MET_x[0] - m_TR_Mu_Py_notZ[0]*m_MET_y[0] - m_TR_Mu_Pz_notZ[0]*m_MET_mu_z_p[Mu_chosenW] );
      UnderSqrt_Mu_n = MassMu*MassMu + 2*( m_TR_Mu_E_notZ[0]*(sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_mu_z_n[Mu_chosenW]*m_MET_mu_z_n[Mu_chosenW]))
      - m_TR_Mu_Px_notZ[0]*m_MET_x[0] - m_TR_Mu_Py_notZ[0]*m_MET_y[0] - m_TR_Mu_Pz_notZ[0]*m_MET_mu_z_n[Mu_chosenW] );
      //cout << "UnderSqrt_Mu_p   " << UnderSqrt_Mu_p << endl;
      //cout << "UnderSqrt_Mu_n   " << UnderSqrt_Mu_n << endl;
      if(UnderSqrt_Mu_p >= 0.0){
      checkMW_Mu_p = sqrt(UnderSqrt_Mu_p);
      }
      if(UnderSqrt_Mu_n >= 0.0){
      checkMW_Mu_n = sqrt(UnderSqrt_Mu_n);
      }
      if(checkMW_Mu_p >= -1.0){
      m_checkMassW_Mu.push_back(checkMW_Mu_p);
      }
      if(checkMW_Mu_n >= -1.0){
      m_checkMassW_Mu.push_back(checkMW_Mu_n);
      }
      }*/
  //cout << "checkMW_El_n  " << checkMW_El_n << endl;
   
  if(INFO == "On"){
    cout << "ReconstructW_TechniRho() completed succesfully   " << endl;
  }
  
}

void Background::ReconstructW_HVLquark_CompLepton(){
  
  //The number of electrons and muons are proportional to m_el_number and m_mu_number, which are themselves proportional to the number of electrons/muons that pass the cuts of the functions ProcessElectrons() and ProcessMuons(). 
  
  int LeptonChosen_El = 0;
  int LeptonChosen_Mu = 0;
  float ElE     = 0.0;
  float ElPx    = 0.0;
  float ElPy    = 0.0;
  float ElPz    = 0.0;
  float ElPt    = 0.0; 
  int ElQuality = 0;
  int ElCharge  = 0;
  int ElChosen  = -1;
  float MuE     = 0.0;
  float MuPx    = 0.0;
  float MuPy    = 0.0;
  float MuPz    = 0.0;
  float MuPt    = 0.0;
  int MuCharge  = 0;
  int MuChosen  = -1;
      
  float LeptonChosenE = 0.0;
  float LeptonChosenPx = 0.0;
  float LeptonChosenPy = 0.0;
  float LeptonChosenPz = 0.0;
  float LeptonChosenPt = 0.0;  
  int LeptonChosenCharge = 0;
  int LeptonChosenQuality = 0;

  float checkMW_El_p = -1.0;
  float checkMW_El_n = -1.0;
  float checkMW_Mu_p = -1.0;
  float checkMW_Mu_n = -1.0;
  float UnderSqrt_El_p = -1.0;
  float UnderSqrt_El_n = -1.0;
  float UnderSqrt_Mu_p = -1.0;
  float UnderSqrt_Mu_n = -1.0;
            
  if( (int) m_el_pt.size() > 0){
    for(int itr = 0 ; itr < (int) m_el_pt.size() ; itr++){ 
     //COUT;
      if(m_el_quality[itr] >= w_el_quality  /*medium*/ && (m_MET_el_z_s[itr] == 1 || m_MET_el_z_s[itr] == 0) ){
	ElE = m_el_e[itr];
	ElPx = m_el_px[itr];
	ElPy = m_el_py[itr];
	ElPz = m_el_pz[itr];
	ElPt = m_el_pt[itr];
	ElCharge = (int) m_el_charge[itr];
	ElQuality = m_el_quality[itr];
	m_el_w_chosen.push_back(itr);
	ElChosen = itr;
	break;
      }
    }
  }
 //COUT;
  if( (int) m_mu_pt.size() > 0){
    for(int itr = 0 ; itr < (int) m_mu_pt.size() ; itr++){
      if(m_mu_quality[itr] > 2 /*tight*/ && (m_MET_mu_z_s[itr] == 1 || m_MET_mu_z_s[itr] == 0) ){
	MuE = m_mu_e[itr];
	MuPx = m_mu_px[itr];
	MuPy = m_mu_py[itr];
	MuPz = m_mu_pz[itr];
	MuPt = m_mu_pt[itr];
	MuCharge = m_mu_charge[itr];
	m_mu_w_chosen.push_back(itr);
	MuChosen = itr;
	break;
      }
    }
  }
 //COUT;
  if( ElChosen != -1 && MuChosen == -1  && ElPt > 0.0){
    LeptonChosenE = ElE;
    LeptonChosenPx = ElPx;
    LeptonChosenPy = ElPy; 
    LeptonChosenPz = ElPz;
    LeptonChosenPt = ElPt;
    LeptonChosenCharge = ElCharge;
    LeptonChosenQuality = ElQuality; 
    LeptonChosen_El = 1;
  }
  if( ElChosen == -1 && MuChosen != -1  && MuPt > 0.0){
    LeptonChosenE = MuE;
    LeptonChosenPx = MuPx;
    LeptonChosenPy = MuPy; 
    LeptonChosenPz = MuPz;
    LeptonChosenPt = MuPt;
    LeptonChosenCharge = MuCharge;
    LeptonChosen_Mu = 1;
  }
      
  if( ElChosen != -1 && MuChosen != -1  && ( (m_MET_el_z_s[ElChosen] == 1 && m_MET_mu_z_s[MuChosen] == 1) || (m_MET_el_z_s[ElChosen] == 0 && m_MET_mu_z_s[MuChosen] == 0) ) ){
    if(  ElPt >  MuPt){               //Picking lepton with highest Pt.
      LeptonChosenE = ElE;
      LeptonChosenPx = ElPx;
      LeptonChosenPy = ElPy;
      LeptonChosenPz = ElPz;
      LeptonChosenPt = ElPt;
      LeptonChosenCharge = ElCharge;
      LeptonChosenQuality = ElQuality;
      LeptonChosen_El = 1;
    }
    if( MuPt > ElPt ){
      LeptonChosenE = MuE;
      LeptonChosenPx = MuPx;
      LeptonChosenPy = MuPy;
      LeptonChosenPz = MuPz;
      LeptonChosenPt = MuPt;
      LeptonChosenCharge = MuCharge;
      LeptonChosen_Mu = 1;
    }
  }
  if( ElChosen != -1 && MuChosen != -1 && ((m_MET_el_z_s[ElChosen] != 1 && m_MET_mu_z_s[MuChosen] == 1) || (m_MET_el_z_s[ElChosen] == -1 && m_MET_mu_z_s[MuChosen] == 0)) ){
    LeptonChosenE = MuE;
    LeptonChosenPx = MuPx;
    LeptonChosenPy = MuPy;
    LeptonChosenPz = MuPz;
    LeptonChosenPt = MuPt;
    LeptonChosenCharge = MuCharge;
    LeptonChosen_Mu = 1;
  }
  if( ElChosen != -1 && MuChosen != -1 && ((m_MET_mu_z_s[MuChosen] != 1 && m_MET_el_z_s[ElChosen] == 1) || (m_MET_mu_z_s[MuChosen] == -1 && m_MET_el_z_s[ElChosen] == 0)) ){
    LeptonChosenE = ElE;
    LeptonChosenPx = ElPx;
    LeptonChosenPy = ElPy;
    LeptonChosenPz = ElPz;
    LeptonChosenPt = ElPt;
    LeptonChosenCharge = ElCharge;
    LeptonChosenQuality = ElQuality;
    LeptonChosen_El = 1;
  }

 //COUT;
  //No good lepton... Do Nothing.
  //cout << "LeptonChosen_El " << LeptonChosen_El << endl;
  //cout << "LeptonChosen_Mu " << LeptonChosen_Mu << endl;  
  //cout << "m_MET[0]  " << m_MET[0] << endl;
  //cout << "ElChosen  " << ElChosen << endl;
  //cout << "MuChosen  " << MuChosen << endl;  
  //cout << "m_MET_mu_z_s[MuChosen] " << m_MET_mu_z_s[MuChosen] << endl;
  //cout << "LeptonChosenPt  " << LeptonChosenPt << endl;

    
  if(LeptonChosen_El == 1 && m_MET[0] > met_Cut){    
   //COUT;
    TLorentzVector W_p;
    TLorentzVector W_n;
    W_p.SetPxPyPzE(LeptonChosenPx + m_MET_x[0], LeptonChosenPy + m_MET_y[0], LeptonChosenPz + m_MET_el_z_p[ElChosen], 
		   LeptonChosenE + sqrt(m_MET_x[0]*m_MET_x[0] +  m_MET_y[0]*m_MET_y[0] + m_MET_el_z_p[ElChosen]*m_MET_el_z_p[ElChosen]));
    W_n.SetPxPyPzE(LeptonChosenPx + m_MET_x[0], LeptonChosenPy + m_MET_y[0], LeptonChosenPz + m_MET_el_z_n[ElChosen], 
		   LeptonChosenE + sqrt(m_MET_x[0]*m_MET_x[0] +  m_MET_y[0]*m_MET_y[0] + m_MET_el_z_n[ElChosen]*m_MET_el_z_n[ElChosen]));
    float E_lep_E_nu_trans = sqrt(LeptonChosenPx*LeptonChosenPx + LeptonChosenPy*LeptonChosenPy) + sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]);
    float WtransMass = sqrt( E_lep_E_nu_trans*E_lep_E_nu_trans - W_p.Px()*W_p.Px() - W_p.Py()*W_p.Py());
    //cout << "W_p.M()  " << W_p.M()  << endl;
    if(W_p.M() > 0.0 && W_n.M() > 0.0){
      m_w_enu_e_p.push_back(W_p.E());
      m_w_enu_e_n.push_back(W_n.E());
      m_w_enu_px.push_back(W_p.Px());
      m_w_enu_py.push_back(W_p.Py());
      m_w_enu_pz_p.push_back(W_p.Pz());
      m_w_enu_pz_n.push_back(W_n.Pz());
      m_w_enu_pt.push_back(W_p.Pt());
      m_w_enu_phi.push_back(W_p.Phi());
     //COUT;
      m_w_enu_eta_p.push_back(W_p.Eta());
      m_w_enu_eta_n.push_back(W_n.Eta());
      m_w_enu_charge.push_back(LeptonChosenCharge);
      m_w_enu_exists.push_back(1);
      m_w_enu_trans_mass.push_back(WtransMass);
      m_w_enu_m_p.push_back(W_p.M());
      m_w_enu_m_n.push_back(W_n.M());
      //h_w_trans_mass->Fill(WtransMass);
      m_w_enu_quality.push_back(LeptonChosenQuality);
      UnderSqrt_El_p = MassEl*MassEl + 2*( LeptonChosenE*(sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_el_z_p[ElChosen]*m_MET_el_z_p[ElChosen])) 
					   - LeptonChosenPx*m_MET_x[0] - LeptonChosenPy*m_MET_y[0] - LeptonChosenPz*m_MET_el_z_p[ElChosen] );
      UnderSqrt_El_n = MassEl*MassEl + 2*( LeptonChosenE*(sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_el_z_n[ElChosen]*m_MET_el_z_n[ElChosen])) 
					   - LeptonChosenPx*m_MET_x[0] - LeptonChosenPy*m_MET_y[0] - LeptonChosenPz*m_MET_el_z_n[ElChosen] );
      if(UnderSqrt_El_p >= 0.0){
	checkMW_El_p = sqrt(UnderSqrt_El_p);
      }
      if(UnderSqrt_El_n >= 0.0){
	checkMW_El_n = sqrt(UnderSqrt_El_n);
      }
      if(checkMW_El_p >= 0.0){
	m_checkMassW_El.push_back(checkMW_El_p);
      }
      if(checkMW_El_n >= 0.0){
	m_checkMassW_El.push_back(checkMW_El_n);
      }
    }
  }
 //COUT;
  if(LeptonChosen_Mu == 1 && m_MET[0] > met_Cut){    
   //COUT;
    TLorentzVector W_p;
    TLorentzVector W_n;
    W_p.SetPxPyPzE(LeptonChosenPx + m_MET_x[0], LeptonChosenPy + m_MET_y[0], LeptonChosenPz + m_MET_mu_z_p[MuChosen], 
		   LeptonChosenE + sqrt(m_MET_x[0]*m_MET_x[0] +  m_MET_y[0]*m_MET_y[0] + m_MET_mu_z_p[MuChosen]*m_MET_mu_z_p[MuChosen]));
    W_n.SetPxPyPzE(LeptonChosenPx + m_MET_x[0], LeptonChosenPy + m_MET_y[0], LeptonChosenPz + m_MET_mu_z_n[MuChosen], 
		   LeptonChosenE + sqrt(m_MET_x[0]*m_MET_x[0] +  m_MET_y[0]*m_MET_y[0] + m_MET_mu_z_n[MuChosen]*m_MET_mu_z_n[MuChosen]));
    float E_lep_E_nu_trans = sqrt(LeptonChosenPx*LeptonChosenPx + LeptonChosenPy*LeptonChosenPy) + sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]);
    float WtransMass = sqrt( E_lep_E_nu_trans*E_lep_E_nu_trans - W_p.Px()*W_p.Px() - W_p.Py()*W_p.Py());
   //COUT;
    if(W_p.M() > 0.0 && W_n.M() > 0.0){
      m_w_munu_e_p.push_back(W_p.E());
      m_w_munu_e_n.push_back(W_n.E());
      m_w_munu_px.push_back(W_p.Px());
      m_w_munu_py.push_back(W_p.Py());
      m_w_munu_pz_p.push_back(W_p.Pz());
      m_w_munu_pz_n.push_back(W_n.Pz());
      m_w_munu_pt.push_back(W_p.Pt());
      m_w_munu_phi.push_back(W_p.Phi());
     //COUT;
      m_w_munu_eta_p.push_back(W_p.Eta());
      m_w_munu_eta_n.push_back(W_n.Eta());
      m_w_munu_charge.push_back(LeptonChosenCharge);
      m_w_munu_exists.push_back(1);
      m_w_munu_m_p.push_back(W_p.M());
      m_w_munu_m_n.push_back(W_n.M());
     //COUT;
      m_w_munu_trans_mass.push_back(WtransMass);
      //h_w_trans_mass->Fill(WtransMass);
      m_w_munu_quality.push_back(LeptonChosenQuality);
      UnderSqrt_Mu_p = MassMu*MassMu + 2*( LeptonChosenE*(sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_mu_z_p[MuChosen]*m_MET_mu_z_p[MuChosen])) 
					   - LeptonChosenPx*m_MET_x[0] - LeptonChosenPy*m_MET_y[0] - LeptonChosenPz*m_MET_mu_z_p[MuChosen] );
      UnderSqrt_Mu_n = MassMu*MassMu + 2*( LeptonChosenE*(sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_mu_z_n[MuChosen]*m_MET_mu_z_n[MuChosen])) 
					   - LeptonChosenPx*m_MET_x[0] - LeptonChosenPy*m_MET_y[0] - LeptonChosenPz*m_MET_mu_z_n[MuChosen] );
      if(UnderSqrt_Mu_p >= 0.0){
	checkMW_Mu_p = sqrt(UnderSqrt_Mu_p);
      }
      if(UnderSqrt_Mu_n >= 0.0){
	checkMW_Mu_n = sqrt(UnderSqrt_Mu_n);
      }
      if(checkMW_Mu_p >= 0.0){
	m_checkMassW_Mu.push_back(checkMW_Mu_p);
      }
      if(checkMW_Mu_n >= 0.0){
	m_checkMassW_Mu.push_back(checkMW_Mu_n);
      }
    }
  }
  //COUT;
  if((int) m_w_enu_exists.size() == 0){
    //COUT;
    m_w_enu_exists.push_back(0);
    //COUT;
  }
  if((int) m_w_munu_exists.size() == 0){
    //COUT;
    m_w_munu_exists.push_back(0);
    //COUT;
  }
  //COUT;
  //W cut flow
  if(m_w_enu_exists[0] == 1 || m_w_munu_exists[0] == 1){
    w_cut_passed[0] += 1.;
    if(m_w_enu_exists[0] == 1){
      if(m_w_enu_trans_mass[0] > WtransMassCut ){
	w_cut_passed[1] += 1.;
      }
    }
    if(m_w_munu_exists[0] == 1){
      if(m_w_munu_trans_mass[0] > WtransMassCut){
	w_cut_passed[1] += 1.;
      }
    }
  }
  
  if(INFO == "On"){
    cout << "ReconstructW_HVLquark_CompLepton() completed succesfully   " << endl;
  }
  
}



void Background::Truth_W_and_Z(){

  if(InputType == "MC"){
    for( int itr = 0 ; itr < (int) (*mc_pdgId).size() ; itr++){
      if( fabs((*mc_pdgId)[itr]) == 24 && fabs((*mc_barcode)[itr]) < 200000){
	COUT;
	TLorentzVector W;
	W.SetPtEtaPhiM((*mc_pt)[itr], (*mc_eta)[itr], (*mc_phi)[itr], (*mc_m)[itr]);
	m_w_e_truth.push_back(W.E());
	m_w_pt_truth.push_back(W.Pt());
	m_w_eta_truth.push_back(W.Eta());
	m_w_phi_truth.push_back(W.Phi());
	m_w_charge_truth.push_back((int) (*mc_charge)[itr]);
	break;
      }
    }
    for( int itr = 0 ; itr < (int) (*mc_pdgId).size() ; itr++){
      if(fabs((*mc_pdgId)[itr]) == 23 && (*mc_barcode)[itr] < 200000){
	TLorentzVector Z;
	Z.SetPtEtaPhiM((*mc_pt)[itr], (*mc_eta)[itr], (*mc_phi)[itr], (*mc_m)[itr]);
	m_z_e_truth.push_back(Z.E());
	m_z_pt_truth.push_back(Z.Pt());
	m_z_eta_truth.push_back(Z.Eta());
	m_z_phi_truth.push_back(Z.Phi());
	break;
      }
    }
  }
  if(INFO == "On"){
    cout << "Truth_W_and_Z() completed succesfully   " << endl;
  }
}

void Background::ReconsWjetMass(){

  TLorentzVector Wenu_pj;
  TLorentzVector Wenu_nj;
  TLorentzVector Wmunu_pj;
  TLorentzVector Wmunu_nj;
  float HVLquark_Mass_trans = 0.0;
  float WET = 0.0;
  float JetEt = 0.0;
  
  int nJets = (int) m_jet_pt.size();
  
  if((int) m_w_enu_pt.size() > 0 && m_jet_number[0] >= 1){
    TLorentzVector W_p;
    TLorentzVector W_n;
    
    TLorentzVector JET[nJets];
    //Looping over jets 
    for(int itr = 0; itr < (int) m_jet_pt.size() ; itr++){
      (JET[itr]).SetPtEtaPhiE(m_jet_pt[itr], m_jet_eta[itr], m_jet_phi[itr], m_jet_e[itr]);
    }
    
    //Defining the two possible W 4-vectors   
    W_p.SetPtEtaPhiM(m_w_enu_pt[0], m_w_enu_eta_p[0], m_w_enu_phi[0], m_w_enu_m_p[0]);
    W_n.SetPtEtaPhiM(m_w_enu_pt[0], m_w_enu_eta_n[0], m_w_enu_phi[0], m_w_enu_m_n[0]);
    
    //Defining the 'VLQ' invariant mass 
    Wenu_pj = W_p + JET[0];
    Wenu_nj = W_n + JET[0];
    
    //For transverse mass calculation
    WET = sqrt(MassW*MassW + m_w_enu_pt[0]*m_w_enu_pt[0]);
    JetEt = m_jet_pt[0];
    HVLquark_Mass_trans = sqrt((WET + JetEt)*(WET + JetEt) - (m_w_enu_px[0] + (JET[0]).Px())*(m_w_enu_px[0] + (JET[0]).Px()) - (m_w_enu_py[0] + (JET[0]).Py())*(m_w_enu_py[0] + (JET[0]).Py()));  
    
    //Push back all 
    m_HQ_inv_mass_p_n.push_back(Wenu_pj.M());
    m_HQ_inv_mass_p_n.push_back(Wenu_nj.M());
    m_HQ_inv_mass_p.push_back(Wenu_pj.M());
    m_HQ_inv_mass_n.push_back(Wenu_nj.M());
    m_HQ_inv_mass_w_enu_p_n.push_back(Wenu_pj.M());
    m_HQ_inv_mass_w_enu_p_n.push_back(Wenu_nj.M());
    m_HQ_inv_mass_w_enu_p.push_back(Wenu_pj.M());
    m_HQ_inv_mass_w_enu_n.push_back(Wenu_nj.M());
    m_HQ_trans_mass_w_enu.push_back(HVLquark_Mass_trans);
    m_HQ_trans_mass.push_back(HVLquark_Mass_trans);
  }

  if((int) m_w_munu_pt.size() > 0 && m_jet_number[0] >= 1){
    TLorentzVector W_p;
    TLorentzVector W_n;
    
    TLorentzVector JET[nJets];
    //Looping over jets 
    for(int itr = 0; itr < (int) m_jet_pt.size() ; itr++){
      (JET[itr]).SetPtEtaPhiE(m_jet_pt[itr], m_jet_eta[itr], m_jet_phi[itr], m_jet_e[itr]);
    }
    
    //Defining the two possible W 4-vectors   
    W_p.SetPtEtaPhiM(m_w_munu_pt[0], m_w_munu_eta_p[0], m_w_munu_phi[0], m_w_munu_m_p[0]);
    W_n.SetPtEtaPhiM(m_w_munu_pt[0], m_w_munu_eta_n[0], m_w_munu_phi[0], m_w_munu_m_n[0]);
    
    //Defining the 'VLQ' invariant mass 
    Wmunu_nj = W_n + JET[0];
    Wmunu_pj = W_p + JET[0];
    
    //For transmass calculation calculation 
    WET = sqrt(MassW*MassW + m_w_munu_pt[0]*m_w_munu_pt[0]);
    JetEt = m_jet_pt[0]; 
    HVLquark_Mass_trans = sqrt((WET + JetEt)*(WET + JetEt) - (m_w_munu_px[0] + (JET[0]).Px())*(m_w_munu_px[0] + (JET[0]).Px()) - (m_w_munu_py[0] + (JET[0]).Py())*(m_w_munu_py[0] + (JET[0]).Py()));   
    
    m_HQ_inv_mass_p_n.push_back(Wmunu_pj.M());
    m_HQ_inv_mass_p_n.push_back(Wmunu_nj.M());
    m_HQ_inv_mass_p.push_back(Wmunu_pj.M());
    m_HQ_inv_mass_n.push_back(Wmunu_nj.M());
    m_HQ_inv_mass_w_munu_p_n.push_back(Wmunu_pj.M());
    m_HQ_inv_mass_w_munu_p_n.push_back(Wmunu_nj.M());
    m_HQ_inv_mass_w_munu_p.push_back(Wmunu_pj.M());
    m_HQ_inv_mass_w_munu_n.push_back(Wmunu_nj.M());
    m_HQ_trans_mass_w_munu.push_back(HVLquark_Mass_trans);
    m_HQ_trans_mass.push_back(HVLquark_Mass_trans);
  
  }
  
  /////////////////////////////////////////////////
  //Cut variables associated with the Wjet mass
  ////////////////////////////////////////////////
  
  if(m_lep_number[0] == 1){
    int isW = 0;
    int isW_enu = 0;
    int isW_munu = 0;
    float Jeta = 0.0;
    TLorentzVector W_p;
    TLorentzVector W_n;
    TLorentzVector MET_p;
    TLorentzVector MET_n;
    TLorentzVector Lep;
    if((int) m_w_enu_pt.size() > 0){ //For HQ w_enu_pt.size() or w_munu_pt.size() == 0 
      isW_enu = 1;
      isW = 1;
      W_p.SetPxPyPzE(m_w_enu_px[0], m_w_enu_py[0], m_w_enu_pz_p[0], m_w_enu_e_p[0]); 
      W_n.SetPxPyPzE(m_w_enu_px[0], m_w_enu_py[0], m_w_enu_pz_n[0], m_w_enu_e_n[0]); 
      MET_p.SetPxPyPzE(m_MET_x[0], m_MET_y[0], m_MET_el_z_p[m_el_w_chosen[0]], sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_el_z_p[m_el_w_chosen[0]]*m_MET_el_z_p[m_el_w_chosen[0]]));  
      MET_n.SetPxPyPzE(m_MET_x[0], m_MET_y[0], m_MET_el_z_n[m_el_w_chosen[0]], sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_el_z_n[m_el_w_chosen[0]]*m_MET_el_z_n[m_el_w_chosen[0]]));  
      Lep.SetPtEtaPhiE(m_el_pt[m_el_w_chosen[0]], m_el_eta[m_el_w_chosen[0]], m_el_phi[m_el_w_chosen[0]], m_el_e[m_el_w_chosen[0]]);
    }
    if(isW_enu == 1){
      cout << "m_w_enu_pz_n[0] " << m_w_enu_pz_n[0] << endl;
    }

    if((int) m_w_munu_pt.size() > 0){
      isW_munu = 1;
      isW = 1;
      W_p.SetPxPyPzE(m_w_munu_px[0], m_w_munu_py[0], m_w_munu_pz_p[0], m_w_munu_e_p[0]); 
      W_n.SetPxPyPzE(m_w_munu_px[0], m_w_munu_py[0], m_w_munu_pz_n[0], m_w_munu_e_n[0]); 
      MET_p.SetPxPyPzE(m_MET_x[0], m_MET_y[0], m_MET_mu_z_p[m_mu_w_chosen[0]], sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_mu_z_p[m_mu_w_chosen[0]]*m_MET_mu_z_p[m_mu_w_chosen[0]]));  
      MET_n.SetPxPyPzE(m_MET_x[0], m_MET_y[0], m_MET_mu_z_n[m_mu_w_chosen[0]], sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0] + m_MET_mu_z_n[m_mu_w_chosen[0]]*m_MET_mu_z_n[m_mu_w_chosen[0]]));
      Lep.SetPtEtaPhiE(m_mu_pt[m_mu_w_chosen[0]], m_mu_eta[m_mu_w_chosen[0]], m_mu_phi[m_mu_w_chosen[0]], m_mu_e[m_mu_w_chosen[0]]);
    }
    if(isW_munu == 1){
      cout << "m_w_munu_pz_n[0] " << m_w_munu_pz_n[0] << endl;
    }

    if(m_jet_number[0] >= 1 && isW == 1){
     
      TLorentzVector JET[nJets];
      //Looping over jets 
      for(int itr = 0; itr < (int) m_jet_pt.size() ; itr++){
	(JET[itr]).SetPtEtaPhiE(m_jet_pt[itr], m_jet_eta[itr], m_jet_phi[itr], m_jet_e[itr]);
      }      
      
      //Lepton and MET      
      m_cut_delta_eta_lep_nu_p.push_back(fabs(Lep.Eta() - MET_p.Eta())); 
      m_cut_delta_eta_lep_nu_n.push_back(fabs(Lep.Eta() - MET_n.Eta())); 
      m_cut_delta_eta_lep_nu_p_n.push_back(fabs(Lep.Eta() - MET_p.Eta())); 
      m_cut_delta_eta_lep_nu_p_n.push_back(fabs(Lep.Eta() - MET_n.Eta()));
      float DPhiLepMET = fabs(Lep.Phi() - MET_p.Phi()); //MET_p and MET_n have same phi
      if(DPhiLepMET > 3.141595426){
	DPhiLepMET = 2*3.141592654 - DPhiLepMET;
      }
      m_cut_delta_phi_lep_nu.push_back(DPhiLepMET);
      
      //Lepton and Leading jet
      m_cut_delta_eta_lep_j1.push_back(fabs(Lep.Eta() - (JET[0]).Eta()));
      float DPhiLepJ1 = fabs(Lep.Phi() - (JET[0]).Phi());
      if(DPhiLepJ1 > 3.141595426){
	DPhiLepJ1 = 2*3.141592654 - DPhiLepJ1;
      }
      m_cut_delta_phi_lep_j1.push_back(DPhiLepJ1);

      //W and Leading Jet
      m_cut_delta_eta_w_j1_p.push_back(fabs(W_p.Eta() - (JET[0]).Eta()));
      m_cut_delta_eta_w_j1_n.push_back(fabs(W_n.Eta() - (JET[0]).Eta()));
      m_cut_delta_eta_w_j1_p_n.push_back(fabs(W_p.Eta() - (JET[0]).Eta()));
      m_cut_delta_eta_w_j1_p_n.push_back(fabs(W_n.Eta() - (JET[0]).Eta()));
      float DPhiWJ1 = fabs(W_p.Phi() - (JET[0]).Phi());
      if(DPhiWJ1 > 3.141595426){
	DPhiWJ1 = 2*3.141592654 - DPhiWJ1;
      }
      m_cut_delta_phi_w_j1.push_back(DPhiWJ1);	
      

      //JET and JET
      if(m_jet_number[0] >= 2){
	int second_jet = 1;
	for(int itr = 1 ; itr < (int) m_jet_pt.size() ; itr++){
	  if(fabs( (JET[0]).Eta() - (JET[itr]).Eta() ) > Jeta){
	    Jeta = fabs( (JET[0]).Eta() - (JET[itr]).Eta() );
	    second_jet = itr;
	  }
	}
	m_cut_delta_eta_j1_j2.push_back(Jeta);
        float DPhiJ1J2 = fabs((JET[0]).Phi() - (JET[second_jet]).Phi());
        if(DPhiJ1J2 > 3.141595426){
          DPhiJ1J2 = 2*3.141592654 - DPhiJ1J2;
        }
        m_cut_delta_phi_j1_j2.push_back(DPhiJ1J2);
	
	//W and associated Jet
	m_cut_delta_eta_w_j2_p.push_back(fabs(W_p.Eta() - (JET[second_jet]).Eta()));
	m_cut_delta_eta_w_j2_n.push_back(fabs(W_n.Eta() - (JET[second_jet]).Eta()));
	m_cut_delta_eta_w_j2_p_n.push_back(fabs(W_p.Eta() - (JET[second_jet]).Eta()));
	m_cut_delta_eta_w_j2_p_n.push_back(fabs(W_n.Eta() - (JET[second_jet]).Eta()));
	float DPhiWJ2 = fabs(W_p.Phi() - (JET[second_jet]).Phi());
	if(DPhiWJ2 > 3.141595426){
	  DPhiWJ2 = 2*3.141592654 - DPhiWJ2;
	}
	m_cut_delta_phi_w_j2.push_back(DPhiWJ2);	
	
	//MET and associated jet
	m_cut_delta_eta_nu_j2_p.push_back(fabs(MET_p.Eta() - (JET[second_jet]).Eta()));
	m_cut_delta_eta_nu_j2_n.push_back(fabs(MET_n.Eta() - (JET[second_jet]).Eta()));
	m_cut_delta_eta_nu_j2_p_n.push_back(fabs(MET_p.Eta() - (JET[second_jet]).Eta()));
	m_cut_delta_eta_nu_j2_p_n.push_back(fabs(MET_n.Eta() - (JET[second_jet]).Eta()));
	float DPhiMETJ2 = fabs(MET_p.Phi() - (JET[second_jet]).Phi());
	if(DPhiMETJ2 > 3.141595426){
	  DPhiMETJ2 = 2*3.141592654 - DPhiMETJ2;
	}
	m_cut_delta_phi_nu_j2.push_back(DPhiMETJ2);

	m_cut_delta_eta_lep_j2.push_back(fabs(Lep.Eta() - (JET[second_jet]).Eta()));
	float DPhiLepJ2 = fabs(Lep.Phi() - (JET[second_jet]).Phi());
	if(DPhiLepJ1 > 3.141595426){
	  DPhiLepJ1 = 2*3.141592654 - DPhiLepJ2;
	}
	m_cut_delta_phi_lep_j2.push_back(DPhiLepJ2);
      
	float VectorSum_lnujj_p = 0.0;
	float VectorSum_lnujj_n = 0.0;
	VectorSum_lnujj_p = sqrt((W_p.Px() + (JET[0]).Px() + (JET[second_jet]).Px())*(W_p.Px() + (JET[0]).Px() + (JET[second_jet]).Px()) + (W_p.Py() + (JET[0]).Py() + (JET[second_jet]).Py())*(W_p.Py() + (JET[0]).Py() + (JET[second_jet]).Py()) + (W_p.Pz() + (JET[0]).Pz() + (JET[second_jet]).Pz())*(W_p.Pz() + (JET[0]).Pz() + (JET[second_jet]).Pz()));
	VectorSum_lnujj_n = sqrt((W_n.Px() + (JET[0]).Px() + (JET[second_jet]).Px())*(W_n.Px() + (JET[0]).Px() + (JET[second_jet]).Px()) + (W_n.Py() + (JET[0]).Py() + (JET[second_jet]).Py())*(W_n.Py() + (JET[0]).Py() + (JET[second_jet]).Py()) + (W_n.Pz() + (JET[0]).Pz() + (JET[second_jet]).Pz())*(W_n.Pz() + (JET[0]).Pz() + (JET[second_jet]).Pz()));
	m_cut_vector_sum_lnujj_p.push_back(VectorSum_lnujj_p);
	m_cut_vector_sum_lnujj_n.push_back(VectorSum_lnujj_n);
	m_cut_vector_sum_lnujj_p_n.push_back(VectorSum_lnujj_p);
	m_cut_vector_sum_lnujj_p_n.push_back(VectorSum_lnujj_n);
      }
        
      /////////////////////////////////////////////////////
      //For Picking Out Best Solution  
      //////////////////////////////////////////////////////
      if(m_runMode == _MODE_HQ){
	if(m_cut_delta_eta_w_j1_p[0] > m_cut_delta_eta_w_j1_n[0]){
	  m_best_solution_deta_w_fjet.push_back(0); 
	  m_best_solution_deta_w_fjet.push_back(1); 
	}
	if(m_cut_delta_eta_w_j1_p[0] < m_cut_delta_eta_w_j1_n[0]){
	  m_best_solution_deta_w_fjet.push_back(1);
	  m_best_solution_deta_w_fjet.push_back(0);
	}
	if(m_cut_delta_eta_w_j1_p[0] == m_cut_delta_eta_w_j1_n[0]){
	  m_best_solution_deta_w_fjet.push_back(1);
	  m_best_solution_deta_w_fjet.push_back(1);
	}
      }
    }
  }
  
  if(INFO == "On"){
    cout << "ReconsWjetMass() completed succesfully   " << endl;
  }
  
}

void Background::ReconsZjetMass(){
  
  //Output Z 4-vector:
  TLorentzVector Z;
  TLorentzVector Zj;
  float Jeta = 0.0;
  int nJets = (int) m_jet_pt.size();

  TLorentzVector JET[nJets];
  //Looping over jets
  for(int itr = 0; itr < (int) m_jet_pt.size() ; itr++){
    (JET[itr]).SetPtEtaPhiE(m_jet_pt[itr], m_jet_eta[itr], m_jet_phi[itr], m_jet_e[itr]);
  }
  
  if(m_jet_number[0] >=1){
    if((int) m_z_ee_pt.size() > 0){
      
      //Defining Z 4-vector
      Z.SetPtEtaPhiM(m_z_ee_pt[0], m_z_ee_eta[0], m_z_ee_phi[0], m_z_ee_m[0]);
      
      //Defining 'VLQ' mass
      Zj = (JET[0]) + Z; 
      
      m_HQ_inv_mass_Zee_jet.push_back(Zj.M());
      m_HQ_inv_mass_Z_jet.push_back(Zj.M());
    }
    
    if((int) m_z_mumu_pt.size() > 0){
      
      //Defining Z 4-vector  
      Z.SetPtEtaPhiM(m_z_mumu_pt[0], m_z_mumu_eta[0], m_z_mumu_phi[0], m_z_mumu_m[0]);
      
      //Defining 'VLQ' mass
      Zj = (JET[0]) + Z; 
      
      m_HQ_inv_mass_Zmumu_jet.push_back(Zj.M());
      m_HQ_inv_mass_Z_jet.push_back(Zj.M());
    }
  
    if(m_jet_number[0] >= 2){
      int second_jet = 1;
      for(int itr = 1 ; itr < (int) m_jet_pt.size() ; itr++){
	if(fabs( (JET[0]).Eta() - (JET[itr]).Eta() ) > Jeta){
	  Jeta = fabs( (JET[0]).Eta() - (JET[itr]).Eta() );
	  second_jet = itr;
	}
      }
      if(m_cut_delta_eta_j1_j2.size() == 0){
	m_cut_delta_eta_j1_j2.push_back(Jeta);
      }
      float DPhiJ1J2 = fabs((JET[0]).Phi() - (JET[second_jet]).Phi());
      if(DPhiJ1J2 > 3.141595426){
	DPhiJ1J2 = 2*3.141592654 - DPhiJ1J2;
      }
      if(m_cut_delta_phi_j1_j2.size() == 0){
	m_cut_delta_phi_j1_j2.push_back(DPhiJ1J2);
      } 
      
      //Z and associated jet
      m_cut_delta_eta_z_j2.push_back(fabs(Z.Eta() - (JET[second_jet]).Eta()));
      float DPhiZJ2 = fabs(Z.Phi() - (JET[second_jet]).Phi());
      if(DPhiZJ2 > 3.141595426){
	DPhiZJ2 = 2*3.141592654 - DPhiZJ2;
      }
      m_cut_delta_phi_z_j2.push_back(DPhiZJ2);
    }
  }
  
  if(INFO == "On"){
    cout << "ReconsZjetMass() completed succesfully   " << endl;
  }
  
}

void Background::ReconsWjetMass_ifbJets(){

  //   //   float HVLquark_Mass_with_2nd_b_p = 0.0;
  //   //   float HVLquark_Mass_with_2nd_b_n = 0.0;
  //   //   int second_b = -1;
  //   //   if(m_w_exists[0] == 1 && m_jet_number[0] > 0 && (float) m_jet_btag_prob[0] > JetsBTagProb_Cut){
  //   //     HVLquark_Mass_with_2nd_b_p = sqrt(m_w_e_p[0]*m_w_e_p[0] - m_w_px[0]*m_w_px[0] - m_w_py[0]*m_w_py[0] - m_w_pz_p[0]*m_w_pz_p[0] + 2*(m_w_e_p[0]*m_jet_e[0] - m_w_px[0]*m_jet_px[0] - m_w_py[0]*m_jet_py[0] - m_w_pz_p[0]*m_jet_pz[0])  );
  //   //     HVLquark_Mass_with_2nd_b_n = sqrt(m_w_e_p[0]*m_w_e_p[0] - m_w_px[0]*m_w_px[0] - m_w_py[0]*m_w_py[0] - m_w_pz_n[0]*m_w_pz_n[0] + 2*(m_w_e_n[0]*m_jet_e[0] - m_w_px[0]*m_jet_px[0] - m_w_py[0]*m_jet_py[0] - m_w_pz_n[0]*m_jet_pz[0])  );
  //   //     m_HQ_inv_mass_btagged_no_cuts.push_back(HVLquark_Mass_with_2nd_b_p);
  //   //     m_HQ_inv_mass_btagged_no_cuts.push_back(HVLquark_Mass_with_2nd_b_n);
  //   //   }
  //   //   for(int itr = 1 ; itr < (int) m_jet_btag_prob.size() ; itr++){
  //   //     if(m_w_exists[0] == 1 &&  m_jet_btag_prob[itr] > JetsBTagProb_Cut && second_b == -1){ // There is a second b!
  //   //       second_b = 1;
  //   //       HVLquark_Mass_with_2nd_b_p = sqrt(m_w_e_p[0]*m_w_e_p[0] - m_w_px[0]*m_w_px[0] - m_w_py[0]*m_w_py[0] - m_w_pz_p[0]*m_w_pz_p[0] + 2*(m_w_e_p[0]*m_jet_e[0] - m_w_px[0]*m_jet_px[0] - m_w_py[0]*m_jet_py[0] - m_w_pz_p[0]*m_jet_pz[0])  );
  //   //       HVLquark_Mass_with_2nd_b_n = sqrt(m_w_e_p[0]*m_w_e_p[0] - m_w_px[0]*m_w_px[0] - m_w_py[0]*m_w_py[0] - m_w_pz_n[0]*m_w_pz_n[0] + 2*(m_w_e_n[0]*m_jet_e[0] - m_w_px[0]*m_jet_px[0] - m_w_py[0]*m_jet_py[0] - m_w_pz_n[0]*m_jet_pz[0])  );
  //   //       m_HQ_inv_mass_with_2nd_b_no_cuts.push_back(HVLquark_Mass_with_2nd_b_p);
  //   //       m_HQ_inv_mass_with_2nd_b_no_cuts.push_back(HVLquark_Mass_with_2nd_b_n);
  //   //     }  
  //   //   }
      
  //   //   if(INFO == "On"){
  //   //     cout << "ReconsWjetMass_ifbJets() completed succesfully   " << endl;
  //   //   }  
  
}

void Background::ReconsWZMass(){

  int PickWEl = -1;
  int PickWMu = -1;
  //Find best W
 //COUT;
  if(m_w_enu_px.size() > 0 && m_w_munu_px.size() == 0){
    float diffW = MassW;
    for(int itr = 0; itr < (int) m_w_enu_px.size() ; itr++){
      if(m_w_enu_exists[itr] == 1){
	if( fabs(m_w_enu_m_p[itr] - MassW) < diffW){
	  PickWEl = itr;
	  diffW = fabs(m_w_enu_m_p[itr] - MassW);
	}
      }
    }
  }
 //COUT;
  if(m_w_enu_px.size() == 0 && m_w_munu_px.size() > 0){
    float diffW = MassW;
    for(int itr = 0; itr < (int) m_w_munu_px.size() ; itr++){
      if(m_w_munu_exists[itr] == 1){
	if( fabs(m_w_munu_m_p[itr] - MassW) < diffW){
	  PickWMu = itr;
	  diffW = fabs(m_w_munu_m_p[itr] - MassW);
	}
      }
    }
  }
 //COUT;
  if(m_w_enu_px.size() > 0 && m_w_munu_px.size() > 0){
    float diffW = MassW;
    for(int itr = 0; itr < (int) m_w_munu_px.size() ; itr++){
      if(m_w_munu_exists[itr] == 1){
	if( fabs(m_w_munu_m_p[itr] - MassW) < diffW){
	  PickWMu = itr;
	  diffW = fabs(m_w_munu_m_p[itr] - MassW);
	}
      }
    }
    for(int itr = 0; itr < (int) m_w_enu_px.size() ; itr++){
      if(m_w_enu_exists[itr] == 1){
	if( fabs(m_w_enu_m_p[itr] - MassW) < diffW){
	  PickWEl = itr;
	  PickWMu = -1;
	  diffW = fabs(m_w_enu_m_p[itr] - MassW);
	}
      }
    }
  }

  //MuMuMu
  if(PickWMu != -1 && m_z_mumu_px.size() > 0){
    TLorentzVector W_n;
    TLorentzVector W_p;
    TLorentzVector Z;
    TLorentzVector W_nZ;
    TLorentzVector W_pZ;
    W_n.SetPxPyPzE(m_w_munu_px[PickWMu],m_w_munu_py[PickWMu],m_w_munu_pz_n[PickWMu], m_w_munu_e_n[PickWMu]);
    W_p.SetPxPyPzE(m_w_munu_px[PickWMu],m_w_munu_py[PickWMu],m_w_munu_pz_p[PickWMu], m_w_munu_e_p[PickWMu]);
    Z.SetPxPyPzE(m_z_mumu_px[0], m_z_mumu_py[0], m_z_mumu_pz[0], m_z_mumu_e[0]);
    W_nZ = W_n + Z;
    W_pZ = W_p + Z;
   //COUT;
    m_TR_WZ_trans_mass_mumumu.push_back(sqrt((W_p.Et() + Z.Et())*(W_p.Et() + Z.Et()) - (W_p.Px() + Z.Px())*(W_p.Px() + Z.Px()) - (W_p.Py() + Z.Py())*(W_p.Py() + Z.Py()) )); 
    m_TR_WZ_inv_mass_mumumu_p.push_back(W_pZ.M());
    m_TR_WZ_inv_mass_mumumu_n.push_back(W_nZ.M());
    m_TR_WZ_inv_mass_mumumu.push_back(W_nZ.M());
    m_TR_WZ_inv_mass_mumumu.push_back(W_pZ.M());
   //COUT;
    if((int) m_TR_WZ_inv_mass.size() == 0){
      m_TR_WZ_trans_mass.push_back(m_TR_WZ_trans_mass_mumumu[0]);
      m_TR_WZ_inv_mass_p.push_back(W_pZ.M());
      m_TR_WZ_inv_mass_n.push_back(W_nZ.M());
      m_TR_WZ_inv_mass.push_back(W_pZ.M());
      m_TR_WZ_inv_mass.push_back(W_nZ.M());
    }
  }

  //MuMuEl
  if(PickWEl != -1 && m_z_mumu_px.size() > 0){
    TLorentzVector W_n;
    TLorentzVector W_p;
    TLorentzVector Z;
    TLorentzVector W_nZ;
    TLorentzVector W_pZ;
    W_n.SetPxPyPzE(m_w_enu_px[PickWEl],m_w_enu_py[PickWEl],m_w_enu_pz_n[PickWEl], m_w_enu_e_n[PickWEl]);
    W_p.SetPxPyPzE(m_w_enu_px[PickWEl],m_w_enu_py[PickWEl],m_w_enu_pz_p[PickWEl], m_w_enu_e_p[PickWEl]);
    Z.SetPxPyPzE(m_z_mumu_px[0], m_z_mumu_py[0], m_z_mumu_pz[0], m_z_mumu_e[0]);
    W_nZ = W_n + Z;
    W_pZ = W_p + Z;
   //COUT;
    m_TR_WZ_trans_mass_mumue.push_back(sqrt((W_p.Et() + Z.Et())*(W_p.Et() + Z.Et()) - (W_p.Px() + Z.Px())*(W_p.Px() + Z.Px()) - (W_p.Py() + Z.Py())*(W_p.Py() + Z.Py()) ));  
    m_TR_WZ_inv_mass_mumue_p.push_back(W_pZ.M());
    m_TR_WZ_inv_mass_mumue_n.push_back(W_nZ.M());
    m_TR_WZ_inv_mass_mumue.push_back(W_nZ.M());
    m_TR_WZ_inv_mass_mumue.push_back(W_pZ.M());
   //COUT;
    if((int) m_TR_WZ_inv_mass.size() == 0){
      m_TR_WZ_trans_mass.push_back(m_TR_WZ_trans_mass_mumue[0]);
      m_TR_WZ_inv_mass_p.push_back(W_pZ.M());
      m_TR_WZ_inv_mass_n.push_back(W_nZ.M());
      m_TR_WZ_inv_mass.push_back(W_pZ.M());
      m_TR_WZ_inv_mass.push_back(W_nZ.M());
    }
  }
    
  //EEMU
  if(PickWMu != -1 && m_z_ee_px.size() > 0){
    TLorentzVector W_n;
    TLorentzVector W_p;
    TLorentzVector Z;
    TLorentzVector W_nZ;
    TLorentzVector W_pZ;
    W_n.SetPxPyPzE(m_w_munu_px[PickWMu],m_w_munu_py[PickWMu],m_w_munu_pz_n[PickWMu], m_w_munu_e_n[PickWMu]);
    W_p.SetPxPyPzE(m_w_munu_px[PickWMu],m_w_munu_py[PickWMu],m_w_munu_pz_p[PickWMu], m_w_munu_e_p[PickWMu]);
    Z.SetPxPyPzE(m_z_ee_px[0], m_z_ee_py[0], m_z_ee_pz[0], m_z_ee_e[0]);
    W_nZ = W_n + Z;
    W_pZ = W_p + Z;
   //COUT;
    m_TR_WZ_trans_mass_eemu.push_back(sqrt((W_p.Et() + Z.Et())*(W_p.Et() + Z.Et()) - (W_p.Px() + Z.Px())*(W_p.Px() + Z.Px()) - (W_p.Py() + Z.Py())*(W_p.Py() + Z.Py()) )); 
    m_TR_WZ_inv_mass_eemu_p.push_back(W_pZ.M());
    m_TR_WZ_inv_mass_eemu_n.push_back(W_nZ.M());
    m_TR_WZ_inv_mass_eemu.push_back(W_nZ.M());
    m_TR_WZ_inv_mass_eemu.push_back(W_pZ.M());
   //COUT;
    if((int) m_TR_WZ_inv_mass.size() == 0){
      m_TR_WZ_trans_mass.push_back(m_TR_WZ_trans_mass_eemu[0]);
      m_TR_WZ_inv_mass_p.push_back(W_pZ.M());
      m_TR_WZ_inv_mass_n.push_back(W_nZ.M());
      m_TR_WZ_inv_mass.push_back(W_pZ.M());
      m_TR_WZ_inv_mass.push_back(W_nZ.M());
    }
  }

  //EEE
  if(PickWEl != -1 && m_z_ee_px.size() > 0){
    TLorentzVector W_n;
    TLorentzVector W_p;
    TLorentzVector Z;
    TLorentzVector W_nZ;
    TLorentzVector W_pZ;
    W_n.SetPxPyPzE(m_w_enu_px[PickWEl],m_w_enu_py[PickWEl],m_w_enu_pz_n[PickWEl], m_w_enu_e_n[PickWEl]);
    W_p.SetPxPyPzE(m_w_enu_px[PickWEl],m_w_enu_py[PickWEl],m_w_enu_pz_p[PickWEl], m_w_enu_e_p[PickWEl]);
    Z.SetPxPyPzE(m_z_ee_px[0], m_z_ee_py[0], m_z_ee_pz[0], m_z_ee_e[0]);
    W_nZ = W_n + Z;
    W_pZ = W_p + Z;
   //COUT;
    m_TR_WZ_trans_mass_eee.push_back(sqrt((W_p.Et() + Z.Et())*(W_p.Et() + Z.Et()) - (W_p.Px() + Z.Px())*(W_p.Px() + Z.Px()) - (W_p.Py() + Z.Py())*(W_p.Py() + Z.Py()) ));  
    m_TR_WZ_inv_mass_eee_p.push_back(W_pZ.M());
    m_TR_WZ_inv_mass_eee_n.push_back(W_nZ.M());
    m_TR_WZ_inv_mass_eee.push_back(W_nZ.M());
    m_TR_WZ_inv_mass_eee.push_back(W_pZ.M());
   //COUT;
    if((int) m_TR_WZ_inv_mass.size() == 0){
      m_TR_WZ_trans_mass.push_back(m_TR_WZ_trans_mass_eee[0]);
      m_TR_WZ_inv_mass_p.push_back(W_pZ.M());
      m_TR_WZ_inv_mass_n.push_back(W_nZ.M());
      m_TR_WZ_inv_mass.push_back(W_pZ.M());
      m_TR_WZ_inv_mass.push_back(W_nZ.M());
    }
  }
  if(PickWEl != -1){
    m_w_enu_chosen_exists.push_back(m_MET_el_z_s[PickWEl]);
  }
  if(PickWMu != -1){
    m_w_munu_chosen_exists.push_back(m_MET_mu_z_s[PickWMu]);
  }
  if(PickWEl == -1){
    m_w_enu_chosen_exists.push_back(-1);
  }
  if(PickWMu == -1){
    m_w_munu_chosen_exists.push_back(-1);
  }
  

  TLorentzVector W;
  TLorentzVector Z;
  TLorentzVector WZ;
  if(m_z_ee_px.size() > 0 && m_w_enu_exists.size() > 0){ //Get WZ transverse mass for those not solving missing pz 
    if(m_w_enu_exists[0] == 0){
      W.SetPxPyPzE(m_w_enu_px[0],m_w_enu_py[0], m_w_enu_pz_n[0], m_w_enu_e_n[0]); //Pz info stored in '_n'  
      Z.SetPxPyPzE(m_z_ee_px[0], m_z_ee_py[0],  m_z_ee_pz[0],    m_z_ee_e[0]);
      WZ = W + Z;
      m_TR_WZ_trans_mass_eee.push_back(sqrt((W.Et() + Z.Et())*(W.Et() + Z.Et()) - (W.Px() + Z.Px())*(W.Px() + Z.Px()) - (W.Py() + Z.Py())*(W.Py() + Z.Py()) ));  
      m_TR_WZ_trans_mass.push_back(sqrt((W.Et() + Z.Et())*(W.Et() + Z.Et()) - (W.Px() + Z.Px())*(W.Px() + Z.Px()) - (W.Py() + Z.Py())*(W.Py() + Z.Py()) ));   
    }
  }
  if(m_z_ee_px.size() > 0 && m_w_munu_exists.size() > 0){ //Get WZ transverse mass for those not solving missing pz 
    if(m_w_munu_exists[0] == 0){
      W.SetPxPyPzE(m_w_munu_px[0],m_w_munu_py[0], m_w_munu_pz_n[0], m_w_munu_e_n[0]);
      Z.SetPxPyPzE(m_z_ee_px[0], m_z_ee_py[0], m_z_ee_pz[0], m_z_ee_e[0]);
      WZ = W + Z;
      m_TR_WZ_trans_mass_eemu.push_back(sqrt((W.Et() + Z.Et())*(W.Et() + Z.Et()) - (W.Px() + Z.Px())*(W.Px() + Z.Px()) - (W.Py() + Z.Py())*(W.Py() + Z.Py()) ));  
      m_TR_WZ_trans_mass.push_back(sqrt((W.Et() + Z.Et())*(W.Et() + Z.Et()) - (W.Px() + Z.Px())*(W.Px() + Z.Px()) - (W.Py() + Z.Py())*(W.Py() + Z.Py()) ));   
    }
  }
  if(m_z_mumu_px.size() > 0 && m_w_enu_exists.size() > 0){ //Get WZ transverse mass for those not solving missing pz 
    if(m_w_enu_exists[0] == 0){
      W.SetPxPyPzE(m_w_enu_px[0],  m_w_enu_py[0],  m_w_enu_pz_n[0],   m_w_enu_e_n[0]); //Info stored in '_n'  
      Z.SetPxPyPzE(m_z_mumu_px[0], m_z_mumu_py[0], m_z_mumu_pz[0],    m_z_mumu_e[0]);
      WZ = W + Z;
      m_TR_WZ_trans_mass_mumue.push_back(sqrt((W.Et() + Z.Et())*(W.Et() + Z.Et()) - (W.Px() + Z.Px())*(W.Px() + Z.Px()) - (W.Py() + Z.Py())*(W.Py() + Z.Py()) ));    
      m_TR_WZ_trans_mass.push_back(sqrt((W.Et() + Z.Et())*(W.Et() + Z.Et()) - (W.Px() + Z.Px())*(W.Px() + Z.Px()) - (W.Py() + Z.Py())*(W.Py() + Z.Py()) ));    
    }
  }
 //COUT;
  if(m_z_mumu_px.size() > 0 && m_w_munu_exists.size() > 0){ //Get WZ transverse mass for those not solving missing pz 
    if(m_w_munu_exists[0] == 0){
      W.SetPxPyPzE(m_w_munu_px[0], m_w_munu_py[0], m_w_munu_pz_n[0], m_w_munu_e_n[0]);
      Z.SetPxPyPzE(m_z_mumu_px[0], m_z_mumu_py[0], m_z_mumu_pz[0], m_z_mumu_e[0]);
      WZ = W + Z;
      m_TR_WZ_trans_mass_mumumu.push_back(sqrt((W.Et() + Z.Et())*(W.Et() + Z.Et()) - (W.Px() + Z.Px())*(W.Px() + Z.Px()) - (W.Py() + Z.Py())*(W.Py() + Z.Py()) ));    
      m_TR_WZ_trans_mass.push_back(sqrt((W.Et() + Z.Et())*(W.Et() + Z.Et()) - (W.Px() + Z.Px())*(W.Px() + Z.Px()) - (W.Py() + Z.Py())*(W.Py() + Z.Py()) ));    
    }
  }
    
 
  if(INFO == "On"){
    cout << "ReconsWZMass() completed succesfully   " << endl;
  }

}  
void Background::Reconstruct_Z_plus_electron(){

  //   //First, find maximum Pt electron that wasn't chosen to reconstruct the Z.
      
  //   int electronFound = -1;
  //   //Z reconstructed with two electrons. Need at least three electrons.
  //   if(m_el_number[0] > 2){
  //     if(m_El_ComboZ[0] != -1){
  //       int El_pair = m_El_ComboZ[0];
  //       if(El_pair == 1){
  // 	m_CL_ElE.push_back(m_el_e[2]);  //Choose third electron
  // 	m_CL_ElPx.push_back(m_el_px[2]);
  // 	m_CL_ElPy.push_back(m_el_py[2]);  
  // 	m_CL_ElPz.push_back(m_el_pz[2]);  
  // 	m_CL_ElPt.push_back(m_el_pt[2]);
  // 	m_CL_ElEta.push_back(m_el_eta[2]);
  // 	m_CL_ElPhi.push_back(m_el_phi[2]);
  // 	electronFound = 1;
  //       }
	  
  //       if(El_pair != 1 && El_pair < m_el_number[0]){
  // 	m_CL_ElE.push_back(m_el_e[1]);  //Choose second electron
  // 	m_CL_ElPx.push_back(m_el_px[1]);
  // 	m_CL_ElPy.push_back(m_el_py[1]);  
  // 	m_CL_ElPz.push_back(m_el_pz[1]);  
  // 	m_CL_ElPt.push_back(m_el_pt[1]);
  // 	m_CL_ElEta.push_back(m_el_eta[1]);
  // 	m_CL_ElPhi.push_back(m_el_phi[1]);
  // 	electronFound = 1;
  //       }
  //       if(El_pair >= m_el_number[0]){
  // 	m_CL_ElE.push_back(m_el_e[0]);  //Choose first electron
  // 	m_CL_ElPx.push_back(m_el_px[0]);
  // 	m_CL_ElPy.push_back(m_el_py[0]);  
  // 	m_CL_ElPz.push_back(m_el_pz[0]);  
  // 	m_CL_ElPt.push_back(m_el_pt[0]);
  // 	m_CL_ElEta.push_back(m_el_eta[0]);
  // 	m_CL_ElPhi.push_back(m_el_phi[0]);
  // 	electronFound = 1;
  //       }
  //     }
  //   }
  //   //Z reconstructed with two muons. Need only one electron.
  //   if(m_el_number[0] >= 1){
  //     if(m_Mu_ComboZ[0] != -1){ 
  //       m_CL_ElE.push_back(m_el_e[0]);  //Choose first electron
  //       m_CL_ElPx.push_back(m_el_px[0]);
  //       m_CL_ElPy.push_back(m_el_py[0]);  
  //       m_CL_ElPz.push_back(m_el_pz[0]);  
  //       m_CL_ElPt.push_back(m_el_pt[0]);
  //       m_CL_ElEta.push_back(m_el_eta[0]);
  //       m_CL_ElPhi.push_back(m_el_phi[0]);
  //       electronFound = 1;
  //     }
  //   }
      
  //   //Calculating Z plus e invariant mass.
  //   float Ze_InvMass;
  //   if(electronFound == 1 && m_z_ee_e[0] > 0.0){ 
  //     Ze_InvMass = sqrt(MassEl*MassEl + MassZ*MassZ + 2*(m_CL_ElE[0]*m_z_ee_e[0] - (m_CL_ElPx[0]*m_z_ee_px[0] - m_CL_ElPy[0]*m_z_ee_py[0] - m_CL_ElPz[0]*m_z_ee_pz[0])));
  //     m_CL_Z_plus_ele_inv_mass.push_back(Ze_InvMass);
  //   }
 
  //   if(INFO == "On"){
  //     cout << "Reconstruct_Z_plus_electron() completed succesfully   " << endl;
  //   }
  
}

void Background::Reconstruct_Z_plus_neutrino(){

  //   //Need to have reconstructed a Z.
  //   for(int itr = 0 ; itr < (int) m_el_pt.size() ; itr++){
  //     if(m_el_pt[itr] >= StrandedElectron_Cut){
  //       if(m_El_ComboZ[0] != -1){
  // 	float Zneu_TransMass;
  // 	float EnergyOfNeutrino;
  // 	EnergyOfNeutrino = sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]); //or MET_RefFinal
  // 	Zneu_TransMass = sqrt((m_z_ee_e[0] + EnergyOfNeutrino)*(m_z_ee_e[0] + EnergyOfNeutrino) + (m_z_ee_px[0] + m_MET_x[0])*(m_z_ee_px[0] + m_MET_x[0]) 
  // 			      + (m_z_ee_py[0] + m_MET_y[0])*(m_z_ee_py[0] + m_MET_y[0]));  
  // 	m_CL_Z_plus_nu_trans_mass.push_back(Zneu_TransMass);
  //       }
  //       if(m_Mu_ComboZ[0] != -1){
  // 	float Zneu_TransMass;
  // 	float EnergyOfNeutrino;
  // 	EnergyOfNeutrino = sqrt(m_MET_x[0]*m_MET_x[0] + m_MET_y[0]*m_MET_y[0]); //or MET_RefFinal
  // 	Zneu_TransMass = sqrt((m_z_mumu_e[0] + EnergyOfNeutrino)*(m_z_mumu_e[0] + EnergyOfNeutrino) + (m_z_mumu_px[0] + m_MET_x[0])*(m_z_mumu_px[0] + m_MET_x[0]) 
  // 			      + (m_z_mumu_py[0] + m_MET_y[0])*(m_z_mumu_py[0] + m_MET_y[0]));  
  // 	m_CL_Z_plus_nu_trans_mass.push_back(Zneu_TransMass);
  //       }
  //       break;
  //     }
  //   }
  
  //   if(INFO == "On"){
  //     cout << "Reconstruct_Z_plus_neutrino() completed succesfully   " << endl;
  //   }
  
}

void Background::ReconstructW_ele_CompLepton(){
  
  //   //If the electron chosen for W reconstruction was a lepton, then take second highest Pt lepton. 
  //   if(m_w_exists[0] == 1){
  //     if((int) m_w_lepton_type[0] == 11 && (int) m_el_number[0] >= 2 ){
  //       float W_ele_InvMass_p;
  //       float W_ele_InvMass_n;
  //       W_ele_InvMass_p = sqrt(MassEl*MassEl + MassW*MassW + 2*(m_w_e_p[0]*m_el_e[1] - m_w_px[0]*m_el_px[1] - m_w_py[0]*m_el_py[1] 
  // 							      - m_w_pz_p[0]*m_el_pz[1]));
  //       W_ele_InvMass_n = sqrt(MassEl*MassEl + MassW*MassW + 2*(m_w_e_n[0]*m_el_e[1] - m_w_px[0]*m_el_px[1] - m_w_py[0]*m_el_py[1] 
  // 							      - m_w_pz_n[0]*m_el_pz[1]));
  //       m_CL_W_ele_inv_mass_p.push_back(W_ele_InvMass_p);
  //       m_CL_W_ele_inv_mass_n.push_back(W_ele_InvMass_n);
  //       m_CL_W_ele_inv_mass.push_back(W_ele_InvMass_p);
  //       m_CL_W_ele_inv_mass.push_back(W_ele_InvMass_n);
  //     }
  //   }
  
  //   if(INFO == "On"){
  //     cout << "ReconstructW_ele_CompLepton() completed succesfully   " << endl;
  //   }
  
}

void Background::ProcessEventQuality(){

  int isGoodEvent = 0; 
  if((larError <= 1 && m_GRL == 1) || InputType == "MC"){
    event_cut_passed[2] += 1.0;
    if(m_MET_bad[0] == 0 || InputType == "MC"){
      event_cut_passed[3] += 1.0;
      if(m_MET_sumEt[0] >= 0.0 || InputType == "MC"){ //Not negative MET_sumEt 
	event_cut_passed[4] += 1.0; 
	if(m_cut_good_PV[0] == 1){
	  event_cut_passed[5] += 1.;  
	  if(m_EventPassed_Trig == 1){
	    event_cut_passed[6] += 1.0;
	    m_good_event = 1; 
	    isGoodEvent = 1;
	  }
	}
      }
    }
  }
  if(isGoodEvent == 0){
    m_good_event = 0;
  }

  
  //For Cut Flow Purposes
  /*  if(m_mu_number[0] >= 3){
      lep3_cut_passed[0] += 1.;
      //With a Z
      if((int) m_z_mumu_e.size() > 0 || (int) m_z_ee_e.size() > 0){
      lep3_cut_passed[1] += 1.;
      if(m_MET[0] > 25000.0){
      lep3_cut_passed[2] += 1.;
      if((int) m_w_pt.size() > 0){
      if(m_w_trans_mass[0] > WtransMassCut){
      lep3_cut_passed[3] += 1.;
      }
      }
      }
      }
      }
      if(m_mu_number[0] >= 2 && m_el_number[0] >= 1){
      lep3_cut_passed[4] += 1.;
      //With a Z                                                                          
      if((int) m_z_mumu_e.size() > 0 || (int) m_z_ee_e.size() > 0){
      lep3_cut_passed[5] += 1.;
      if(m_MET[0] > 25000.0){
      lep3_cut_passed[6] += 1.;
      if((int) m_w_pt.size() > 0){
      if(m_w_trans_mass[0] > WtransMassCut){
      lep3_cut_passed[7] += 1.;
      }
      }
      } 
      }
      }
      if(m_el_number[0] >= 2 && m_mu_number[0] >= 1){
      lep3_cut_passed[8] += 1.;
      //With a Z
      if((int) m_z_mumu_e.size() > 0 || (int) m_z_ee_e.size() > 0){
      lep3_cut_passed[9] += 1.;
      if(m_MET[0] > 25000.0){
      lep3_cut_passed[10] += 1.;
      if((int) m_w_pt.size() > 0){
      if(m_w_trans_mass[0] > WtransMassCut){
      lep3_cut_passed[11] += 1.;
      }
      }
      }
      }
      }
      if(m_el_number[0] >= 3){
      lep3_cut_passed[12] += 1.;
      if((int) m_z_mumu_e.size() > 0 || (int) m_z_ee_e.size() > 0){
      lep3_cut_passed[13] += 1.;
      if(m_MET[0] > 25000.0){
      lep3_cut_passed[14] += 1.;
      if((int) m_w_pt.size() > 0){
      if(m_w_trans_mass[0] > WtransMassCut){
      lep3_cut_passed[15] += 1.;
      }
      }
      }
      }
      }
  */
}


//Functions
int Background::FindEBin(float a){
  float et = a;
  if(et <= 5000.0){
    return 0;
  }
  if(et > 5000.0 && et <= 10000.0){
    return 1;
  }
  if(et > 10000.0 && et <= 15000.0){
    return 2;
  }
  if(et > 15000.0 && et <= 20000.0){
    return 3;
  }
  if(et > 20000.0 && et <= 30000.0){
    return 4;
  }
  if(et > 30000.0 && et <= 40000.0){
    return 5;
  }
  if(et > 40000.0 && et <= 50000.0){
    return 6;
  }
  if(et > 50000.0 && et <= 60000.0){
    return 7;
  }
  if(et > 60000.0 && et <= 70000.0){
    return 8;
  }
  if(et > 70000.0 && et <= 80000.0){
    return 9;
  }
  if(et > 80000.0){
    return 10;
  }
  else 
    return -1;
}

int Background::FindEtaBin(float a){
  float eta = a; //the input is in absolute value
  if(eta <= .1){
    return 0;
  }
  if(eta > 0.1 && eta <= 0.6){
    return 1;
  }
  if(eta > 0.6 && eta <= 0.8){
    return 2;
  }
  if(eta > 0.8 && eta <= 1.15){
    return 3;
  }
  if(eta > 1.15 && eta <= 1.37){
    return 4;
  }
  if(eta > 1.37 && eta <= 1.52){
    return 5;
  }
  if(eta > 1.52 && eta <= 1.81){
    return 6;
  }
  if(eta > 1.81 && eta <= 2.01){
    return 7;
  }
  if(eta > 2.01 && eta <= 2.37){
    return 8;
  }
  if(eta > 2.37 && eta <= 2.47){
    return 9;
  }
  else
    return -1;
}

bool Background::IsLArHole(float eta, float phi)
{
  if (eta < -0.1 /*etamin*/ || eta > 1.5 /*etamax*/) return false;
  if (phi < -0.9 /*phimin*/ || phi > -0.5 /*phimax*/) return false;
  return true;     
}
  
bool Background::IsLArHoleVeto(float jet_pt, 
			       float jet_eta,                
			       float jet_phi,                
			       float jet_BCH_CORR_JET, 
			       float jet_BCH_CORR_CELL,
			       bool kIsData,                  //data or mc flag
			       float threshold)
{
  if (!IsLArHole(jet_eta,jet_phi)) return false;
  float pt = threshold;
  // Correct threshold cut by missing energy in LAr hole in data.
  // BCH_CORR_CELL is necessary to take into account dead tile module near LAr hole.
  if (kIsData) pt = pt*(1. - jet_BCH_CORR_JET)/(1. - jet_BCH_CORR_CELL);
  if (jet_pt <= pt) return false;
  return true;
}

int Background::IS_techniA(){
  int isA_T = 0;
  int isRho_T = 0;
  float rho_mass = 0;
  float a_mass = 0;

  //Set Masses  
  if(RunNumber == 145166){
    rho_mass = 200000.0;
  }
  if(RunNumber == 145167){
    rho_mass = 250000.0;
  }
  if(RunNumber == 145168){
    rho_mass = 300000.0;
  }
  if(RunNumber == 145169){
    rho_mass = 350000.0;
  }
  if(RunNumber == 145170){
    rho_mass = 400000.0; 
  }
  if(RunNumber == 145171){
    rho_mass = 450000.0;
  }
  if(RunNumber == 145172){
    rho_mass = 500000.0;
  }
  if(RunNumber == 145174){
    rho_mass = 600000.0;
  }
  if(RunNumber == 145176){
    rho_mass = 700000.0;
  }
  if(RunNumber == 145178){
    rho_mass = 800000.0;
  }
  a_mass = 1.1*rho_mass;
  
  TLorentzVector W;
  TLorentzVector Z;
  int isW = 0;
  int isZ = 0;
  TLorentzVector Resonance;
  //Loop over truth particles
  for(int itr = 0; itr < (int) (*mc_pdgId).size() ; itr++){
    //Find W
    if(fabs((*mc_pdgId)[itr]) == 24){
      W.SetPtEtaPhiM((*mc_pt)[itr], (*mc_eta)[itr], (*mc_phi)[itr], (*mc_m)[itr]);
      isW = 1; 
    }
    //Find Z
    if(fabs((*mc_pdgId)[itr]) == 23){
      Z.SetPtEtaPhiM((*mc_pt)[itr], (*mc_eta)[itr], (*mc_phi)[itr], (*mc_m)[itr]);
      isZ = 1;
    }
    if(isW == 1 && isZ == 1){
      break;
    }
  }

  //Calculate Resonance Mass 
  Resonance = W + Z;
  cout << "Resonance.M()  " << Resonance.M() << endl;
  if(fabs(Resonance.M() - rho_mass) < fabs(Resonance.M() - a_mass)){
    isRho_T = 1;
  }
  else if(fabs(Resonance.M() - rho_mass) > fabs(Resonance.M() - a_mass)){
    isA_T = 1;
  }
  m_WZ_mass_truth.push_back(Resonance.M());

  return isA_T;
} 
void Background::CountPileUpReweightedEvents(){
  m_pileup_events += m_pileup_weight*mc_event_weight; 
}