#include <TFile.h>
#include <TROOT.h>
#include <TH1.h>
#include <TH2.h>
#include <TSystem.h>
#include <TGraph.h>
#include <TLorentzVector.h>
#include <TGraphAsymmErrors.h>
#include <vector>
#include <iostream>
#include <algorithm>

#include "TMath.h"

using namespace std;

#include <TFile.h>
#include <TTree.h>
#include <TROOT.h>
#include <TH1.h>
#include <TH2.h>
#include <TSystem.h>
#include <vector>
#include <TLorentzVector.h>
#include <math.h>
#include "TMath.h"
#include <iostream>
#include <fstream>
#include <algorithm>
#include <map>
#include <TFileMerger.h>

void new_macro()
{
   TFile *f = new TFile("root://eoscms.cern.ch//eos/cms/store/user/meshoaib/Moriond/MCs/1fab0e5/MC13TeV_tZq_ll_lat/MergedMiniEvents_0.root");
   TTree *t = (TTree*)f->Get("analysis/data");
   Int_t nentries(t->GetEntriesFast());
   t->GetEntry(0);
   //Initiliaze Histograms
      TH1F *el_multi_bc      = new TH1F("el_multi_bc","; Muon pt ;Events" ,5, 0.,5.);
   TH1F *mu_multi_bc      = new TH1F("mu_multi_bc","; Muon pt ;Events" ,5, 0.,5.);
   TH1F *lepton_multi_bc  = new TH1F("lepton_multi_bc","; Muon pt ;Events" ,5, 0.,5.);
   TH1F *vetoLep_multi_bc = new TH1F("vetoLep_multi_","; Electron Multiplicity ;Events" ,7, 0.,7.);
   TH1F *VetoMu_pt         = new TH1F("VetoMu_pt","; Muon pt ;Events" ,300, 0.,300.);
   TH1F *lelectron_pt     = new TH1F("lelectron_pt","; Electron pt ;Events" ,300, 0.,300.);
   TH1F *VetoMu_eta        = new TH1F("VetoMu_eta","; Muon eta ;Events" ,100, -3.0,3.0);
   TH1F *lelectron_eta    = new TH1F("lelectron_eta","; Muon eta ;Events" ,100, -3.0,3.0);
 /*  TH1F *VetoMu_px         = new TH1F("VetoMu_px","; Muon px ;Events" ,300, 0.,300.);
   TH1F *VetoMu_py         = new TH1F("VetoMu_py","; Muon py ;Events" ,300, 0.,300.);
   TH1F *VetoMu_pz         = new TH1F("VetoMu_pz","; Muon pz ;Events" ,300, 0.,300.);
   TH1F *VetoMu_en         = new TH1F("VetoMu_en","; Muon en ;Events" ,300, 0.,2500.);
   TH1F *VetoMu_phi         = new TH1F("VetoMu_phi","; Muon phi ;Events" ,100, -3.,3);
   TH1F *VetoMu_charge         = new TH1F("VetoMu_charge","; Muon charge ;Events" ,100,-2.,2.);
*/
   ///Muons
   Int_t nMu;
   Bool_t Mu_isPromptFinalState[50], Mu_isDirectPromptTauDecayProductFinalState[50];
   Int_t Mu_id[50],Mu_charge[50],Mu_pid[50],Mu_g[200];
   Float_t Mu_pt[50],Mu_eta[50],Mu_phi[50], Mu_mass[50], Mu_scaleUnc[50], Mu_miniIso[50], Mu_chargedHadronIso[50], Mu_relIso[50], Mu_ip3d[50], Mu_ip3dsig[50],Mu_mva[50];

   ///Electrons 
   Int_t nEl;
   Bool_t El_isPromptFinalState[50], El_isDirectPromptTauDecayProductFinalState[50];
   Int_t El_id[50],El_charge[50],El_pid[50],El_g[200];
   Float_t El_pt[50],El_eta[50],El_phi[50], El_mass[50], El_scaleUnc[50], El_miniIso[50], El_chargedHadronIso[50], El_relIso[50], El_ip3d[50], El_ip3dsig[50],El_mva[50];

   //Electron info                                                                                                          
t->SetBranchAddress("nEl", &nEl);
   t->SetBranchAddress("El_isPromptFinalState",                         El_isPromptFinalState);
   t->SetBranchAddress("El_isDirectPromptTauDecayProductFinalState",    El_isDirectPromptTauDecayProductFinalState);
   t->SetBranchAddress("El_mva",      El_mva);
   t->SetBranchAddress("El_id",       El_id);
   t->SetBranchAddress("El_pid",      El_pid);
   t->SetBranchAddress("El_g",        El_g);
   t->SetBranchAddress("El_charge",   El_charge);
   t->SetBranchAddress("El_pt",       El_pt);
   t->SetBranchAddress("El_eta",      El_eta);
   t->SetBranchAddress("El_phi",      El_phi);
   t->SetBranchAddress("El_mass",     El_mass);
   t->SetBranchAddress("El_scaleUnc",         El_scaleUnc);
   t->SetBranchAddress("El_chargedHadronIso", El_chargedHadronIso);
   t->SetBranchAddress("El_miniIso",          El_miniIso);
   t->SetBranchAddress("El_relIso",           El_relIso);
   t->SetBranchAddress("El_ip3d",             El_ip3d);
   t->SetBranchAddress("El_ip3dsig",          El_ip3dsig);
   
   //Muon info 
   t->SetBranchAddress("nMu", &nMu);
   t->SetBranchAddress("Mu_isPromptFinalState",                         Mu_isPromptFinalState);
   t->SetBranchAddress("Mu_isDirectPromptTauDecayProductFinalState",    Mu_isDirectPromptTauDecayProductFinalState);
   t->SetBranchAddress("Mu_mva",      Mu_mva);
   t->SetBranchAddress("Mu_id",       Mu_id);
   t->SetBranchAddress("Mu_pid",      Mu_pid);
   t->SetBranchAddress("Mu_g",        Mu_g);
   t->SetBranchAddress("Mu_charge",   Mu_charge);
   t->SetBranchAddress("Mu_pt",       Mu_pt);
   t->SetBranchAddress("Mu_eta",      Mu_eta);
   t->SetBranchAddress("Mu_phi",      Mu_phi);
   t->SetBranchAddress("Mu_mass",     Mu_mass);
   t->SetBranchAddress("Mu_scaleUnc",         Mu_scaleUnc);
   t->SetBranchAddress("Mu_chargedHadronIso", Mu_chargedHadronIso);
   t->SetBranchAddress("Mu_miniIso",          Mu_miniIso);
   t->SetBranchAddress("Mu_relIso",           Mu_relIso);
   t->SetBranchAddress("Mu_ip3d",             Mu_ip3d);
   t->SetBranchAddress("Mu_ip3dsig",          Mu_ip3dsig);



   //LOOP OVER EVENTS
   //   for (Int_t iev=0;iev<nentries;iev++)
for (Int_t iev=0;iev<10000;iev++)
     {
       t->GetEntry(iev);
       if(iev%1000==0) printf ("\r [%3.0f/100] done",100.*(float)(iev)/(float)(nentries));

       float wgt=1.0;
       float genwgt=1.0;
       std::vector<TLorentzVector> selectedMuons, selectedElectrons, selectedNonIsoMuons, selectedNonIsoElectrons;
       std::vector<TLorentzVector> vetoMuons, vetoElectrons;
       std::vector<int> VetoMu_ch, el_charge, el_iso1, el_iso2, mu_isTight, mu_ismuon, el_isTight;
       std::vector<float> mu_iso, el_iso;
       
       //selected muons 
       for(int m=0; m<nMu;m++)

	 {
	   TLorentzVector tmp(0,0,0,0);
	   bool passTightKin(Mu_pt[m]>=25 && fabs(Mu_eta[m])<2.4);
	   bool passVetoKin(Mu_pt[m]>10 && fabs(Mu_eta[m])<2.5);
	   bool passTightId( (Mu_pid[m]>>2)&0x1);
	   float relIso(Mu_relIso[m]);
	   bool passIso(relIso<0.12);
	   bool passNonIso(relIso>0.4);
	   bool passVetoIso( Mu_id[m]==13 ? relIso<0.25 : true);
	   bool passSIP3d(Mu_ip3dsig[m]<4);
	   tmp.SetPtEtaPhiM(Mu_pt[m], Mu_eta[m], Mu_phi[m], Mu_mass[m]);
	   if(passTightKin && passTightId && passSIP3d)
	     {
	       if(passIso)
		 {
		   selectedMuons.push_back(tmp);
		   VetoMu_ch.push_back(Mu_charge[m]);
//plots["VetoMu_charge"]->Fill(Mu_charge[m],wgt);

		 }

	       else if(passNonIso) selectedNonIsoMuons.push_back(tmp);
	     }
	   else if(passVetoKin && passVetoIso) vetoMuons.push_back(tmp);
	 }

       //Selected Electrons 
       for(int e=0; e<nEl;e++)
	 {
	   TLorentzVector tmp1(0,0,0,0);
	   bool  e_passTightKin(El_pt[e]>=25 && fabs(El_eta[e])<2.4);
	   bool  e_passVetoKin(El_pt[e]>10 && fabs(El_eta[e])<2.5);
	   bool  e_passTightId( (El_pid[e]>>2)&0x1);
	   float e_relIso(El_relIso[e]);
	   bool  e_passIso((El_pid[e]>>1)&0x1);
	   bool e_passNonIso(e_relIso>0.4);
	   if(e_passIso || e_relIso<0.4) e_passNonIso=false;
	   bool e_passVetoIso = true;
	   bool e_passSIP3d(El_ip3dsig[e]<4);
	   tmp1.SetPtEtaPhiM(El_pt[e], El_eta[e], El_phi[e], El_mass[e]);
	   if(e_passTightKin && e_passTightId && e_passSIP3d)
	     {
	       if(e_passIso)
		 {
		   selectedElectrons.push_back(tmp1);
		   el_charge.push_back(El_charge[e]);
		 }
	       else if(e_passNonIso) selectedNonIsoElectrons.push_back(tmp1);
	     }
	   else if(e_passVetoKin && e_passVetoIso) vetoElectrons.push_back(tmp1);
	 }

       int nSelMuons = selectedMuons.size();
       int nSelElectrons = selectedElectrons.size();
       int nSelLeptons = nSelElectrons + nSelMuons;
       int nvetoLeptons = vetoMuons.size()+vetoElectrons.size();
       //       std::cout << " No of Selected Muons : " << nSelMuons << "No of Veto Muons :" << vetoMuons.size() << std::endl;
       lepton_multi_bc ->Fill(nSelLeptons,wgt);
       el_multi_bc ->Fill(nSelElectrons,wgt);
       mu_multi_bc ->Fill(nSelMuons,wgt);
       vetoLep_multi_bc ->Fill(nvetoLeptons,wgt);
  //     VetoMu_charge->Fill(Mu_charge,wgt);
       //THREE LEPTON SELECTION CUT                                                                                         
       if (nSelLeptons != 3) continue;
       if (nSelLeptons > 3) continue;
       if (nvetoLeptons != 0) continue;
       if (nvetoLeptons > 0) continue;

float        VetoMuphi(0), VetoMupt(0), VetoMueta(0), lelectronpt(0), lelectroneta(0), VetoMupx(0), VetoMupy(0), VetoMupz(0), VetoMuen(0);

 float    	 VetoMucharge(0);
       // plots pt and eta of leading muon
       if(nSelMuons >0.){
	 VetoMupt   = selectedMuons[0].Pt();
	 VetoMueta  = selectedMuons[0].Eta();
         VetoMupx   = selectedMuons[0].Px();
         VetoMupy   = selectedMuons[0].Py();
         VetoMupz   = selectedMuons[0].Pz();
         VetoMuen   = selectedMuons[0].E();
         VetoMuphi   = selectedMuons[0].Phi();
        VetoMucharge   = Mu_charge[0];

/*	 VetoMu_pt ->Fill(VetoMupt,wgt);
	 VetoMu_eta ->Fill(VetoMueta,wgt);
         VetoMu_px ->Fill(VetoMupx,wgt);
         VetoMu_py ->Fill(VetoMupy,wgt);
         VetoMu_pz ->Fill(VetoMupz,wgt);
         VetoMu_en ->Fill(VetoMuen,wgt);
         VetoMu_phi ->Fill(VetoMuphi,wgt);
         VetoMu_charge ->Fill(VetoMucharge,wgt);
*///         VetoMu_charge->Fill(Mu_charge,wgt);


       }


       // plots pt and eta of leading electron
       if(nSelElectrons >0.){
	 lelectronpt = selectedElectrons[0].Pt();
	 lelectroneta = selectedElectrons[0].Eta();
	 lelectron_pt ->Fill(lelectronpt,wgt);
	 lelectron_eta ->Fill(lelectroneta,wgt);
       }
TFile *ff = new TFile("output_Veto.root","RECREATE");
TTree *t = new TTree("AnaTree","an example tree");
float VetoMupx, VetoMupy, VetoMupz, VetoMuen, VetoMucharge;

t->Branch("VetoMupx",&VetoMupx,"VetoMupx/F");
t->Branch("VetoMupy",&VetoMupy,"VetoMupy/F");
t->Branch("VetoMupz",&VetoMupz,"VetoMupz/F");
t->Branch("VetoMuen",&VetoMuen,"VetoMuen/F");
t->Branch("VetoMucharge",&VetoMucharge,"VetoMucharge/F");
{
t->Fill();
}


//TFile *ff = new TFile("output_Veto.root","RECREATE");
   /// Write histograms to output.root file
//   lepton_multi_bc ->Write();
  // el_multi_bc ->Write();
//   mu_multi_bc ->Write();
//   vetoLep_multi_bc ->Write();
//   VetoMu_pt ->Write();
//   VetoMu_eta ->Write();
//   VetoMupx ->Write();
//   VetoMupy ->Write();
//   VetoMupz ->Write();
//   VetoMuen ->Write();
//   VetoMu_phi ->Write();
//   VetoMucharge ->Write();
ff->Write();
   lelectron_pt ->Write();
   lelectron_eta ->Write();
   /*
   /// Create Sumw2() of hostigrams
   lepton_multi_bc -> Sumw2();
   el_multi_bc -> Sumw2();
   mu_multi_bc -> Sumw2();
   vetoLep_multi_bc -> Sumw2();
   lmuon_pt -> Sumw2();
   lmuon_eta -> Sumw2();
   lelectron_pt -> Sumw2();
   lelectron_eta -> Sumw2();
*/
ff->Close();
     }
   f->Close();
   
   
        
        }