#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 <iomanip>

#include "TMath.h"

using namespace std;
//using std::setw;

#include <TTree.h>
#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>
#include "TBranch.h"
#include "TBasket.h"
//#include "Event.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 *lelectron_eta    = new TH1F("lelectron_eta","; Muon eta ;Events" ,100, -3.0,3.0);

   ///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);



TFile *ff = new TFile("output1_ajeeb_Veto.root","RECREATE");
TTree *t1 = new TTree("AnaTree","an example tree");

//class MyClass : public TObject {
//  private:
Float_t VetoMu_px[500], VetoMu_py[500], VetoMu_pz[500], VetoMu_en[500], VetoMu_eta[500], VetoMu_phi[500], VetoMu_pt[500], VetoMu_iso[500];
Int_t VetoMu_ismuon[500], VetoMu_idTight[500], VetoMu_charge[500], nMu, Veto;
Int_t VetoMu;
//};
Int_t basketsize = 32000;
Int_t splitlevel = 99;

t1->Branch("VetoMu",VetoMu,"VetoMu/I");
t1->Branch("VetoMu_px",VetoMu_px,"VetoMu_px[VetoMu]/F", 32000, 1);
t1->Branch("VetoMu_py",VetoMu_py,"VetoMu_py[VetoMu]/F");
t1->Branch("VetoMu_pz",VetoMu_pz,"VetoMu_pz[VetoMu]/F");
t1->Branch("VetoMu_en",VetoMu_en,"VetoMu_en[VetoMu]/F");
t1->Branch("VetoMu_charge",VetoMu_charge,"VetoMu_charge[VetoMu]/I");
t1->Branch("VetoMu_pt",VetoMu_pt,"VetoMu_pt[VetoMu]/F");
t1->Branch("VetoMu_eta",VetoMu_eta,"VetoMu_eta[VetoMu]/F");
t1->Branch("VetoMu_phi",VetoMu_phi,"VetoMu_phi[VetoMu]/F");
t1->Branch("VetoMu_idTight",VetoMu_idTight,"VetoMu_idTight[VetoMu]/I");
t1->Branch("VetoMu_ismuon",VetoMu_ismuon,"VetoMu_ismuon[VetoMu]/I");
t1->Branch("VetoMu_iso",VetoMu_iso,"VetoMu_iso[VetoMu]/F");
//t1->Branch("VetoMu","Event", &Event, 32000, 99);
//t1->Branch("nMu",&nMu,"nMu/I");
//TBranch::TBranch(t1, "Veto", Veto, "Veto/I", 32000, -1);
   //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, vetomu_ismuon;
       std::vector<float> mu_iso, el_iso, vetomu_iso;
//       std::vector<bool> vetomu_isTight; 
       
       //selected muons 
       for(int m=0; m<nMu;m++)

	 {
	//   VetoMu_isTight(m)= false;
	   TLorentzVector tmp(0,0,0,0);
	   bool passTightKin(Mu_pt[m]>=10 && fabs(Mu_eta[m])<2.5);// I made selected muons as a loose to make it equal to veto muons by changing cuts
	   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.25);
	  // 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 && passSIP3d)
	     {
	       if(passIso)
		 {
		   selectedMuons.push_back(tmp);
		   VetoMu_ch.push_back(Mu_charge[m]);
		 }
	   //    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);
       //THREE LEPTON SELECTION CUT                                                                                         
       if (nSelLeptons != 3) continue;
       if (nSelLeptons > 3) continue;
       if (nvetoLeptons != 0) continue;
       if (nvetoLeptons > 0) continue;
       // plots pt and eta of leading muon

//TLorentzVector tmp(0,0,0,0);
//tmp.SetPtEtaPhiM(Mu_pt, Mu_eta, Mu_phi, Mu_mass);
//for (int m=0; m<nSelMuons; m++) {
for (int m=0; m<selectedMuons.size(); m++) {

        VetoMu[m] = nSelMuons[m];
	 VetoMu_pt[m]   = selectedMuons[m].Pt();
	 VetoMu_eta[m]  = selectedMuons[m].Eta();
         VetoMu_px[m]   = selectedMuons[m].Px();
         VetoMu_py[m]   = selectedMuons[m].Py();
         VetoMu_pz[m]   = selectedMuons[m].Pz();
         VetoMu_en[m]   = selectedMuons[m].E();
         VetoMu_phi[m]   = selectedMuons[m].Phi();
        VetoMu_charge[m]   = Mu_charge[m];
	VetoMu_iso[m] = Mu_relIso[m];
	VetoMu_idTight[m] = ( (Mu_pid[m]>>2)&0x1);
	VetoMu_ismuon[m] = Mu_ip3dsig[m];
//	VetoMu[m] = nSelMuons[m];
  
	}

//    int    nMu = nSelMuons;
        t1->Fill();
       
}
t1->Write();
ff->Write();
ff->Close();
f->Close();
}