#define Selector_cxx
// The class definition in Selector.h has been generated automatically
// by the ROOT utility TTree::MakeSelector(). This class is derived
// from the ROOT class TSelector. For more information on the TSelector
// framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.

// The following methods are defined in this file:
//    Begin():        called every time a loop on the tree starts,
//                    a convenient place to create your histograms.
//    SlaveBegin():   called after Begin(), when on PROOF called only on the
//                    slave servers.
//    Process():      called for each event, in this function you decide what
//                    to read and fill your histograms.
//    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
//                    called only on the slave servers.
//    Terminate():    called at the end of the loop on the tree,
//                    a convenient place to draw/fit your histograms.
//
// To use this file, try the following session on your Tree T:
//
// Root > T->Process("Selector.C")
// Root > T->Process("Selector.C","some options")
// Root > T->Process("Selector.C+")
//

#include "Selector.h"
#include <iostream>
#include <TH2.h>
#include <TStyle.h>
#include <stdio.h>
#include "TFile.h"
#include "TMath.h"
#include "TLorentzVector.h"

using namespace std;

TFile *outfile;

TH2D *Eta_Pt_SI_DIall                ;
TH2D *Eta_Pt_SI_DIsel                ;

TH1D *TrigRight_Wrong                      ;


TH1D *InvMass                     ;
TH1D *InvMass_EFMU4_Jpsimumupass  ;
TH1D *InvMass_EF_2MU4_Jpsimumupass;

TH1D *Pt_Mu                        ; 
TH1D *Eta_Mu                       ; 
TH1D *Phi_Mu                       ; 
TH1D *DR_Mu                        ; 

TH1D *Pt_Jpsi                      ;                   
TH1D *Phi_Jpsi                     ;
TH1D *Eta_Jpsi                     ; 


//histo useful for efficiency
//numerators no weight
TH1D *PtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                    ; 
TH1D *PtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                  ; 
TH1D *EtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                   ; 
TH1D *EtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                   ; 
TH1D *DeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                    ; 

//Barrel
//numerators
TH1D *WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b                    ; 
TH1D *WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b                  ; 
                  ; 
//denominators
TH1D *PtMajor_Jpsi_EFMU4b                                          ; 
TH1D *PtMinor_Jpsi_EFMU4b                                        ; 
                                       
//EndCap
//numerators
TH1D *WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e                    ; 
TH1D *WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e                  ; 
                  
//denominators
TH1D *PtMajor_Jpsi_EFMU4e                                          ; 
TH1D *PtMinor_Jpsi_EFMU4e                                        ; 

//B+E
//numerators
TH1D *WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                    ; 
TH1D *WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                  ; 
TH1D *WEtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                   ; 
TH1D *WEtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                   ; 
TH1D *WDeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4                    ; 

//denominators
TH1D *PtMajor_Jpsi_EFMU4                                          ; 
TH1D *PtMinor_Jpsi_EFMU4                                        ; 
TH1D *EtaMajor_Jpsi_EFMU4                                         ; 
TH1D *EtaMinor_Jpsi_EFMU4                                         ; 
TH1D *DeltaR_Jpsi_EFMU4                                          ; 
 

//TFile *F1 = new TFile("TPout_Zmumu_staco.root");
TFile *F1 = new TFile("TPout_MCh150_CombComb_staco.root");
TFile *F2 = new TFile("Eta_Pt_SI_DI_mapEF.root","read");
TH2D *EffMapall=(TH2D*) F1->Get("hmapselalleff");
TH2D *EffMapall_den=(TH2D*) F2->Get("Eta_Pt_SI_DIsel");
TH2D *Eta_Pt_SingleEmu_Num;
TH2D *Eta_Pt_SingleEmu_Den;

long i=0;

const float mu_mass=0.105658367;
const int nbinsPt=11;
const int nbinsEta=18;
const float binsPt[nbinsPt+1]={1,5,7,10,14,18,25,30,35,40,45,50};// ef2mu10 binning
const float binsEta[nbinsEta+1]={-2.4,-2.0,-1.7,-1.5,-1.3,-1.05,-0.8,-0.5,-0.1,0,0.1,0.5,0.8,1.05,1.3,1.5,1.7,2.0,2.4};



const float minJpsi=70000;
const float maxJpsi=110000;
const int mu1Author=6;
const int mu2Author=6;
const float EtaCut=2.4;
const float Chi2Vtx_cut=1000;
const int nbinsEtaMap=18;
const float binsEtaMap[nbinsEtaMap+1]={-2.4,-2.0,-1.7,-1.5,-1.3,-1.05,-0.8,-0.5,-0.1,0,0.1,0.5,0.8,1.05,1.3,1.5,1.7,2.0,2.4};
const int efmu4_nbinsEtaMap=9;
const float efmu4_binsEtaMap[efmu4_nbinsEtaMap+1]={0,0.1,0.5,0.8,1.05,1.3,1.5,1.7,2.0,2.4};


void Selector::Begin(TTree * /*tree*/)
{
   // The Begin() function is called at the start of the query.
   // When running with PROOF Begin() is only called on the client.
   // The tree argument is deprecated (on PROOF 0 is passed).

   TString option = GetOption();

   outfile = new TFile("test.root", "RECREATE");
  
   Eta_Pt_SI_DIall=new TH2D("Eta_Pt_SI_DIall","Eta_Pt_SI_DIall",nbinsEtaMap,binsEtaMap,nbinsPt,binsPt);
   Eta_Pt_SI_DIsel=new TH2D("Eta_Pt_SI_DIsel","Eta_Pt_SI_DIsel",nbinsEtaMap,binsEtaMap,nbinsPt,binsPt);

   Eta_Pt_SingleEmu_Num=new TH2D("Eta_Pt_SingleEmu_Num","Eta_Pt_SingleEmu_Num",nbinsEtaMap,binsEtaMap,nbinsPt,binsPt);
   Eta_Pt_SingleEmu_Den=new TH2D("Eta_Pt_SingleEmu_Den","Eta_Pt_SingleEmu_Den",nbinsEtaMap,binsEtaMap,nbinsPt,binsPt);


   InvMass=new  TH1D("InvMass","InvMass",1000,0,120000);
   InvMass_EFMU4_Jpsimumupass=new TH1D("InvMass_EFMU4_Jpsimumupass","InvMass_EFMU4_Jpsimumupass",1000,0,120000);
   InvMass_EF_2MU4_Jpsimumupass=new TH1D("InvMass_EF_2MU4_Jpsimumupass","InvMass_EF_2MU4_Jpsimumupass",1000,0,120000);
 
   Pt_Mu                        =new TH1D("Pt_Mu","Pt_Mu",100,0,120000);
   Eta_Mu                       =new TH1D("Eta_Mu","Eta_Mu",100,-3,3);
   Phi_Mu                       =new TH1D("Phi_Mu","Phi_Mu",100,-(TMath::Pi()),TMath::Pi());
   DR_Mu                        =new TH1D("DR_Mu","DR_Mu",100,0,6);

   Pt_Jpsi                      =new TH1D("Pt_Jpsi","Pt_Jpsi",50,0,120000);
   Phi_Jpsi                     =new TH1D("Phi_Jpsi","Phi_Jpsi",50,-(TMath::Pi()),TMath::Pi());
   Eta_Jpsi                     =new TH1D("Eta_Jpsi","Eta_Jpsi",50,-3,3);
  
   TrigRight_Wrong =new TH1D("TrigRight_Wrong","TrigRight_Wrong",2,0,2);                      ;
   
   //histo useful for efficiency
   PtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4   =new TH1D("PtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","PtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",nbinsPt,binsPt); 
   PtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4 =new TH1D("PtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","PtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",nbinsPt,binsPt); 
   EtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4  =new TH1D("EtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","EtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",nbinsEta,binsEta); 
   EtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4  =new TH1D("EtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","EtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",nbinsEta,binsEta); 
   DeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4   =new TH1D("DeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","DeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",20,0,1.6); 
   
   //numerators
   WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4   =new TH1D("WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",nbinsPt,binsPt); 
   WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4 =new TH1D("WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",nbinsPt,binsPt); 
   WEtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4  =new TH1D("WEtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","WEtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",nbinsEta,binsEta);  
   WEtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4  =new TH1D("WEtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","WEtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",nbinsEta,binsEta);  
   WDeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4   =new TH1D("WDeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4","WDeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4",20,0,1.6); 
   
   //denominators
   PtMajor_Jpsi_EFMU4                   =new TH1D("PtMajor_Jpsi_EFMU4","PtMajor_Jpsi_EFMU4",nbinsPt,binsPt); 
   PtMinor_Jpsi_EFMU4                 =new TH1D("PtMinor_Jpsi_EFMU4","PtMinor_Jpsi_EFMU4",nbinsPt,binsPt); 
   EtaMajor_Jpsi_EFMU4                  =new TH1D("EtaMajor_Jpsi_EFMU4","EtaMajor_Jpsi_EFMU4",nbinsEta,binsEta);
   EtaMinor_Jpsi_EFMU4                  =new TH1D("EtaMinor_Jpsi_EFMU4","EtaMinor_Jpsi_EFMU4",nbinsEta,binsEta);
   DeltaR_Jpsi_EFMU4                   =new TH1D("DeltaR_Jpsi_EFMU4","DeltaR_Jpsi_EFMU4",20,0,1.6);

   //Barrel
   //numerators
   WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b   =new TH1D("WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b","WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b",nbinsPt,binsPt); 
   WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b =new TH1D("WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b","WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b",nbinsPt,binsPt); 
   
   //denominators
   PtMajor_Jpsi_EFMU4b                   =new TH1D("PtMajor_Jpsi_EFMU4b","PtMajor_Jpsi_EFMU4b",nbinsPt,binsPt); 
   PtMinor_Jpsi_EFMU4b                 =new TH1D("PtMinor_Jpsi_EFMU4b","PtMinor_Jpsi_EFMU4b",nbinsPt,binsPt); 
  
   //EndCap
   //numerators
   WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e   =new TH1D("WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e","WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e",nbinsPt,binsPt); 
   WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e =new TH1D("WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e","WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e",nbinsPt,binsPt); 
  
   //denominators
   PtMajor_Jpsi_EFMU4e                   =new TH1D("PtMajor_Jpsi_EFMU4e","PtMajor_Jpsi_EFMU4e",nbinsPt,binsPt); 
   PtMinor_Jpsi_EFMU4e                 =new TH1D("PtMinor_Jpsi_EFMU4e","PtMinor_Jpsi_EFMU4e",nbinsPt,binsPt); 
  

  
}

void Selector::SlaveBegin(TTree * /*tree*/)
{
   // The SlaveBegin() function is called after the Begin() function.
   // When running with PROOF SlaveBegin() is called on each slave server.
   // The tree argument is deprecated (on PROOF 0 is passed).

   TString option = GetOption();

}

Bool_t Selector::Process(Long64_t entry)
{
   // The Process() function is called for each entry in the tree (or possibly
   // keyed object in the case of PROOF) to be processed. The entry argument
   // specifies which entry in the currently loaded tree is to be processed.
   // It can be passed to either Selector::GetEntry() or TBranch::GetEntry()
   // to read either all or the required parts of the data. When processing
   // keyed objects with PROOF, the object is already loaded and is available
   // via the fObject pointer.
   //
   // This function should contain the "body" of the analysis. It can contain
   // simple or elaborate selection criteria, run algorithms on the data
   // of the event and typically fill histograms.
   //
   // The processing can be stopped by calling Abort().
   //
   // Use fStatus to set the return value of TTree::Process().
   //
   // The return value is currently not used.

  //Branch opening
 
  //isGoodEvent used
  //if( isGoodEvent(runNumber, lumiBlock, bcId) != 1 ) return kTRUE;
 
  //new variables in which put the TTree variables
  i++;
  bool isJpsi=false;
  if(i%1000000==0) cout<<" event "<<i<<endl;
  
  b_mu1author->GetEntry(entry);
  b_mu2author->GetEntry(entry);
  b_mu1eta->GetEntry(entry);
  b_mu2eta->GetEntry(entry);
  b_mu1pt->GetEntry(entry);
  b_mu2pt->GetEntry(entry);

  
  if(!(mu1author==mu1Author && mu2author==mu2Author && fabs(mu1eta)<EtaCut && fabs(mu2eta)<EtaCut /*&&  mu1pt>4000*/ && mu2pt>4000)) return kTRUE;

  b_q->GetEntry(entry);
  if(q!=0)  return kTRUE;

  b_invmass->GetEntry(entry);
 
  if(invmass>200000)  return kTRUE;
  
  b_m_secVtxChiSq->GetEntry(entry);
  b_mu1q->GetEntry(entry);
  b_mu2q->GetEntry(entry);
  b_mu1phi->GetEntry(entry);
  b_mu2phi->GetEntry(entry);
  b_muL1MU10pass->GetEntry(entry);
  b_mu1L1MU10dr->GetEntry(entry);
  b_mu2L1MU10dr->GetEntry(entry);
  b_muEFMU10pass->GetEntry(entry);
  b_muEF_2MU10pass->GetEntry(entry);
  b_mu1EFMU10dr->GetEntry(entry);
 
  b_mu1EFMU10eta->GetEntry(entry);
  b_mu1EFMU10phi->GetEntry(entry);
  b_mu2EFMU10dr->GetEntry(entry);
  b_mu2EFMU10eta->GetEntry(entry);
  b_mu2EFMU10phi->GetEntry(entry);
  b_mu1EF_2MU10dr->GetEntry(entry);
  b_mu1EF_2MU10dpt->GetEntry(entry);
  
  b_mu1EF_2MU10eta->GetEntry(entry);
  b_mu1EF_2MU10phi->GetEntry(entry);
  b_mu2EF_2MU10dr->GetEntry(entry);
  b_mu2EF_2MU10dpt->GetEntry(entry);
  b_mu2EF_2MU10eta->GetEntry(entry);
  b_mu2EF_2MU10phi->GetEntry(entry);
  
  b_mu2pt_EF->GetEntry(entry);
  b_mu2eta_EF->GetEntry(entry);
  b_mu2phi_EF->GetEntry(entry);

  b_mu2pt_L2->GetEntry(entry);
  b_mu2eta_L2->GetEntry(entry);
  b_mu2phi_L2->GetEntry(entry);
  

  int SingleL1Pass = muL1MU10pass;
  int SinglePass   = muEFMU10pass;
  int DimuPass     = muEF_2MU10pass;
  
  float SingleL1M1dr =mu1L1MU10dr;
  float SingleM1dr   =mu1EFMU10dr;
  float SingleM1eta  =mu1EFMU10eta;
  float SingleM1phi  =mu1EFMU10phi;
  
  float SingleL1M2dr =mu2L1MU10dr;
  float SingleM2dr =mu2EFMU10dr;
  float SingleM2eta=mu2EFMU10eta;
  float SingleM2phi=mu2EFMU10phi;

  float DimuM1dr =mu1EF_2MU10dr ;
  float DimuM1eta=mu1EF_2MU10eta;
  float DimuM1phi=mu1EF_2MU10phi; 
  
  float DimuM2dr =mu2EF_2MU10dr ;
  float DimuM2eta=mu2EF_2MU10eta;
  float DimuM2phi=mu2EF_2MU10phi;

  float weit=0.,weit_den=0.;
  unsigned MuTrig=0;
  float dr1=0,dr2=0;
  unsigned MuMax=0;

  bool EF_mu4_passed=false;
  bool EF_mu4_Jpsimumu_passed=false;
  bool EF_mu4_Jpsimumu_passed_only=false;

  TLorentzVector mu1; mu1.SetPtEtaPhiM(mu1pt/1000.,mu1eta,mu1phi,mu_mass);
  TLorentzVector mu2; mu2.SetPtEtaPhiM(mu2pt/1000.,mu2eta,mu2phi,mu_mass);
  float dr=-1;
  dr=mu1.DeltaR(mu2);

  TLorentzVector Jpsi,major,minor;
  Jpsi=mu1+mu2;
 
 

  InvMass->Fill(invmass);

  if(invmass>minJpsi && invmass<maxJpsi && m_secVtxChiSq<Chi2Vtx_cut) 
    {
      cout << " pass mass and vertex"<<endl;
      isJpsi=true;
      Pt_Mu->Fill(mu1pt); 
      Eta_Mu->Fill(mu1eta);
      Phi_Mu->Fill(mu1phi);
      
      Pt_Mu->Fill(mu2pt); 
      Eta_Mu->Fill(mu2eta);
      Phi_Mu->Fill(mu2phi);

      
      DR_Mu->Fill(dr);

      Pt_Jpsi->Fill(Jpsi.Pt());                    
      Eta_Jpsi->Fill(Jpsi.Eta());                   
      Phi_Jpsi->Fill(Jpsi.Phi()); 
    }

  if(mu1.Pt()>mu2.Pt()) 
    {
      MuMax=1;
      major=mu1;
      minor=mu2;
      if(MuTrig=1) TrigRight_Wrong->Fill(0.5);
      else TrigRight_Wrong->Fill(1.5);
    }
  else
    {
      MuMax=2;
      major=mu2;
      minor=mu1;
      if(MuTrig=2) TrigRight_Wrong->Fill(0.5);
      else TrigRight_Wrong->Fill(1.5);
    }

  if(SinglePass==1 /*&& (SingleM1dr<0.005 || SingleM2dr<0.005)*/ && SingleL1Pass==1 && (SingleL1M1dr<0.4 || SingleL1M2dr<0.4))
    {
      cout << " pass single EFmu10 + l1mu10 + l1dr  "<<endl;

      if(MuMax==1 && SingleM1dr<0.005)
	{
	  EF_mu4_passed=true;
	  cout << " pass single EFmu10dr  "<<endl;      	  
	  if(DimuPass==1 && (DimuM1dr<0.005 && DimuM2dr<0.005))
	    {
	      EF_mu4_Jpsimumu_passed=true;
	      dr1=DR(SingleM1eta,SingleM1phi,DimuM1eta,DimuM1phi);
	    }
	}
      else if(MuMax==2 && SingleM2dr<0.005)
	{
	  EF_mu4_passed=true;
	  cout << " pass single EFmu10dr  "<<endl;      	  
	  if(DimuPass==1 && (DimuM1dr<0.005 && DimuM2dr<0.005))
	    {
	      EF_mu4_Jpsimumu_passed=true;
	      dr2=DR(SingleM2eta,SingleM2eta,DimuM2eta,DimuM2phi);
	    }
	} 
    }

 

 if(DimuPass==1 && (DimuM1dr<0.005 && DimuM2dr<0.005))
   {
     cout << " pass single EF2mu10 and EF2mu10dr  "<<endl;      	  
     EF_mu4_Jpsimumu_passed_only=true;
     Eta_Pt_SingleEmu_Den->Fill(fabs(mu2eta_EF),mu2pt_EF);
     if(PassedEF(mu2pt_EF,mu2eta_EF) && PassedL2(fabs(mu2pt_L2),mu2eta_L2) && DR(mu2eta_L2,mu2phi_L2,mu2eta_EF,mu2phi_EF)<0.003)
       {
	 Eta_Pt_SingleEmu_Num->Fill(fabs(mu2eta_EF),mu2pt_EF);   
       }
   }
  
 if(isJpsi && EF_mu4_Jpsimumu_passed_only)
   {
     Eta_Pt_SI_DIall->Fill(major.Eta(),major.Pt());
     if(EF_mu4_passed && (dr1<0.001 || dr2<0.001))
       {
	 if(MuMax==1 && SingleM1dr<0.005)
	   {
	     Eta_Pt_SI_DIsel->Fill(major.Eta(),major.Pt());
	   }
	 if(MuMax==2 && SingleM2dr<0.005)
	   {
	     Eta_Pt_SI_DIsel->Fill(major.Eta(),major.Pt());
	   }
       }
   }
 

  //numerators
  if(isJpsi && EF_mu4_passed && EF_mu4_Jpsimumu_passed && (dr1<0.001 || dr2<0.001))
    {
      cout << " go into numerators:: Eta = "<<major.Eta()<<endl;
      cout << " go into numerators:: Eta = "<<major.Phi()<<endl;
      cout << " bin x = "<<BinX(major.Eta())<<endl;
      cout << " bin x = "<<BinY(major.Pt())<<endl;

      InvMass_EFMU4_Jpsimumupass->Fill(invmass);
      weit=EffMapall->GetBinContent(BinX(major.Eta()),BinY(major.Pt()));
      cout << " weit = "<<weit<<endl;
      //weit_den=EffMapall_den->GetBinContent(BinX(major.Eta()),BinY(major.Pt())); // not needed for topological

      if(weit_den==0.) weit_den=0.10; 
      weit_den=1.;
      WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(major.Pt(),weit/weit_den);
      WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(minor.Pt(),weit/weit_den);
      WEtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(major.Eta(),weit/weit_den);
      WEtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(minor.Eta(),weit/weit_den);
      if(fabs(major.Eta())<1.05)
	{
	  WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b->Fill(major.Pt(),weit/weit_den);
	  WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b->Fill(minor.Pt(),weit/weit_den);
	}
      else
	{
	  WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e->Fill(major.Pt(),weit/weit_den);
	  WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e->Fill(minor.Pt(),weit/weit_den);
	}
      
      PtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(major.Pt());
      PtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(minor.Pt());
      EtaMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(major.Eta());
      EtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(minor.Eta());

      WDeltaR_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(dr,weit/weit_den);     
    }
  
  
  //Denominators
  if(isJpsi && EF_mu4_passed)
    {
      
      PtMajor_Jpsi_EFMU4->Fill(major.Pt());
      PtMinor_Jpsi_EFMU4->Fill(minor.Pt());
      EtaMajor_Jpsi_EFMU4->Fill(major.Eta());
      EtaMinor_Jpsi_EFMU4->Fill(minor.Eta());
      if(fabs(major.Eta())<1.05)
	{
	  PtMajor_Jpsi_EFMU4b->Fill(major.Pt());
	  PtMinor_Jpsi_EFMU4b->Fill(minor.Pt());
	     }
      else
	{
	  PtMajor_Jpsi_EFMU4e->Fill(major.Pt());
	  PtMinor_Jpsi_EFMU4e->Fill(minor.Pt());
	}
      
      DeltaR_Jpsi_EFMU4->Fill(dr);
    }
  
  return kTRUE;
}

void Selector::SlaveTerminate()
{
   // The SlaveTerminate() function is called after all entries or objects
   // have been processed. When running with PROOF SlaveTerminate() is called
   // on each slave server.

}

void Selector::Terminate()
{
   // The Terminate() function is the last function to be called during
   // a query. It always runs on the client, it can be used to present
   // the results graphically or save the results to file.
  
  //Write of Histograms or TTree
 

  outfile->Write();
  outfile->Close();


}

int Selector::BinX(float Eta)
{
  float eta;
  eta=fabs(Eta);
  if(eta<-2.0  && eta>= -2.4) return 1;
  if(eta<-1.7  && eta>= -2.0) return 2;
  if(eta<-1.5  && eta>= -1.7) return 3;
  if(eta<-1.3  && eta>= -1.5) return 4;
  if(eta<-1.05 && eta>= -1.3) return 5;
  if(eta<-0.8  && eta>= -1.05) return 6;
  if(eta<-0.5  && eta>= -0.8) return 7;
  if(eta<-0.1  && eta>= -0.5) return 8;
  if(eta< 0.   && eta>= -0.1) return 9;
  if(eta< 0.1  && eta>=  0.0) return 10;
  if(eta< 0.5  && eta>=0.1) return 11;
  if(eta<0.8   && eta>=0.5) return 12;
  if(eta<1.05  && eta>=0.8) return 13;
  if(eta<1.3   && eta>=1.05) return 14;
  if(eta<1.5   && eta>=1.3) return 15;
  if(eta<1.7   && eta>=1.5) return 16;
  if(eta<2.0   && eta>=1.7) return 17;
  if(eta<2.4   && eta>=2.0) return 18;
}

int Selector::BinY(float pT)
{
  if(pT<1) return 1;
  if(pT<2 && pT>=1) return 2;
  if(pT<3 && pT>=2) return 3;
  if(pT<4 && pT>=3) return 4;
  if(pT<5 && pT>=4) return 5;
  if(pT<6 && pT>=5) return 6;
  if(pT<7 && pT>=6) return 7;
  if(pT<8 && pT>=7) return 8;
  if(pT<9 && pT>=8) return 9;
  if(pT<10 && pT>=9) return 10;
  if(pT>=10) return 11;
}

float Selector::DR(float eta1, float phi1, float eta2, float phi2){
  
  float dPhi,dEta;

  dPhi=fabs(phi1-phi2);
  dEta=fabs(eta1-eta2);

  if(dPhi>TMath::Pi()) dPhi=2*TMath::Pi()-dPhi;
  
  return  sqrt(dPhi*dPhi+dEta*dEta);
} 

bool Selector::PassedL2(float pt,float eta)
{
  bool pass=false;
  if(fabs(eta)<1.05)
    {
      if(pt>=3000) pass=true;
    }
  else if(1.05<=fabs(eta)<1.5)
    {
      if(pt>=2500) pass=true;
    }
  else if(1.5<=fabs(eta)<2.0)
    {
      if(pt>=2500) pass=true;
    }
  else if(2.0<=fabs(eta))
    {
      if(pt>=2500) pass=true;
    } 
  return pass;
}

bool Selector::PassedEF(float pt,float eta)
{
  bool pass=false;
  if(fabs(eta)<1.05)
    {
      if(pt>=3930) pass=true;
    }
  else if(1.05<=fabs(eta)<1.5)
    {
      if(pt>=3910) pass=true;
    }
  else if(1.5<=fabs(eta)<2.0)
    {
      if(pt>=3880) pass=true;
    }
  else if(2.0<=fabs(eta))
    {
      if(pt>=3880) pass=true;
    } 
  return pass;
}